anchor.diff:          let (trueBranch, instructions) = instructions |> List.splitAt (falseBranch - 3)
           let (_branch, falseBranch) = instructions |> List.splitAt 1
           ConditionalBlock {
  -            condition = invertCondition (condition |> Seq.map (fun (_, i, _) -> i) |> Seq.toArray)
  +            condition = invertCondition (getInstructions condition)
               trueBranch = scope pastLoop trueBranch
               falseBranch = scope pastLoop falseBranch
           }
   
  -let forLoop (pastLoop: int) (condition: int) (afterLoop: int) (instructions: (int * ILInstruction * int option) list): Block =
  +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 (_, Branch { target = t }, _) when (int)t = afterLoop -> true | _ -> false) 
  +        |> List.findIndex (function (_, Br target, _) when target = pastLoop -> true | _ -> false) 
           |> (+) 1
       let (condition, body) = instructions |> List.splitAt bodyStart
       ForBlock {
  -        condition = invertCondition (condition |> Seq.map (fun (_, i, _) -> i) |> Seq.toArray)
  -        modifier = modifier |> Seq.map (fun (_, i, _) -> i) |> Seq.toArray
  +        condition = invertCondition (getInstructions condition)
  +        modifier = getInstructions modifier
           body = scope pastLoop body
       }
   
  -let doWhileLoop (pastLoop: int) (condition: int) (instructions: (int * ILInstruction * int option) list): Block =
  +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 = conditionInstructions |> Seq.map (fun (_, i, _) -> i) |> Seq.toArray
  +        condition = getInstructions conditionInstructions
           body = scope pastLoop body
       }
   
  -let whileLoop (pastLoop: int) (instructions: (int * ILInstruction * int option) list): Block =
  +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 (condition |> Seq.map (fun (_, i, _) -> i) |> Seq.toArray)
  +        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 =
  
positive.code:     condition.[condition.Length - 1] <- branch
      condition
  
  let invert (type_: BranchType): BranchType =
      match type_ with
      | Equal -> NotEqual
      | NotEqual -> Equal
  
negative.code:             END:                             |    ...
              ...
          *)
          | ((start, _, _) :: (_, Br falseBranch, _) :: _) as all ->
              let end_ =
                  match all |> List.skip (falseBranch - start - 1) with
                  | (_, Jmp end_, _) :: _ when end_ <> pastLoop -> end_
                  | _ -> falseBranch // no else case
              let (ifThenElse, rest) = all |> List.splitAt (end_ - start)
              let block = conditional pastLoop (falseBranch - start) ifThenElse
              Right block :: run rest
          (** sequential flow **
              ...
          *)
          | (_, Jmp target, _) :: rest when target = pastLoop ->
              Left Break :: run rest
          | (_, instr, _) :: rest ->
              Left instr :: run rest
  