anchor.diff:      condition.[condition.Length - 1] <- branch
       condition
   
  -let invert (type_: BranchType): BranchType =
  +let private invert (type_: BranchType): BranchType =
       match type_ with
       | Equal -> NotEqual
       | NotEqual -> Equal
  
positive.code:             ...
          *)
          | ((start, _, Some end_) :: _) as all when end_ > start ->
              let block = doWhileLoop (end_ + 1) (end_ - start - 1) (all |> List.take (end_ - start + 1))
              Right block :: run (all |> List.skip (end_ - start + 1))
          (** conditional **
            * if-then-else *  |  * if then *   |  * if else *
              ...             |    ...         |    ...
  
negative.code:         let (trueBranch, instructions) = instructions |> List.splitAt (falseBranch - 3)
          let (_branch, falseBranch) = instructions |> List.splitAt 1
          ConditionalBlock {
              condition = invertCondition (getInstructions condition)
              trueBranch = scope pastLoop trueBranch
              falseBranch = scope pastLoop falseBranch
          }
  
  let private forLoop (pastLoop: int) (condition: int) (instructions: (int * ILInstruction * int option) list): Block =
      let (modifier, instructions) = instructions |> List.splitAt (condition - 1)
      let bodyStart =
          instructions
          |> List.findIndex (function (_, Br target, _) when target = pastLoop -> true | _ -> false) 
          |> (+) 1
      let (condition, body) = instructions |> List.splitAt bodyStart
      ForBlock {
          condition = invertCondition (getInstructions condition)
          modifier = getInstructions modifier
          body = scope pastLoop body
      }
  
  let private doWhileLoop (pastLoop: int) (condition: int) (instructions: (int * ILInstruction * int option) list): Block =
      let (instructions, conditionInstructions) = instructions |> List.splitAt condition
      let body =
          match instructions with
          | (start, instr, _) :: rest -> (start, instr, None) :: rest
          | _ -> impossible
      DoWhileBlock {
          condition = getInstructions conditionInstructions
          body = scope pastLoop body
      }
  
  let private whileLoop (pastLoop: int) (instructions: (int * ILInstruction * int option) list): Block =
      let (condition, instructions) = instructions |> List.splitAt 2
      let body =
          match instructions with
          | (start, instr, _) :: rest -> (start, instr, None) :: rest
          | _ -> impossible
      WhileBlock {
          condition = invertCondition (getInstructions condition)
          body = scope pastLoop body
      }
  
  let getInstructions: (int * ILInstruction * int option) list -> ILInstruction[] =
      Seq.map (fun (_, i, _) -> i)
      >> Seq.toArray
  
  let invertCondition (condition: ILInstruction[]): ILInstruction[] =
      let branch =
  