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