anchor.diff:    let astMap = new Dict<int, Ast.Types.Scope * Ast.Node>()
     let closureMap = new SafeDict<ClrType, int>()
     let delegateCache = new SafeDict<DelegateCell, System.Delegate>()
  +  let classId = 0
  +  let baseClass = new Class(0, new Dict<string, int>())
   
     //Implementation of IEnvironment.GetDelegate
     member x.GetDelegate (func:Function) delegateType types =
  
positive.code:       
    //Implementation of IEnvironment.AstMap
    member x.AstMap = astMap
    
    //Implementation of IEnvironment.GetClosureId
    member x.GetClosureId clrType = 
  
negative.code:     #endif
    end
  
  and [<AllowNullLiteral>] Class =
    val mutable ClassId : int
    val mutable SubClasses : SafeDict<string, Class>
    val mutable Variables : Dict<string, int>
  
    new(classId, variables) = {
      ClassId = classId
      Variables = variables
      SubClasses = new SafeDict<string, Class>();
    }
  
    member x.GetSubClass (varName:string, env:Environment) =
      (*Note: I hate interfacing with C# code*)
      let mutable cls:Class = null
      if x.SubClasses.TryGetValue (varName, ref cls) 
        then cls
        else
          let newVars = new Dict<string, int>(x.Variables)
          newVars.Add(varName, newVars.Count)
          let subClass = new Class(env.GetClassId(), newVars)
          if x.SubClasses.TryAdd(varName, subClass) 
            then subClass
            else x.GetSubClass(varName, env)
  
    member x.GetIndex (varName:string, index:int byref) =
      x.Variables.TryGetValue(varName, ref index)
  
  (*Class representing a Javascript native object*)
  and [<AllowNullLiteral>] Object =
    val mutable ClassId : int
    val mutable Class : Class
    val mutable Properties : Box array
  
    new(cls:Class) = {
      Class = cls
      ClassId = cls.ClassId
      Properties = Array.zeroCreate<Box> 4
    }
  
  