anchor.diff:          il.Emit(OpCodes.Ldarg_2)
           il.Emit(OpCodes.Ldarg_3)
           il.Emit(OpCodes.Ldarg_S, 4uy)
  -        il.EmitCall(OpCodes.Call, rebuildMeth, null)
  +        il.Call(rebuildMeth, false)
           il.Emit(OpCodes.Ret)
   
           let newSelf = meth.CreateDelegate<FuncRef1<Dispatcher<'b, 'r>, obj[], obj, 'b, 'r, bool>>()
  
positive.code: 
  [<AutoOpen>]
  module private ``ILGenerator Extensions`` =
  
      type ILGenerator with
          member x.Ldc(value : nativeint) =
  
negative.code:                 if should.IsAssignableFrom is then ()
                  else failwith "bad dispatcher method"
  
     
          member x.InlineCall(meth : MethodInfo) =
              let code =
                  inlineCode.GetOrAdd(meth, fun meth ->
                      let code = Disassembler.disassemble meth
  
  
  
                      let parameters = meth.GetParameters() |> Array.map (fun p -> Local(p.ParameterType))
                      let this = 
                          if meth.IsStatic then None
                          else Some(Local(meth.DeclaringType))
  
                      let arg (i : int) =
                          match this with
                              | Some t ->
                                  if i = 0 then t
                                  else parameters.[i-1]
                              | _ ->
                                  parameters.[i]
  
              
                      let endLabel = Label()
  
                      let usedArgs = 
                          code.Body 
                              |> List.choose (function Ldarg a -> Some a | _ -> None)
                              |> Set.ofList
                              |> Set.map arg
  
                      let code =
                          [
                              for p in Array.rev parameters do
                                  if Set.contains p usedArgs then yield Stloc(p)
                                  else yield Pop
  
                              match this with
                                  | Some t -> 
                                      if Set.contains t usedArgs then yield Stloc(t)
                                      else yield Pop
                                  | _ -> ()
  
                              let mutable needsEndLabel = false
                              let body = List.toArray code.Body
                              for i in 0..body.Length-1 do
                                  match body.[i] with
                                      | Start | Nop -> ()
                                      | Ldarg a -> yield Ldloc (arg a)
                                      | Ret -> 
                                          if i <> body.Length-1 then 
                                              needsEndLabel <- true
                                              yield Jump(endLabel)
  
                                      | i -> 
                                          yield i
  
                              if needsEndLabel then
                                  yield Mark(endLabel)
                          ]
  
                      Log.start "inlining %A" meth
                      for i in code do
                          match i with
                              | Start | Nop -> ()
                              | _ -> Log.line "%A" i
                      Log.stop()
  
                      code
                  )
  
              Assembler.assembleTo x code
  
          member x.Call(meth : MethodInfo, ?tryInline : bool) =
              let tryInline = defaultArg tryInline false
              if tryInline then
                  x.InlineCall(meth)
              else 
                  if meth.IsVirtual then x.EmitCall(OpCodes.Callvirt, meth, null)
                  else x.EmitCall(OpCodes.Call, meth, null)
              
  
      type DynamicMethod with
          member x.CreateDelegate<'a>() =
  