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