anchor.diff:          let varRenames, reusable = env.varRenames |> Map.partition (fun _ id -> id.Length > 2 || set.Contains id)
           let reusable = reusable |> Seq.filter (fun x -> not (List.exists ((=) x.Value) options.noRenamingList))
           let allAvailable = [for i in reusable -> i.Value] @ env.availableNames |> Seq.distinct |> Seq.toList
  -        {env with varRenames = varRenames; availableNames = allAvailable}
  +        env.Update(varRenames, env.funRenames, allAvailable)
   
       let rec renStmt env =
           let renOpt o = Option.map (renExpr env) o
  
positive.code:                 // overload an existing function name used with a different arity
                  let newName = res.Key
                  let funRenames = env.funRenames.Add (res.Key, res.Value.Add(nbArgs, id))
                  let env = {env with funRenames = funRenames; varRenames = env.varRenames.Add(id, newName)}
                  env, newName
              | _ ->
                  // find a new function name
                  let env, newName = env.newName env id
                  let funRenames = env.funRenames.Add (newName, Map.empty.Add(nbArgs, id))
                  let env = {env with funRenames = funRenames}
                  env, newName
  
      let renFctName env (f: FunctionType) =
  
negative.code: 
                                      (* ** Renamer ** *)
  
      let alwaysNewName (numberOfUsedIdents: int ref) (env: Env) id =
          incr numberOfUsedIdents
          let newName = sprintf "%04d" !numberOfUsedIdents
          env.Rename(id, newName), newName
  
      // FIXME: handle 2-letter names
      let optimizeContext contextTable env id =
          let cid = char (1000 + int id)
          let newName = chooseIdent contextTable cid env.availableNames
          env.Rename(id, newName), newName
  
      let dontRename (env: Env) name =
          env.Rename(name, name)
  
      let dontRenameList env names =
          let mutable env = env
  