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