anchor.diff:      #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() = {
  +  new(cls:Class) = {
  +    Class = cls
  +    ClassId = cls.ClassId
       Properties = Array.zeroCreate<Box> 4
     }
   
  
positive.code:   let astMap = new Dict<int, Ast.Types.Scope * Ast.Node>()
    let closureMap = new SafeDict<ClrType, int>()
    let delegateCache = new SafeDict<DelegateCell, System.Delegate>()
  
    //Implementation of IEnvironment.GetDelegate
    member x.GetDelegate (func:Function) delegateType types =
  
negative.code:       then id
        else closureMap.GetOrAdd(clrType, closureMap.Count)
  
    member x.GetClassId () = 
      System.Threading.Interlocked.Increment(ref classId) 
  
    //Static
    static member Create sa eg =
      let env = new Environment(sa, eg)
      env.Globals <- new Object(env.BaseClass)
      env
  
  and [<StructLayout(LayoutKind.Explicit)>] Box =
  