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