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