anchor.diff:              | TAdd _ | TRem _ | TCollapse _ -> true
               | _ -> false
   
  -    type TaskTree<'a>(mapping : CancellationToken -> ILodTreeNode -> Task<'a>, rootId : int) =
  +    type TaskTree<'a>(mapping : CancellationToken -> ILodTreeNode -> Task<option<'a>>, rootId : int) =
           static let cmp = Func<float * _, float * _, int>(fun (a,_) (b,_) -> compare a b)
           static let cmpNode = Func<float * ILodTreeNode, float * ILodTreeNode, int>(fun (a,_) (b,_) -> compare a b)
   
  
positive.code: 
              | None -> 
                  let create () =
                      let n = TaskTreeNode(state, mapping, rootId, t)
                      root <- Some n
                      n.Task.ContinueWith (fun (t : Task<_>) -> MVar.put state.trigger ()) |> ignore
  
  
negative.code:             | None, Some n ->
                  let qc = ref AtomicQueue.empty
                  n.children |> List.iter (fun c -> traverse2 qc None (Some c))
                  let op = AtomicQueue.toOperation !qc
  
                  match n.value with
                  | Some value ->
                      let op = 
                          op +
                          AtomicOperation.ofList [ n.original, Operation.Alloc(value, List.isEmpty n.children) ]
                           
                      lock q (fun () -> q := AtomicQueue.enqueue op !q) 
                  | None ->
                      lock q (fun () -> q := AtomicQueue.enqueue op !q) 
  
              | Some o, Some n ->
                  assert (Unchecked.equals o.original n.original)
                  match o.children, n.children with
  