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:             state.AddRunning()
              let c = cancel.Value
              let s = c.Token.Register(fun _ -> state.RemoveRunning())
              (mapping c.Token original).ContinueWith(fun (t : Task<'a>) -> 
                  c.Cancel()
                  s.Dispose()
                  c.Dispose()
  
negative.code:         let rec kill (t : TreeNode<'a>) =
              match t.children with
              | [] -> 
                  match t.value with
                  | Some _ -> AtomicOperation.ofList [t.original, { alloc = -1; active = -1; value = None }]
                  | None -> AtomicOperation.empty
              | cs ->
                  let mutable op = 
                      match t.value with
                      | Some _ -> AtomicOperation.ofList [t.original, { alloc = -1; active = 0; value = None }]
                      | None -> AtomicOperation.empty
  
                  for c in cs do
                      op <- op + kill c
                  op
  
          let rec snap (n : TaskTreeNode<'a>) : option<TreeNode<'a>> =
              match n.TryValue with
              | Some v -> 
                  let nc = n.Children
  