anchor.diff:          {message,
            #message{data = Data, message_id = Id}, Report} ->
             try
  -            case Name of
  -              init ->
  -                {From, Request} = Data,
  -                erlang:send(Wrapped, {self(), Request}),
  -                receive
  -                  Msg ->
  -                    Report ! {system_reply, From, Id, Msg, Name},
  -                    ok
  -                end;
  -              error_logger ->
  -                %% erlang:send(Wrapped, Data),
  -                Report ! {trapping, false},
  -                ok;
  -              file_server_2 ->
  -                case Data of
  -                  {Call, {From, Ref}, Request} ->
  -                    check_fileserver_request(Request),
  -                    erlang:send(Wrapped, {Call, {self(), Ref}, Request}),
  -                    receive
  -                      Msg ->
  -                        Report ! {system_reply, From, Id, Msg, Name},
  -                        ok
  -                    end
  -                end;
  -              standard_error ->
  -                #concuerror_info{logger = Logger} = Info,
  -                {From, Reply, _} = handle_io(Data, {standard_error, Logger}),
  -                Report ! {system_reply, From, Id, Reply, Name},
  -                ok;
  -              user ->
  -                #concuerror_info{logger = Logger} = Info,
  -                {From, Reply, _} = handle_io(Data, {standard_io, Logger}),
  -                Report ! {system_reply, From, Id, Reply, Name},
  -                ok;
  -              Else ->
  -                ?crash({unknown_protocol_for_system, Else})
  -            end
  +            {F, R} =
  +              case Name of
  +                code_server ->
  +                  case Data of
  +                    {Call, From, Request} ->
  +                      check_request(Name, Request),
  +                      erlang:send(Wrapped, {Call, self(), Request}),
  +                      receive
  +                        Msg -> {From, Msg}
  +                      end
  +                  end;
  +                erl_prim_loader ->
  +                  case Data of
  +                    {From, Request} ->
  +                      check_request(Name, Request),
  +                      erlang:send(Wrapped, {self(), Request}),
  +                      receive
  +                        {_, Msg} -> {From, {self(), Msg}}
  +                      end
  +                  end;
  +                error_logger ->
  +                  %% erlang:send(Wrapped, Data),
  +                  throw(no_reply);
  +                file_server_2 ->
  +                  case Data of
  +                    {Call, {From, Ref}, Request} ->
  +                      check_request(Name, Request),
  +                      erlang:send(Wrapped, {Call, {self(), Ref}, Request}),
  +                      receive
  +                        Msg -> {From, Msg}
  +                      end
  +                  end;
  +                init ->
  +                  {From, Request} = Data,
  +                  check_request(Name, Request),
  +                  erlang:send(Wrapped, {self(), Request}),
  +                  receive
  +                    Msg -> {From, Msg}
  +                  end;
  +                standard_error ->
  +                  #concuerror_info{logger = Logger} = Info,
  +                  {From, Reply, _} = handle_io(Data, {standard_error, Logger}),
  +                  {From, Reply};
  +                user ->
  +                  #concuerror_info{logger = Logger} = Info,
  +                  {From, Reply, _} = handle_io(Data, {standard_io, Logger}),
  +                  {From, Reply};
  +                Else ->
  +                  ?crash({unknown_protocol_for_system, Else})
  +              end,
  +            Report ! {system_reply, F, Id, R, Name},
  +            ok
             catch
               exit:{?MODULE, _} = Reason -> exit(Reason);
  +            throw:no_reply ->
  +              Report ! {trapping, false},
  +              ok;
               Type:Reason ->
                 Stacktrace = erlang:get_stacktrace(),
                 ?crash({system_wrapper_error, Name, Type, Reason, Stacktrace})
  
positive.code:   end,
    system_wrapper_loop(Name, Wrapped, Info).
  
  check_fileserver_request({get_cwd}) -> ok;
  check_fileserver_request(Other) ->
    ?crash({unsupported_fileserver, element(1,Other)}).
  
  reset_concuerror_info(Info) ->
    #concuerror_info{
  
negative.code:     "No special handling found for built-in ~p:~p/~p. Run without"
      " --report_unknown or contact the developers to add support for it.",
      [Module, Name, Arity]);
  explain_error({unsupported_request, Name, Type}) ->
    io_lib:format(
      "A process send a request of type '~p' to ~p. This type of"
      " request has not been checked to ensure it always returns the same"
      " result.~n"
      ?notify_us_msg,
      [Type, Name]).
  