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