anchor.diff:          write : 'fragment -> array<'instruction> -> bool
           writeNext : 'fragment -> 'fragment -> int
           isNext : 'fragment -> 'fragment -> bool
  +        disassemble : 'fragment -> list<'instruction>
           dispose : unit -> unit
       }
   
  
positive.code:         member x.Next
              with get() : ManagedFragment<'a> = next
              and set (n : ManagedFragment<'a>) = next <- n
  
      let test (translate : float32 -> NativeCall) (compile : int -> float32) =
          native 6 |> wrapSimple translate (fun l -> new AdaptiveCode<_>([Mod.constant [compile l]]) :> IAdaptiveCode<_>)
  
      let managedDifferential (compileDelta : Option<'v> -> 'v -> IAdaptiveCode<'i -> unit>) () : FragmentHandler<'i, 'v, 'i -> unit, ManagedFragment<'i -> unit>> =
          let prolog = ManagedFragment [||]
  
negative.code:                 writeWatch.Restart()
                  for d in dirtySet do
                      if d.WriteContent x then
                          relinkSet.Add d.Prev |> ignore
  
  
                  relinkSet.UnionWith(fragments |> Seq.collect (fun (KeyValue(_,v)) -> v))
  
                  for d in relinkSet do
                      d.LinkNext x
  
  //                prolog.LinkNext x
  //                epilog.LinkPrev x
                  writeWatch.Stop()
  
                  if autoDefragmentation = 1 && relinkSet.Count > 0 && !handler.jumpDistance > 0 then
  