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:             onEnterFunction = onEnterFunction
          }
  
          member this.Rename(oldName, newName) =
              let names = this.availableNames |> List.filter ((<>) newName)
              {this with varRenames = this.varRenames.Add(oldName, newName); availableNames = names}
  
          member this.Update(varRenames, funRenames, availableNames) = 
              {this with varRenames = varRenames; funRenames = funRenames; availableNames = availableNames}
  
  
            (* Contextual renaming *)
  
  