anchor.diff:                  Tag::any(), SourcePid::comm:erl_local_pid() | null)
       -> dht_node_state:state().
   make_jump(State, TargetId, Tag, SourcePid) ->
  -    % check whether the operation is a slide_succ -> if so, do that instead
  -    % (check here, although a check is in setup_slide_with2_not_found - this
  -    % avoids going through make_slide from inside setup_slide_with2_not_found
  -    % again)
  -    case dht_node_state:is_responsible(TargetId, State) orelse
  -             intervals:in(TargetId, dht_node_state:get(State, succ_range)) of
  -        true ->
  -            make_slide(State, succ, TargetId, Tag, SourcePid);
  -        _ ->
  -            MoveFullId = util:get_global_uid(),
  -            MyNode = dht_node_state:get(State, node),
  -            TargetNode = dht_node_state:get(State, succ),
  -            log:log(info, "[ Node ~.0p ] starting jump (succ: ~.0p, TargetId: ~.0p)~n",
  -                    [MyNode, TargetNode, TargetId]),
  -            setup_slide_with(State, {jump, 'send'},
  -                             MoveFullId, MyNode, TargetNode, TargetId, Tag,
  -                             get_max_transport_bytes(), SourcePid, true)
  -    end.
  +    MoveFullId = util:get_global_uid(),
  +    MyNode = dht_node_state:get(State, node),
  +    TargetNode = dht_node_state:get(State, succ),
  +    log:log(info, "[ Node ~.0p ] starting jump (succ: ~.0p, TargetId: ~.0p)~n",
  +            [MyNode, TargetNode, TargetId]),
  +    setup_slide(State, {jump, 'send'},
  +                MoveFullId, MyNode, TargetNode, TargetId, Tag,
  +                get_max_transport_bytes(), SourcePid, true).
   
   %% @doc Creates a slide that will move all data to the successor and leave the
   %%      ring. Note: Will re-try (forever) to successfully start a leaving slide
  
positive.code:                   NotifyNode::boolean()) -> dht_node_state:state().
  abort_slide(State, Node, SlideOpId, Phase, SourcePid, Tag, Type, Reason, NotifyNode) ->
      PredOrSucc = slide_op:get_predORsucc(Type),
      PredOrSuccOther = case PredOrSucc of
                            pred -> succ;
                            succ -> pred
                        end,
      % abort slide on the (other) node:
      case NotifyNode of
          true ->
              comm:send(node:pidX(Node),
                        {move, slide_abort, PredOrSuccOther, SlideOpId, Reason});
          _ -> ok
      end,
      notify_source_pid(SourcePid, {move, result, Tag, Reason}),
      % set a 'null' slide_op if there was an old one with the given ID
      State2 =
          case dht_node_state:get_slide_op(State, SlideOpId) of
              not_found -> State;
              {PredOrSucc, _} ->
                  State1 = dht_node_state:set_slide(State, PredOrSucc, null),
                  dht_node_state:set_db(State1, ?DB:stop_record_changes(
                                          dht_node_state:get(State1, db)))
          end,
      % re-start a leaving slide on the leaving node if it hasn't left the ring yet:
      case slide_op:is_leave(Type, 'send') andalso
               not slide_op:is_jump(Type) andalso
               lists:member(Phase, [null, wait_for_succ_ack]) of
          true -> make_slide_leave(State2);
          _    -> State2
      end.
  
  %% @doc Creates a slide with the node's successor or predecessor. TargetId will
  
negative.code: % notification from predecessor/successor that it wants to slide with our node
  process_move_msg({move, slide, OtherType, MoveFullId, OtherNode,
                    OtherTargetNode, TargetId, Tag, MaxTransportBytes}, State) ->
      setup_slide(State, slide_op:other_type_to_my_type(OtherType), MoveFullId,
                  OtherTargetNode, OtherNode, TargetId, Tag, MaxTransportBytes,
                  null, false);
  
  % notification from pred/succ that he could not aggree on a slide with us
  process_move_msg({move, slide_abort, PredOrSucc, MoveFullId, Reason}, State) ->
  