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