anchor.diff:              for c, _ in prevs do
                   match contextTable.TryFind (c, firstLetter) with
                   | None -> ()
  -                | Some occ2 -> score <- score + occ2 // * occ
  +                | Some occ -> score <- score + occ
   
               for c, _ in nexts do
                   match contextTable.TryFind (lastLetter, c) with
                   | None -> ()
  -                | Some occ2 -> score <- score + occ2 // * occ
  +                | Some occ -> score <- score + occ
   
               if word.Length > 1 then
                   score <- score - 1000 // avoid long names if there are 1-letter names available
                   match contextTable.TryFind (firstLetter, lastLetter) with
                   | None -> ()
  -                | Some occ2 -> score <- score + occ2
  +                | Some occ -> score <- score + occ
   
               if score > fst best then best <- score, word
   
  
positive.code: 
                                      (* ** Renamer ** *)
  
      let alwaysNewName (numberOfUsedIdents: int ref) env id =
          incr numberOfUsedIdents
          let newName = sprintf "%04d" !numberOfUsedIdents
          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
  
negative.code:         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.Update(varRenames, env.funRenames, allAvailable)
  
      let rec renStmt env =
          let renOpt o = Option.map (renExpr env) o
  