anchor.diff:        #endif
   
     let locals = 
  -    vars
  +    ctx.Locals
         |> Map.toSeq
         |> Seq.filter isLocal 
         |> Seq.map toParm
  
positive.code: (*Compiles a Ast.Node tree into a DLR Expression-tree*)
  let compileAst (env:Runtime.IEnvironment) (delegateType:ClrType) (closureType:ClrType) (scope:Ast.Scope) (ast:Ast.Node) =
  
    let vars, dynamicCount, dynamicArray = buildVarsMap scope
  
    let ctx = {
      Context.New with
        DynamicArray = dynamicArray
        DynamicCount = dynamicCount
        Closure = Dlr.Expr.param "~closure" closureType
        Scope = scope
        Builder = Compiler.ExprGen.builder
        TemporaryTypes = new SafeDict<string, ClrType>()
        Env = env
        Locals = vars
    }
  
    let initGlobals = Expr.assign ctx.Globals (Expr.field ctx.Environment "Globals")
    let initClosure = Expr.assign ctx.Closure (Expr.cast closureType (Expr.field ctx.Function "Closure"))
    let initDynamic = 
      if dynamicCount = 0 then Expr.empty
      else 
        Expr.assign ctx.DynamicArray (Expr.Array.newT<Runtime.Box> [Expr.constant dynamicCount])
  
    let body = 
      [ctx.Builder2 ast; Expr.labelExprT<Runtime.Box> ctx.Return]
        |> List.toSeq
        |> Seq.append [initGlobals; initClosure; initDynamic]
        #if DEBUG
        |> Seq.toArray
        |> fun x -> Expr.block x
        #endif
  
    let parms  = 
      vars
        |> Map.toSeq
        |> Seq.filter isParameter
        |> Seq.map toParm
  
negative.code:   let (|Proxied|Not|) (input:Ast.Local) =
      if Set.contains F.NeedProxy input.Flags then Proxied else Not
  
    let createVar (l:Ast.Local) =
      let clrTyp = Utils.Type.jsToClr l.UsedAs
      if l.ClosedOver 
  