anchor.diff:      let private jumpSize = 5n
       
       [<AllowNullLiteral>]
  -    type Fragment<'a> =
  +    type private Fragment<'a> =
           class
               val mutable prev : Fragment<'a>
               val mutable next : Fragment<'a>
  
positive.code:                 f.Realloc(offset)
                  capacity <- f.Capacity
  
      type MyDelegate = delegate of int * int * int * int -> unit
  
  
      let report =
          MyDelegate (fun a b c d ->
              Log.start "cb"
              Log.line "a: %A" a
              Log.line "b: %A" b
              Log.line "c: %A" c
              Log.line "d: %A" d
              Log.stop()
          )
  
      let mutable all = 0L
      let sum =
          MyDelegate (fun a b c d ->
              all <- all + int64 d
          )
  
      let pReport = Marshal.PinDelegate(report)
      let pSum = Marshal.PinDelegate(sum)
  
      type AdaptiveProgram<'a> private(data : alist<'a>, isDifferential : bool, compileDelta : Option<'a> -> 'a -> IAssemblerStream -> unit) =
          inherit AdaptiveObject()
          let mutable disposed = false
          let manager = MemoryManager.createExecutable()
  
  
negative.code:             new(totalJumps, manager, tag) = { TotalJumpDistance = totalJumps; JumpDistance = 0L; Manager = manager; Tag = tag; Pointer = manager.Alloc(jumpSize); prev = null; next = null }
          end
  
      and private FragmentStream<'a>(f : Fragment<'a>) =
          inherit Stream()
  
          let mutable capacity = f.Capacity
  