anchor.diff:                    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 ->
  +            PredOrSuccOther = case PredOrSucc of
  +                                  pred -> succ;
  +                                  succ -> pred
  +                              end,
               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
  +        true -> make_slide_leave(State);
  +        _    -> State
       end.
   
   %% @doc Creates a slide with the node's successor or predecessor. TargetId will
  
positive.code:                 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.
  
  %% @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
  
negative.code:     rm_loop:unsubscribe(self(), RMSubscrTag),
      State1 = dht_node_state:rm_db_range(State, slide_op:get_interval(SlideOp1)),
      State2 = dht_node_state:rm_msg_fwd(State1, slide_op:get_interval(SlideOp1)),
      % set a 'null' slide_op if there was an old one with the given ID
      Type = slide_op:get_type(SlideOp1),
      PredOrSucc = slide_op:get_predORsucc(Type),
      State3 = dht_node_state:set_slide(State2, PredOrSucc, null),
      NewDB = ?DB:stop_record_changes(dht_node_state:get(State3, db),
                                      slide_op:get_interval(SlideOp)),
      State4 = dht_node_state:set_db(State3, NewDB),
      abort_slide(State4, slide_op:get_node(SlideOp1), slide_op:get_id(SlideOp1),
                  slide_op:get_phase(SlideOp1),
                  slide_op:get_source_pid(SlideOp1), slide_op:get_tag(SlideOp1),
                  Type, Reason, NotifyNode).
  
  %% @doc Like abort_slide/5 but does not need a slide operation in order to
  %%      work. Note: prefer using abort_slide/5 when a slide operation is
  