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