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