anchor.diff:          }
   
       let managedSimple (compile : 'v -> IAdaptiveCode<'i -> unit>) () =
  -        { managedOptimized (fun _ v -> compile v) () with compileNeedsPrev = false }
  +        { managedDifferential (fun _ v -> compile v) () with compileNeedsPrev = false }
   
   module AdaptiveProgram =
       
       let nativeDifferential (maxArgs : int) (comparer : IComparer<'k>) (compileDelta : Option<'v> -> 'v -> IAdaptiveCode<NativeCall>) (input : aset<'k * 'v>) =
  -        new GenericProgram.Program<_,_,_,_,_>(input, comparer, FragmentHandler.nativeOptimized maxArgs compileDelta) :> IAdaptiveProgram<'i>
  +        new GenericProgram.Program<_,_,_,_,_>(input, comparer, FragmentHandler.nativeDifferential maxArgs compileDelta) :> IAdaptiveProgram<'i>
   
       let nativeSimple (maxArgs : int) (comparer : IComparer<'k>) (compile : 'v -> IAdaptiveCode<NativeCall>) (input : aset<'k * 'v>) =
  -        new GenericProgram.Program<_,_,_,_,_>(input, comparer, FragmentHandler.nativeUnoptimized maxArgs compile) :> IAdaptiveProgram<'i>
  +        new GenericProgram.Program<_,_,_,_,_>(input, comparer, FragmentHandler.nativeSimple maxArgs compile) :> IAdaptiveProgram<'i>
   
       let managedDifferential (comparer : IComparer<'k>) (compileDelta : Option<'v> -> 'v -> IAdaptiveCode<_>) (input : aset<'k * 'v>) =
  -        new GenericProgram.Program<_,_,_,_,_>(input, comparer, FragmentHandler.managedOptimized compileDelta) :> IAdaptiveProgram<'i>
  +        new GenericProgram.Program<_,_,_,_,_>(input, comparer, FragmentHandler.managedDifferential compileDelta) :> IAdaptiveProgram<'i>
   
       let managedSimple (comparer : IComparer<'k>) (compile : 'v -> IAdaptiveCode<_>) (input : aset<'k * 'v>) =
           new GenericProgram.Program<_,_,_,_,_>(input, comparer, FragmentHandler.managedSimple compile) :> IAdaptiveProgram<'i>
  
positive.code:                 memory.Value.Dispose()
          }
  
      let nativeUnoptimized (maxArgs : int) (compile : 'value -> IAdaptiveCode<NativeCall>) ()  =
          let desc = nativeOptimized maxArgs (fun _ v -> compile v) ()
          { desc with compileNeedsPrev = false }
  
  
  
      [<AllowNullLiteral>]
  
negative.code: 
  
  
      let nativeDifferential (maxArgs : int) (compileDelta : Option<'value> -> 'value -> IAdaptiveCode<NativeCall>) () : FragmentHandler<'i, 'value, NativeCall, CodeFragment>=
          
          let dynamicArgs =
              if typeof<'i> = typeof<unit> then 0
  