anchor.diff:  
                           | Patterns.Throw            -> yield Throw
                           | Patterns.EndFinally       -> yield EndFinally
  -                        | Patterns.Leave            -> yield Leave
  +                        | Patterns.Leave t          -> yield Leave(branchTargetIds.[t])
   
                           | Patterns.Switch targets ->
                               yield Switch(targets |> Array.map (fun t -> branchTargetIds.[t]))
  
positive.code:             locals      = Map.empty
              stack       = []
          } |> ignore
  
      let assembleDelegateInternal (tdel : Type) (m : list<Instruction>) : Delegate =
          let invoke = tdel.GetMethod("Invoke")
  
negative.code: 
              static member GetLocal (l : Local) : Asm<LocalBuilder> =
                  fun s ->
                      match Map.tryFind l s.locals with
                          | Some l -> s,l
                          | None ->
                              let res = s.generator.DeclareLocal(l.Type)
                              let s = { s with locals = Map.add l res s.locals }
                              s, res
  
              static member GetLabel (l : Label) : Asm<System.Reflection.Emit.Label> =
  