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