You are given a bootloader program as a list of text instructions. Each instruction has an opcode and a signed integer value, such as `plus +1` or `jump -3`. The instruction pointer starts at index `0`, and the global accumulator starts at `0`. Instruction semantics: - `plus v`: add `v` to the accumulator, then move to the next instruction. - `next v`: do nothing with `v`, then move to the next instruction. - `jump v`: move to instruction index `current_index + v`. A program terminates normally when the instruction pointer moves to the position immediately after the last instruction. If the program attempts to execute an instruction that has already been executed during the same run, it is considered to be in an infinite loop. Exactly one instruction whose opcode is either `next` or `jump` was accidentally swapped: a `next` should have been a `jump`, or a `jump` should have been a `next`. `plus` instructions are always correct. Write a function that finds the single corrupted instruction, flips it, runs the corrected program, and returns the accumulator value after the corrected program terminates normally. You may assume there is exactly one valid fix. Example: ```text plus +1 next +0 plus +2 jump +2 plus +100 jump -3 plus +4 ``` In the original program, execution eventually repeats an instruction and loops. If instruction `5` is changed from `jump -3` to `next -3`, the program terminates normally, and the final accumulator is `7`.