anchor.diff:  %%% Internal functions
   %%%===================================================================
   
  --spec prepareDictionary([term()], dict:dict(), standard_io | string(), [atom()])
  +-spec prepare_dictionary([term()], dict:dict(), standard_io | string(), [atom()])
                          -> dict:dict().
  -prepareDictionary([], Dict, _Path, _Stats) ->
  +prepare_dictionary([], Dict, _Path, _Stats) ->
       Dict;
   
  -prepareDictionary([Key|Rest], Dict, Path, Stats) ->
  -    IslandPath = createDir(Path, length(Rest) + 1),
  -    NewDict = dict:store(Key, createFDs(IslandPath, dict:new(), Stats), Dict),
  -    prepareDictionary(Rest, NewDict, Path, Stats).
  +prepare_dictionary([Key|Rest], Dict, Path, Stats) ->
  +    IslandPath = create_dir(Path, length(Rest) + 1),
  +    NewDict = dict:store(Key, create_fds(IslandPath, dict:new(), Stats), Dict),
  +    prepare_dictionary(Rest, NewDict, Path, Stats).
   
   
  --spec createDir(standard_io | string(), pos_integer()) -> standard_io | string().
  -createDir(standard_io, _IslandsNr) ->
  +-spec create_dir(standard_io | string(), pos_integer()) -> standard_io | string().
  +create_dir(standard_io, _IslandsNr) ->
       standard_io;
   
  -createDir("standard_io", _IslandsNr) ->
  +create_dir("standard_io", _IslandsNr) ->
       standard_io;
   
  -createDir(Path, IslandsNr) ->
  +create_dir(Path, IslandsNr) ->
       NewPath = filename:join([Path, "island" ++ integer_to_list(IslandsNr)]),
       file:make_dir(NewPath),
       NewPath.
   
   
   %% @doc Creates a dictionary with stat names as keys and corresponding file descriptors
  --spec createFDs(standard_io | string(), dict:dict(), [atom()]) -> FDs :: dict:dict().
  -createFDs(standard_io, InitDict, Files) ->
  +-spec create_fds(standard_io | string(), dict:dict(), [atom()]) -> FDs :: dict:dict().
  +create_fds(standard_io, InitDict, Files) ->
       lists:foldl(fun(Atom, Dict) ->
                           dict:store(Atom, standard_io, Dict)
                   end, InitDict, Files);
   
  -createFDs(Path, InitDict, Files) ->
  +create_fds(Path, InitDict, Files) ->
       lists:foldl(fun(Atom, Dict) ->
                           Filename = atom_to_list(Atom) ++ ".txt",
                           {ok, Descriptor} = file:open(filename:join([Path, Filename]), [append, delayed_write, raw]),
  
positive.code:                      _Tuple ->
                           Counter
                   end,
      logIsland(Key, FDs, NewCounter, Funstats).
  
  
  -spec closeFiles(dict:dict()) -> any().
  closeFiles(Dict) ->
      [case X of
           {Id, FD} when is_atom(Id) -> file:close(FD);
           {_Id, D} -> [file:close(FD) || {_Stat, FD} <- dict:to_list(D)]
  
negative.code: handle_info(timer, St = #state{fds = FDs, counters = Counters, funstats = Funstats}) ->
      NewCounters = dict:map(fun(Key, CounterDict) ->
                                     FDDict = dict:fetch(Key, FDs),
                                     log_island(Key, dict:to_list(FDDict), CounterDict, Funstats)
                             end, Counters),
      {noreply, St#state{counters = NewCounters}, St#state.timeout};
  
  