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