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