anchor.diff:          string(chars.[first]) + string(chars.[second])
   
   let computeContextTable text =
  +    let contextTable = new HashMultiMap<(char*char), int>(HashIdentity.Structural)
       Seq.pairwise text |> Seq.iter (fun (prev, next) ->
           match contextTable.TryFind (prev, next) with
           | Some n -> contextTable.[(prev, next)] <- n + 1
           | None -> contextTable.[(prev, next)] <- 1
       )
  +    contextTable
       //let chars, n = Seq.maxBy snd [for pair in contextTable -> pair.Key, pair.Value]
       //printfn "max occ: %A -> %d" chars n
   
   // /!\ This function is a performance bottleneck.
  -let chooseIdent ident candidates =
  +let chooseIdent (contextTable: HashMultiMap<(char*char), int>) ident candidates =
       let allChars = [char 32 .. char 127] // printable chars
       let prevs = allChars |> Seq.choose (fun c ->
           match contextTable.TryFind (c, ident) with
  
positive.code:         let env = {env with map = Map.add name name env.map; reusable = re}
          doNotOverload env li
  
  let renameTopLevel li mode (identTable: string[]) =
      let idents = identTable |> Array.toList
                |> List.filter (fun x -> x.Length = 1)
                |> List.filter (fun x -> not <| List.exists ((=) x) forbiddenNames)
      let newId =
          match mode with
          | Unambiguous -> alwaysNewName
          | Frequency -> optimizeFrequency
          | Context -> optimizeContext
  
      let env = {
          map = Map.empty
          max = 0
          fct = Map.empty
          reusable = idents
          numberOfUsedIdents = ref 0
          allowOverloading = mode <> Unambiguous
          newId = newId
          enterFunction =
             if mode <> Unambiguous then shadowVariables else fun env _ -> env
      }
      // Rename top-level values first
      let env = doNotOverload env options.noRenamingList
      let env, li = renList env renTopLevelName li
  
negative.code: 
                                  (* ** Renamer ** *)
  
  let alwaysNewName (numberOfUsedIdents: int ref) env id =
      incr numberOfUsedIdents
      let newName = sprintf "%04d" !numberOfUsedIdents
      let env = {env with map = Map.add id newName env.map}
      env, newName
  
  // TODO: expose this renaming strategy
  let optimizeFrequency env id =
      match env.reusable with
      | [] -> // create a new variable
  