anchor.diff:                  memory.Value.Dispose()
           }
   
  -    let nativeUnoptimized (maxArgs : int) (compile : 'value -> IAdaptiveCode<NativeCall>) ()  =
  -        let desc = nativeOptimized maxArgs (fun _ v -> compile v) ()
  +    let nativeSimple (maxArgs : int) (compile : 'value -> IAdaptiveCode<NativeCall>) ()  =
  +        let desc = nativeDifferential maxArgs (fun _ v -> compile v) ()
           { desc with compileNeedsPrev = false }
   
  +    let native (maxArgs : int) () =
  +        nativeDifferential maxArgs (fun _ _ -> failwith "no compileDelta given") ()
  +
  +    let warpDifferential (mapping : 'a -> 'b) (compile : Option<'v> -> 'v -> IAdaptiveCode<'a>) (newInner : unit -> FragmentHandler<'i, 'v, 'b, 'frag>) =
  +        fun () ->
  +            let inner = newInner()
  +            {
  +                compileNeedsPrev = true
  +                nativeCallCount = inner.nativeCallCount
  +                jumpDistance = inner.jumpDistance
  +                prolog = inner.prolog
  +                epilog = inner.epilog
  +                compileDelta = compile
  +                startDefragmentation = inner.startDefragmentation
  +                run = inner.run
  +                memorySize = inner.memorySize
  +                alloc = fun code -> inner.alloc(code |> Array.map mapping)
  +                free = ignore
  +                write = fun frag code -> inner.write frag (code |> Array.map mapping)
  +                writeNext = fun prev next -> inner.writeNext prev next
  +                isNext = fun prev frag -> inner.isNext prev frag
  +                dispose = inner.dispose
  +            }
  +    
  +    let wrapSimple (mapping : 'a -> 'b) (compile : 'v -> IAdaptiveCode<'a>) (newInner : unit -> FragmentHandler<'i, 'v, 'b, 'frag>) =
  +        fun () ->
  +            let inner = newInner()
  +            {
  +                compileNeedsPrev = false
  +                nativeCallCount = inner.nativeCallCount
  +                jumpDistance = inner.jumpDistance
  +                prolog = inner.prolog
  +                epilog = inner.epilog
  +                compileDelta = fun _ v -> compile v
  +                startDefragmentation = inner.startDefragmentation
  +                run = inner.run
  +                memorySize = inner.memorySize
  +                alloc = fun code -> inner.alloc(code |> Array.map mapping)
  +                free = ignore
  +                write = fun frag code -> inner.write frag (code |> Array.map mapping)
  +                writeNext = fun prev next -> inner.writeNext prev next
  +                isNext = fun prev frag -> inner.isNext prev frag
  +                dispose = inner.dispose
  +            }
   
   
       [<AllowNullLiteral>]
  
positive.code:         isNext : 'fragment -> 'fragment -> bool
          dispose : unit -> unit
      }
  
  module internal GenericProgram =
  
  
negative.code:     abstract member Next : IFragment<'store>
      abstract member JumpDistance : int with get, set
  
  
  type FragmentHandler<'i, 'value, 'instruction, 'fragment> =
      {
          compileNeedsPrev : bool
  