anchor.diff:      type Leak(cnt : ref<int>) =
           do cnt := !cnt + 1
           override x.Finalize() = cnt := !cnt - 1
  +
           
       let leakCnt = ref 0
  +
  +    type LS = Leak * Ag.Scope * IMod<int>* int
   
       [<Semantic>]
       type LSemantics() =
  
positive.code:         GC.Collect()
          GC.WaitForPendingFinalizers()
  
          Console.ReadLine() |> ignore
          !leakCnt |> should equal 0 
  
          r.GetDelta() |> printfn "delta2=%A"
          printfn "c=%A" r.Content
  
  
          ()     
          
  //    [<EntryPoint>]
  //    let main args =
  
negative.code:             aset {
                  yield Leak leakCnt
              }
  
          member x.Flatten2(n : LNode) : aset<LS>=
              aset {
                  for i in n.Children do
                      let a : IMod<int> = n?SomeInhValue
                      let! ab = a
                      printfn "AB:%A" ab
                      yield! i?Flatten2()
              }
  
          member x.Flatten2(l : LLeaf) : aset<LS> =
              aset {
                  let vm : IMod<int> = l?SomeInhValue
                  let! v = vm
                  yield Leak leakCnt, Ag.getContext(), l?SomeInhValue, v
              }
  
          member x.SomeInhValue(r : Root<IL>) = r.Child?SomeInhValue <- Mod.init 1
  
      [<Test>]
      let ``[Ag] Leaky leaky test``() =
  