anchor.diff:              terminate_now(Reason, [Child | ChildAsyncs]);
           {'$async_req', From, {register_child_async, Pid}} ->
               reply(From, ok),
  -            async_loop_wait_result(Type, ParentMRef, Child,
  -                                   Reply, [Pid | ChildAsyncs]);
  +            async_loop_wait_result(Type, Child, Reply, [Pid | ChildAsyncs]);
           {Reply, Result} ->
  -            async_loop_handle_result(Type, ParentMRef, Child, ChildAsyncs, Result);
  +            async_loop_handle_result(Type, Child, ChildAsyncs, Result);
           {'$async_msg', Msg} ->
               Child ! Msg,
  -            async_loop_wait_result(Type, ParentMRef, Child, Reply, ChildAsyncs)
  +            async_loop_wait_result(Type, Child, Reply, ChildAsyncs)
       end.
   
   terminate_now(Reason, Children) ->
       misc:terminate_and_wait(Reason, Children),
       exit(Reason).
   
  -terminate_on_query(perform, _ParentMRef, Reason, Children) ->
  +terminate_on_query(perform, Reason, Children) ->
       terminate_now(Reason, Children);
  -terminate_on_query(wait, ParentMRef, Reason, Children) ->
  +terminate_on_query(wait, Reason, Children) ->
       misc:terminate_and_wait(Reason, Children),
  -    async_loop_with_result(ParentMRef, {die, Reason}).
  -
  -async_loop_handle_result(Type, ParentMRef, Child, ChildAsyncs, Result) ->
  +    async_loop_with_result({die, Reason}).
  +
  +async_loop_handle_result(Type, Child, ChildAsyncs, Result) ->
       unlink(Child),
       ?flush({'EXIT', Child, _}),
   
  
positive.code:     controller = get_role(),
      ok = call(Pid, {register_child_async, self()}).
  
  async_loop_wait_result(Type, ParentMRef, Child, Reply, ChildAsyncs) ->
      receive
          {'DOWN', ParentMRef, _, _, Reason} ->
              terminate_now(Reason, [Child | ChildAsyncs]);
          {'EXIT', Child, Reason} ->
              terminate_on_query(Type, ParentMRef, {child_died, Reason}, ChildAsyncs);
          %% note, we don't assume that this comes from the parent, because we
          %% can be terminated by parent async, for example, which is not the
          %% actual parent of our process
  
negative.code:         wait ->
              case Result of
                  {ok, Success} ->
                      async_loop_with_result({reply, Success});
                  {raised, _} = Raised ->
                      async_loop_with_result({die, Raised})
              end
      end.
  
  async_loop_with_result(Result) ->
      receive
          {'DOWN', _MRef, process, _Pid, Reason} = Down ->
              exit(Reason);
          {'EXIT', _, Reason} ->
              exit(Reason);
  