anchor.diff:          onEnterFunction: Env -> Stmt -> Env
       }
       with
  -        static member Create(reusableNames, allowOverloading, newName, onEnterFunction) = {
  +        static member Create(availableNames, allowOverloading, newName, onEnterFunction) = {
               varRenames = Map.empty
  -            nextID = 0
               funRenames = Map.empty
  -            reusableNames = reusableNames
  +            availableNames = availableNames
               allowOverloading = allowOverloading
               newName = newName
               onEnterFunction = onEnterFunction
  
positive.code:         let env = {env with varRenames = Map.add id newName env.varRenames}
          env, newName
  
      // TODO: expose this renaming strategy
      let optimizeFrequency env id =
          match env.reusableNames with
          | [] -> // create a new variable
              let newName = sprintf "%04d" env.nextID
              let env = {env with varRenames = Map.add id newName env.varRenames; nextID = env.nextID + 1}
              env, newName
          | e::l -> // reuse a variable name
              {env with varRenames = Map.add id e env.varRenames; reusableNames = l}, e
  
      // FIXME: handle 2-letter names
      let optimizeContext contextTable env id =
          let cid = char (1000 + int id)
          let newName = chooseIdent contextTable cid env.reusableNames
          let l = env.reusableNames |> List.filter (fun x -> x <> newName)
          {env with varRenames = Map.add id newName env.varRenames; reusableNames = l}, newName
  
      let dontRename env name =
          let names = env.reusableNames |> List.filter ((<>) name)
          {env with varRenames = env.varRenames.Add(name, name); reusableNames = names}
  
      let dontRenameList env names =
          let mutable env = env
  
negative.code:             | e -> e
          mapStmt (mapEnv collect id) block |> ignore
          let set = HashSet(Seq.choose env.varRenames.TryFind d)
          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}
  
      let rec renStmt env =
          let renOpt o = Option.map (renExpr env) o
  