anchor.diff:                  handler.run v
               )
   
  -        member x.Disassemble() = null
  +        member x.Disassemble() =
  +            let code = List()
  +            let mutable current = prolog
  +            while current <> epilog do
  +                if current <> prolog then
  +                    match current.Storage with
  +                        | None -> code.Add [||]
  +                        | Some s -> code.Add(handler.disassemble s |> List.toArray)
  +
  +                match current.Storage, current.Next.Storage with
  +                    | Some l, Some r -> 
  +                        if not (handler.isNext l r) then
  +                            failwith "bad pointers"
  +                    | _ -> ()
  +
  +                current <- current.Next
  +            code.ToArray()
   
           member x.Update caller = 
               x.EvaluateIfNeeded caller AdaptiveProgramStatistics.Zero (fun v ->
  
positive.code: 
              dispose = fun () ->
                  memory.Value.Dispose()
          }
  
      let nativeSimple (maxArgs : int) (compile : 'value -> IAdaptiveCode<NativeCall>) ()  =
  
negative.code: 
  
                  let createBetween (prev : Option<Fragment<'i, 'a, 'instruction, 'fragment>>) (v : 'a) (next : Option<Fragment<'i, 'a, 'instruction, 'fragment>>)  =
                      //let code = desc.compileDelta (Option.map DynamicFragment.tag prev) v (Option.map DynamicFragment.tag next)
                      let fragment = new Fragment<'i, 'a, 'instruction, 'fragment>(handler, v)
  
                      let l = 
                          match prev with 
                              | Some l -> l 
                              | None -> prolog
  
                      let r = 
                          match next with 
                              | Some r -> 
                                  if handler.compileNeedsPrev then recompileSet.Add r |> ignore
                                  r 
                              | None -> epilog
                      
                      relinkSet.Add l |> ignore
                      relinkSet.Add fragment |> ignore
  
                      r.Prev <- fragment
                      fragment.Prev <- l
  