anchor.diff:                              % slide with pred, send data
                               State1 = dht_node_state:add_db_range(
                                          State, slide_op:get_interval(SlideOp)),
  -                            notify_other_slide(pred, SlideOp, State1);
  +                            notify_other_slide(SlideOp, State1);
                           'send' when TargetIdInRange andalso PredOrSucc =:= succ ->
                               % slide with succ, send data
                               case First of
  -                                true -> notify_other_slide(succ, SlideOp, State);
  +                                true -> notify_other_slide(SlideOp, State);
                                   _    ->
                                       State1 = dht_node_state:add_db_range(
                                                  State, slide_op:get_interval(SlideOp)),
  
positive.code:                 case (slide_op:get_timeouts(SlideOp) < get_notify_pred_retries()) of
                      true ->
                          NewSlideOp = slide_op:inc_timeouts(SlideOp),
                          notify_other_slide(pred, NewSlideOp, State);
                      _ ->
                          % if the message was received by pred, it will itself run
                          % into a timeout since we do not reply to it anymore
  
negative.code: %%      correct, i.e. its target node is still the node's successor. No timer
  %%      should have been set on NewSlideOp. Will also set the appropriate
  %%      slide_phase and update the slide op in the dht_node.
  -spec notify_other_slide(NewSlideOp::slide_op:slide_op(), State::dht_node_state:state()) -> dht_node_state:state().
  notify_other_slide(NewSlideOp, State) ->
      Type = slide_op:get_type(NewSlideOp),
      PredOrSucc = slide_op:get_predORsucc(Type),
      OtherNode = dht_node_state:get(State, PredOrSucc),
      SlOpNodePid = slide_op:get_node(NewSlideOp),
      case node:same_process(OtherNode, SlOpNodePid) of
          true ->
              {Timeout_ms, Timeout_msgtag, NewPhase} =
                  case PredOrSucc of
                      succ -> {get_notify_succ_timeout(),
                               notify_succ_timeout,
                               wait_for_succ_ack};
                      pred ->
                          SendOrReceive = slide_op:get_sendORreceive(Type),
                          case SendOrReceive of
                              'rcv'  -> {get_notify_pred_timeout(),
                                         notify_pred_timeout,
                                         wait_for_data};
                              'send' -> {get_notify_pred_timeout(),
                                         notify_pred_timeout,
                                         wait_for_req_data}
                          end
                  end,
              SlideOp = slide_op:set_timer(NewSlideOp, Timeout_ms,
                                           {move, Timeout_msgtag, slide_op:get_id(NewSlideOp)}),
              comm:send(SlOpNodePid, {move, slide, Type,
                                      slide_op:get_id(SlideOp),
                                      dht_node_state:get(State, node),
                                      OtherNode, slide_op:get_target_id(SlideOp),
                                      slide_op:get_tag(SlideOp),
                                      get_max_transport_bytes()}),
              PredOrSucc = slide_op:get_predORsucc(SlideOp),
              dht_node_state:set_slide(State, PredOrSucc,
                                       slide_op:set_phase(SlideOp, NewPhase));
          _ ->
              dht_node_state:set_slide(State, PredOrSucc, null)
      end.
  
  %% @doc Sets up a new slide operation with the node's successor or predecessor
  %%      after a request for a slide has been received.
  