anchor.diff:          let rec kill (t : TreeNode<'a>) =
               match t.children with
               | [] -> 
  -                AtomicOperation.ofList [t.original, { alloc = -1; active = -1; value = None }]
  +                match t.value with
  +                | Some _ -> AtomicOperation.ofList [t.original, { alloc = -1; active = -1; value = None }]
  +                | None -> AtomicOperation.empty
               | cs ->
  -                let mutable op = AtomicOperation.ofList [t.original, { alloc = -1; active = 0; value = None }]
  +                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>) =
  +        let rec snap (n : TaskTreeNode<'a>) : option<TreeNode<'a>> =
               match n.TryValue with
               | Some v -> 
                   let nc = n.Children
  
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:                         let startTime = time()
                          let (g,u) = node.GetData(ct, wantedInputs)
  
                          if g.FaceVertexCount <= 0 then
                              None
                          else
  
                              let cnt = 
                                  match Seq.tryHead u with
                                  | Some (KeyValue(_, (v : Array) )) -> v.Length
                                  | _ -> 1
  
                              let u = MapExt.add "TreeId" (Array.create cnt rootId :> System.Array) u
                              let loaded = GeometryPoolInstance.ofGeometry signature g u
                                  
                              let endTime = time()
                              addLoadTime node.DataSource node.DataSize (endTime - startTime)
  
                          
  
                              if not ct.IsCancellationRequested then
                                  let res = cont ct node loaded
                                  Some res
                              else
                                  raise <| OperationCanceledException()
                      )
  
                        
  