anchor.diff:      static let EnqueueProbe = Symbol.Create "[Transaction] Enqueue"
       static let CommitProbe = Symbol.Create "[Transaction] Commit"
       static let emptyArray : IAdaptiveObject[] = Array.empty
  +    let mutable outputs = emptyArray
   
       // each thread may have its own running transaction
       static let running = new TrackAllThreadLocal<Option<Transaction>>(fun () -> None)
  
positive.code:                             if !depth > 1 then Transaction.RunningLevel - 1
                              else Transaction.RunningLevel
  
                          if level > maxAllowedLevel then
                              //printfn "%A tried to pull from level %A but has level %A" top.Id level top.Level
                              // all greater pulls would be from the future
                              raise <| LevelChangedException(this, level, !depth - 1)
                              
                          res <- r
  
  
negative.code: /// defines a base class for all adaptive objects implementing
  /// IAdaptiveObject.
  /// </summary>
  type AdaptiveObject =
      class
          [<DefaultValue>]
          static val mutable private time : IAdaptiveObject 
          val mutable public Id : int
          val mutable public OutOfDate : bool
          val mutable public Level : int 
          val mutable public Outputs : VolatileCollection<IAdaptiveObject>
  
          new() =
              { Id = newId(); OutOfDate = true; 
                Level = 0; Outputs = VolatileCollection<IAdaptiveObject>() }
  
      
          member inline this.evaluate (caller : IAdaptiveObject) (otherwise : Option<'a>) (f : unit -> 'a) =
              let depth = AdaptiveSystemState.curerntEvaluationDepth.Value
              let top = isNull caller && !depth = 0 && not Transaction.HasRunning
  
  
  