anchor.diff:  
     member x.Update (obj:Object, env:Environment) =
       let box = obj.Get(x, env)
  -    if x.ClassId <> obj.ClassId then
  +
  +    //We found what we were looking for
  +    if x.ClassId = obj.ClassId then
  +      box
  +
  +    //If not...
  +    else
  +      //Check if a prototype has it
         let index, classIds = obj.PrototypeHas x.Name
   
  +      //The constants -4 and -2 here could be anything
  +      //They are used to differ types of configurations
  +      //from eachother in the lambdaCache SafeDict key
         let throwToggle = if x.ThrowOnMissing then -4 else -2
         let wasFoundToggle = if index < 0 then -4 else -2
   
  +      //Build key and try to find an already cached crawler
         let cacheKey = throwToggle :: wasFoundToggle :: obj.ClassId :: classIds
         let success, cached = lambdaCache.TryGetValue cacheKey
   
         let crawler = 
  -        if success then cached
  +        //If we found a cached crawler use it
  +        if success then cached 
  +
  +        //Else build a new one
           else
  +          //Parameters
             let cache = Expr.paramT<GetCache> "~cache"
             let object' = Expr.paramT<Object> "~object"
             let env' = Expr.paramT<Environment> "~env"
  
positive.code:               )
              )
  
            let body = 
              if index >= 0 then
                (Expr.access 
                  (Expr.field (crawlPrototypeChain object' (classIds.Length)) "Properties") 
                  [Expr.field cache "index"]
                )
              else
                (Expr.field env' "UndefinedBox")
  
            let lambda = 
              (Expr.lambdaT<System.Func<GetCache, Object, Environment, Box>> 
                [cache; object'; env']
                (Expr.ternary 
                  (conditions)
                  (body)
                  (Expr.call cache "Update" [object'; env'])
                )
              )
  
            let compiled = lambda.Compile()
            if lambdaCache.TryAdd(cacheKey, compiled) 
              then compiled
              else lambdaCache.[cacheKey]
  
        x.Index   <- index
        x.ClassId <- -1 //This makes sure we will hit the crawler next time
        
        x.Crawler <- crawler
        x.Crawler.Invoke(x, obj, env)
      else
        box
  
    static member New(name:string) =
      let cache = Dlr.Expr.constant (new GetCache(name))
  
negative.code:   
      (*==== Inline cache for property get operations ====*)
  and GetCache(name) as x =
  
    [<DefaultValue>] val mutable Name : string
    [<DefaultValue>] val mutable ClassId : int
    [<DefaultValue>] val mutable Index : int
  