anchor.diff:                  writeNext = fun prev next -> inner.writeNext prev next
                   isNext = fun prev frag -> inner.isNext prev frag
                   dispose = inner.dispose
  +                disassemble = fun f -> f |> inner.disassemble |> List.map backward
               }
       
  -    let wrapSimple (mapping : 'a -> 'b) (compile : 'v -> IAdaptiveCode<'a>) (newInner : unit -> FragmentHandler<'i, 'v, 'b, 'frag>) =
  +    let wrapSimple (mapping : 'a -> 'b) (backward : 'b -> 'a) (compile : 'v -> IAdaptiveCode<'a>) (newInner : unit -> FragmentHandler<'i, 'v, 'b, 'frag>) =
           fun () ->
               let inner = newInner()
               {
  
positive.code:             writeNext = fun prev next -> prev.Next <- next; 0
              isNext = fun prev frag -> prev.Next = frag
              dispose = fun () -> ()
          }
  
      let managedSimple (compile : 'v -> IAdaptiveCode<'i -> unit>) () =
  
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
  