anchor.diff:                                    pred -> succ;
                                     succ -> pred
                                 end,
  +            NodePid = node:pidX(Node),
               Msg = {move, slide_abort, PredOrSuccOther, SlideOpId, Reason},
               send_no_slide(NodePid, Msg, 0);
           _ -> ok
  
positive.code:                             State2 = dht_node_state:set_slide(State1, PredOrSucc, null),
                              MyNode = dht_node_state:get(State2, node),
                              TargetNode = dht_node_state:get(State2, PredOrSucc),
                              MoveFullId = slide_op:get_id(SlideOp1),
                              Tag = slide_op:get_tag(SlideOp1),
                              SourcePid = slide_op:get_source_pid(SlideOp1),
                              OtherMTE = slide_op:get_other_max_entries(SlideOp1),
                              Command = check_setup_slide_not_found(
                                          State2, Type, MyNode, TargetNode, NewTargetId),
                              case Command of
                                  {ok, {slide, _, 'rcv'} = NewType} ->
                                      Neighbors = dht_node_state:get(State2, neighbors),
                                      % continued slide with pred/succ, receive data
                                      % -> reserve slide_op with pred/succ
                                      NewMoveFullId = uid:get_global_uid(),
                                      fd:subscribe([node:pidX(TargetNode)], {move, NewMoveFullId}),
                                      NextSlideOp =
                                          slide_op:new_slide(
                                            NewMoveFullId, NewType, NewTargetId, Tag,
                                            SourcePid, OtherMTE, {none}, Neighbors),
                                      NextSlideOp1 = slide_op:set_phase(NextSlideOp, wait_for_data),
                                      notify_other_in_delta_ack(MoveFullId, NextSlideOp1, State2);
                                  {abort, Reason, _Type} -> % note: the type returned here is the same as Type 
                                      abort_slide(State2, TargetNode, MoveFullId, null, SourcePid, Tag,
                                                  Type, Reason, true)
                              end;
                          {jump, continue, _NewTargetId} ->
                              % TODO
                              send_delta_ack(SlideOp1),
                              finish_slide(State1, SlideOp1);
                          {leave, continue} ->
                              % TODO
                              send_delta_ack(SlideOp1),
                              finish_slide(State1, SlideOp1)
                      end;
                  _ ->
                      % note: send delta_ack and a potential new slide setup in two
                      %       messages so new op suggestions also have a chance to be
                      %       setup instead
                      send_delta_ack(SlideOp1),
                      State2 = finish_slide(State1, SlideOp1),
                      continue_with_next_op(State2, SlideOp1)
              end;
  
negative.code:                   NotifyNode::boolean()) -> dht_node_state:state().
  abort_slide(State, Node, SlideOpId, _Phase, SourcePid, Tag, Type, Reason, NotifyNode) ->
      PredOrSucc = slide_op:get_predORsucc(Type),
      % abort slide on the (other) node:
      case NotifyNode of
          true ->
  