anchor.diff:      |> Seq.toList
       |> scope 0
   
  -let scope (pastLoop: int) (instructions: (int * ILInstruction * int option) list): List<Block> =
  +let private scope (pastLoop: int) (instructions: (int * ILInstruction * int option) list): List<Block> =
       let rec run: (int * ILInstruction * int option) list -> Either<ILInstruction, Block> list =
           function
           (** for loop **
  
positive.code:         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)
              trueBranch = scope pastLoop trueBranch
              falseBranch = scope pastLoop falseBranch
          }
  
  let forLoop (pastLoop: int) (condition: int) (afterLoop: 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) 
          |> (+) 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
          body = scope pastLoop body
      }
  
  let 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
          body = scope pastLoop body
      }
  
  let 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)
          body = scope pastLoop body
      }
  
  let invertCondition (condition: ILInstruction[]): ILInstruction[] =
      let branch =
  
negative.code:     | SequentialBlock of SequentialBlock
      | WhileBlock of WhileBlock
  
  (* Active patterns for parsing the input IL *)
  
  let (|Br|_|) (instr: ILInstruction) =
      match instr with
      | Branch b when b.type_ <> Unconditional -> Some (int b.target)
      | _ -> None
  
  let (|Jmp|_|) (instr: ILInstruction) =
      match instr with
      | Branch b when b.type_ = Unconditional -> Some (int b.target)
      | _ -> None
  
  let buildFlowGraph (il: IReadOnlyList<ILInstruction>): List<Block> =
      let branchTargets = Array.create il.Count None
      for instr in il |> Seq.indexed do
          match instr with
          | address, Branch { target = target } ->
              branchTargets.[int target] <- Some address
          | _ -> ()
      Seq.zip il branchTargets
      |> Seq.indexed
  