anchor.diff:  
   
   nyi(D) ->
  -    io:format(D,'Not yet implemented~n',[]),
  +    io__format(D,'Not yet implemented~n',[]),
       nyi.
  +
  +%%%################################################################
  +
  +io__nl(D) when is_atom(D) -> io:nl(D);
  +io__nl(P) when is_pid(P) -> P ! {string,io_lib:nl()}.
  +
  +io__format(D, Fmt, Args) when is_atom(D) -> io:format(D, Fmt, Args);
  +io__format(P, Fmt, Args) when is_pid(P) -> P ! {string,io_lib:format(Fmt, Args)}.
  +
  +
  +init() -> loop([]).
  +
  +loop(Acc) ->
  +    receive
  +	{string,Str} ->
  +	    loop([Str|Acc]);
  +	{get,Who} ->
  +	    Who ! {result,lists:flatten(lists:reverse(Acc))}
  +    end.
  +	
  
positive.code: 	lists:foreach(PrintServer, supervisor:which_children(sshd_sup))
      catch
  	C:E ->
  	    io:format(D, '***FAILED: ~p:~p~n',[C,E])
      end.
  
  print_server(D, {{server,ssh_system_sup,LocalHost,LocalPort},Pid,supervisor,[ssh_system_sup]}) when is_pid(Pid) ->
      io:format(D, 'Local=~s (~p children)~n',[fmt_host_port({LocalHost,LocalPort}),
  					     ssh_acceptor:number_of_connections(Pid)]),
      PrintSystemSup = fun(X) -> print_system_sup(D,X) end,
      lists:foreach(PrintSystemSup, supervisor:which_children(Pid));
  print_server(D, Other) ->
      io:format(D, "    [[Other 2: ~p]]~n",[Other]).
      
  print_system_sup(D, {Ref,Pid,supervisor,[ssh_subsystem_sup]}) when is_reference(Ref),
  								is_pid(Pid) ->
      PrintChannels =  fun(X) -> print_channels(D,X) end,
      lists:foreach(PrintChannels, supervisor:which_children(Pid));
  print_system_sup(D, {{ssh_acceptor_sup,LocalHost,LocalPort}, Pid,supervisor, [ssh_acceptor_sup]}) when is_pid(Pid) ->
      io:format(D, "    [Acceptor for ~s]~n",[fmt_host_port({LocalHost,LocalPort})]);
  print_system_sup(D, Other) -> 
      io:format(D, "    [[Other 3: ~p]]~n",[Other]).
  
  print_channels(D, {{server,ssh_channel_sup,_,_},Pid,supervisor,[ssh_channel_sup]}) when is_pid(Pid) ->
      PrintChannel =  fun(X) -> print_channel(D,X) end,
      lists:foreach(PrintChannel, supervisor:which_children(Pid));
  print_channels(D, Other) -> 
      io:format(D, "    [[Other 4: ~p]]~n",[Other]).
  
  
  print_channel(D, {Ref,Pid,worker,[ssh_channel]}) when is_reference(Ref), 
  						      is_pid(Pid)  ->
      {{ConnManager,ChannelID}, Str} = ssh_channel:get_print_info(Pid),
      {{Local,Remote},StrM} = ssh_connection_handler:get_print_info(ConnManager),
      io:format(D, '    ch ~p: ~s ~s',[ChannelID, StrM, Str]),
      io:format(D, "    Local=~s Remote=~s~n",[fmt_host_port(Local),fmt_host_port(Remote)]);
  print_channel(D, Other) -> 
      io:format(D, "    [[Other 5: ~p]]~n",[Other]).
  	      
  %%%================================================================
  -define(inc(N), (N+4)).
  
  walk_sups(D, StartPid) ->
      io:format(D, "Start at ~p, ~s.~n",[StartPid,dead_or_alive(StartPid)]),
      walk_sups(D, children(StartPid), _Indent=?inc(0)).
  
  walk_sups(D, [H={_,Pid,_,_}|T], Indent) ->
      indent(D, Indent), io:format(D, '~200p  ~p is ~s~n',[H,Pid,dead_or_alive(Pid)]),
      case H of
  	{_,_,supervisor,[ssh_connection_handler]} -> ok;
  	{_,Pid,supervisor,_} -> walk_sups(D, children(Pid), ?inc(Indent));
  
negative.code: 
  underline(D, Str, LineChar) ->
      Len = lists:flatlength(Str),
      io__format(D, '~s~n',[Str]),
      line(D,Len,LineChar).
  
  line(D, Len, Char) ->
      io__format(D, '~*c~n', [Len,Char]).
  	    
  
  datetime() ->
  