anchor.diff:          Some args.[n]
       | _ -> None
   
  -//-------------------------------------------------------------------------
  -// Optimize/analyze a for-loop
  -//------------------------------------------------------------------------- 
  -
  +/// Optimize/analyze a for-loop
   and OptimizeFastIntegerForLoop cenv env (spStart, v, e1, dir, e2, e3, m) =
  -    let e1', e1info = OptimizeExpr cenv env e1 
  -    let e2', e2info = OptimizeExpr cenv env e2 
  +    let e1R, e1info = OptimizeExpr cenv env e1 
  +    let e2R, e2info = OptimizeExpr cenv env e2 
       let env = BindInternalValToUnknown cenv v env 
  -    let e3', e3info = OptimizeExpr cenv env e3 
  +    let e3R, e3info = OptimizeExpr cenv env e3 
       // Try to replace F#-style loops with C# style loops that recompute their bounds but which are compiled more efficiently by the JITs, e.g.
       //  F#  "for x = 0 to arr.Length - 1 do ..." --> C# "for (int x = 0; x < arr.Length; x++) { ... }"
       //  F#  "for x = 0 to 10 do ..." --> C# "for (int x = 0; x < 11; x++) { ... }"
  -    let e2', dir = 
  -        match dir, e2' with 
  +    let e2R, dir = 
  +        match dir, e2R with 
           // detect upwards for loops with bounds of the form "arr.Length - 1" and convert them to a C#-style for loop
           | FSharpForLoopUp, Expr.Op(TOp.ILAsm([ (AI_sub | AI_sub_ovf)], _), _, [Expr.Op(TOp.ILAsm([ I_ldlen; (AI_conv DT_I4)], _), _, [arre], _); Expr.Const(Const.Int32 1, _, _)], _) 
                     when not (snd(OptimizeExpr cenv env arre)).HasEffect -> 
   
  -            mkLdlen cenv.g (e2'.Range) arre, CSharpForLoopUp
  +            mkLdlen cenv.g (e2R.Range) arre, CSharpForLoopUp
   
           // detect upwards for loops with constant bounds, but not MaxValue!
           | FSharpForLoopUp, Expr.Const(Const.Int32 n, _, _) 
                     when n < System.Int32.MaxValue -> 
  -            mkIncr cenv.g (e2'.Range) e2', CSharpForLoopUp
  +            mkIncr cenv.g (e2R.Range) e2R, CSharpForLoopUp
   
           | _ ->
  -            e2', dir
  +            e2R, dir
    
       let einfos = [e1info;e2info;e3info] 
       let eff = OrEffects einfos 
  
positive.code:     let rec abstractModulInfo (ss:ModuleInfo) =
           { ModuleOrNamespaceInfos = NameMap.map (Lazy.force >> abstractModulInfo >> notlazy) ss.ModuleOrNamespaceInfos
             ValInfos =  ss.ValInfos.Filter (fun (v, _) -> v.MustInline) }
      and abstractLazyModulInfo ss = ss |> Lazy.force |> abstractModulInfo |> notlazy
        
      abstractLazyModulInfo
  
  
  //-------------------------------------------------------------------------
  // Hide information because of a "let ... in ..." or "let rec  ... in ... "
  //------------------------------------------------------------------------- 
  
  let AbstractExprInfoByVars (boundVars:Val list, boundTyVars) ivalue =
    // Module and member bindings can be skipped when checking abstraction, since abstraction of these values has already been done when 
    // we hit the end of the module and called AbstractLazyModulInfoByHiding. If we don't skip these then we end up quadtratically retraversing  
  
negative.code:     methRef.ReturnType.BasicQualifiedName = "System.String" &&
      methRef.ArgTypes.Length = 1 && methRef.ArgTypes.Head.BasicQualifiedName = "System.String[]"
      
  /// Optimize/analyze an expression
  let rec OptimizeExpr cenv (env:IncrementalOptimizationEnv) expr =
  
      // Eliminate subsumption coercions for functions. This must be done post-typechecking because we need
  