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