anchor.diff:              {error, {recv, C, E, S}}
       end.
       
  -sc_rc_tcp_handler_announce_ready(Parent, Result) ->
  +sc_rc_tcp_handler_announce_ready(Parent, Slogan, Result) ->
       ?SEV_IPRINT("announce ready"),
  -    Parent ! {ready, self(), Result},
  +    ?SEV_ANNOUNCE_READY(Parent, Slogan, Result),
       ok.
  -
  -sc_rc_tcp_handler_await_terminate(Parent) ->
  -    ?SEV_IPRINT("await terminate"),
  -    receive
  -        {terminate, Parent, Reason} ->
  -            Reason;
  -        {'DOWN', _, process, Parent, Reason} ->
  -            ?SEV_EPRINT("received DOWN regarding parent: "
  -                        "~n   ~p", [Reason]),
  -            {parent, Reason}
  -    end.
   
   
   %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  
positive.code:     Self     = self(),
      Fun      = fun() -> sc_rc_tcp_handler(ID, Self, Recv, Sock) end,
      {Pid, _} = erlang:spawn_monitor(Fun),
      receive
          {started, Pid} ->
              {ok, Pid};
          {'DOWN', _, process, Pid, Reason} ->
              {error, Reason}
      end.
  
  sc_rc_tcp_handler(ID, Parent, Recv, Sock) ->
      sc_rc_tcp_handler_init(ID, Parent),
      sc_rc_tcp_handler_await_recv(Parent),
      RecvRes = sc_rc_tcp_handler_recv(Recv, Sock),
      sc_rc_tcp_handler_announce_ready(Parent, RecvRes),
      Reason = sc_rc_tcp_handler_await_terminate(Parent),
      exit(Reason).
  
  sc_rc_tcp_handler_init(ID, Parent) ->
      put(sname, f("handler-~w", [ID])),
      _MRef = erlang:monitor(process, Parent),
      Parent ! {started, self()},
      ?SEV_IPRINT("started"),
      ok.
  
  sc_rc_tcp_handler_await_recv(Parent) ->
      ?SEV_IPRINT("await recv"),
      receive
          {recv, Parent} ->
              ok;
          {'DOWN', _, process, Parent, Reason} ->
              ?SEV_EPRINT("received DOWN regarding parent: "
                 "~n   ~p", [Reason]),
              exit({parent, Reason})
      end.
  
  sc_rc_tcp_handler_recv(Recv, Sock) ->
      ?SEV_IPRINT("recv"),
  
negative.code:                    end},
           #{desc => "order handler 1 to terminate",
             cmd  => fun(#{handler1 := Pid} = _State) ->
                             %% Pid ! {terminate, self(), ok},
                             ?SEV_ANNOUNCE_TERMINATE(Pid),
                             ok
                     end},
           #{desc => "await handler 1 termination",
             cmd  => fun(#{handler1 := Pid} = State) ->
                             ?SEV_AWAIT_TERMINATION(Pid),
                             State1 = maps:remove(csock1,   State),
                             State2 = maps:remove(handler1, State1),
                             {ok, State2}
                     end},
           #{desc => "order handler 2 to terminate",
             cmd  => fun(#{handler2 := Pid} = _State) ->
                             ?SEV_ANNOUNCE_TERMINATE(Pid),
                             ok
                     end},
           #{desc => "await handler 2 termination",
             cmd  => fun(#{handler2 := Pid} = State) ->
                             ?SEV_AWAIT_TERMINATION(Pid),
                             State1 = maps:remove(csock2,   State),
                             State2 = maps:remove(handler2, State1),
                             {ok, State2}
                     end},
           #{desc => "order handler 3 to terminate",
             cmd  => fun(#{handler3 := Pid} = _State) ->
                             ?SEV_ANNOUNCE_TERMINATE(Pid),
                             ok
                     end},
           #{desc => "await handler 3 termination",
             cmd  => fun(#{handler3 := Pid} = State) ->
                             ?SEV_AWAIT_TERMINATION(Pid),
                             State1 = maps:remove(csock3,   State),
                             State2 = maps:remove(handler3, State1),
                             {ok, State2}
                     end},
           #{desc => "close listen socket",
             cmd  => fun(#{lsock := LSock} = State) ->
  