anchor.diff:  prepare_exchange(timeout, State) ->
       do_timeout(State);
   prepare_exchange({remote_exchange, Pid}, State) when is_pid(Pid) ->
  +    _ = gen_fsm:cancel_timer(State#state.timer),
       monitor(process, Pid),
  -    State2 = State#state{remote_tree=Pid},
  +    State2 = State#state{remote_tree=Pid, timer=undefined},
       update_trees(start_exchange, State2);
   prepare_exchange({remote_exchange, Error}, State) ->
  +    _ = gen_fsm:cancel_timer(State#state.timer),
       send_exchange_status({remote, Error}, State),
  -    {stop, normal, State}.
  +    {stop, normal, State#state{timer=undefined}}.
   
   %% @doc Now that locks have been acquired, ask both the local and remote
   %%      hashtrees to perform a tree update. If updates do not occur within
  
positive.code:     Count = riak_core_index_hashtree:compare(IndexN, Remote, AccFun, 0,
                                               LocalTree),
      if Count == 0 ->
              ok;
         true ->
              %% Sort the keys.  For vnodes that use backends that preserve
  
negative.code:                                                    local_fsm) of
                  ok ->
                      remote_exchange_request(Service, RemoteVN, IndexN),
                      Timer = gen_fsm:send_event_after(State#state.timeout,
                                                       timeout),
                      {next_state, prepare_exchange, State#state{timer=Timer}};
                  _ ->
                      send_exchange_status(already_locked, State),
                      {stop, normal, State}
  