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