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