anchor.diff:          let operand = pair.Key
           finalizeType t operand
       for pair in t.coalescedIds |> Seq.rev do
  -        for item in traverse blocks do
  -        match item with
  -        | Right instr ->
  -            match instr with
  -            | Negate unary
  -            | Not unary
  -            | Call unary
  -            | Return unary ->
  -                if unary.operandId = pair.Key then
  -                    unary.operandId <- pair.Value
  -            | Add binary
  -            | And binary
  -            | Compare binary
  -            | Divide binary
  -            | Multiply binary
  -            | Or binary
  -            | ShiftLeft binary
  -            | ShiftRight binary
  -            | Subtract binary
  -            | Xor binary
  -            | Assign binary ->
  -                if binary.leftId = pair.Key then
  -                    binary.leftId <- pair.Value
  -                if binary.rightId = pair.Key then
  -                    binary.rightId <- pair.Value
  -            | Break
  -            | Branch _
  -            | Nop ->
  -                ()
  -        | _ -> ()
  +        blocks
  +        |> convert
  +            (fun _ -> ())
  +            (fun instr ->
  +                match instr with
  +                | Negate unary
  +                | Not unary
  +                | Call unary
  +                | Return unary ->
  +                    if unary.operandId = pair.Key then
  +                        unary.operandId <- pair.Value
  +                | Add binary
  +                | And binary
  +                | Compare binary
  +                | Divide binary
  +                | Multiply binary
  +                | Or binary
  +                | ShiftLeft binary
  +                | ShiftRight binary
  +                | Subtract binary
  +                | Xor binary
  +                | Assign binary ->
  +                    if binary.leftId = pair.Key then
  +                        binary.leftId <- pair.Value
  +                    if binary.rightId = pair.Key then
  +                        binary.rightId <- pair.Value
  +                | Break
  +                | Branch _
  +                | Nop ->
  +                    ()
  +                instr
  +            )
  +        |> ignore
       {
           parameterTypes = parameterTypes
           localTypes = localTypes
  
positive.code:         coalescedIds = new SortedDictionary<int, int>()
          nextId = 0
      }
      for item in traverse blocks do
          match item with
          | Left marker ->
              match marker with
              | PushIds ->
                  let copy = t.currentIds.ToDictionary((fun p -> p.Key), (fun p -> p.Value))
  
negative.code:                             t.sameIds.Add(value, ids)
                      | Some _ -> () // skip unchanged ids
                      | None -> t.currentIds.Add(pair.Key, pair.Value)
          )
          (fun instr ->
              match instr with
              | Negate unary
              | Not unary ->
                  unary.operandId <- getCurrentId t unary.operand
                  instr
              | Add binary
              | And binary
              | Compare binary
  