anchor.diff:  
   trace_loop(L) ->
       receive
  -	{trace_ts, Pid, call, {M,F,Args}, TS} = Ev -> 
  -	    cond_pal(Ev),
  -	    trace_loop(save_event(call, Pid, {M,F,Args}, TS, L));
  -	{trace_ts, Pid, return_from, {M,F,Arity}, Ret, TS} = Ev -> 
  -	    cond_pal(Ev),
  -	    trace_loop(save_event(return_from, Pid, {M,F,Arity,Ret}, TS, L));
   	{get_trace_list, From} ->
   	    From ! {trace_list, L},
  -	    trace_loop(L)
  -
  -	; Other -> io:format('~p got ~p~n',[self(),Other]), trace_loop(L)
  +	    trace_loop(L);
  +	Ev ->
  +	    trace_loop([Ev|L])
       end.
  -	    
  -%%cond_pal(Ev) -> ct:pal("~p",[Ev]).
  -cond_pal(Ev) -> ok.
  -    
  -
  -save_event(_Type, _Pid, MFA, TimeStamp, L) ->
  -    try	
  -	event_name(MFA)
  -    of
  -	{Tag, 'TS'} -> [{Tag,TimeStamp} | L];
  -	Val -> [Val | L]
  -    catch
  -	_:_ -> L
  -    end.
  -
  -event_name({ssh_acceptor,handle_connection,_}) ->                      {tcp_accept, 'TS'};
  -event_name({ssh_connection_handler,hello,[socket_control|_]}) ->       {{send,hello}, 'TS'};
  -event_name({ssh_connection_handler,hello,[{version_exchange,_}|_]}) -> {{recv,hello}, 'TS'};
  -event_name({ssh_message,encode,[Msg]}) ->                              {{send,element(1,Msg)}, 'TS'};
  -event_name({ssh_message,decode,1,
  -	    #ssh_msg_channel_request{request_type=ReqType}}) ->  {{recv,{ssh_msg_channel_request,ReqType}}, 'TS'};
  -event_name({ssh_message,decode,1,Return}) ->                     {{recv,element(1,Return)}, 'TS'};
  -event_name({ssh_transport,select_algorithm,3,{ok,Algs}}) ->      {algorithms,Algs};
  -event_name({ssh_transport,encrypt,[S,Data]}) ->   {{{encrypt,S#ssh.encrypt},start, {S#ssh.send_sequence,size(Data)}}, 'TS'};
  -event_name({ssh_transport,encrypt,2,{S,Ret}}) ->  {{{encrypt,S#ssh.encrypt},stop,  {S#ssh.send_sequence,size(Ret) }}, 'TS'};
  -event_name({ssh_transport,decrypt,[S,Data]}) ->   {{{decrypt,S#ssh.decrypt},start, {S#ssh.recv_sequence,size(Data)}}, 'TS'};
  -event_name({ssh_transport,decrypt,2,{S,Ret}}) ->  {{{decrypt,S#ssh.decrypt},stop,  {S#ssh.recv_sequence,size(Ret) }}, 'TS'}.
  -
  -
  +
  +pair_events(L) ->
  +    pair_events(L, []).
  +
  +pair_events([{trace_ts,Pid,call,{M,F,Args},TS0} | L], Acc) ->
  +    Arity = length(Args),
  +    {ReturnValue,TS1} = find_return(Pid, {M,F,Arity}, L),
  +    pair_events(L, [#call{mfa = {M,F,Arity},
  +			  pid = Pid,
  +			  t_call = TS0,
  +			  t_return = TS1,
  +			  args = Args,
  +			  result = ReturnValue} | Acc]);
  +pair_events([_|L], Acc) ->
  +    pair_events(L, Acc);
  +pair_events([], Acc) ->
  +    lists:reverse(Acc).
  +
  +
  +find_return(Pid, MFA, 
  +	    [{trace_ts, Pid, return_from, MFA, ReturnValue, TS}|_]) ->
  +    {ReturnValue, TS};
  +find_return(Pid, MFA, [_|L]) ->
  +    find_return(Pid, MFA, L);
  +find_return(_, _, []) ->
  +    {undefined, undefined}.
  +
  +%%%----------------------------------------------------------------
   now2sec({A,B,C}) -> A*1000000 + B + C/1000000.
   
   now2micro_sec({A,B,C}) -> (A*1000000 + B)*1000000 + C.
   		    
   now_diff({A1,B1,C1}, {A0,B0,C0}) -> {A1-A0, B1-B0, C1-C0}.
  -    
  +
  
positive.code: 			     Parent ! {self(),os:cmd(Cmd)}
  		     end),
      receive
  	{SlavePid, ClientResponse} ->
  %%	    ct:pal("ClientResponse = ~p",[ClientResponse]),
  	    {ok, List} = get_trace_list(TracerPid),
  	    Times = find_times(List),
  	    Algs = proplists:get_value(algorithms, List, #alg{}),
  	    ct:pal("List = ~p~n~nAlgorithms = ~p~n~nTimes = ~p",[List,Algs,Times]),
  	    lists:foreach(
  	      fun({Tag0,MicroSeconds,Unit}) ->
  		      Tag = case Tag0 of
  				{A,B} -> lists:concat([A," ",B]);
  				_ when is_list(Tag0) -> lists:concat(Tag0);
  
negative.code: -include_lib("common_test/include/ct.hrl").
  
  -include_lib("ssh/src/ssh.hrl").
  -include_lib("ssh/src/ssh_transport.hrl").
  -include_lib("ssh/src/ssh_connect.hrl").
  -include_lib("ssh/src/ssh_userauth.hrl").
  
  
  suite() -> [{ct_hooks,[{ts_install_cth,[{nodenames,2}]}]}].
  %%suite() -> [{ct_hooks,[ts_install_cth]}].
  