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