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