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