anchor.diff:                                              Acc;
                                           _ ->
                                               case dict:find(Id, Map) of
  -                                                {ok, Value} -> Acc ++ [Value];
  -                                                error -> Acc
  +                                                {ok, {Host,Port}} ->
  +                                                    Acc ++ [{Host, Port}];
  +                                                error -> 
  +                                                    Acc
                                               end
                                       end
                                   end, [], Value),
  
positive.code:     end,
      file:close(TreeFile),
      {ok, S1#state{map=dict:new()}}.
  
  handle_call({set_myid, MyId}, _From, S0) ->
      {reply, ok, S0#state{myid=MyId}};
  
negative.code:                     tree_from_file(Device, Counter + 1, LeavesLeft - 1, Tree1, Path0)
              end
      end.
     
  path_from_tree_dict(Tree, Leaves) ->
      lists:foldl(fun({Id, Row}, Paths0) ->
                      case (Id >= Leaves) of
                          true ->
                              {OneHopPath, _} = lists:foldl(fun(Elem, {Acc, C}) ->
                                                              case Elem of
                                                                  -1 ->
                                                                      {Acc, C+1};
                                                                  _ ->
                                                                      {Acc ++ [C], C+1}
                                                               end
                                                             end, {[], 0}, Row),
                              dict:store(Id, OneHopPath, Paths0);
                          false ->
                              Paths0
                      end
                  end, dict:new(), dict:to_list(Tree)).
  
  is_leaf(Id, Total) ->
      Id<Total.
  