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