anchor.diff:              | e -> e
           mapStmt (mapEnv collect id) block |> ignore
           let set = HashSet(Seq.choose env.varRenames.TryFind d)
  -        let varRenames, availableNames = env.varRenames |> Map.partition (fun _ id -> id.Length > 2 || set.Contains id)
  -        let availableNames = availableNames |> Seq.filter (fun x -> not (List.exists ((=) x.Value) options.noRenamingList))
  -        let merged = [for i in availableNames -> i.Value] @ env.reusableNames |> Seq.distinct |> Seq.toList
  -        {env with varRenames=varRenames; reusableNames=merged}
  +        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
  
positive.code:         varRenames: Map<Ident, Ident>
          // Map from a new function name and function arity to the old name.
          funRenames: Map<Ident, Map<int, Ident>>
          // List of names that are still available after having been used before.
          reusableNames: Ident list
  
          // Used only for optimizeFrequency.
          nextID: int
  
          // Whether multiple functions can have the same name (but different arity).
          allowOverloading: bool
  
negative.code:         let env = {env with varRenames = Map.add id newName env.varRenames}
          env, newName
  
      // FIXME: handle 2-letter names
      let optimizeContext contextTable env id =
          let cid = char (1000 + int id)
          let newName = chooseIdent contextTable cid env.availableNames
          let l = env.availableNames |> List.filter (fun x -> x <> newName)
          {env with varRenames = Map.add id newName env.varRenames; availableNames = l}, newName
  
      let dontRename env name =
          let names = env.availableNames |> List.filter ((<>) name)
          {env with varRenames = env.varRenames.Add(name, name); availableNames = names}
  
      let dontRenameList env names =
          let mutable env = env
  