anchor.diff:      {reply, Reply, State};
   handle_call({lease_req, get_lease_path, Public}, _From, State) ->
       Reply = case p_get_lease(Public) of
  -                {ok, #lease{path = Path}} ->
  -                    {ok, Path};
  +                {ok, #lease{path = {Repo, Path}}} ->
  +                    {ok, <<Repo/binary, Path/binary>>};
                   Other ->
                       Other
               end,
  
positive.code:                                 {busy, RemainingTime};
                              %% The old lease is expired. Delete it and insert the new one
                              false ->
                                  mnesia:delete({lease, Path}),
                                  p_write_row(KeyId, Path, Public, Secret)
                          end;
                      %% No overlapping paths were found; just insert the new entry
                      _ ->
                          p_write_row(KeyId, Path, Public, Secret)
                  end
          end,
      {atomic, Result} = mnesia:sync_transaction(T),
  
negative.code:                 %% We filter out entries which don't overlap with Path
                  case lists:filter(AreOverlapping, mnesia:select(lease, MS)) of
                      %% An everlapping path was found
                      [#lease{path = ConflictingPath, time = Time} | _] ->
                          RemainingTime = MaxLeaseTime - (CurrentTime - Time),
                          case RemainingTime > 0 of
                              %% The old lease is still valid, return busy message
  