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