__attribute__((visibility ("hidden")))
mono_debugger_agent_parse_options (char * options)
{
  _Bool iftmp.0;
  long unsigned int D.27526;
  int D.27529;
  int D.27531;
  char * D.27534;
  gchar * D.27535;
  _Bool iftmp.1;
  long unsigned int D.27538;
  int D.27541;
  int D.27543;
  char * D.27546;
  gchar * D.27547;
  _Bool iftmp.2;
  long unsigned int D.27550;
  int D.27553;
  int D.27555;
  char * D.27558;
  int D.27559;
  _Bool iftmp.3;
  long unsigned int D.27562;
  int D.27565;
  int D.27567;
  gchar * D.27570;
  _Bool iftmp.4;
  long unsigned int D.27573;
  int D.27576;
  int D.27578;
  int D.27581;
  _Bool iftmp.5;
  long unsigned int D.27584;
  int D.27587;
  int D.27589;
  char * D.27592;
  int D.27593;
  _Bool iftmp.6;
  long unsigned int D.27596;
  int D.27599;
  int D.27601;
  char * D.27604;
  int D.27605;
  _Bool iftmp.7;
  long unsigned int D.27608;
  int D.27611;
  int D.27613;
  struct GSList * D.27616;
  gchar * D.27617;
  struct GSList * D.27618;
  _Bool iftmp.8;
  long unsigned int D.27621;
  int D.27624;
  int D.27626;
  gchar * D.27629;
  struct GSList * D.27630;
  _Bool iftmp.9;
  long unsigned int D.27633;
  int D.27636;
  int D.27638;
  _Bool iftmp.10;
  long unsigned int D.27642;
  int D.27645;
  int D.27647;
  int D.27650;
  _Bool iftmp.11;
  long unsigned int D.27653;
  int D.27656;
  int D.27658;
  gchar * D.27661;
  _Bool iftmp.12;
  long unsigned int D.27664;
  int D.27667;
  int D.27669;
  int D.27672;
  _Bool D.27673;
  int D.27674;
  _Bool iftmp.13;
  long unsigned int D.27677;
  int D.27680;
  int D.27682;
  int D.27685;
  _Bool iftmp.14;
  long unsigned int D.27688;
  int D.27691;
  int D.27693;
  int D.27696;
  char * D.27699;
  int D.27700;
  int D.27703;
  char * D.27706;
  unsigned int D.27709;
  unsigned int D.27710;
  unsigned int D.27711;
  gchar * D.27712;
  char * D.27713;
  struct _IO_FILE * stderr.15;
  int D.27721;
  int D.27726;
  char * * args;
  char * * ptr;
  char * host;
  int port;
  const char * extra;

  try
    {
      extra = monoeg_g_getenv ("MONO_SDB_ENV_OPTIONS");
      if (extra != 0B) goto <D.27523>; else goto <D.27524>;
      <D.27523>:
      options = monoeg_g_strdup_printf ("%s,%s", options, extra);
      <D.27524>:
      agent_config.enabled = 1;
      agent_config.suspend = 1;
      agent_config.server = 0;
      agent_config.defer = 0;
      agent_config.address = 0B;
      args = monoeg_g_strsplit (options, ",", -1);
      ptr = args;
      goto <D.25013>;
      <D.25012>:
      {
        char * arg;

        arg = *ptr;
        D.27526 = __strlen_g ("transport=");
        if (D.27526 <= 9) goto <D.27527>; else goto <D.27528>;
        <D.27527>:
        D.27529 = strcmp (arg, "transport=");
        iftmp.0 = D.27529 == 0;
        goto <D.27530>;
        <D.27528>:
        D.27531 = strncmp (arg, "transport=", 10);
        iftmp.0 = D.27531 == 0;
        <D.27530>:
        if (iftmp.0 != 0) goto <D.27532>; else goto <D.27533>;
        <D.27532>:
        D.27534 = arg + 10;
        D.27535 = monoeg_strdup (D.27534);
        agent_config.transport = D.27535;
        goto <D.27536>;
        <D.27533>:
        D.27538 = __strlen_g ("address=");
        if (D.27538 <= 7) goto <D.27539>; else goto <D.27540>;
        <D.27539>:
        D.27541 = strcmp (arg, "address=");
        iftmp.1 = D.27541 == 0;
        goto <D.27542>;
        <D.27540>:
        D.27543 = strncmp (arg, "address=", 8);
        iftmp.1 = D.27543 == 0;
        <D.27542>:
        if (iftmp.1 != 0) goto <D.27544>; else goto <D.27545>;
        <D.27544>:
        D.27546 = arg + 8;
        D.27547 = monoeg_strdup (D.27546);
        agent_config.address = D.27547;
        goto <D.27548>;
        <D.27545>:
        D.27550 = __strlen_g ("loglevel=");
        if (D.27550 <= 8) goto <D.27551>; else goto <D.27552>;
        <D.27551>:
        D.27553 = strcmp (arg, "loglevel=");
        iftmp.2 = D.27553 == 0;
        goto <D.27554>;
        <D.27552>:
        D.27555 = strncmp (arg, "loglevel=", 9);
        iftmp.2 = D.27555 == 0;
        <D.27554>:
        if (iftmp.2 != 0) goto <D.27556>; else goto <D.27557>;
        <D.27556>:
        D.27558 = arg + 9;
        D.27559 = atoi (D.27558);
        agent_config.log_level = D.27559;
        goto <D.27560>;
        <D.27557>:
        D.27562 = __strlen_g ("logfile=");
        if (D.27562 <= 7) goto <D.27563>; else goto <D.27564>;
        <D.27563>:
        D.27565 = strcmp (arg, "logfile=");
        iftmp.3 = D.27565 == 0;
        goto <D.27566>;
        <D.27564>:
        D.27567 = strncmp (arg, "logfile=", 8);
        iftmp.3 = D.27567 == 0;
        <D.27566>:
        if (iftmp.3 != 0) goto <D.27568>; else goto <D.27569>;
        <D.27568>:
        D.27546 = arg + 8;
        D.27570 = monoeg_strdup (D.27546);
        agent_config.log_file = D.27570;
        goto <D.27571>;
        <D.27569>:
        D.27573 = __strlen_g ("suspend=");
        if (D.27573 <= 7) goto <D.27574>; else goto <D.27575>;
        <D.27574>:
        D.27576 = strcmp (arg, "suspend=");
        iftmp.4 = D.27576 == 0;
        goto <D.27577>;
        <D.27575>:
        D.27578 = strncmp (arg, "suspend=", 8);
        iftmp.4 = D.27578 == 0;
        <D.27577>:
        if (iftmp.4 != 0) goto <D.27579>; else goto <D.27580>;
        <D.27579>:
        D.27546 = arg + 8;
        D.27581 = parse_flag ("suspend", D.27546);
        agent_config.suspend = D.27581;
        goto <D.27582>;
        <D.27580>:
        D.27584 = __strlen_g ("server=");
        if (D.27584 <= 6) goto <D.27585>; else goto <D.27586>;
        <D.27585>:
        D.27587 = strcmp (arg, "server=");
        iftmp.5 = D.27587 == 0;
        goto <D.27588>;
        <D.27586>:
        D.27589 = strncmp (arg, "server=", 7);
        iftmp.5 = D.27589 == 0;
        <D.27588>:
        if (iftmp.5 != 0) goto <D.27590>; else goto <D.27591>;
        <D.27590>:
        D.27592 = arg + 7;
        D.27593 = parse_flag ("server", D.27592);
        agent_config.server = D.27593;
        goto <D.27594>;
        <D.27591>:
        D.27596 = __strlen_g ("onuncaught=");
        if (D.27596 <= 10) goto <D.27597>; else goto <D.27598>;
        <D.27597>:
        D.27599 = strcmp (arg, "onuncaught=");
        iftmp.6 = D.27599 == 0;
        goto <D.27600>;
        <D.27598>:
        D.27601 = strncmp (arg, "onuncaught=", 11);
        iftmp.6 = D.27601 == 0;
        <D.27600>:
        if (iftmp.6 != 0) goto <D.27602>; else goto <D.27603>;
        <D.27602>:
        D.27604 = arg + 11;
        D.27605 = parse_flag ("onuncaught", D.27604);
        agent_config.onuncaught = D.27605;
        goto <D.27606>;
        <D.27603>:
        D.27608 = __strlen_g ("onthrow=");
        if (D.27608 <= 7) goto <D.27609>; else goto <D.27610>;
        <D.27609>:
        D.27611 = strcmp (arg, "onthrow=");
        iftmp.7 = D.27611 == 0;
        goto <D.27612>;
        <D.27610>:
        D.27613 = strncmp (arg, "onthrow=", 8);
        iftmp.7 = D.27613 == 0;
        <D.27612>:
        if (iftmp.7 != 0) goto <D.27614>; else goto <D.27615>;
        <D.27614>:
        D.27616 = agent_config.onthrow;
        D.27546 = arg + 8;
        D.27617 = monoeg_strdup (D.27546);
        D.27618 = monoeg_g_slist_append (D.27616, D.27617);
        agent_config.onthrow = D.27618;
        goto <D.27619>;
        <D.27615>:
        D.27621 = __strlen_g ("onthrow");
        if (D.27621 <= 6) goto <D.27622>; else goto <D.27623>;
        <D.27622>:
        D.27624 = strcmp (arg, "onthrow");
        iftmp.8 = D.27624 == 0;
        goto <D.27625>;
        <D.27623>:
        D.27626 = strncmp (arg, "onthrow", 7);
        iftmp.8 = D.27626 == 0;
        <D.27625>:
        if (iftmp.8 != 0) goto <D.27627>; else goto <D.27628>;
        <D.27627>:
        D.27616 = agent_config.onthrow;
        D.27629 = monoeg_strdup ("");
        D.27630 = monoeg_g_slist_append (D.27616, D.27629);
        agent_config.onthrow = D.27630;
        goto <D.27631>;
        <D.27628>:
        D.27633 = __strlen_g ("help");
        if (D.27633 <= 3) goto <D.27634>; else goto <D.27635>;
        <D.27634>:
        D.27636 = strcmp (arg, "help");
        iftmp.9 = D.27636 == 0;
        goto <D.27637>;
        <D.27635>:
        D.27638 = strncmp (arg, "help", 4);
        iftmp.9 = D.27638 == 0;
        <D.27637>:
        if (iftmp.9 != 0) goto <D.27639>; else goto <D.27640>;
        <D.27639>:
        print_usage ();
        exit (0);
        <D.27640>:
        D.27642 = __strlen_g ("timeout=");
        if (D.27642 <= 7) goto <D.27643>; else goto <D.27644>;
        <D.27643>:
        D.27645 = strcmp (arg, "timeout=");
        iftmp.10 = D.27645 == 0;
        goto <D.27646>;
        <D.27644>:
        D.27647 = strncmp (arg, "timeout=", 8);
        iftmp.10 = D.27647 == 0;
        <D.27646>:
        if (iftmp.10 != 0) goto <D.27648>; else goto <D.27649>;
        <D.27648>:
        D.27546 = arg + 8;
        D.27650 = atoi (D.27546);
        agent_config.timeout = D.27650;
        goto <D.27651>;
        <D.27649>:
        D.27653 = __strlen_g ("launch=");
        if (D.27653 <= 6) goto <D.27654>; else goto <D.27655>;
        <D.27654>:
        D.27656 = strcmp (arg, "launch=");
        iftmp.11 = D.27656 == 0;
        goto <D.27657>;
        <D.27655>:
        D.27658 = strncmp (arg, "launch=", 7);
        iftmp.11 = D.27658 == 0;
        <D.27657>:
        if (iftmp.11 != 0) goto <D.27659>; else goto <D.27660>;
        <D.27659>:
        D.27592 = arg + 7;
        D.27661 = monoeg_strdup (D.27592);
        agent_config.launch = D.27661;
        goto <D.27662>;
        <D.27660>:
        D.27664 = __strlen_g ("embedding=");
        if (D.27664 <= 9) goto <D.27665>; else goto <D.27666>;
        <D.27665>:
        D.27667 = strcmp (arg, "embedding=");
        iftmp.12 = D.27667 == 0;
        goto <D.27668>;
        <D.27666>:
        D.27669 = strncmp (arg, "embedding=", 10);
        iftmp.12 = D.27669 == 0;
        <D.27668>:
        if (iftmp.12 != 0) goto <D.27670>; else goto <D.27671>;
        <D.27670>:
        D.27534 = arg + 10;
        D.27672 = atoi (D.27534);
        D.27673 = D.27672 == 1;
        D.27674 = (int) D.27673;
        agent_config.embedding = D.27674;
        goto <D.27675>;
        <D.27671>:
        D.27677 = __strlen_g ("keepalive=");
        if (D.27677 <= 9) goto <D.27678>; else goto <D.27679>;
        <D.27678>:
        D.27680 = strcmp (arg, "keepalive=");
        iftmp.13 = D.27680 == 0;
        goto <D.27681>;
        <D.27679>:
        D.27682 = strncmp (arg, "keepalive=", 10);
        iftmp.13 = D.27682 == 0;
        <D.27681>:
        if (iftmp.13 != 0) goto <D.27683>; else goto <D.27684>;
        <D.27683>:
        D.27534 = arg + 10;
        D.27685 = atoi (D.27534);
        agent_config.keepalive = D.27685;
        goto <D.27686>;
        <D.27684>:
        D.27688 = __strlen_g ("setpgid=");
        if (D.27688 <= 7) goto <D.27689>; else goto <D.27690>;
        <D.27689>:
        D.27691 = strcmp (arg, "setpgid=");
        iftmp.14 = D.27691 == 0;
        goto <D.27692>;
        <D.27690>:
        D.27693 = strncmp (arg, "setpgid=", 8);
        iftmp.14 = D.27693 == 0;
        <D.27692>:
        if (iftmp.14 != 0) goto <D.27694>; else goto <D.27695>;
        <D.27694>:
        D.27546 = arg + 8;
        D.27696 = parse_flag ("setpgid", D.27546);
        agent_config.setpgid = D.27696;
        goto <D.27697>;
        <D.27695>:
        print_usage ();
        exit (1);
        <D.27697>:
        <D.27686>:
        <D.27675>:
        <D.27662>:
        <D.27651>:
        <D.27631>:
        <D.27619>:
        <D.27606>:
        <D.27594>:
        <D.27582>:
        <D.27571>:
        <D.27560>:
        <D.27548>:
        <D.27536>:
      }
      ptr = ptr + 8;
      <D.25013>:
      if (ptr != 0B) goto <D.27698>; else goto <D.25014>;
      <D.27698>:
      D.27699 = *ptr;
      if (D.27699 != 0B) goto <D.25012>; else goto <D.25014>;
      <D.25014>:
      D.27700 = agent_config.server;
      if (D.27700 != 0) goto <D.27701>; else goto <D.27702>;
      <D.27701>:
      D.27703 = agent_config.suspend;
      if (D.27703 == 0) goto <D.27704>; else goto <D.27705>;
      <D.27704>:
      agent_config.defer = 1;
      D.27706 = agent_config.address;
      if (D.27706 == 0B) goto <D.27707>; else goto <D.27708>;
      <D.27707>:
      D.27709 = GetCurrentProcessId ();
      D.27710 = D.27709 % 1000;
      D.27711 = D.27710 + 56000;
      D.27712 = monoeg_g_strdup_printf ("0.0.0.0:%u", D.27711);
      agent_config.address = D.27712;
      <D.27708>:
      <D.27705>:
      <D.27702>:
      D.27713 = agent_config.transport;
      if (D.27713 == 0B) goto <D.27714>; else goto <D.27715>;
      <D.27714>:
      stderr.15 = stderr;
      fprintf (stderr.15, "debugger-agent: The \'transport\' option is mandatory.\n");
      exit (1);
      <D.27715>:
      D.27706 = agent_config.address;
      if (D.27706 == 0B) goto <D.27717>; else goto <D.27718>;
      <D.27717>:
      D.27700 = agent_config.server;
      if (D.27700 == 0) goto <D.27719>; else goto <D.27720>;
      <D.27719>:
      stderr.15 = stderr;
      fprintf (stderr.15, "debugger-agent: The \'address\' option is mandatory.\n");
      exit (1);
      <D.27720>:
      <D.27718>:
      D.27713 = agent_config.transport;
      D.27721 = strcmp (D.27713, "dt_socket");
      if (D.27721 == 0) goto <D.27722>; else goto <D.27723>;
      <D.27722>:
      D.27706 = agent_config.address;
      if (D.27706 != 0B) goto <D.27724>; else goto <D.27725>;
      <D.27724>:
      D.27706 = agent_config.address;
      D.27726 = parse_address (D.27706, &host, &port);
      if (D.27726 != 0) goto <D.27727>; else goto <D.27728>;
      <D.27727>:
      stderr.15 = stderr;
      fprintf (stderr.15, "debugger-agent: The format of the \'address\' options is \'<host>:<port>\'\n");
      exit (1);
      <D.27728>:
      <D.27725>:
      <D.27723>:
    }
  finally
    {
      host = {CLOBBER};
      port = {CLOBBER};
    }
}


monoeg_strdup (const gchar * str)
{
  gchar * D.27731;

  if (str != 0B) goto <D.27729>; else goto <D.27730>;
  <D.27729>:
  D.27731 = __strdup (str);
  return D.27731;
  <D.27730>:
  D.27731 = 0B;
  return D.27731;
}


__attribute__((__gnu_inline__, __pure__, __leaf__, __nothrow__))
atoi (const char * __nptr)
{
  int D.27733;
  long int D.27734;

  D.27734 = strtol (__nptr, 0B, 10);
  D.27733 = (int) D.27734;
  return D.27733;
}


__attribute__((__gnu_inline__))
__strlen_g (const char * __str)
{
  size_t D.27736;
  long int __ptr.16;
  long int __str.17;
  long int D.27739;
  char * __ptr;
  char * __tmp;

  __ptr = 0B;
  __tmp = __str;
  __asm__ __volatile__("   la    0,0
0: srst  %0,%1
   jo    0b
" : "=&a" __ptr, "=&a" __tmp : "0" __ptr, "1" __tmp : "0", "memory", "cc");
  __ptr.16 = (long int) __ptr;
  __str.17 = (long int) __str;
  D.27739 = __ptr.16 - __str.17;
  D.27736 = (size_t) D.27739;
  return D.27736;
}


parse_flag (const char * option, char * flag)
{
  int D.27741;
  gboolean D.27744;
  int D.27745;
  struct _IO_FILE * stderr.18;

  D.27741 = strcmp (flag, "y");
  if (D.27741 == 0) goto <D.27742>; else goto <D.27743>;
  <D.27742>:
  D.27744 = 1;
  return D.27744;
  <D.27743>:
  D.27745 = strcmp (flag, "n");
  if (D.27745 == 0) goto <D.27746>; else goto <D.27747>;
  <D.27746>:
  D.27744 = 0;
  return D.27744;
  <D.27747>:
  stderr.18 = stderr;
  fprintf (stderr.18, "debugger-agent: The valid values for the \'%s\' option are \'y\' and \'n\'.\n", option);
  exit (1);
  D.27744 = 0;
  return D.27744;
}


print_usage ()
{
  struct _IO_FILE * stderr.19;

  stderr.19 = stderr;
  fprintf (stderr.19, "Usage: mono --debugger-agent=[<option>=<value>,...] ...\n");
  stderr.19 = stderr;
  fprintf (stderr.19, "Available options:\n");
  stderr.19 = stderr;
  fprintf (stderr.19, "  transport=<transport>\t\tTransport to use for connecting to the debugger (mandatory, possible values: \'dt_socket\')\n");
  stderr.19 = stderr;
  fprintf (stderr.19, "  address=<hostname>:<port>\tAddress to connect to (mandatory)\n");
  stderr.19 = stderr;
  fprintf (stderr.19, "  loglevel=<n>\t\t\tLog level (defaults to 0)\n");
  stderr.19 = stderr;
  fprintf (stderr.19, "  logfile=<file>\t\tFile to log to (defaults to stdout)\n");
  stderr.19 = stderr;
  fprintf (stderr.19, "  suspend=y/n\t\t\tWhether to suspend after startup.\n");
  stderr.19 = stderr;
  fprintf (stderr.19, "  timeout=<n>\t\t\tTimeout for connecting in milliseconds.\n");
  stderr.19 = stderr;
  fprintf (stderr.19, "  server=y/n\t\t\tWhether to listen for a client connection.\n");
  stderr.19 = stderr;
  fprintf (stderr.19, "  keepalive=<n>\t\t\tSend keepalive events every n milliseconds.\n");
  stderr.19 = stderr;
  fprintf (stderr.19, "  setpgid=y/n\t\t\tWhether to call setpid(0, 0) after startup.\n");
  stderr.19 = stderr;
  fprintf (stderr.19, "  help\t\t\t\tPrint this help.\n");
}


__attribute__((__gnu_inline__, nothrow, leaf, pure))
strcmp (const char * __s1, const char * __s2)
{
  int iftmp.20;
  int iftmp.21;
  int D.27759;
  char * __p1;
  char * __p2;
  int __ret;

  __p1 = __s1;
  __p2 = __s2;
  __asm__ __volatile__("   slr   0,0
0: clst  %1,%2
   jo    0b
   ipm   %0
   srl   %0,28" : "=d" __ret, "=&a" __p1, "=&a" __p2 : "1" __p1, "2" __p2 : "0", "memory", "cc");
  if (__ret != 0) goto <D.27752>; else goto <D.27753>;
  <D.27752>:
  if (__ret == 1) goto <D.27755>; else goto <D.27756>;
  <D.27755>:
  iftmp.21 = -1;
  goto <D.27757>;
  <D.27756>:
  iftmp.21 = 1;
  <D.27757>:
  iftmp.20 = iftmp.21;
  goto <D.27758>;
  <D.27753>:
  iftmp.20 = 0;
  <D.27758>:
  __ret = iftmp.20;
  D.27759 = __ret;
  return D.27759;
}


parse_address (char * address, char * * host, int * port)
{
  int D.27764;
  long int pos.22;
  long int address.23;
  long int D.27767;
  long int D.27768;
  long unsigned int D.27769;
  void * D.27770;
  char * D.27771;
  long unsigned int D.27772;
  sizetype D.27773;
  char * D.27774;
  char * D.27775;
  int D.27776;
  char * pos;

  pos = __builtin_strchr (address, 58);
  if (pos == 0B) goto <D.27761>; else goto <D.27763>;
  <D.27763>:
  if (pos == address) goto <D.27761>; else goto <D.27762>;
  <D.27761>:
  D.27764 = 1;
  return D.27764;
  <D.27762>:
  pos.22 = (long int) pos;
  address.23 = (long int) address;
  D.27767 = pos.22 - address.23;
  D.27768 = D.27767 + 1;
  D.27769 = (long unsigned int) D.27768;
  D.27770 = monoeg_malloc (D.27769);
  *host = D.27770;
  D.27771 = *host;
  pos.22 = (long int) pos;
  address.23 = (long int) address;
  D.27767 = pos.22 - address.23;
  D.27772 = (long unsigned int) D.27767;
  strncpy (D.27771, address, D.27772);
  D.27771 = *host;
  pos.22 = (long int) pos;
  address.23 = (long int) address;
  D.27767 = pos.22 - address.23;
  D.27773 = (sizetype) D.27767;
  D.27774 = D.27771 + D.27773;
  *D.27774 = 0;
  D.27775 = pos + 1;
  D.27776 = atoi (D.27775);
  *port = D.27776;
  D.27764 = 0;
  return D.27764;
}


__attribute__((__artificial__, __gnu_inline__, __always_inline__, __nothrow__, __leaf__))
strncpy (char * restrict __dest, const char * restrict __src, size_t __len)
{
  char * D.27778;
  long unsigned int D.27779;

  D.27779 = __builtin_object_size (__dest, 1);
  D.27778 = __builtin___strncpy_chk (__dest, __src, __len, D.27779);
  return D.27778;
}


__attribute__((__artificial__, __gnu_inline__, __always_inline__))
fprintf (struct FILE * restrict __stream, const char * restrict __fmt)
{
  int D.27781;

  D.27781 = __fprintf_chk (__stream, 1, __fmt, __builtin_va_arg_pack ());
  return D.27781;
}


__attribute__((visibility ("hidden")))
mono_debugger_agent_init ()
{
  int D.27783;
  struct GPtrArray * D.27786;
  struct MonoGHashTable * D.27787;
  int D.27788;
  struct MonoGHashTable * D.27791;
  int D.27792;
  struct MonoGHashTable * D.27795;
  int D.27796;
  struct GPtrArray * D.27799;
  struct GHashTable * D.27800;
  int D.27801;
  int D.27802;
  char * D.27803;
  struct FILE * D.27806;
  struct FILE * log_file.24;
  struct _IO_FILE * stderr.25;
  int * D.27811;
  int D.27812;
  char * D.27813;
  struct _IO_FILE * stdout.26;
  struct MonoDebugOptions * D.27816;
  struct MonoDebugOptions * D.27817;
  struct MonoDebugOptions * D.27818;
  int D.27819;
  int D.27822;
  struct GSList * D.27825;

  D.27783 = agent_config.enabled;
  if (D.27783 == 0) goto <D.27784>; else goto <D.27785>;
  <D.27784>:
  return;
  <D.27785>:
  transport_init ();
  mono_loader_lock_track_ownership (1);
  D.27786 = monoeg_g_ptr_array_new ();
  event_requests = D.27786;
  pthread_mutex_init (&debugger_thread_exited_mutex, 0B);
  pthread_cond_init (&debugger_thread_exited_cond, 0B);
  mono_profiler_install (&debugger_profiler, runtime_shutdown);
  mono_profiler_set_events (66067);
  mono_profiler_install_runtime_initialized (runtime_initialized);
  mono_profiler_install_appdomain (0B, appdomain_load, 0B, appdomain_unload);
  mono_profiler_install_thread (thread_startup, thread_end);
  mono_profiler_install_assembly (0B, assembly_load, assembly_unload, 0B);
  mono_profiler_install_jit_end (jit_end);
  mono_profiler_install_method_invoke (start_runtime_invoke, end_runtime_invoke);
  mono_native_tls_alloc (&debugger_tls_id, 0B);
  D.27787 = mono_g_hash_table_new_type (0B, 0B, 1);
  thread_to_tls = D.27787;
  D.27788 = mono_gc_is_moving ();
  if (D.27788 == 0) goto <D.27789>; else goto <D.27790>;
  <D.27789>:
  mono_gc_register_root (&thread_to_tls, 8, 0B);
  <D.27790>:
  D.27791 = mono_g_hash_table_new_type (0B, 0B, 2);
  tid_to_thread = D.27791;
  D.27792 = mono_gc_is_moving ();
  if (D.27792 == 0) goto <D.27793>; else goto <D.27794>;
  <D.27793>:
  mono_gc_register_root (&tid_to_thread, 8, 0B);
  <D.27794>:
  D.27795 = mono_g_hash_table_new_type (0B, 0B, 2);
  tid_to_thread_obj = D.27795;
  D.27796 = mono_gc_is_moving ();
  if (D.27796 == 0) goto <D.27797>; else goto <D.27798>;
  <D.27797>:
  mono_gc_register_root (&tid_to_thread_obj, 8, 0B);
  <D.27798>:
  D.27799 = monoeg_g_ptr_array_new ();
  pending_assembly_loads = D.27799;
  D.27800 = monoeg_g_hash_table_new (mono_aligned_addr_hash, 0B);
  domains = D.27800;
  D.27801 = agent_config.log_level;
  log_level = D.27801;
  D.27802 = agent_config.embedding;
  embedding = D.27802;
  disconnected = 1;
  D.27803 = agent_config.log_file;
  if (D.27803 != 0B) goto <D.27804>; else goto <D.27805>;
  <D.27804>:
  D.27803 = agent_config.log_file;
  D.27806 = fopen (D.27803, "w+");
  log_file = D.27806;
  log_file.24 = log_file;
  if (log_file.24 == 0B) goto <D.27808>; else goto <D.27809>;
  <D.27808>:
  stderr.25 = stderr;
  D.27803 = agent_config.log_file;
  D.27811 = __errno_location ();
  D.27812 = *D.27811;
  D.27813 = strerror (D.27812);
  fprintf (stderr.25, "Unable to create log file \'%s\': %s.\n", D.27803, D.27813);
  exit (1);
  <D.27809>:
  goto <D.27814>;
  <D.27805>:
  stdout.26 = stdout;
  log_file = stdout.26;
  <D.27814>:
  ids_init ();
  objrefs_init ();
  breakpoints_init ();
  suspend_init ();
  D.27816 = mini_get_debug_options ();
  D.27816->gen_seq_points = 1;
  D.27817 = mini_get_debug_options ();
  D.27817->mdb_optimizations = 1;
  D.27818 = mini_get_debug_options ();
  D.27818->load_aot_jit_info_eagerly = 1;
  D.27819 = agent_config.setpgid;
  if (D.27819 != 0) goto <D.27820>; else goto <D.27821>;
  <D.27820>:
  setpgid (0, 0);
  <D.27821>:
  D.27822 = agent_config.onuncaught;
  if (D.27822 == 0) goto <D.27823>; else goto <D.27824>;
  <D.27823>:
  D.27825 = agent_config.onthrow;
  if (D.27825 == 0B) goto <D.27826>; else goto <D.27827>;
  <D.27826>:
  finish_agent_init (1);
  <D.27827>:
  <D.27824>:
}


end_runtime_invoke (struct MonoProfiler * prof, struct MonoMethod * method)
{
  int embedding.27;
  struct SingleStepReq * ss_req.28;
  void * ss_invoke_addr.29;
  struct MonoInternalThread * D.27837;
  struct MonoInternalThread * D.27838;
  struct GPtrArray * event_requests.30;
  void * * D.27840;
  long unsigned int D.27841;
  long unsigned int D.27842;
  void * * D.27843;
  int D.27844;
  void * D.27847;
  unsigned int i.31;
  unsigned int D.27849;
  int i;
  void * stackptr;

  stackptr = __builtin_frame_address (1);
  embedding.27 = embedding;
  if (embedding.27 == 0) goto <D.27829>; else goto <D.27832>;
  <D.27832>:
  ss_req.28 = ss_req;
  if (ss_req.28 == 0B) goto <D.27829>; else goto <D.27834>;
  <D.27834>:
  ss_invoke_addr.29 = ss_invoke_addr;
  if (stackptr != ss_invoke_addr.29) goto <D.27829>; else goto <D.27836>;
  <D.27836>:
  ss_req.28 = ss_req;
  D.27837 = ss_req.28->thread;
  D.27838 = mono_thread_internal_current ();
  if (D.27837 != D.27838) goto <D.27829>; else goto <D.27830>;
  <D.27829>:
  return;
  <D.27830>:
  mono_loader_lock ();
  ss_invoke_addr = 0B;
  i = 0;
  goto <D.25916>;
  <D.25915>:
  {
    struct EventRequest * req;

    event_requests.30 = event_requests;
    D.27840 = event_requests.30->pdata;
    D.27841 = (long unsigned int) i;
    D.27842 = D.27841 * 8;
    D.27843 = D.27840 + D.27842;
    req = *D.27843;
    D.27844 = req->event_kind;
    if (D.27844 == 11) goto <D.27845>; else goto <D.27846>;
    <D.27845>:
    D.27847 = req->info;
    ss_destroy (D.27847);
    event_requests.30 = event_requests;
    i.31 = (unsigned int) i;
    monoeg_g_ptr_array_remove_index_fast (event_requests.30, i.31);
    monoeg_g_free (req);
    goto <D.25914>;
    <D.27846>:
  }
  i = i + 1;
  <D.25916>:
  event_requests.30 = event_requests;
  D.27849 = event_requests.30->len;
  i.31 = (unsigned int) i;
  if (D.27849 > i.31) goto <D.25915>; else goto <D.25914>;
  <D.25914>:
  mono_loader_unlock ();
}


ss_destroy (struct SingleStepReq * req)
{
  struct SingleStepReq * ss_req.32;
  _Bool D.27852;
  long int D.27853;
  long int D.27854;

  ss_req.32 = ss_req;
  D.27852 = ss_req.32 != req;
  D.27853 = (long int) D.27852;
  D.27854 = __builtin_expect (D.27853, 0);
  if (D.27854 != 0) goto <D.27855>; else goto <D.27856>;
  <D.27855>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 5255, "ss_req == req");
  <D.27856>:
  ss_req.32 = ss_req;
  ss_stop (ss_req.32);
  ss_req.32 = ss_req;
  monoeg_g_free (ss_req.32);
  ss_req = 0B;
}


ss_stop (struct SingleStepReq * ss_req)
{
  struct GSList * D.27857;
  void * D.27860;
  int D.27861;

  D.27857 = ss_req->bps;
  if (D.27857 != 0B) goto <D.27858>; else goto <D.27859>;
  <D.27858>:
  {
    struct GSList * l;

    l = ss_req->bps;
    goto <D.26215>;
    <D.26214>:
    D.27860 = l->data;
    clear_breakpoint (D.27860);
    l = l->next;
    <D.26215>:
    if (l != 0B) goto <D.26214>; else goto <D.26216>;
    <D.26216>:
    D.27857 = ss_req->bps;
    monoeg_g_slist_free (D.27857);
    ss_req->bps = 0B;
  }
  <D.27859>:
  D.27861 = ss_req->global;
  if (D.27861 != 0) goto <D.27862>; else goto <D.27863>;
  <D.27862>:
  stop_single_stepping ();
  ss_req->global = 0;
  <D.27863>:
}


clear_breakpoint (struct MonoBreakpoint * bp)
{
  struct GPtrArray * D.27864;
  void * * D.27865;
  long unsigned int D.27866;
  long unsigned int D.27867;
  void * * D.27868;
  unsigned int D.27869;
  unsigned int i.33;
  struct GPtrArray * breakpoints.34;
  int i;

  i = 0;
  goto <D.26056>;
  <D.26055>:
  {
    struct BreakpointInstance * inst;

    D.27864 = bp->children;
    D.27865 = D.27864->pdata;
    D.27866 = (long unsigned int) i;
    D.27867 = D.27866 * 8;
    D.27868 = D.27865 + D.27867;
    inst = *D.27868;
    remove_breakpoint (inst);
    monoeg_g_free (inst);
  }
  i = i + 1;
  <D.26056>:
  D.27864 = bp->children;
  D.27869 = D.27864->len;
  i.33 = (unsigned int) i;
  if (D.27869 > i.33) goto <D.26055>; else goto <D.26057>;
  <D.26057>:
  mono_loader_lock ();
  breakpoints.34 = breakpoints;
  monoeg_g_ptr_array_remove (breakpoints.34, bp);
  mono_loader_unlock ();
  D.27864 = bp->children;
  monoeg_g_ptr_array_free (D.27864, 1);
  monoeg_g_free (bp);
}


remove_breakpoint (struct BreakpointInstance * inst)
{
  struct GHashTable * bp_locs.35;
  void * D.27873;
  long int D.27874;
  int D.27875;
  long int D.27876;
  void * D.27877;
  _Bool D.27878;
  long int D.27879;
  long int D.27880;
  long int D.27885;
  int count;
  struct MonoJitInfo * ji;
  guint8 * ip;

  ji = inst->ji;
  ip = inst->ip;
  mono_loader_lock ();
  bp_locs.35 = bp_locs;
  D.27873 = monoeg_g_hash_table_lookup (bp_locs.35, ip);
  D.27874 = (long int) D.27873;
  count = (int) D.27874;
  bp_locs.35 = bp_locs;
  D.27875 = count + -1;
  D.27876 = (long int) D.27875;
  D.27877 = (void *) D.27876;
  monoeg_g_hash_table_insert_replace (bp_locs.35, ip, D.27877, 0);
  mono_loader_unlock ();
  D.27878 = count <= 0;
  D.27879 = (long int) D.27878;
  D.27880 = __builtin_expect (D.27879, 0);
  if (D.27880 != 0) goto <D.27881>; else goto <D.27882>;
  <D.27881>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 4193, "count > 0");
  <D.27882>:
  if (count == 1) goto <D.27883>; else goto <D.27884>;
  <D.27883>:
  D.27885 = inst->native_offset;
  if (D.27885 != -1) goto <D.27886>; else goto <D.27887>;
  <D.27886>:
  mono_arch_clear_breakpoint (ji, ip);
  <D.27887>:
  <D.27884>:
}


stop_single_stepping ()
{
  struct SingleStepReq * ss_req.36;
  int val;

  val = InterlockedDecrement (&ss_count);
  if (val == 0) goto <D.27888>; else goto <D.27889>;
  <D.27888>:
  mono_arch_stop_single_stepping ();
  <D.27889>:
  ss_req.36 = ss_req;
  if (ss_req.36 != 0B) goto <D.27891>; else goto <D.27892>;
  <D.27891>:
  ss_invoke_addr = 0B;
  <D.27892>:
}


InterlockedDecrement (volatile gint32 * val)
{
  gint32 D.27893;
  unsigned int D.27894;

  D.27894 = __sync_sub_and_fetch_4 (val, 1);
  D.27893 = (gint32) D.27894;
  return D.27893;
}


start_runtime_invoke (struct MonoProfiler * prof, struct MonoMethod * method)
{
  struct MonoGHashTable * thread_to_tls.37;
  void * stackptr;
  struct MonoInternalThread * thread;
  struct DebuggerTlsData * tls;

  stackptr = __builtin_frame_address (1);
  thread = mono_thread_internal_current ();
  mono_loader_lock ();
  thread_to_tls.37 = thread_to_tls;
  tls = mono_g_hash_table_lookup (thread_to_tls.37, thread);
  if (tls != 0B) goto <D.27897>; else goto <D.27898>;
  <D.27897>:
  tls->invoke_addr = stackptr;
  <D.27898>:
  mono_loader_unlock ();
}


jit_end (struct MonoProfiler * prof, struct MonoMethod * method, struct MonoJitInfo * jinfo, int result)
{
  struct GPtrArray * pending_assembly_loads.38;
  unsigned int D.27900;
  void * * D.27903;
  struct MonoClass * D.27905;

  <D.25940>:
  {
    struct MonoAssembly * assembly;

    assembly = 0B;
    mono_loader_lock ();
    pending_assembly_loads.38 = pending_assembly_loads;
    D.27900 = pending_assembly_loads.38->len;
    if (D.27900 != 0) goto <D.27901>; else goto <D.27902>;
    <D.27901>:
    pending_assembly_loads.38 = pending_assembly_loads;
    D.27903 = pending_assembly_loads.38->pdata;
    assembly = *D.27903;
    pending_assembly_loads.38 = pending_assembly_loads;
    monoeg_g_ptr_array_remove_index (pending_assembly_loads.38, 0);
    <D.27902>:
    mono_loader_unlock ();
    if (assembly != 0B) goto <D.27904>; else goto <D.25939>;
    <D.27904>:
    process_profiler_event (8, assembly);
  }
  goto <D.25940>;
  <D.25939>:
  D.27905 = method->klass;
  send_type_load (D.27905);
  if (result == 0) goto <D.27906>; else goto <D.27907>;
  <D.27906>:
  add_pending_breakpoints (method, jinfo);
  <D.27907>:
}


process_profiler_event (EventKind event, void * arg)
{
  int suspend_policy.39;
  int suspend_policy;
  struct GSList * events;
  struct EventInfo ei;
  struct EventInfo * ei_arg;

  try
    {
      ei_arg = 0B;
      if (event == 12) goto <D.27908>; else goto <D.27909>;
      <D.27908>:
      ei.klass = arg;
      ei_arg = &ei;
      <D.27909>:
      mono_loader_lock ();
      events = create_event_list (event, 0B, 0B, ei_arg, &suspend_policy);
      mono_loader_unlock ();
      suspend_policy.39 = suspend_policy;
      process_event (event, arg, 0, 0B, events, suspend_policy.39);
    }
  finally
    {
      suspend_policy = {CLOBBER};
      ei = {CLOBBER};
    }
}


create_event_list (EventKind event, struct GPtrArray * reqs, struct MonoJitInfo * ji, struct EventInfo * ei, int * suspend_policy)
{
  struct GSList * D.27915;
  void * * D.27916;
  long unsigned int D.27917;
  long unsigned int D.27918;
  void * * D.27919;
  int D.27920;
  unsigned int D.27921;
  <unnamed type> D.27924;
  int D.27927;
  int D.27932;
  struct MonoInternalThread * D.27938;
  struct MonoInternalThread * D.27939;
  struct MonoClass * D.27947;
  int D.27950;
  struct MonoObject * D.27953;
  struct MonoVTable * D.27954;
  struct MonoClass * D.27955;
  int D.27956;
  int D.27965;
  int D.27968;
  int D.27973;
  long unsigned int D.27982;
  long unsigned int D.27983;
  struct MonoAssembly * * D.27984;
  struct MonoAssembly * D.27985;
  struct MonoMethod * D.27986;
  struct MonoClass * D.27987;
  struct MonoImage * D.27988;
  struct MonoAssembly * D.27989;
  struct MonoClass * D.27998;
  struct GPtrArray * source_file_list.40;
  void * * D.28003;
  long unsigned int D.28004;
  long unsigned int D.28005;
  void * * D.28006;
  char * D.28007;
  struct GHashTable * D.28008;
  void * D.28009;
  void * D.28013;
  unsigned int D.28016;
  unsigned int i.41;
  struct MonoType * D.28025;
  struct GHashTable * D.28026;
  void * D.28027;
  <unnamed type> D.28032;
  unsigned int D.28033;
  struct MonoMethod * D.28038;
  short unsigned int D.28039;
  int D.28040;
  int D.28041;
  struct MonoMethod * D.28044;
  const char * D.28045;
  int D.28046;
  unsigned int D.28049;
  struct MonoClass * klass.42;
  struct MonoImage * D.28057;
  struct MonoClass * klass.43;
  _Bool D.28059;
  long int D.28060;
  long int D.28061;
  long unsigned int D.28064;
  long unsigned int D.28065;
  struct MonoMethod * D.28068;
  int D.28071;
  long unsigned int D.28074;
  unsigned int D.28077;
  struct MonoClass * klass.44;
  struct MonoClass * klass.45;
  _Bool D.28086;
  long int D.28087;
  long int D.28088;
  long unsigned int D.28091;
  struct MonoMethod * D.28094;
  int D.28097;
  struct MonoMethod * D.28100;
  struct MonoClass * D.28101;
  int D.28104;
  long unsigned int D.28107;
  int D.28110;
  int D.28113;
  int D.28114;
  int D.28115;
  int D.28116;
  long int D.28117;
  void * D.28118;
  unsigned int D.28119;
  unsigned int i.46;
  int i;
  int j;
  struct GSList * events;

  events = 0B;
  *suspend_policy = 0;
  if (reqs == 0B) goto <D.27911>; else goto <D.27912>;
  <D.27911>:
  reqs = event_requests;
  <D.27912>:
  if (reqs == 0B) goto <D.27913>; else goto <D.27914>;
  <D.27913>:
  D.27915 = 0B;
  return D.27915;
  <D.27914>:
  i = 0;
  goto <D.25782>;
  <D.25781>:
  {
    struct EventRequest * req;

    D.27916 = reqs->pdata;
    D.27917 = (long unsigned int) i;
    D.27918 = D.27917 * 8;
    D.27919 = D.27916 + D.27918;
    req = *D.27919;
    D.27920 = req->event_kind;
    D.27921 = (unsigned int) D.27920;
    if (D.27921 == event) goto <D.27922>; else goto <D.27923>;
    <D.27922>:
    {
      gboolean filtered;

      filtered = 0;
      j = 0;
      goto <D.25779>;
      <D.25778>:
      {
        struct Modifier * mod;

        mod = &req->modifiers[j];
        D.27924 = mod->kind;
        if (D.27924 == 1) goto <D.27925>; else goto <D.27926>;
        <D.27925>:
        filtered = 1;
        D.27927 = mod->data.count;
        if (D.27927 > 0) goto <D.27928>; else goto <D.27929>;
        <D.27928>:
        D.27927 = mod->data.count;
        if (D.27927 > 0) goto <D.27930>; else goto <D.27931>;
        <D.27930>:
        D.27927 = mod->data.count;
        D.27932 = D.27927 + -1;
        mod->data.count = D.27932;
        D.27927 = mod->data.count;
        if (D.27927 == 0) goto <D.27933>; else goto <D.27934>;
        <D.27933>:
        filtered = 0;
        <D.27934>:
        <D.27931>:
        <D.27929>:
        goto <D.27935>;
        <D.27926>:
        D.27924 = mod->kind;
        if (D.27924 == 3) goto <D.27936>; else goto <D.27937>;
        <D.27936>:
        D.27938 = mod->data.thread;
        D.27939 = mono_thread_internal_current ();
        if (D.27938 != D.27939) goto <D.27940>; else goto <D.27941>;
        <D.27940>:
        filtered = 1;
        <D.27941>:
        goto <D.27942>;
        <D.27937>:
        D.27924 = mod->kind;
        if (D.27924 == 8) goto <D.27945>; else goto <D.27943>;
        <D.27945>:
        if (ei != 0B) goto <D.27946>; else goto <D.27943>;
        <D.27946>:
        D.27947 = mod->data.exc_class;
        if (D.27947 != 0B) goto <D.27948>; else goto <D.27949>;
        <D.27948>:
        D.27950 = mod->subclasses;
        if (D.27950 != 0) goto <D.27951>; else goto <D.27952>;
        <D.27951>:
        D.27947 = mod->data.exc_class;
        D.27953 = ei->exc;
        D.27954 = D.27953->vtable;
        D.27955 = D.27954->klass;
        D.27956 = mono_class_is_assignable_from (D.27947, D.27955);
        if (D.27956 == 0) goto <D.27957>; else goto <D.27958>;
        <D.27957>:
        filtered = 1;
        <D.27958>:
        <D.27952>:
        <D.27949>:
        D.27947 = mod->data.exc_class;
        if (D.27947 != 0B) goto <D.27959>; else goto <D.27960>;
        <D.27959>:
        D.27950 = mod->subclasses;
        if (D.27950 == 0) goto <D.27961>; else goto <D.27962>;
        <D.27961>:
        D.27947 = mod->data.exc_class;
        D.27953 = ei->exc;
        D.27954 = D.27953->vtable;
        D.27955 = D.27954->klass;
        if (D.27947 != D.27955) goto <D.27963>; else goto <D.27964>;
        <D.27963>:
        filtered = 1;
        <D.27964>:
        <D.27962>:
        <D.27960>:
        D.27965 = ei->caught;
        if (D.27965 != 0) goto <D.27966>; else goto <D.27967>;
        <D.27966>:
        D.27968 = mod->caught;
        if (D.27968 == 0) goto <D.27969>; else goto <D.27970>;
        <D.27969>:
        filtered = 1;
        <D.27970>:
        <D.27967>:
        D.27965 = ei->caught;
        if (D.27965 == 0) goto <D.27971>; else goto <D.27972>;
        <D.27971>:
        D.27973 = mod->uncaught;
        if (D.27973 == 0) goto <D.27974>; else goto <D.27975>;
        <D.27974>:
        filtered = 1;
        <D.27975>:
        <D.27972>:
        goto <D.27944>;
        <D.27943>:
        D.27924 = mod->kind;
        if (D.27924 == 11) goto <D.27978>; else goto <D.27976>;
        <D.27978>:
        if (ji != 0B) goto <D.27979>; else goto <D.27976>;
        <D.27979>:
        {
          int k;
          gboolean found;
          struct MonoAssembly * * assemblies;

          found = 0;
          assemblies = mod->data.assemblies;
          if (assemblies != 0B) goto <D.27980>; else goto <D.27981>;
          <D.27980>:
          k = 0;
          goto <D.25754>;
          <D.25753>:
          D.27982 = (long unsigned int) k;
          D.27983 = D.27982 * 8;
          D.27984 = assemblies + D.27983;
          D.27985 = *D.27984;
          D.27986 = jinfo_get_method (ji);
          D.27987 = D.27986->klass;
          D.27988 = D.27987->image;
          D.27989 = D.27988->assembly;
          if (D.27985 == D.27989) goto <D.27990>; else goto <D.27991>;
          <D.27990>:
          found = 1;
          <D.27991>:
          k = k + 1;
          <D.25754>:
          D.27982 = (long unsigned int) k;
          D.27983 = D.27982 * 8;
          D.27984 = assemblies + D.27983;
          D.27985 = *D.27984;
          if (D.27985 != 0B) goto <D.25753>; else goto <D.25755>;
          <D.25755>:
          <D.27981>:
          if (found == 0) goto <D.27992>; else goto <D.27993>;
          <D.27992>:
          filtered = 1;
          <D.27993>:
        }
        goto <D.27977>;
        <D.27976>:
        D.27924 = mod->kind;
        if (D.27924 == 12) goto <D.27996>; else goto <D.27994>;
        <D.27996>:
        if (ei != 0B) goto <D.27997>; else goto <D.27994>;
        <D.27997>:
        D.27998 = ei->klass;
        if (D.27998 != 0B) goto <D.27999>; else goto <D.27994>;
        <D.27999>:
        {
          void * iter;
          struct MonoMethod * method;
          struct MonoDebugSourceInfo * sinfo;
          char * source_file;
          char * s;
          gboolean found;
          int i;
          struct GPtrArray * source_file_list;

          try
            {
              iter = 0B;
              found = 0;
              goto <D.25771>;
              <D.25770>:
              {
                struct MonoDebugMethodInfo * minfo;

                minfo = mono_debug_lookup_method (method);
                if (minfo != 0B) goto <D.28000>; else goto <D.28001>;
                <D.28000>:
                mono_debug_symfile_get_line_numbers_full (minfo, &source_file, &source_file_list, 0B, 0B, 0B, 0B, 0B);
                i = 0;
                goto <D.25768>;
                <D.25767>:
                source_file_list.40 = source_file_list;
                D.28003 = source_file_list.40->pdata;
                D.28004 = (long unsigned int) i;
                D.28005 = D.28004 * 8;
                D.28006 = D.28003 + D.28005;
                sinfo = *D.28006;
                D.28007 = sinfo->source_file;
                s = strdup_tolower (D.28007);
                D.28008 = mod->data.source_files;
                D.28009 = monoeg_g_hash_table_lookup (D.28008, s);
                if (D.28009 != 0B) goto <D.28010>; else goto <D.28011>;
                <D.28010>:
                found = 1;
                goto <D.28012>;
                <D.28011>:
                {
                  char * s2;
                  char * s3;

                  D.28007 = sinfo->source_file;
                  s2 = monoeg_g_path_get_basename (D.28007);
                  s3 = strdup_tolower (s2);
                  D.28008 = mod->data.source_files;
                  D.28013 = monoeg_g_hash_table_lookup (D.28008, s3);
                  if (D.28013 != 0B) goto <D.28014>; else goto <D.28015>;
                  <D.28014>:
                  found = 1;
                  <D.28015>:
                  monoeg_g_free (s2);
                  monoeg_g_free (s3);
                }
                <D.28012>:
                monoeg_g_free (s);
                i = i + 1;
                <D.25768>:
                source_file_list.40 = source_file_list;
                D.28016 = source_file_list.40->len;
                i.41 = (unsigned int) i;
                if (D.28016 > i.41) goto <D.25767>; else goto <D.25769>;
                <D.25769>:
                source_file_list.40 = source_file_list;
                monoeg_g_ptr_array_free (source_file_list.40, 1);
                <D.28001>:
              }
              <D.25771>:
              D.27998 = ei->klass;
              method = mono_class_get_methods (D.27998, &iter);
              if (method != 0B) goto <D.25770>; else goto <D.25772>;
              <D.25772>:
              if (found == 0) goto <D.28018>; else goto <D.28019>;
              <D.28018>:
              filtered = 1;
              <D.28019>:
            }
          finally
            {
              iter = {CLOBBER};
              source_file = {CLOBBER};
              source_file_list = {CLOBBER};
            }
        }
        goto <D.27995>;
        <D.27994>:
        D.27924 = mod->kind;
        if (D.27924 == 13) goto <D.28022>; else goto <D.28020>;
        <D.28022>:
        if (ei != 0B) goto <D.28023>; else goto <D.28020>;
        <D.28023>:
        D.27998 = ei->klass;
        if (D.27998 != 0B) goto <D.28024>; else goto <D.28020>;
        <D.28024>:
        {
          char * s;

          D.27998 = ei->klass;
          D.28025 = &D.27998->byval_arg;
          s = mono_type_full_name (D.28025);
          D.28026 = mod->data.type_names;
          D.28027 = monoeg_g_hash_table_lookup (D.28026, s);
          if (D.28027 == 0B) goto <D.28028>; else goto <D.28029>;
          <D.28028>:
          filtered = 1;
          <D.28029>:
          monoeg_g_free (s);
        }
        goto <D.28021>;
        <D.28020>:
        D.27924 = mod->kind;
        if (D.27924 == 10) goto <D.28030>; else goto <D.28031>;
        <D.28030>:
        D.28032 = mod->data.filter;
        D.28033 = D.28032 & 1;
        if (D.28033 != 0) goto <D.28034>; else goto <D.28035>;
        <D.28034>:
        if (ji != 0B) goto <D.28036>; else goto <D.28037>;
        <D.28036>:
        D.28038 = jinfo_get_method (ji);
        D.28039 = D.28038->flags;
        D.28040 = (int) D.28039;
        D.28041 = D.28040 & 2048;
        if (D.28041 != 0) goto <D.28042>; else goto <D.28043>;
        <D.28042>:
        D.28044 = jinfo_get_method (ji);
        D.28045 = D.28044->name;
        D.28046 = strcmp (D.28045, ".cctor");
        if (D.28046 == 0) goto <D.28047>; else goto <D.28048>;
        <D.28047>:
        filtered = 1;
        <D.28048>:
        <D.28043>:
        <D.28037>:
        <D.28035>:
        D.28032 = mod->data.filter;
        D.28049 = D.28032 & 2;
        if (D.28049 != 0) goto <D.28050>; else goto <D.28051>;
        <D.28050>:
        if (ji != 0B) goto <D.28052>; else goto <D.28053>;
        <D.28052>:
        {
          struct MonoCustomAttrInfo * ainfo;
          static struct MonoClass * klass;

          klass.42 = klass;
          if (klass.42 == 0B) goto <D.28055>; else goto <D.28056>;
          <D.28055>:
          D.28057 = mono_defaults.corlib;
          klass.43 = mono_class_from_name (D.28057, "System.Diagnostics", "DebuggerHiddenAttribute");
          klass = klass.43;
          klass.42 = klass;
          D.28059 = klass.42 == 0B;
          D.28060 = (long int) D.28059;
          D.28061 = __builtin_expect (D.28060, 0);
          if (D.28061 != 0) goto <D.28062>; else goto <D.28063>;
          <D.28062>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 3454, "klass");
          <D.28063>:
          <D.28056>:
          D.28064 = BIT_FIELD_REF <*ji, 64, 256>;
          D.28065 = D.28064 & 2199023255552;
          if (D.28065 == 0) goto <D.28066>; else goto <D.28067>;
          <D.28066>:
          D.28068 = jinfo_get_method (ji);
          ainfo = mono_custom_attrs_from_method (D.28068);
          if (ainfo != 0B) goto <D.28069>; else goto <D.28070>;
          <D.28069>:
          klass.42 = klass;
          D.28071 = mono_custom_attrs_has_attr (ainfo, klass.42);
          if (D.28071 != 0) goto <D.28072>; else goto <D.28073>;
          <D.28072>:
          ji->dbg_hidden = -1;
          <D.28073>:
          mono_custom_attrs_free (ainfo);
          <D.28070>:
          ji->dbg_hidden_inited = -1;
          <D.28067>:
          D.28064 = BIT_FIELD_REF <*ji, 64, 256>;
          D.28074 = D.28064 & 1099511627776;
          if (D.28074 != 0) goto <D.28075>; else goto <D.28076>;
          <D.28075>:
          filtered = 1;
          <D.28076>:
        }
        <D.28053>:
        <D.28051>:
        D.28032 = mod->data.filter;
        D.28077 = D.28032 & 4;
        if (D.28077 != 0) goto <D.28078>; else goto <D.28079>;
        <D.28078>:
        if (ji != 0B) goto <D.28080>; else goto <D.28081>;
        <D.28080>:
        {
          struct MonoCustomAttrInfo * ainfo;
          static struct MonoClass * klass;

          klass.44 = klass;
          if (klass.44 == 0B) goto <D.28083>; else goto <D.28084>;
          <D.28083>:
          D.28057 = mono_defaults.corlib;
          klass.45 = mono_class_from_name (D.28057, "System.Diagnostics", "DebuggerStepThroughAttribute");
          klass = klass.45;
          klass.44 = klass;
          D.28086 = klass.44 == 0B;
          D.28087 = (long int) D.28086;
          D.28088 = __builtin_expect (D.28087, 0);
          if (D.28088 != 0) goto <D.28089>; else goto <D.28090>;
          <D.28089>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 3474, "klass");
          <D.28090>:
          <D.28084>:
          D.28064 = BIT_FIELD_REF <*ji, 64, 256>;
          D.28091 = D.28064 & 274877906944;
          if (D.28091 == 0) goto <D.28092>; else goto <D.28093>;
          <D.28092>:
          D.28094 = jinfo_get_method (ji);
          ainfo = mono_custom_attrs_from_method (D.28094);
          if (ainfo != 0B) goto <D.28095>; else goto <D.28096>;
          <D.28095>:
          klass.44 = klass;
          D.28097 = mono_custom_attrs_has_attr (ainfo, klass.44);
          if (D.28097 != 0) goto <D.28098>; else goto <D.28099>;
          <D.28098>:
          ji->dbg_step_through = -1;
          <D.28099>:
          mono_custom_attrs_free (ainfo);
          <D.28096>:
          D.28100 = jinfo_get_method (ji);
          D.28101 = D.28100->klass;
          ainfo = mono_custom_attrs_from_class (D.28101);
          if (ainfo != 0B) goto <D.28102>; else goto <D.28103>;
          <D.28102>:
          klass.44 = klass;
          D.28104 = mono_custom_attrs_has_attr (ainfo, klass.44);
          if (D.28104 != 0) goto <D.28105>; else goto <D.28106>;
          <D.28105>:
          ji->dbg_step_through = -1;
          <D.28106>:
          mono_custom_attrs_free (ainfo);
          <D.28103>:
          ji->dbg_step_through_inited = -1;
          <D.28093>:
          D.28064 = BIT_FIELD_REF <*ji, 64, 256>;
          D.28107 = D.28064 & 137438953472;
          if (D.28107 != 0) goto <D.28108>; else goto <D.28109>;
          <D.28108>:
          filtered = 1;
          <D.28109>:
        }
        <D.28081>:
        <D.28079>:
        <D.28031>:
        <D.28021>:
        <D.27995>:
        <D.27977>:
        <D.27944>:
        <D.27942>:
        <D.27935>:
      }
      j = j + 1;
      <D.25779>:
      D.28110 = req->nmodifiers;
      if (D.28110 > j) goto <D.25778>; else goto <D.25780>;
      <D.25780>:
      if (filtered == 0) goto <D.28111>; else goto <D.28112>;
      <D.28111>:
      D.28113 = req->suspend_policy;
      D.28114 = *suspend_policy;
      D.28115 = MAX_EXPR <D.28113, D.28114>;
      *suspend_policy = D.28115;
      D.28116 = req->id;
      D.28117 = (long int) D.28116;
      D.28118 = (void *) D.28117;
      events = monoeg_g_slist_append (events, D.28118);
      <D.28112>:
    }
    <D.27923>:
  }
  i = i + 1;
  <D.25782>:
  D.28119 = reqs->len;
  i.46 = (unsigned int) i;
  if (D.28119 > i.46) goto <D.25781>; else goto <D.25783>;
  <D.25783>:
  if (event == 0) goto <D.28121>; else goto <D.28122>;
  <D.28121>:
  events = monoeg_g_slist_append (events, 0B);
  <D.28122>:
  if (event == 1) goto <D.28123>; else goto <D.28124>;
  <D.28123>:
  events = monoeg_g_slist_append (events, 0B);
  <D.28124>:
  D.27915 = events;
  return D.27915;
}


strdup_tolower (char * s)
{
  int D.25733;
  char D.28128;
  int D.28129;
  int D.28130;
  const int iftmp.47;
  unsigned int __c.48;
  unsigned int D.28135;
  const __int32_t * * D.28138;
  const __int32_t * D.28139;
  long unsigned int D.28140;
  long unsigned int D.28141;
  const __int32_t * D.28142;
  long unsigned int D.28146;
  long unsigned int D.28147;
  const __int32_t * D.28148;
  char D.28149;
  char * D.28150;
  char * s2;
  char * p;

  s2 = monoeg_strdup (s);
  p = s2;
  goto <D.25735>;
  <D.25734>:
  {
    int __res;

    {
      if (0 != 0) goto <D.28126>; else goto <D.28127>;
      <D.28126>:
      D.28128 = *p;
      D.28129 = (int) D.28128;
      D.28130 = __builtin_constant_p (D.28129);
      if (D.28130 != 0) goto <D.28131>; else goto <D.28132>;
      <D.28131>:
      {
        int __c;

        D.28128 = *p;
        __c = (int) D.28128;
        __c.48 = (unsigned int) __c;
        D.28135 = __c.48 + 128;
        if (D.28135 <= 383) goto <D.28136>; else goto <D.28137>;
        <D.28136>:
        D.28138 = __ctype_tolower_loc ();
        D.28139 = *D.28138;
        D.28140 = (long unsigned int) __c;
        D.28141 = D.28140 * 4;
        D.28142 = D.28139 + D.28141;
        iftmp.47 = *D.28142;
        goto <D.28143>;
        <D.28137>:
        iftmp.47 = __c;
        <D.28143>:
        __res = iftmp.47;
      }
      goto <D.28144>;
      <D.28132>:
      D.28128 = *p;
      D.28129 = (int) D.28128;
      __res = tolower (D.28129);
      <D.28144>:
      goto <D.28145>;
      <D.28127>:
      D.28138 = __ctype_tolower_loc ();
      D.28139 = *D.28138;
      D.28128 = *p;
      D.28146 = (long unsigned int) D.28128;
      D.28147 = D.28146 * 4;
      D.28148 = D.28139 + D.28147;
      __res = *D.28148;
      <D.28145>:
    }
    D.25733 = __res;
  }
  D.28149 = (char) D.25733;
  *p = D.28149;
  p = p + 1;
  <D.25735>:
  D.28128 = *p;
  if (D.28128 != 0) goto <D.25734>; else goto <D.25736>;
  <D.25736>:
  D.28150 = s2;
  return D.28150;
}


jinfo_get_method (struct MonoJitInfo * ji)
{
  struct MonoMethod * D.28152;

  D.28152 = mono_jit_info_get_method (ji);
  return D.28152;
}


process_event (EventKind event, void * arg, gint32 il_offset, struct MonoContext * ctx, struct GSList * events, int suspend_policy)
{
  int inited.49;
  int log_level.50;
  _Bool D.28158;
  long int D.28159;
  long int D.28160;
  struct FILE * log_file.51;
  const char * D.28164;
  int vm_start_event_sent.52;
  const char * D.28172;
  int vm_death_event_sent.53;
  const char * D.28178;
  int D.28179;
  const char * D.28186;
  int disconnected.54;
  const char * D.28192;
  int D.28198;
  long unsigned int D.28201;
  long unsigned int debugger_thread_id.55;
  long unsigned int D.28207;
  unsigned int D.28212;
  unsigned char D.28213;
  unsigned int nevents.56;
  unsigned char D.28215;
  void * D.28216;
  long int D.28217;
  unsigned int D.28218;
  int ecount.57;
  int ecount.58;
  long unsigned int D.28227;
  struct MonoDomain * D.28228;
  int protocol_version_set.59;
  int major_version.60;
  int minor_version.61;
  int D.28238;
  unsigned int D.28239;
  struct MonoObject * D.28240;
  int D.28241;
  unsigned int D.28242;
  const char * iftmp.62;
  char * D.28244;
  const char * iftmp.63;
  char * D.28249;
  int iftmp.64;
  int D.28256;
  int D.28264;
  const char * D.28275;
  _Bool D.28278;
  long int D.28279;
  long int D.28280;
  long unsigned int D.28283;
  void * D.28284;
  const char * D.28285;
  struct Buffer buf;
  struct GSList * l;
  struct MonoDomain * domain;
  struct MonoThread * thread;
  struct MonoObject * keepalive_obj;
  gboolean send_success;
  static int ecount;
  int nevents;

  try
    {
      domain = mono_domain_get ();
      thread = 0B;
      keepalive_obj = 0B;
      send_success = 0;
      inited.49 = inited;
      if (inited.49 == 0) goto <D.28155>; else goto <D.28156>;
      <D.28155>:
      log_level.50 = log_level;
      D.28158 = log_level.50 > 1;
      D.28159 = (long int) D.28158;
      D.28160 = __builtin_expect (D.28159, 0);
      if (D.28160 != 0) goto <D.28161>; else goto <D.28162>;
      <D.28161>:
      log_file.51 = log_file;
      D.28164 = event_to_string (event);
      fprintf (log_file.51, "Debugger agent not initialized yet: dropping %s\n", D.28164);
      log_file.51 = log_file;
      fflush (log_file.51);
      <D.28162>:
      return;
      <D.28156>:
      vm_start_event_sent.52 = vm_start_event_sent;
      if (vm_start_event_sent.52 == 0) goto <D.28166>; else goto <D.28167>;
      <D.28166>:
      if (event != 0) goto <D.28168>; else goto <D.28169>;
      <D.28168>:
      log_level.50 = log_level;
      D.28158 = log_level.50 > 1;
      D.28159 = (long int) D.28158;
      D.28160 = __builtin_expect (D.28159, 0);
      if (D.28160 != 0) goto <D.28170>; else goto <D.28171>;
      <D.28170>:
      log_file.51 = log_file;
      D.28172 = event_to_string (event);
      fprintf (log_file.51, "VM start event not sent yet: dropping %s\n", D.28172);
      log_file.51 = log_file;
      fflush (log_file.51);
      <D.28171>:
      return;
      <D.28169>:
      <D.28167>:
      vm_death_event_sent.53 = vm_death_event_sent;
      if (vm_death_event_sent.53 != 0) goto <D.28174>; else goto <D.28175>;
      <D.28174>:
      log_level.50 = log_level;
      D.28158 = log_level.50 > 1;
      D.28159 = (long int) D.28158;
      D.28160 = __builtin_expect (D.28159, 0);
      if (D.28160 != 0) goto <D.28176>; else goto <D.28177>;
      <D.28176>:
      log_file.51 = log_file;
      D.28178 = event_to_string (event);
      fprintf (log_file.51, "VM death event has been sent: dropping %s\n", D.28178);
      log_file.51 = log_file;
      fflush (log_file.51);
      <D.28177>:
      return;
      <D.28175>:
      D.28179 = mono_runtime_is_shutting_down ();
      if (D.28179 != 0) goto <D.28180>; else goto <D.28181>;
      <D.28180>:
      if (event != 1) goto <D.28182>; else goto <D.28183>;
      <D.28182>:
      log_level.50 = log_level;
      D.28158 = log_level.50 > 1;
      D.28159 = (long int) D.28158;
      D.28160 = __builtin_expect (D.28159, 0);
      if (D.28160 != 0) goto <D.28184>; else goto <D.28185>;
      <D.28184>:
      log_file.51 = log_file;
      D.28186 = event_to_string (event);
      fprintf (log_file.51, "Mono runtime is shutting down: dropping %s\n", D.28186);
      log_file.51 = log_file;
      fflush (log_file.51);
      <D.28185>:
      return;
      <D.28183>:
      <D.28181>:
      disconnected.54 = disconnected;
      if (disconnected.54 != 0) goto <D.28188>; else goto <D.28189>;
      <D.28188>:
      log_level.50 = log_level;
      D.28158 = log_level.50 > 1;
      D.28159 = (long int) D.28158;
      D.28160 = __builtin_expect (D.28159, 0);
      if (D.28160 != 0) goto <D.28190>; else goto <D.28191>;
      <D.28190>:
      log_file.51 = log_file;
      D.28192 = event_to_string (event);
      fprintf (log_file.51, "Debugger client is not connected: dropping %s\n", D.28192);
      log_file.51 = log_file;
      fflush (log_file.51);
      <D.28191>:
      return;
      <D.28189>:
      if (event == 14) goto <D.28193>; else goto <D.28194>;
      <D.28193>:
      suspend_policy = 0;
      goto <D.28195>;
      <D.28194>:
      if (events == 0B) goto <D.28196>; else goto <D.28197>;
      <D.28196>:
      return;
      <D.28197>:
      D.28198 = agent_config.defer;
      if (D.28198 != 0) goto <D.28199>; else goto <D.28200>;
      <D.28199>:
      D.28201 = GetCurrentThreadId ();
      debugger_thread_id.55 = debugger_thread_id;
      if (D.28201 == debugger_thread_id.55) goto <D.28203>; else goto <D.28204>;
      <D.28203>:
      suspend_policy = 0;
      thread = mono_thread_get_main ();
      goto <D.28205>;
      <D.28204>:
      thread = mono_thread_current ();
      <D.28205>:
      goto <D.28206>;
      <D.28200>:
      D.28207 = GetCurrentThreadId ();
      debugger_thread_id.55 = debugger_thread_id;
      if (D.28207 == debugger_thread_id.55) goto <D.28208>; else goto <D.28209>;
      <D.28208>:
      if (event != 1) goto <D.28210>; else goto <D.28211>;
      <D.28210>:
      return;
      <D.28211>:
      <D.28209>:
      <D.28206>:
      <D.28195>:
      D.28212 = monoeg_g_slist_length (events);
      nevents = (int) D.28212;
      buffer_init (&buf, 128);
      D.28213 = (unsigned char) suspend_policy;
      buffer_add_byte (&buf, D.28213);
      nevents.56 = (unsigned int) nevents;
      buffer_add_int (&buf, nevents.56);
      l = events;
      goto <D.25843>;
      <D.25842>:
      D.28215 = (unsigned char) event;
      buffer_add_byte (&buf, D.28215);
      D.28216 = l->data;
      D.28217 = (long int) D.28216;
      D.28218 = (unsigned int) D.28217;
      buffer_add_int (&buf, D.28218);
      ecount.57 = ecount;
      ecount.58 = ecount.57 + 1;
      ecount = ecount.58;
      if (thread == 0B) goto <D.28221>; else goto <D.28222>;
      <D.28221>:
      thread = mono_thread_current ();
      <D.28222>:
      if (event == 0) goto <D.28223>; else goto <D.28224>;
      <D.28223>:
      if (arg != 0B) goto <D.28225>; else goto <D.28226>;
      <D.28225>:
      thread = arg;
      <D.28226>:
      <D.28224>:
      buffer_add_objid (&buf, thread);
      switch (event) <default: <D.25841>, case 0: <D.25833>, case 1: <D.25834>, case 2: <D.25821>, case 3: <D.25822>, case 4: <D.25824>, case 5: <D.25825>, case 6: <D.25826>, case 7: <D.25827>, case 8: <D.25828>, case 9: <D.25829>, case 10: <D.25831>, case 11: <D.25832>, case 12: <D.25830>, case 13: <D.25835>, case 14: <D.25840>, case 15: <D.25837>, case 16: <D.25838>>
      <D.25821>:
      <D.25822>:
      goto <D.25823>;
      <D.25824>:
      <D.25825>:
      buffer_add_domainid (&buf, arg);
      goto <D.25823>;
      <D.25826>:
      <D.25827>:
      buffer_add_methodid (&buf, domain, arg);
      goto <D.25823>;
      <D.25828>:
      <D.25829>:
      buffer_add_assemblyid (&buf, domain, arg);
      goto <D.25823>;
      <D.25830>:
      buffer_add_typeid (&buf, domain, arg);
      goto <D.25823>;
      <D.25831>:
      <D.25832>:
      buffer_add_methodid (&buf, domain, arg);
      D.28227 = (long unsigned int) il_offset;
      buffer_add_long (&buf, D.28227);
      goto <D.25823>;
      <D.25833>:
      D.28228 = mono_get_root_domain ();
      buffer_add_domainid (&buf, D.28228);
      goto <D.25823>;
      <D.25834>:
      protocol_version_set.59 = protocol_version_set;
      if (protocol_version_set.59 != 0) goto <D.28232>; else goto <D.28233>;
      <D.28232>:
      major_version.60 = major_version;
      if (major_version.60 > 2) goto <D.28229>; else goto <D.28235>;
      <D.28235>:
      major_version.60 = major_version;
      if (major_version.60 == 2) goto <D.28236>; else goto <D.28230>;
      <D.28236>:
      minor_version.61 = minor_version;
      if (minor_version.61 > 26) goto <D.28229>; else goto <D.28230>;
      <D.28229>:
      D.28238 = mono_environment_exitcode_get ();
      D.28239 = (unsigned int) D.28238;
      buffer_add_int (&buf, D.28239);
      <D.28230>:
      <D.28233>:
      goto <D.25823>;
      <D.25835>:
      {
        struct EventInfo * ei;

        ei = arg;
        D.28240 = ei->exc;
        buffer_add_objid (&buf, D.28240);
        keepalive_obj = ei->exc;
        goto <D.25823>;
      }
      <D.25837>:
      goto <D.25823>;
      <D.25838>:
      {
        struct EventInfo * ei;

        ei = arg;
        D.28241 = ei->level;
        D.28242 = (unsigned int) D.28241;
        buffer_add_int (&buf, D.28242);
        D.28244 = ei->category;
        if (D.28244 != 0B) goto <D.28245>; else goto <D.28246>;
        <D.28245>:
        iftmp.62 = ei->category;
        goto <D.28247>;
        <D.28246>:
        iftmp.62 = "";
        <D.28247>:
        buffer_add_string (&buf, iftmp.62);
        D.28249 = ei->message;
        if (D.28249 != 0B) goto <D.28250>; else goto <D.28251>;
        <D.28250>:
        iftmp.63 = ei->message;
        goto <D.28252>;
        <D.28251>:
        iftmp.63 = "";
        <D.28252>:
        buffer_add_string (&buf, iftmp.63);
        goto <D.25823>;
      }
      <D.25840>:
      suspend_policy = 0;
      goto <D.25823>;
      <D.25841>:
      monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "debugger-agent.c", 3680);
      <D.25823>:
      l = l->next;
      <D.25843>:
      if (l != 0B) goto <D.25842>; else goto <D.25844>;
      <D.25844>:
      if (event == 0) goto <D.28253>; else goto <D.28254>;
      <D.28253>:
      D.28256 = agent_config.suspend;
      if (D.28256 != 0) goto <D.28257>; else goto <D.28258>;
      <D.28257>:
      iftmp.64 = 2;
      goto <D.28259>;
      <D.28258>:
      iftmp.64 = 0;
      <D.28259>:
      suspend_policy = iftmp.64;
      D.28198 = agent_config.defer;
      if (D.28198 == 0) goto <D.28260>; else goto <D.28261>;
      <D.28260>:
      start_debugger_thread ();
      <D.28261>:
      <D.28254>:
      if (event == 1) goto <D.28262>; else goto <D.28263>;
      <D.28262>:
      vm_death_event_sent = 1;
      suspend_policy = 0;
      <D.28263>:
      D.28264 = mono_runtime_is_shutting_down ();
      if (D.28264 != 0) goto <D.28265>; else goto <D.28266>;
      <D.28265>:
      suspend_policy = 0;
      <D.28266>:
      if (suspend_policy != 0) goto <D.28267>; else goto <D.28268>;
      <D.28267>:
      save_thread_context (ctx);
      suspend_vm ();
      if (keepalive_obj != 0B) goto <D.28269>; else goto <D.28270>;
      <D.28269>:
      get_objref (keepalive_obj);
      <D.28270>:
      <D.28268>:
      send_success = send_packet (64, 100, &buf);
      buffer_free (&buf);
      monoeg_g_slist_free (events);
      events = 0B;
      if (send_success == 0) goto <D.28271>; else goto <D.28272>;
      <D.28271>:
      log_level.50 = log_level;
      D.28158 = log_level.50 > 1;
      D.28159 = (long int) D.28158;
      D.28160 = __builtin_expect (D.28159, 0);
      if (D.28160 != 0) goto <D.28273>; else goto <D.28274>;
      <D.28273>:
      log_file.51 = log_file;
      D.28275 = event_to_string (event);
      fprintf (log_file.51, "Sending command %s failed.\n", D.28275);
      log_file.51 = log_file;
      fflush (log_file.51);
      <D.28274>:
      return;
      <D.28272>:
      if (event == 0) goto <D.28276>; else goto <D.28277>;
      <D.28276>:
      vm_start_event_sent = 1;
      <D.28277>:
      log_level.50 = log_level;
      D.28278 = log_level.50 > 0;
      D.28279 = (long int) D.28278;
      D.28280 = __builtin_expect (D.28279, 0);
      if (D.28280 != 0) goto <D.28281>; else goto <D.28282>;
      <D.28281>:
      log_file.51 = log_file;
      D.28283 = GetCurrentThreadId ();
      D.28284 = (void *) D.28283;
      D.28285 = event_to_string (event);
      ecount.57 = ecount;
      fprintf (log_file.51, "[%p] Sent %d events %s(%d), suspend=%d.\n", D.28284, nevents, D.28285, ecount.57, suspend_policy);
      log_file.51 = log_file;
      fflush (log_file.51);
      <D.28282>:
      switch (suspend_policy) <default: <D.25849>, case 0: <D.25845>, case 1: <D.25848>, case 2: <D.25847>>
      <D.25845>:
      goto <D.25846>;
      <D.25847>:
      suspend_current ();
      goto <D.25846>;
      <D.25848>:
      monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "debugger-agent.c", 3737);
      <D.25849>:
      monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "debugger-agent.c", 3740);
      <D.25846>:
    }
  finally
    {
      buf = {CLOBBER};
    }
}


buffer_init (struct Buffer * buf, int size)
{
  long unsigned int D.28291;
  void * D.28292;
  guint8 * D.28293;
  sizetype D.28294;
  guint8 * D.28295;

  D.28291 = (long unsigned int) size;
  D.28292 = monoeg_malloc (D.28291);
  buf->buf = D.28292;
  D.28293 = buf->buf;
  buf->p = D.28293;
  D.28293 = buf->buf;
  D.28294 = (sizetype) size;
  D.28295 = D.28293 + D.28294;
  buf->end = D.28295;
}


buffer_add_byte (struct Buffer * buf, guint8 val)
{
  guint8 * D.28296;
  guint8 * D.28297;

  buffer_make_room (buf, 1);
  D.28296 = buf->p;
  *D.28296 = val;
  D.28296 = buf->p;
  D.28297 = D.28296 + 1;
  buf->p = D.28297;
}


buffer_make_room (struct Buffer * buf, int size)
{
  guint8 * D.28298;
  long int D.28299;
  guint8 * D.28300;
  long int D.28301;
  long int D.28302;
  long int D.28303;
  guint8 * D.28306;
  long int D.28307;
  long int D.28308;
  unsigned int D.28309;
  unsigned int size.65;
  unsigned int D.28311;
  unsigned int D.28312;
  long unsigned int D.28313;
  long int D.28314;
  sizetype D.28315;
  guint8 * D.28316;
  sizetype D.28317;
  guint8 * D.28318;

  D.28298 = buf->end;
  D.28299 = (long int) D.28298;
  D.28300 = buf->p;
  D.28301 = (long int) D.28300;
  D.28302 = D.28299 - D.28301;
  D.28303 = (long int) size;
  if (D.28302 < D.28303) goto <D.28304>; else goto <D.28305>;
  <D.28304>:
  {
    int new_size;
    guint8 * p;

    D.28298 = buf->end;
    D.28299 = (long int) D.28298;
    D.28306 = buf->buf;
    D.28307 = (long int) D.28306;
    D.28308 = D.28299 - D.28307;
    D.28309 = (unsigned int) D.28308;
    size.65 = (unsigned int) size;
    D.28311 = D.28309 + size.65;
    D.28312 = D.28311 + 32;
    new_size = (int) D.28312;
    D.28306 = buf->buf;
    D.28313 = (long unsigned int) new_size;
    p = monoeg_realloc (D.28306, D.28313);
    D.28300 = buf->p;
    D.28301 = (long int) D.28300;
    D.28306 = buf->buf;
    D.28307 = (long int) D.28306;
    D.28314 = D.28301 - D.28307;
    size = (int) D.28314;
    buf->buf = p;
    D.28315 = (sizetype) size;
    D.28316 = p + D.28315;
    buf->p = D.28316;
    D.28306 = buf->buf;
    D.28317 = (sizetype) new_size;
    D.28318 = D.28306 + D.28317;
    buf->end = D.28318;
  }
  <D.28305>:
}


buffer_add_assemblyid (struct Buffer * buf, struct MonoDomain * domain, struct MonoAssembly * assembly)
{
  buffer_add_ptr_id (buf, domain, 0, assembly);
}


buffer_add_ptr_id (struct Buffer * buf, struct MonoDomain * domain, IdType type, void * val)
{
  int D.28319;

  D.28319 = get_id (domain, type, val);
  buffer_add_id (buf, D.28319);
}


get_id (struct MonoDomain * domain, IdType type, void * val)
{
  int D.28322;
  union mono_mutex_t * D.28323;
  _Bool D.28326;
  long int D.28327;
  long int D.28328;
  struct GHashTable * D.28331;
  struct GHashTable * D.28334;
  _Bool D.28339;
  long int D.28340;
  long int D.28341;
  struct GPtrArray * D.28344;
  unsigned int D.28345;
  unsigned int D.28346;
  int D.28347;
  _Bool D.28350;
  long int D.28351;
  long int D.28352;
  struct Id * id;
  struct AgentDomainInfo * info;

  if (val == 0B) goto <D.28320>; else goto <D.28321>;
  <D.28320>:
  D.28322 = 0;
  return D.28322;
  <D.28321>:
  mono_loader_lock ();
  {
    int ret;

    D.28323 = &domain->lock.mutex;
    ret = pthread_mutex_lock (D.28323);
    if (ret != 0) goto <D.28324>; else goto <D.28325>;
    <D.28324>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.28325>:
    D.28326 = ret != 0;
    D.28327 = (long int) D.28326;
    D.28328 = __builtin_expect (D.28327, 0);
    if (D.28328 != 0) goto <D.28329>; else goto <D.28330>;
    <D.28329>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 2149, "ret == 0");
    <D.28330>:
  }
  info = get_agent_domain_info (domain);
  D.28331 = info->val_to_id[type];
  if (D.28331 == 0B) goto <D.28332>; else goto <D.28333>;
  <D.28332>:
  D.28334 = monoeg_g_hash_table_new (mono_aligned_addr_hash, 0B);
  info->val_to_id[type] = D.28334;
  <D.28333>:
  D.28331 = info->val_to_id[type];
  id = monoeg_g_hash_table_lookup (D.28331, val);
  if (id != 0B) goto <D.28335>; else goto <D.28336>;
  <D.28335>:
  {
    int ret;

    D.28323 = &domain->lock.mutex;
    ret = pthread_mutex_unlock (D.28323);
    if (ret != 0) goto <D.28337>; else goto <D.28338>;
    <D.28337>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.28338>:
    D.28339 = ret != 0;
    D.28340 = (long int) D.28339;
    D.28341 = __builtin_expect (D.28340, 0);
    if (D.28341 != 0) goto <D.28342>; else goto <D.28343>;
    <D.28342>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 2158, "ret == 0");
    <D.28343>:
  }
  mono_loader_unlock ();
  D.28322 = id->id;
  return D.28322;
  <D.28336>:
  id = monoeg_malloc0 (24);
  D.28344 = ids[type];
  D.28345 = D.28344->len;
  D.28346 = D.28345 + 1;
  D.28347 = (int) D.28346;
  id->id = D.28347;
  id->domain = domain;
  id->data.val = val;
  D.28331 = info->val_to_id[type];
  monoeg_g_hash_table_insert_replace (D.28331, val, id, 0);
  {
    int ret;

    D.28323 = &domain->lock.mutex;
    ret = pthread_mutex_unlock (D.28323);
    if (ret != 0) goto <D.28348>; else goto <D.28349>;
    <D.28348>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.28349>:
    D.28350 = ret != 0;
    D.28351 = (long int) D.28350;
    D.28352 = __builtin_expect (D.28351, 0);
    if (D.28352 != 0) goto <D.28353>; else goto <D.28354>;
    <D.28353>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 2171, "ret == 0");
    <D.28354>:
  }
  D.28344 = ids[type];
  monoeg_g_ptr_array_add (D.28344, id);
  mono_loader_unlock ();
  D.28322 = id->id;
  return D.28322;
}


get_agent_domain_info (struct MonoDomain * domain)
{
  union mono_mutex_t * D.28356;
  _Bool D.28359;
  long int D.28360;
  long int D.28361;
  void * D.28364;
  void * D.28367;
  struct GHashTable * D.28368;
  struct GHashTable * D.28369;
  struct GHashTable * D.28370;
  struct GHashTable * D.28371;
  _Bool D.28374;
  long int D.28375;
  long int D.28376;
  struct AgentDomainInfo * D.28379;
  struct AgentDomainInfo * info;

  info = 0B;
  {
    int ret;

    D.28356 = &domain->lock.mutex;
    ret = pthread_mutex_lock (D.28356);
    if (ret != 0) goto <D.28357>; else goto <D.28358>;
    <D.28357>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.28358>:
    D.28359 = ret != 0;
    D.28360 = (long int) D.28359;
    D.28361 = __builtin_expect (D.28360, 0);
    if (D.28361 != 0) goto <D.28362>; else goto <D.28363>;
    <D.28362>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 2122, "ret == 0");
    <D.28363>:
  }
  D.28364 = domain->runtime_info;
  info = MEM[(struct MonoJitDomainInfo *)D.28364].agent_info;
  if (info == 0B) goto <D.28365>; else goto <D.28366>;
  <D.28365>:
  D.28364 = domain->runtime_info;
  D.28367 = monoeg_malloc0 (88);
  MEM[(struct MonoJitDomainInfo *)D.28364].agent_info = D.28367;
  info = MEM[(struct MonoJitDomainInfo *)D.28364].agent_info;
  D.28368 = monoeg_g_hash_table_new (mono_aligned_addr_hash, 0B);
  info->loaded_classes = D.28368;
  D.28369 = monoeg_g_hash_table_new (mono_aligned_addr_hash, 0B);
  info->source_files = D.28369;
  D.28370 = monoeg_g_hash_table_new (monoeg_g_str_hash, monoeg_g_str_equal);
  info->source_file_to_class = D.28370;
  D.28371 = monoeg_g_hash_table_new (monoeg_g_str_hash, monoeg_g_str_equal);
  info->source_file_to_class_ignorecase = D.28371;
  <D.28366>:
  {
    int ret;

    D.28356 = &domain->lock.mutex;
    ret = pthread_mutex_unlock (D.28356);
    if (ret != 0) goto <D.28372>; else goto <D.28373>;
    <D.28372>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.28373>:
    D.28374 = ret != 0;
    D.28375 = (long int) D.28374;
    D.28376 = __builtin_expect (D.28375, 0);
    if (D.28376 != 0) goto <D.28377>; else goto <D.28378>;
    <D.28377>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 2133, "ret == 0");
    <D.28378>:
  }
  D.28379 = info;
  return D.28379;
}


buffer_add_id (struct Buffer * buf, int id)
{
  unsigned int id.66;

  id.66 = (unsigned int) id;
  buffer_add_int (buf, id.66);
}


buffer_add_typeid (struct Buffer * buf, struct MonoDomain * domain, struct MonoClass * klass)
{
  int log_level.67;
  _Bool D.28383;
  long int D.28384;
  long int D.28385;
  struct MonoType * D.28390;
  long unsigned int D.28391;
  long unsigned int debugger_thread_id.68;
  struct FILE * log_file.69;
  long unsigned int D.28401;
  void * D.28402;

  buffer_add_ptr_id (buf, domain, 2, klass);
  log_level.67 = log_level;
  D.28383 = log_level.67 > 1;
  D.28384 = (long int) D.28383;
  D.28385 = __builtin_expect (D.28384, 0);
  if (D.28385 != 0) goto <D.28386>; else goto <D.28387>;
  <D.28386>:
  if (klass != 0B) goto <D.28388>; else goto <D.28389>;
  <D.28388>:
  {
    char * s;

    D.28390 = &klass->byval_arg;
    s = mono_type_full_name (D.28390);
    D.28391 = GetCurrentThreadId ();
    debugger_thread_id.68 = debugger_thread_id;
    if (D.28391 == debugger_thread_id.68) goto <D.28393>; else goto <D.28394>;
    <D.28393>:
    log_level.67 = log_level;
    D.28383 = log_level.67 > 1;
    D.28384 = (long int) D.28383;
    D.28385 = __builtin_expect (D.28384, 0);
    if (D.28385 != 0) goto <D.28395>; else goto <D.28396>;
    <D.28395>:
    log_file.69 = log_file;
    fprintf (log_file.69, "[dbg]   send class [%s]\n", s);
    log_file.69 = log_file;
    fflush (log_file.69);
    <D.28396>:
    goto <D.28398>;
    <D.28394>:
    log_level.67 = log_level;
    D.28383 = log_level.67 > 1;
    D.28384 = (long int) D.28383;
    D.28385 = __builtin_expect (D.28384, 0);
    if (D.28385 != 0) goto <D.28399>; else goto <D.28400>;
    <D.28399>:
    log_file.69 = log_file;
    D.28401 = GetCurrentThreadId ();
    D.28402 = (void *) D.28401;
    fprintf (log_file.69, "[%p]   send class [%s]\n", D.28402, s);
    log_file.69 = log_file;
    fflush (log_file.69);
    <D.28400>:
    <D.28398>:
    monoeg_g_free (s);
  }
  <D.28389>:
  <D.28387>:
}


buffer_add_methodid (struct Buffer * buf, struct MonoDomain * domain, struct MonoMethod * method)
{
  int log_level.70;
  _Bool D.28404;
  long int D.28405;
  long int D.28406;
  struct FILE * log_file.71;

  buffer_add_ptr_id (buf, domain, 3, method);
  log_level.70 = log_level;
  D.28404 = log_level.70 > 1;
  D.28405 = (long int) D.28404;
  D.28406 = __builtin_expect (D.28405, 0);
  if (D.28406 != 0) goto <D.28407>; else goto <D.28408>;
  <D.28407>:
  if (method != 0B) goto <D.28409>; else goto <D.28410>;
  <D.28409>:
  {
    char * s;

    s = mono_method_full_name (method, 1);
    log_level.70 = log_level;
    D.28404 = log_level.70 > 1;
    D.28405 = (long int) D.28404;
    D.28406 = __builtin_expect (D.28405, 0);
    if (D.28406 != 0) goto <D.28411>; else goto <D.28412>;
    <D.28411>:
    log_file.71 = log_file;
    fprintf (log_file.71, "[dbg]   send method [%s]\n", s);
    log_file.71 = log_file;
    fflush (log_file.71);
    <D.28412>:
    monoeg_g_free (s);
  }
  <D.28410>:
  <D.28408>:
}


buffer_add_long (struct Buffer * buf, guint64 l)
{
  long unsigned int D.28414;
  unsigned int D.28415;
  unsigned int D.28416;

  D.28414 = l >> 32;
  D.28415 = (unsigned int) D.28414;
  buffer_add_int (buf, D.28415);
  D.28416 = (unsigned int) l;
  buffer_add_int (buf, D.28416);
}


buffer_add_domainid (struct Buffer * buf, struct MonoDomain * domain)
{
  buffer_add_ptr_id (buf, domain, 5, domain);
}


buffer_add_objid (struct Buffer * buf, struct MonoObject * o)
{
  int D.28417;

  D.28417 = get_objid (o);
  buffer_add_id (buf, D.28417);
}


get_objid (struct MonoObject * obj)
{
  int D.28418;
  struct ObjRef * D.28419;

  D.28419 = get_objref (obj);
  D.28418 = D.28419->id;
  return D.28418;
}


buffer_add_int (struct Buffer * buf, guint32 val)
{
  guint8 * D.28421;
  unsigned int D.28422;
  unsigned char D.28423;
  guint8 * D.28424;
  unsigned int D.28425;
  unsigned char D.28426;
  guint8 * D.28427;
  unsigned int D.28428;
  unsigned char D.28429;
  guint8 * D.28430;
  unsigned char D.28431;
  guint8 * D.28432;

  buffer_make_room (buf, 4);
  D.28421 = buf->p;
  D.28422 = val >> 24;
  D.28423 = (unsigned char) D.28422;
  *D.28421 = D.28423;
  D.28421 = buf->p;
  D.28424 = D.28421 + 1;
  D.28425 = val >> 16;
  D.28426 = (unsigned char) D.28425;
  *D.28424 = D.28426;
  D.28421 = buf->p;
  D.28427 = D.28421 + 2;
  D.28428 = val >> 8;
  D.28429 = (unsigned char) D.28428;
  *D.28427 = D.28429;
  D.28421 = buf->p;
  D.28430 = D.28421 + 3;
  D.28431 = (unsigned char) val;
  *D.28430 = D.28431;
  D.28421 = buf->p;
  D.28432 = D.28421 + 4;
  buf->p = D.28432;
}


buffer_add_string (struct Buffer * buf, const char * str)
{
  long unsigned int D.28436;
  unsigned int len.72;
  int len;

  if (str == 0B) goto <D.28433>; else goto <D.28434>;
  <D.28433>:
  buffer_add_int (buf, 0);
  goto <D.28435>;
  <D.28434>:
  D.28436 = __strlen_g (str);
  len = (int) D.28436;
  len.72 = (unsigned int) len;
  buffer_add_int (buf, len.72);
  buffer_add_data (buf, str, len);
  <D.28435>:
}


buffer_add_data (struct Buffer * buf, guint8 * data, int len)
{
  guint8 * D.28438;
  long unsigned int D.28439;
  sizetype D.28440;
  guint8 * D.28441;

  buffer_make_room (buf, len);
  D.28438 = buf->p;
  D.28439 = (long unsigned int) len;
  memcpy (D.28438, data, D.28439);
  D.28438 = buf->p;
  D.28440 = (sizetype) len;
  D.28441 = D.28438 + D.28440;
  buf->p = D.28441;
}


__attribute__((__artificial__, __gnu_inline__, __always_inline__, __nothrow__, __leaf__))
memcpy (void * restrict __dest, const void * restrict __src, size_t __len)
{
  void * D.28442;
  long unsigned int D.28443;

  D.28443 = __builtin_object_size (__dest, 0);
  D.28442 = __builtin___memcpy_chk (__dest, __src, __len, D.28443);
  return D.28442;
}


start_debugger_thread ()
{
  void * D.28445;
  void * debugger_thread_handle.73;
  _Bool D.28447;
  long int D.28448;
  long int D.28449;

  D.28445 = mono_threads_create_thread (debugger_thread, 0B, 0, 0, 0B);
  debugger_thread_handle = D.28445;
  debugger_thread_handle.73 = debugger_thread_handle;
  D.28447 = debugger_thread_handle.73 == 0B;
  D.28448 = (long int) D.28447;
  D.28449 = __builtin_expect (D.28448, 0);
  if (D.28449 != 0) goto <D.28450>; else goto <D.28451>;
  <D.28450>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 1580, "debugger_thread_handle");
  <D.28451>:
}


debugger_thread (void * arg)
{
  int log_level.74;
  _Bool D.28453;
  long int D.28454;
  long int D.28455;
  struct FILE * log_file.75;
  long unsigned int D.28459;
  void * D.28460;
  long unsigned int D.28461;
  struct MonoDomain * D.28462;
  struct MonoInternalThread * D.28463;
  long unsigned int D.28464;
  long unsigned int D.28465;
  int D.28466;
  int D.28469;
  struct MonoThread * D.28475;
  guint8 * p.76;
  _Bool D.28481;
  long int D.28482;
  long int D.28483;
  <unnamed type> command_set.77;
  const char * D.28493;
  int D.28494;
  long unsigned int D.28495;
  sizetype D.28502;
  sizetype D.28503;
  int err.78;
  unsigned int command.79;
  unsigned int D.28514;
  int vm_death_event_sent.80;
  int D.28527;
  _Bool D.28530;
  long int D.28531;
  long int D.28532;
  guint32 D.28535;
  int res;
  int len;
  int id;
  int flags;
  int command_set;
  int command;
  guint8 header[11];
  guint8 * data;
  guint8 * p;
  guint8 * end;
  struct Buffer buf;
  ErrorCode err;
  gboolean no_reply;
  gboolean attach_failed;

  try
    {
      command_set = 0;
      command = 0;
      attach_failed = 0;
      log_level.74 = log_level;
      D.28453 = log_level.74 > 0;
      D.28454 = (long int) D.28453;
      D.28455 = __builtin_expect (D.28454, 0);
      if (D.28455 != 0) goto <D.28456>; else goto <D.28457>;
      <D.28456>:
      log_file.75 = log_file;
      D.28459 = GetCurrentThreadId ();
      D.28460 = (void *) D.28459;
      fprintf (log_file.75, "[dbg] Agent thread started, pid=%p\n", D.28460);
      log_file.75 = log_file;
      fflush (log_file.75);
      <D.28457>:
      D.28461 = GetCurrentThreadId ();
      debugger_thread_id = D.28461;
      D.28462 = mono_get_root_domain ();
      mono_jit_thread_attach (D.28462);
      D.28463 = mono_thread_internal_current ();
      D.28464 = D.28463->flags;
      D.28465 = D.28464 | 1;
      D.28463->flags = D.28465;
      mono_set_is_debugger_attached (1);
      D.28466 = agent_config.defer;
      if (D.28466 != 0) goto <D.28467>; else goto <D.28468>;
      <D.28467>:
      D.28469 = wait_for_attach ();
      if (D.28469 == 0) goto <D.28470>; else goto <D.28471>;
      <D.28470>:
      log_level.74 = log_level;
      D.28453 = log_level.74 > 0;
      D.28454 = (long int) D.28453;
      D.28455 = __builtin_expect (D.28454, 0);
      if (D.28455 != 0) goto <D.28472>; else goto <D.28473>;
      <D.28472>:
      log_file.75 = log_file;
      fprintf (log_file.75, "[dbg] Can\'t attach, aborting debugger thread.\n");
      log_file.75 = log_file;
      fflush (log_file.75);
      <D.28473>:
      attach_failed = 1;
      goto <D.28474>;
      <D.28471>:
      D.28475 = mono_thread_get_main ();
      process_profiler_event (0, D.28475);
      <D.28474>:
      <D.28468>:
      goto <D.27521>;
      <D.27520>:
      res = transport_recv (&header, 11);
      if (res != 11) goto <D.28476>; else goto <D.28477>;
      <D.28476>:
      log_level.74 = log_level;
      D.28453 = log_level.74 > 0;
      D.28454 = (long int) D.28453;
      D.28455 = __builtin_expect (D.28454, 0);
      if (D.28455 != 0) goto <D.28478>; else goto <D.28479>;
      <D.28478>:
      log_file.75 = log_file;
      fprintf (log_file.75, "[dbg] transport_recv () returned %d, expected %d.\n", res, 11);
      log_file.75 = log_file;
      fflush (log_file.75);
      <D.28479>:
      goto <D.27503>;
      <D.28477>:
      p = &header;
      end = &header + 11;
      p.76 = p;
      len = decode_int (p.76, &p, end);
      p.76 = p;
      id = decode_int (p.76, &p, end);
      p.76 = p;
      flags = decode_byte (p.76, &p, end);
      p.76 = p;
      command_set = decode_byte (p.76, &p, end);
      p.76 = p;
      command = decode_byte (p.76, &p, end);
      D.28481 = flags != 0;
      D.28482 = (long int) D.28481;
      D.28483 = __builtin_expect (D.28482, 0);
      if (D.28483 != 0) goto <D.28484>; else goto <D.28485>;
      <D.28484>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 9156, "flags == 0");
      <D.28485>:
      log_level.74 = log_level;
      if (log_level.74 != 0) goto <D.28486>; else goto <D.28487>;
      <D.28486>:
      {
        const char * cmd_str;
        char cmd_num[256];

        try
          {
            command_set.77 = (<unnamed type>) command_set;
            cmd_str = cmd_to_string (command_set.77, command);
            if (cmd_str == 0B) goto <D.28489>; else goto <D.28490>;
            <D.28489>:
            sprintf (&cmd_num, "%d", command);
            cmd_str = &cmd_num;
            <D.28490>:
            log_level.74 = log_level;
            D.28453 = log_level.74 > 0;
            D.28454 = (long int) D.28453;
            D.28455 = __builtin_expect (D.28454, 0);
            if (D.28455 != 0) goto <D.28491>; else goto <D.28492>;
            <D.28491>:
            log_file.75 = log_file;
            command_set.77 = (<unnamed type>) command_set;
            D.28493 = command_set_to_string (command_set.77);
            fprintf (log_file.75, "[dbg] Command %s(%s) [%d].\n", D.28493, cmd_str, id);
            log_file.75 = log_file;
            fflush (log_file.75);
            <D.28492>:
          }
        finally
          {
            cmd_num = {CLOBBER};
          }
      }
      <D.28487>:
      D.28494 = len + -11;
      D.28495 = (long unsigned int) D.28494;
      data = monoeg_malloc (D.28495);
      if (len > 11) goto <D.28496>; else goto <D.28497>;
      <D.28496>:
      D.28494 = len + -11;
      res = transport_recv (data, D.28494);
      D.28494 = len + -11;
      if (D.28494 != res) goto <D.28498>; else goto <D.28499>;
      <D.28498>:
      log_level.74 = log_level;
      D.28453 = log_level.74 > 0;
      D.28454 = (long int) D.28453;
      D.28455 = __builtin_expect (D.28454, 0);
      if (D.28455 != 0) goto <D.28500>; else goto <D.28501>;
      <D.28500>:
      log_file.75 = log_file;
      D.28494 = len + -11;
      fprintf (log_file.75, "[dbg] transport_recv () returned %d, expected %d.\n", res, D.28494);
      log_file.75 = log_file;
      fflush (log_file.75);
      <D.28501>:
      goto <D.27503>;
      <D.28499>:
      <D.28497>:
      p = data;
      D.28502 = (sizetype) len;
      D.28503 = D.28502 + 18446744073709551605;
      end = data + D.28503;
      buffer_init (&buf, 128);
      err = 0;
      no_reply = 0;
      switch (command_set) <default: <D.27519>, case 1: <D.27506>, case 9: <D.27518>, case 10: <D.27517>, case 11: <D.27514>, case 13: <D.27516>, case 15: <D.27508>, case 16: <D.27515>, case 20: <D.27509>, case 21: <D.27510>, case 22: <D.27513>, case 23: <D.27512>, case 24: <D.27511>>
      <D.27506>:
      p.76 = p;
      err = vm_commands (command, id, p.76, end, &buf);
      if (err == 0) goto <D.28504>; else goto <D.28505>;
      <D.28504>:
      if (command == 7) goto <D.28506>; else goto <D.28507>;
      <D.28506>:
      no_reply = 1;
      <D.28507>:
      <D.28505>:
      goto <D.27507>;
      <D.27508>:
      p.76 = p;
      err = event_commands (command, p.76, end, &buf);
      goto <D.27507>;
      <D.27509>:
      p.76 = p;
      err = domain_commands (command, p.76, end, &buf);
      goto <D.27507>;
      <D.27510>:
      p.76 = p;
      err = assembly_commands (command, p.76, end, &buf);
      goto <D.27507>;
      <D.27511>:
      p.76 = p;
      err = module_commands (command, p.76, end, &buf);
      goto <D.27507>;
      <D.27512>:
      p.76 = p;
      err = type_commands (command, p.76, end, &buf);
      goto <D.27507>;
      <D.27513>:
      p.76 = p;
      err = method_commands (command, p.76, end, &buf);
      goto <D.27507>;
      <D.27514>:
      p.76 = p;
      err = thread_commands (command, p.76, end, &buf);
      goto <D.27507>;
      <D.27515>:
      p.76 = p;
      err = frame_commands (command, p.76, end, &buf);
      goto <D.27507>;
      <D.27516>:
      p.76 = p;
      err = array_commands (command, p.76, end, &buf);
      goto <D.27507>;
      <D.27517>:
      p.76 = p;
      err = string_commands (command, p.76, end, &buf);
      goto <D.27507>;
      <D.27518>:
      p.76 = p;
      err = object_commands (command, p.76, end, &buf);
      goto <D.27507>;
      <D.27519>:
      err = 100;
      <D.27507>:
      if (no_reply == 0) goto <D.28508>; else goto <D.28509>;
      <D.28508>:
      err.78 = (int) err;
      send_reply_packet (id, err.78, &buf);
      <D.28509>:
      monoeg_g_free (data);
      buffer_free (&buf);
      if (command_set == 1) goto <D.28511>; else goto <D.28512>;
      <D.28511>:
      command.79 = (unsigned int) command;
      D.28514 = command.79 + 4294967291;
      if (D.28514 <= 1) goto <D.27503>; else goto <D.28515>;
      <D.28515>:
      <D.28512>:
      <D.27521>:
      if (attach_failed == 0) goto <D.27520>; else goto <D.27503>;
      <D.27503>:
      mono_set_is_debugger_attached (0);
      pthread_mutex_lock (&debugger_thread_exited_mutex);
      debugger_thread_exited = 1;
      pthread_cond_signal (&debugger_thread_exited_cond);
      pthread_mutex_unlock (&debugger_thread_exited_mutex);
      log_level.74 = log_level;
      D.28453 = log_level.74 > 0;
      D.28454 = (long int) D.28453;
      D.28455 = __builtin_expect (D.28454, 0);
      if (D.28455 != 0) goto <D.28516>; else goto <D.28517>;
      <D.28516>:
      log_file.75 = log_file;
      fprintf (log_file.75, "[dbg] Debugger thread exited.\n");
      log_file.75 = log_file;
      fflush (log_file.75);
      <D.28517>:
      if (attach_failed == 0) goto <D.28518>; else goto <D.28519>;
      <D.28518>:
      if (command_set == 1) goto <D.28520>; else goto <D.28521>;
      <D.28520>:
      if (command == 6) goto <D.28522>; else goto <D.28523>;
      <D.28522>:
      vm_death_event_sent.80 = vm_death_event_sent;
      if (vm_death_event_sent.80 == 0) goto <D.28525>; else goto <D.28526>;
      <D.28525>:
      D.28527 = mono_runtime_is_shutting_down ();
      if (D.28527 == 0) goto <D.28528>; else goto <D.28529>;
      <D.28528>:
      log_level.74 = log_level;
      D.28530 = log_level.74 > 1;
      D.28531 = (long int) D.28530;
      D.28532 = __builtin_expect (D.28531, 0);
      if (D.28532 != 0) goto <D.28533>; else goto <D.28534>;
      <D.28533>:
      log_file.75 = log_file;
      fprintf (log_file.75, "[dbg] Detached - restarting clean debugger thread.\n");
      log_file.75 = log_file;
      fflush (log_file.75);
      <D.28534>:
      start_debugger_thread ();
      <D.28529>:
      <D.28526>:
      <D.28523>:
      <D.28521>:
      <D.28519>:
      D.28535 = 0;
      return D.28535;
    }
  finally
    {
      header = {CLOBBER};
      p = {CLOBBER};
      buf = {CLOBBER};
    }
}


wait_for_attach ()
{
  int listen_fd.81;
  int log_level.82;
  _Bool D.28542;
  long int D.28543;
  long int D.28544;
  struct FILE * log_file.83;
  gboolean D.28548;
  int D.28549;
  int conn_fd.84;
  int D.28557;
  _Bool D.28558;
  int D.28559;
  int disconnected.85;

  listen_fd.81 = listen_fd;
  if (listen_fd.81 == -1) goto <D.28539>; else goto <D.28540>;
  <D.28539>:
  log_level.82 = log_level;
  D.28542 = log_level.82 > 0;
  D.28543 = (long int) D.28542;
  D.28544 = __builtin_expect (D.28543, 0);
  if (D.28544 != 0) goto <D.28545>; else goto <D.28546>;
  <D.28545>:
  log_file.83 = log_file;
  fprintf (log_file.83, "[dbg] Invalid listening socket\n");
  log_file.83 = log_file;
  fflush (log_file.83);
  <D.28546>:
  D.28548 = 0;
  return D.28548;
  <D.28540>:
  listen_fd.81 = listen_fd;
  D.28549 = socket_transport_accept (listen_fd.81);
  conn_fd = D.28549;
  log_level.82 = log_level;
  D.28542 = log_level.82 > 0;
  D.28543 = (long int) D.28542;
  D.28544 = __builtin_expect (D.28543, 0);
  if (D.28544 != 0) goto <D.28550>; else goto <D.28551>;
  <D.28550>:
  log_file.83 = log_file;
  conn_fd.84 = conn_fd;
  fprintf (log_file.83, "Accepted connection on %d\n", conn_fd.84);
  log_file.83 = log_file;
  fflush (log_file.83);
  <D.28551>:
  conn_fd.84 = conn_fd;
  if (conn_fd.84 == -1) goto <D.28553>; else goto <D.28554>;
  <D.28553>:
  log_level.82 = log_level;
  D.28542 = log_level.82 > 0;
  D.28543 = (long int) D.28542;
  D.28544 = __builtin_expect (D.28543, 0);
  if (D.28544 != 0) goto <D.28555>; else goto <D.28556>;
  <D.28555>:
  log_file.83 = log_file;
  fprintf (log_file.83, "[dbg] Bad client connection\n");
  log_file.83 = log_file;
  fflush (log_file.83);
  <D.28556>:
  D.28548 = 0;
  return D.28548;
  <D.28554>:
  D.28557 = transport_handshake ();
  D.28558 = D.28557 == 0;
  D.28559 = (int) D.28558;
  disconnected = D.28559;
  disconnected.85 = disconnected;
  if (disconnected.85 != 0) goto <D.28561>; else goto <D.28562>;
  <D.28561>:
  log_level.82 = log_level;
  D.28542 = log_level.82 > 0;
  D.28543 = (long int) D.28542;
  D.28544 = __builtin_expect (D.28543, 0);
  if (D.28544 != 0) goto <D.28563>; else goto <D.28564>;
  <D.28563>:
  log_file.83 = log_file;
  fprintf (log_file.83, "Transport handshake failed!\n");
  log_file.83 = log_file;
  fflush (log_file.83);
  <D.28564>:
  D.28548 = 0;
  return D.28548;
  <D.28562>:
  D.28548 = 1;
  return D.28548;
}


socket_transport_accept (int socket_fd)
{
  union 
{
  struct sockaddr * restrict __sockaddr__;
  struct sockaddr_at * restrict __sockaddr_at__;
  struct sockaddr_ax25 * restrict __sockaddr_ax25__;
  struct sockaddr_dl * restrict __sockaddr_dl__;
  struct sockaddr_eon * restrict __sockaddr_eon__;
  struct sockaddr_in * restrict __sockaddr_in__;
  struct sockaddr_in6 * restrict __sockaddr_in6__;
  struct sockaddr_inarp * restrict __sockaddr_inarp__;
  struct sockaddr_ipx * restrict __sockaddr_ipx__;
  struct sockaddr_iso * restrict __sockaddr_iso__;
  struct sockaddr_ns * restrict __sockaddr_ns__;
  struct sockaddr_un * restrict __sockaddr_un__;
  struct sockaddr_x25 * restrict __sockaddr_x25__;
} D.28566;
  int D.28567;
  int conn_fd.86;
  struct _IO_FILE * stderr.87;
  int log_level.88;
  _Bool D.28574;
  long int D.28575;
  long int D.28576;
  struct FILE * log_file.89;
  int D.28580;

  D.28566.__sockaddr__ = 0B;
  D.28567 = accept (socket_fd, D.28566, 0B);
  conn_fd = D.28567;
  conn_fd.86 = conn_fd;
  if (conn_fd.86 == -1) goto <D.28569>; else goto <D.28570>;
  <D.28569>:
  stderr.87 = stderr;
  fprintf (stderr.87, "debugger-agent: Unable to listen on %d\n", socket_fd);
  goto <D.28572>;
  <D.28570>:
  log_level.88 = log_level;
  D.28574 = log_level.88 > 0;
  D.28575 = (long int) D.28574;
  D.28576 = __builtin_expect (D.28575, 0);
  if (D.28576 != 0) goto <D.28577>; else goto <D.28578>;
  <D.28577>:
  log_file.89 = log_file;
  conn_fd.86 = conn_fd;
  fprintf (log_file.89, "Accepted connection from client, connection fd=%d.\n", conn_fd.86);
  log_file.89 = log_file;
  fflush (log_file.89);
  <D.28578>:
  <D.28572>:
  D.28580 = conn_fd;
  return D.28580;
}


transport_handshake ()
{
  long unsigned int D.28582;
  int D.28583;
  int * D.28585;
  int D.28586;
  _Bool D.28587;
  long int D.28588;
  long int D.28589;
  long unsigned int D.28592;
  int D.28593;
  long unsigned int D.28596;
  long unsigned int D.28597;
  long unsigned int D.28599;
  _Bool D.28600;
  long unsigned int D.28601;
  int D.28602;
  struct _IO_FILE * stderr.90;
  gboolean D.28604;
  int conn_fd.91;
  _Bool D.28608;
  long int D.28609;
  long int D.28610;
  char handshake_msg[128];
  guint8 buf[128];
  int res;

  try
    {
      disconnected = 1;
      sprintf (&handshake_msg, "DWP-Handshake");
      <D.25144>:
      D.28582 = __strlen_g (&handshake_msg);
      D.28583 = (int) D.28582;
      res = transport_send (&handshake_msg, D.28583);
      if (res == -1) goto <D.28584>; else goto <D.25145>;
      <D.28584>:
      D.28585 = __errno_location ();
      D.28586 = *D.28585;
      if (D.28586 == 4) goto <D.25144>; else goto <D.25145>;
      <D.25145>:
      D.28587 = res == -1;
      D.28588 = (long int) D.28587;
      D.28589 = __builtin_expect (D.28588, 0);
      if (D.28589 != 0) goto <D.28590>; else goto <D.28591>;
      <D.28590>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 1498, "res != -1");
      <D.28591>:
      D.28592 = __strlen_g (&handshake_msg);
      D.28593 = (int) D.28592;
      res = transport_recv (&buf, D.28593);
      D.28596 = (long unsigned int) res;
      D.28597 = __strlen_g (&handshake_msg);
      if (D.28596 != D.28597) goto <D.28594>; else goto <D.28598>;
      <D.28598>:
      D.28599 = __strlen_g (&handshake_msg);
      D.28600 = D.28599 != 0;
      D.28601 = (long unsigned int) D.28600;
      D.28602 = memcmp (&buf, &handshake_msg, D.28601);
      if (D.28602 != 0) goto <D.28594>; else goto <D.28595>;
      <D.28594>:
      stderr.90 = stderr;
      fprintf (stderr.90, "debugger-agent: DWP handshake failed.\n");
      D.28604 = 0;
      return D.28604;
      <D.28595>:
      major_version = 2;
      minor_version = 27;
      protocol_version_set = 0;
      conn_fd.91 = conn_fd;
      if (conn_fd.91 != 0) goto <D.28606>; else goto <D.28607>;
      <D.28606>:
      {
        int flag;
        int result;

        try
          {
            flag = 1;
            conn_fd.91 = conn_fd;
            result = setsockopt (conn_fd.91, 6, 1, &flag, 4);
            D.28608 = result < 0;
            D.28609 = (long int) D.28608;
            D.28610 = __builtin_expect (D.28609, 0);
            if (D.28610 != 0) goto <D.28611>; else goto <D.28612>;
            <D.28611>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 1528, "result >= 0");
            <D.28612>:
          }
        finally
          {
            flag = {CLOBBER};
          }
      }
      <D.28607>:
      set_keepalive ();
      disconnected = 0;
      D.28604 = 1;
      return D.28604;
    }
  finally
    {
      handshake_msg = {CLOBBER};
      buf = {CLOBBER};
    }
}


transport_send (void * buf, int len)
{
  int D.28615;
  struct DebuggerTransport * transport.92;
  gboolean (*<T40ad>) (void *, int) D.28617;

  transport.92 = transport;
  D.28617 = transport.92->send;
  D.28615 = D.28617 (buf, len);
  return D.28615;
}


set_keepalive ()
{
  int D.28621;
  int conn_fd.93;
  int D.28624;
  long int D.28625;
  int D.28626;
  int D.28627;
  long int D.28628;
  _Bool D.28629;
  long int D.28630;
  long int D.28631;
  struct timeval tv;
  int result;

  try
    {
      D.28621 = agent_config.keepalive;
      if (D.28621 == 0) goto <D.28619>; else goto <D.28622>;
      <D.28622>:
      conn_fd.93 = conn_fd;
      if (conn_fd.93 == 0) goto <D.28619>; else goto <D.28620>;
      <D.28619>:
      return;
      <D.28620>:
      D.28621 = agent_config.keepalive;
      D.28624 = D.28621 / 1000;
      D.28625 = (long int) D.28624;
      tv.tv_sec = D.28625;
      D.28621 = agent_config.keepalive;
      D.28626 = D.28621 % 1000;
      D.28627 = D.28626 * 1000;
      D.28628 = (long int) D.28627;
      tv.tv_usec = D.28628;
      conn_fd.93 = conn_fd;
      result = setsockopt (conn_fd.93, 1, 20, &tv, 16);
      D.28629 = result < 0;
      D.28630 = (long int) D.28629;
      D.28631 = __builtin_expect (D.28630, 0);
      if (D.28631 != 0) goto <D.28632>; else goto <D.28633>;
      <D.28632>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 1126, "result >= 0");
      <D.28633>:
    }
  finally
    {
      tv = {CLOBBER};
    }
}


decode_int (guint8 * buf, guint8 * * endbuf, guint8 * limit)
{
  guint8 * D.28637;
  guint8 * D.28638;
  _Bool D.28639;
  long int D.28640;
  long int D.28641;
  int D.28644;
  unsigned char D.28645;
  int D.28646;
  int D.28647;
  guint8 * D.28648;
  unsigned char D.28649;
  int D.28650;
  int D.28651;
  int D.28652;
  guint8 * D.28653;
  unsigned char D.28654;
  int D.28655;
  int D.28656;
  int D.28657;
  guint8 * D.28658;
  unsigned char D.28659;
  int D.28660;

  D.28637 = buf + 4;
  *endbuf = D.28637;
  D.28638 = *endbuf;
  D.28639 = D.28638 > limit;
  D.28640 = (long int) D.28639;
  D.28641 = __builtin_expect (D.28640, 0);
  if (D.28641 != 0) goto <D.28642>; else goto <D.28643>;
  <D.28642>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 1599, "*endbuf <= limit");
  <D.28643>:
  D.28645 = *buf;
  D.28646 = (int) D.28645;
  D.28647 = D.28646 << 24;
  D.28648 = buf + 1;
  D.28649 = *D.28648;
  D.28650 = (int) D.28649;
  D.28651 = D.28650 << 16;
  D.28652 = D.28647 | D.28651;
  D.28653 = buf + 2;
  D.28654 = *D.28653;
  D.28655 = (int) D.28654;
  D.28656 = D.28655 << 8;
  D.28657 = D.28652 | D.28656;
  D.28658 = buf + 3;
  D.28659 = *D.28658;
  D.28660 = (int) D.28659;
  D.28644 = D.28657 | D.28660;
  return D.28644;
}


decode_byte (guint8 * buf, guint8 * * endbuf, guint8 * limit)
{
  guint8 * D.28662;
  guint8 * D.28663;
  _Bool D.28664;
  long int D.28665;
  long int D.28666;
  int D.28669;
  unsigned char D.28670;

  D.28662 = buf + 1;
  *endbuf = D.28662;
  D.28663 = *endbuf;
  D.28664 = D.28663 > limit;
  D.28665 = (long int) D.28664;
  D.28666 = __builtin_expect (D.28665, 0);
  if (D.28666 != 0) goto <D.28667>; else goto <D.28668>;
  <D.28667>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 1591, "*endbuf <= limit");
  <D.28668>:
  D.28670 = *buf;
  D.28669 = (int) D.28670;
  return D.28669;
}


cmd_to_string (CommandSet set, int command)
{
  const char * D.28672;
  long unsigned int D.28676;
  long unsigned int D.28677;
  sizetype D.28678;
  const char * * D.28679;
  const char * * cmds;
  int cmds_len;

  cmds_len = 0;
  switch (set) <default: <D.27482>, case 1: <D.27468>, case 9: <D.27470>, case 10: <D.27471>, case 11: <D.27472>, case 13: <D.27473>, case 15: <D.27474>, case 16: <D.27475>, case 20: <D.27476>, case 21: <D.27477>, case 22: <D.27478>, case 23: <D.27479>, case 24: <D.27480>, case 64: <D.27481>>
  <D.27468>:
  cmds = &vm_cmds_str;
  cmds_len = 12;
  goto <D.27469>;
  <D.27470>:
  cmds = &object_cmds_str;
  cmds_len = 7;
  goto <D.27469>;
  <D.27471>:
  cmds = &string_cmds_str;
  cmds_len = 3;
  goto <D.27469>;
  <D.27472>:
  cmds = &thread_cmds_str;
  cmds_len = 6;
  goto <D.27469>;
  <D.27473>:
  cmds = &array_cmds_str;
  cmds_len = 3;
  goto <D.27469>;
  <D.27474>:
  cmds = &event_cmds_str;
  cmds_len = 3;
  goto <D.27469>;
  <D.27475>:
  cmds = &stack_frame_cmds_str;
  cmds_len = 3;
  goto <D.27469>;
  <D.27476>:
  cmds = &appdomain_cmds_str;
  cmds_len = 7;
  goto <D.27469>;
  <D.27477>:
  cmds = &assembly_cmds_str;
  cmds_len = 6;
  goto <D.27469>;
  <D.27478>:
  cmds = &method_cmds_str;
  cmds_len = 10;
  goto <D.27469>;
  <D.27479>:
  cmds = &type_cmds_str;
  cmds_len = 18;
  goto <D.27469>;
  <D.27480>:
  cmds = &module_cmds_str;
  cmds_len = 1;
  goto <D.27469>;
  <D.27481>:
  cmds = &event_cmds_str;
  cmds_len = 3;
  goto <D.27469>;
  <D.27482>:
  D.28672 = 0B;
  return D.28672;
  <D.27469>:
  if (command > 0) goto <D.28674>; else goto <D.28673>;
  <D.28674>:
  if (command <= cmds_len) goto <D.28675>; else goto <D.28673>;
  <D.28675>:
  D.28676 = (long unsigned int) command;
  D.28677 = D.28676 * 8;
  D.28678 = D.28677 + 18446744073709551608;
  D.28679 = cmds + D.28678;
  D.28672 = *D.28679;
  return D.28672;
  <D.28673>:
  D.28672 = 0B;
  return D.28672;
}


__attribute__((__artificial__, __gnu_inline__, __always_inline__, __leaf__, __nothrow__))
sprintf (char * restrict __s, const char * restrict __fmt)
{
  int D.28681;
  long unsigned int D.28682;

  D.28682 = __builtin_object_size (__s, 1);
  D.28681 = __builtin___sprintf_chk (__s, 1, D.28682, __fmt, __builtin_va_arg_pack ());
  return D.28681;
}


command_set_to_string (CommandSet command_set)
{
  const char * D.28684;

  switch (command_set) <default: <D.27449>, case 1: <D.27436>, case 9: <D.27437>, case 10: <D.27438>, case 11: <D.27439>, case 13: <D.27440>, case 15: <D.27441>, case 16: <D.27442>, case 20: <D.27443>, case 21: <D.27444>, case 22: <D.27445>, case 23: <D.27446>, case 24: <D.27447>, case 64: <D.27448>>
  <D.27436>:
  D.28684 = "VM";
  return D.28684;
  <D.27437>:
  D.28684 = "OBJECT_REF";
  return D.28684;
  <D.27438>:
  D.28684 = "STRING_REF";
  return D.28684;
  <D.27439>:
  D.28684 = "THREAD";
  return D.28684;
  <D.27440>:
  D.28684 = "ARRAY_REF";
  return D.28684;
  <D.27441>:
  D.28684 = "EVENT_REQUEST";
  return D.28684;
  <D.27442>:
  D.28684 = "STACK_FRAME";
  return D.28684;
  <D.27443>:
  D.28684 = "APPDOMAIN";
  return D.28684;
  <D.27444>:
  D.28684 = "ASSEMBLY";
  return D.28684;
  <D.27445>:
  D.28684 = "METHOD";
  return D.28684;
  <D.27446>:
  D.28684 = "TYPE";
  return D.28684;
  <D.27447>:
  D.28684 = "MODULE";
  return D.28684;
  <D.27448>:
  D.28684 = "EVENT";
  return D.28684;
  <D.27449>:
  D.28684 = "";
  return D.28684;
}


transport_recv (void * buf, int len)
{
  int D.28686;
  struct DebuggerTransport * transport.94;
  int (*<T40ae>) (void *, int) D.28688;

  transport.94 = transport;
  D.28688 = transport.94->recv;
  D.28686 = D.28688 (buf, len);
  return D.28686;
}


vm_commands (int command, int id, guint8 * p, guint8 * end, struct Buffer * buf)
{
  guint8 * p.95;
  int D.28691;
  int D.28692;
  int log_level.96;
  _Bool D.28694;
  long int D.28695;
  long int D.28696;
  struct FILE * log_file.97;
  int major_version.98;
  int minor_version.99;
  struct MonoGHashTable * tid_to_thread_obj.100;
  unsigned int D.28703;
  int suspend_count.101;
  ErrorCode D.28707;
  struct GPtrArray * event_requests.102;
  void * * D.28709;
  int D.28710;
  int D.28711;
  unsigned int D.28712;
  int D.28713;
  int D.28714;
  struct MonoImage * D.28715;
  struct MonoGHashTable * tid_to_thread.103;
  struct MonoGHashTable * thread_to_tls.104;
  void * D.28724;
  void * D.28725;
  void * D.28726;
  struct InvokeData * D.28727;
  int D.28728;
  <unnamed type> D.28736;
  int D.28744;
  struct MonoThread * thread.105;
  struct _MonoInternalThread * D.28748;
  _Bool D.28749;
  long int D.28750;
  long int D.28751;
  int D.28754;
  struct InvokeData * D.28757;
  void * D.28760;
  long int end.106;
  long int p.107;
  long int D.28763;
  long unsigned int D.28764;
  void * D.28765;
  guint8 * D.28766;
  long unsigned int D.28767;
  sizetype D.28768;
  guint8 * D.28769;
  unsigned int suspend_count.108;
  int D.28771;
  <unnamed type> D.28775;
  struct MonoThread * thread.109;
  struct _MonoInternalThread * D.28779;
  _Bool D.28780;
  long int D.28781;
  long int D.28782;
  int D.28785;
  struct InvokeData * D.28790;
  int D.28792;
  struct GHashTable * domains.110;
  struct MonoDomain * domain.111;
  void * D.28795;
  struct GHashTable * D.28796;
  struct GHashTable * D.28797;
  struct MonoClass * klass.112;
  void * D.28799;
  void * * D.28802;
  long unsigned int D.28803;
  long unsigned int D.28804;
  void * * D.28805;
  struct GHashTable * D.28806;
  gchar * D.28809;
  struct GHashTable * D.28811;
  gchar * D.28814;
  unsigned int D.28816;
  unsigned int i.113;
  int D.28818;
  void * klass.114;
  int D.28823;
  unsigned int D.28824;
  void * * D.28825;
  void * * D.28826;
  void * D.28827;
  void * * D.28828;
  void * * D.28829;
  void * D.28830;
  int D.28831;
  struct MonoDomain * domain.115;
  union mono_mutex_t * D.28835;
  _Bool D.28838;
  long int D.28839;
  long int D.28840;
  struct MonoImage * D.28843;
  struct MonoClass * D.28848;
  _Bool D.28851;
  long int D.28852;
  long int D.28853;
  int D.28856;
  unsigned int D.28857;
  void * * D.28858;
  long unsigned int D.28859;
  long unsigned int D.28860;
  void * * D.28861;
  void * D.28862;
  void * * D.28863;
  void * * D.28864;
  void * D.28865;
  unsigned int i.116;

  switch (command) <default: <D.26788>, case 1: <D.26676>, case 2: <D.26681>, case 3: <D.26682>, case 4: <D.26683>, case 5: <D.26692>, case 6: <D.26684>, case 7: <D.26709>, case 8: <D.26680>, case 9: <D.26722>, case 10: <D.26728>, case 11: <D.26730>, case 12: <D.26764>, case 13: <D.26710>>
  <D.26676>:
  {
    char * build_info;
    char * version;

    build_info = mono_get_runtime_build_info ();
    version = monoeg_g_strdup_printf ("mono %s", build_info);
    buffer_add_string (buf, version);
    buffer_add_int (buf, 2);
    buffer_add_int (buf, 27);
    monoeg_g_free (build_info);
    monoeg_g_free (version);
    goto <D.26679>;
  }
  <D.26680>:
  p.95 = p;
  D.28691 = decode_int (p.95, &p, end);
  major_version = D.28691;
  p.95 = p;
  D.28692 = decode_int (p.95, &p, end);
  minor_version = D.28692;
  protocol_version_set = 1;
  log_level.96 = log_level;
  D.28694 = log_level.96 > 0;
  D.28695 = (long int) D.28694;
  D.28696 = __builtin_expect (D.28695, 0);
  if (D.28696 != 0) goto <D.28697>; else goto <D.28698>;
  <D.28697>:
  log_file.97 = log_file;
  major_version.98 = major_version;
  minor_version.99 = minor_version;
  fprintf (log_file.97, "[dbg] Protocol version %d.%d, client protocol version %d.%d.\n", 2, 27, major_version.98, minor_version.99);
  log_file.97 = log_file;
  fflush (log_file.97);
  <D.28698>:
  goto <D.26679>;
  <D.26681>:
  mono_loader_lock ();
  tid_to_thread_obj.100 = tid_to_thread_obj;
  D.28703 = mono_g_hash_table_size (tid_to_thread_obj.100);
  buffer_add_int (buf, D.28703);
  tid_to_thread_obj.100 = tid_to_thread_obj;
  mono_g_hash_table_foreach (tid_to_thread_obj.100, add_thread, buf);
  mono_loader_unlock ();
  goto <D.26679>;
  <D.26682>:
  suspend_vm ();
  wait_for_suspend ();
  goto <D.26679>;
  <D.26683>:
  suspend_count.101 = suspend_count;
  if (suspend_count.101 == 0) goto <D.28705>; else goto <D.28706>;
  <D.28705>:
  D.28707 = 101;
  return D.28707;
  <D.28706>:
  resume_vm ();
  clear_suspended_objs ();
  goto <D.26679>;
  <D.26684>:
  mono_loader_lock ();
  goto <D.26687>;
  <D.26686>:
  {
    struct EventRequest * req;

    event_requests.102 = event_requests;
    D.28709 = event_requests.102->pdata;
    req = *D.28709;
    D.28710 = req->id;
    D.28711 = req->event_kind;
    clear_event_request (D.28710, D.28711);
  }
  <D.26687>:
  event_requests.102 = event_requests;
  D.28712 = event_requests.102->len;
  if (D.28712 != 0) goto <D.26686>; else goto <D.26688>;
  <D.26688>:
  mono_loader_unlock ();
  goto <D.26690>;
  <D.26689>:
  resume_vm ();
  <D.26690>:
  suspend_count.101 = suspend_count;
  if (suspend_count.101 > 0) goto <D.26689>; else goto <D.26691>;
  <D.26691>:
  disconnected = 1;
  vm_start_event_sent = 0;
  goto <D.26679>;
  <D.26692>:
  {
    struct MonoInternalThread * thread;
    struct DebuggerTlsData * tls;
    struct MonoClass * env_class;
    struct MonoMethod * exit_method;
    void * * args;
    int exit_code;

    exit_method = 0B;
    p.95 = p;
    exit_code = decode_int (p.95, &p, end);
    send_reply_packet (id, 0, buf);
    mono_loader_lock ();
    goto <D.26701>;
    <D.26700>:
    {
      struct EventRequest * req;

      event_requests.102 = event_requests;
      D.28709 = event_requests.102->pdata;
      req = *D.28709;
      D.28713 = req->id;
      D.28714 = req->event_kind;
      clear_event_request (D.28713, D.28714);
    }
    <D.26701>:
    event_requests.102 = event_requests;
    D.28712 = event_requests.102->len;
    if (D.28712 != 0) goto <D.26700>; else goto <D.26702>;
    <D.26702>:
    mono_loader_unlock ();
    suspend_vm ();
    wait_for_suspend ();
    D.28715 = mono_defaults.corlib;
    env_class = mono_class_from_name (D.28715, "System", "Environment");
    if (env_class != 0B) goto <D.28716>; else goto <D.28717>;
    <D.28716>:
    exit_method = mono_class_get_method_from_name (env_class, "Exit", 1);
    <D.28717>:
    mono_loader_lock ();
    tid_to_thread.103 = tid_to_thread;
    thread = mono_g_hash_table_find (tid_to_thread.103, is_really_suspended, 0B);
    mono_loader_unlock ();
    if (thread != 0B) goto <D.28721>; else goto <D.28719>;
    <D.28721>:
    if (exit_method != 0B) goto <D.28722>; else goto <D.28719>;
    <D.28722>:
    mono_loader_lock ();
    thread_to_tls.104 = thread_to_tls;
    tls = mono_g_hash_table_lookup (thread_to_tls.104, thread);
    mono_loader_unlock ();
    args = monoeg_malloc0 (8);
    D.28724 = monoeg_malloc (4);
    *args = D.28724;
    D.28725 = *args;
    MEM[(int *)D.28725] = exit_code;
    D.28726 = monoeg_malloc0 (576);
    tls->pending_invoke = D.28726;
    D.28727 = tls->pending_invoke;
    D.28727->method = exit_method;
    D.28727 = tls->pending_invoke;
    D.28727->args = args;
    D.28727 = tls->pending_invoke;
    D.28727->nmethods = 1;
    goto <D.26704>;
    <D.26703>:
    resume_vm ();
    <D.26704>:
    suspend_count.101 = suspend_count;
    if (suspend_count.101 > 0) goto <D.26703>; else goto <D.26705>;
    <D.26705>:
    goto <D.28720>;
    <D.28719>:
    goto <D.26707>;
    <D.26706>:
    resume_vm ();
    <D.26707>:
    suspend_count.101 = suspend_count;
    if (suspend_count.101 > 0) goto <D.26706>; else goto <D.26708>;
    <D.26708>:
    D.28728 = mono_runtime_try_shutdown ();
    if (D.28728 == 0) goto <D.26679>; else goto <D.28729>;
    <D.28729>:
    mono_environment_exitcode_set (exit_code);
    log_level.96 = log_level;
    D.28694 = log_level.96 > 0;
    D.28695 = (long int) D.28694;
    D.28696 = __builtin_expect (D.28695, 0);
    if (D.28696 != 0) goto <D.28730>; else goto <D.28731>;
    <D.28730>:
    log_file.97 = log_file;
    fprintf (log_file.97, "Suspending all threads...\n");
    log_file.97 = log_file;
    fflush (log_file.97);
    <D.28731>:
    mono_thread_suspend_all_other_threads ();
    log_level.96 = log_level;
    D.28694 = log_level.96 > 0;
    D.28695 = (long int) D.28694;
    D.28696 = __builtin_expect (D.28695, 0);
    if (D.28696 != 0) goto <D.28732>; else goto <D.28733>;
    <D.28732>:
    log_file.97 = log_file;
    fprintf (log_file.97, "Shutting down the runtime...\n");
    log_file.97 = log_file;
    fflush (log_file.97);
    <D.28733>:
    mono_runtime_quit ();
    transport_close2 ();
    log_level.96 = log_level;
    D.28694 = log_level.96 > 0;
    D.28695 = (long int) D.28694;
    D.28696 = __builtin_expect (D.28695, 0);
    if (D.28696 != 0) goto <D.28734>; else goto <D.28735>;
    <D.28734>:
    log_file.97 = log_file;
    fprintf (log_file.97, "Exiting...\n");
    log_file.97 = log_file;
    fflush (log_file.97);
    <D.28735>:
    exit (exit_code);
    <D.28720>:
    goto <D.26679>;
  }
  <D.26709>:
  <D.26710>:
  {
    int objid;
    struct MonoThread * thread;
    struct DebuggerTlsData * tls;
    int i;
    int count;
    int err;
    int flags;
    int nmethods;

    try
      {
        p.95 = p;
        objid = decode_objid (p.95, &p, end);
        D.28736 = get_object (objid, &thread);
        err = (int) D.28736;
        if (err != 0) goto <D.28737>; else goto <D.28738>;
        <D.28737>:
        D.28707 = (ErrorCode) err;
        return D.28707;
        <D.28738>:
        p.95 = p;
        flags = decode_int (p.95, &p, end);
        if (command == 13) goto <D.28739>; else goto <D.28740>;
        <D.28739>:
        p.95 = p;
        nmethods = decode_int (p.95, &p, end);
        goto <D.28741>;
        <D.28740>:
        nmethods = 1;
        <D.28741>:
        suspend_count.101 = suspend_count;
        if (suspend_count.101 != 0) goto <D.28742>; else goto <D.28743>;
        <D.28742>:
        wait_for_suspend ();
        <D.28743>:
        D.28744 = is_suspended ();
        if (D.28744 == 0) goto <D.28745>; else goto <D.28746>;
        <D.28745>:
        D.28707 = 101;
        return D.28707;
        <D.28746>:
        mono_loader_lock ();
        thread_to_tls.104 = thread_to_tls;
        thread.105 = thread;
        D.28748 = thread.105->internal_thread;
        tls = mono_g_hash_table_lookup (thread_to_tls.104, D.28748);
        mono_loader_unlock ();
        D.28749 = tls == 0B;
        D.28750 = (long int) D.28749;
        D.28751 = __builtin_expect (D.28750, 0);
        if (D.28751 != 0) goto <D.28752>; else goto <D.28753>;
        <D.28752>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 6722, "tls");
        <D.28753>:
        D.28754 = tls->really_suspended;
        if (D.28754 == 0) goto <D.28755>; else goto <D.28756>;
        <D.28755>:
        D.28707 = 101;
        return D.28707;
        <D.28756>:
        D.28757 = tls->pending_invoke;
        if (D.28757 != 0B) goto <D.28758>; else goto <D.28759>;
        <D.28758>:
        D.28707 = 101;
        return D.28707;
        <D.28759>:
        D.28760 = monoeg_malloc0 (576);
        tls->pending_invoke = D.28760;
        D.28757 = tls->pending_invoke;
        D.28757->id = id;
        D.28757 = tls->pending_invoke;
        D.28757->flags = flags;
        D.28757 = tls->pending_invoke;
        end.106 = (long int) end;
        p.95 = p;
        p.107 = (long int) p.95;
        D.28763 = end.106 - p.107;
        D.28764 = (long unsigned int) D.28763;
        D.28765 = monoeg_malloc (D.28764);
        D.28757->p = D.28765;
        D.28757 = tls->pending_invoke;
        D.28766 = D.28757->p;
        p.95 = p;
        end.106 = (long int) end;
        p.95 = p;
        p.107 = (long int) p.95;
        D.28763 = end.106 - p.107;
        D.28767 = (long unsigned int) D.28763;
        memcpy (D.28766, p.95, D.28767);
        D.28757 = tls->pending_invoke;
        D.28757 = tls->pending_invoke;
        D.28766 = D.28757->p;
        end.106 = (long int) end;
        p.95 = p;
        p.107 = (long int) p.95;
        D.28763 = end.106 - p.107;
        D.28768 = (sizetype) D.28763;
        D.28769 = D.28766 + D.28768;
        D.28757->endp = D.28769;
        D.28757 = tls->pending_invoke;
        suspend_count.101 = suspend_count;
        suspend_count.108 = (unsigned int) suspend_count.101;
        D.28757->suspend_count = suspend_count.108;
        D.28757 = tls->pending_invoke;
        D.28757->nmethods = nmethods;
        D.28771 = flags & 2;
        if (D.28771 != 0) goto <D.28772>; else goto <D.28773>;
        <D.28772>:
        thread.105 = thread;
        D.28748 = thread.105->internal_thread;
        resume_thread (D.28748);
        goto <D.28774>;
        <D.28773>:
        count = suspend_count;
        i = 0;
        goto <D.26720>;
        <D.26719>:
        resume_vm ();
        i = i + 1;
        <D.26720>:
        if (i < count) goto <D.26719>; else goto <D.26721>;
        <D.26721>:
        <D.28774>:
        goto <D.26679>;
      }
    finally
      {
        thread = {CLOBBER};
      }
  }
  <D.26722>:
  {
    int objid;
    struct MonoThread * thread;
    struct DebuggerTlsData * tls;
    int invoke_id;
    int err;

    try
      {
        p.95 = p;
        objid = decode_objid (p.95, &p, end);
        D.28775 = get_object (objid, &thread);
        err = (int) D.28775;
        if (err != 0) goto <D.28776>; else goto <D.28777>;
        <D.28776>:
        D.28707 = (ErrorCode) err;
        return D.28707;
        <D.28777>:
        p.95 = p;
        invoke_id = decode_int (p.95, &p, end);
        mono_loader_lock ();
        thread_to_tls.104 = thread_to_tls;
        thread.109 = thread;
        D.28779 = thread.109->internal_thread;
        tls = mono_g_hash_table_lookup (thread_to_tls.104, D.28779);
        D.28780 = tls == 0B;
        D.28781 = (long int) D.28780;
        D.28782 = __builtin_expect (D.28781, 0);
        if (D.28782 != 0) goto <D.28783>; else goto <D.28784>;
        <D.28783>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 6767, "tls");
        <D.28784>:
        D.28785 = tls->abort_requested;
        if (D.28785 != 0) goto <D.28786>; else goto <D.28787>;
        <D.28786>:
        mono_loader_unlock ();
        goto <D.26679>;
        <D.28787>:
        D.28790 = tls->invoke;
        if (D.28790 == 0B) goto <D.28788>; else goto <D.28791>;
        <D.28791>:
        D.28790 = tls->invoke;
        D.28792 = D.28790->id;
        if (D.28792 != invoke_id) goto <D.28788>; else goto <D.28789>;
        <D.28788>:
        mono_loader_unlock ();
        D.28707 = 104;
        return D.28707;
        <D.28789>:
        tls->abort_requested = 1;
        thread.109 = thread;
        D.28779 = thread.109->internal_thread;
        ves_icall_System_Threading_Thread_Abort (D.28779, 0B);
        mono_loader_unlock ();
        goto <D.26679>;
      }
    finally
      {
        thread = {CLOBBER};
      }
  }
  <D.26728>:
  {
    int timeout;

    p.95 = p;
    timeout = decode_int (p.95, &p, end);
    agent_config.keepalive = timeout;
    set_keepalive ();
    goto <D.26679>;
  }
  <D.26730>:
  {
    struct GHashTableIter iter;
    struct GHashTableIter kiter;
    struct MonoDomain * domain;
    struct MonoClass * klass;
    struct GPtrArray * files;
    int i;
    char * fname;
    char * basename;
    gboolean ignore_case;
    struct GSList * class_list;
    struct GSList * l;
    struct GPtrArray * res_classes;
    struct GPtrArray * res_domains;

    try
      {
        p.95 = p;
        fname = decode_string (p.95, &p, end);
        p.95 = p;
        ignore_case = decode_byte (p.95, &p, end);
        basename = monoeg_g_path_get_basename (fname);
        res_classes = monoeg_g_ptr_array_new ();
        res_domains = monoeg_g_ptr_array_new ();
        mono_loader_lock ();
        domains.110 = domains;
        monoeg_g_hash_table_iter_init (&iter, domains.110);
        goto <D.26759>;
        <D.26758>:
        {
          struct AgentDomainInfo * info;

          domain.111 = domain;
          D.28795 = domain.111->runtime_info;
          info = MEM[(struct MonoJitDomainInfo *)D.28795].agent_info;
          D.28796 = info->loaded_classes;
          monoeg_g_hash_table_iter_init (&kiter, D.28796);
          goto <D.26752>;
          <D.26751>:
          D.28797 = info->source_files;
          klass.112 = klass;
          D.28799 = monoeg_g_hash_table_lookup (D.28797, klass.112);
          if (D.28799 == 0B) goto <D.28800>; else goto <D.28801>;
          <D.28800>:
          klass.112 = klass;
          files = get_source_files_for_type (klass.112);
          D.28797 = info->source_files;
          klass.112 = klass;
          monoeg_g_hash_table_insert_replace (D.28797, klass.112, files, 0);
          i = 0;
          goto <D.26749>;
          <D.26748>:
          {
            char * s;
            char * s2;
            char * s3;

            D.28802 = files->pdata;
            D.28803 = (long unsigned int) i;
            D.28804 = D.28803 * 8;
            D.28805 = D.28802 + D.28804;
            s = *D.28805;
            s2 = monoeg_g_path_get_basename (s);
            D.28806 = info->source_file_to_class;
            class_list = monoeg_g_hash_table_lookup (D.28806, s2);
            if (class_list == 0B) goto <D.28807>; else goto <D.28808>;
            <D.28807>:
            klass.112 = klass;
            class_list = monoeg_g_slist_prepend (class_list, klass.112);
            D.28806 = info->source_file_to_class;
            D.28809 = monoeg_strdup (s2);
            monoeg_g_hash_table_insert_replace (D.28806, D.28809, class_list, 0);
            goto <D.28810>;
            <D.28808>:
            klass.112 = klass;
            class_list = monoeg_g_slist_prepend (class_list, klass.112);
            D.28806 = info->source_file_to_class;
            monoeg_g_hash_table_insert_replace (D.28806, s2, class_list, 0);
            <D.28810>:
            s3 = strdup_tolower (s2);
            D.28811 = info->source_file_to_class_ignorecase;
            class_list = monoeg_g_hash_table_lookup (D.28811, s3);
            if (class_list == 0B) goto <D.28812>; else goto <D.28813>;
            <D.28812>:
            klass.112 = klass;
            class_list = monoeg_g_slist_prepend (class_list, klass.112);
            D.28811 = info->source_file_to_class_ignorecase;
            D.28814 = monoeg_strdup (s3);
            monoeg_g_hash_table_insert_replace (D.28811, D.28814, class_list, 0);
            goto <D.28815>;
            <D.28813>:
            klass.112 = klass;
            class_list = monoeg_g_slist_prepend (class_list, klass.112);
            D.28811 = info->source_file_to_class_ignorecase;
            monoeg_g_hash_table_insert_replace (D.28811, s3, class_list, 0);
            <D.28815>:
            monoeg_g_free (s2);
            monoeg_g_free (s3);
          }
          i = i + 1;
          <D.26749>:
          D.28816 = files->len;
          i.113 = (unsigned int) i;
          if (D.28816 > i.113) goto <D.26748>; else goto <D.26750>;
          <D.26750>:
          <D.28801>:
          <D.26752>:
          D.28818 = monoeg_g_hash_table_iter_next (&kiter, 0B, &klass);
          if (D.28818 != 0) goto <D.26751>; else goto <D.26753>;
          <D.26753>:
          if (ignore_case != 0) goto <D.28819>; else goto <D.28820>;
          <D.28819>:
          {
            char * s;

            s = strdup_tolower (basename);
            D.28811 = info->source_file_to_class_ignorecase;
            class_list = monoeg_g_hash_table_lookup (D.28811, s);
            monoeg_g_free (s);
          }
          goto <D.28821>;
          <D.28820>:
          D.28806 = info->source_file_to_class;
          class_list = monoeg_g_hash_table_lookup (D.28806, basename);
          <D.28821>:
          l = class_list;
          goto <D.26756>;
          <D.26755>:
          klass.114 = l->data;
          klass = klass.114;
          klass.112 = klass;
          monoeg_g_ptr_array_add (res_classes, klass.112);
          domain.111 = domain;
          monoeg_g_ptr_array_add (res_domains, domain.111);
          l = l->next;
          <D.26756>:
          if (l != 0B) goto <D.26755>; else goto <D.26757>;
          <D.26757>:
        }
        <D.26759>:
        D.28823 = monoeg_g_hash_table_iter_next (&iter, 0B, &domain);
        if (D.28823 != 0) goto <D.26758>; else goto <D.26760>;
        <D.26760>:
        mono_loader_unlock ();
        monoeg_g_free (fname);
        monoeg_g_free (basename);
        D.28824 = res_classes->len;
        buffer_add_int (buf, D.28824);
        i = 0;
        goto <D.26762>;
        <D.26761>:
        D.28825 = res_domains->pdata;
        D.28803 = (long unsigned int) i;
        D.28804 = D.28803 * 8;
        D.28826 = D.28825 + D.28804;
        D.28827 = *D.28826;
        D.28828 = res_classes->pdata;
        D.28803 = (long unsigned int) i;
        D.28804 = D.28803 * 8;
        D.28829 = D.28828 + D.28804;
        D.28830 = *D.28829;
        buffer_add_typeid (buf, D.28827, D.28830);
        i = i + 1;
        <D.26762>:
        D.28824 = res_classes->len;
        i.113 = (unsigned int) i;
        if (D.28824 > i.113) goto <D.26761>; else goto <D.26763>;
        <D.26763>:
        monoeg_g_ptr_array_free (res_classes, 1);
        monoeg_g_ptr_array_free (res_domains, 1);
        goto <D.26679>;
      }
    finally
      {
        iter = {CLOBBER};
        kiter = {CLOBBER};
        domain = {CLOBBER};
        klass = {CLOBBER};
      }
  }
  <D.26764>:
  {
    struct GHashTableIter iter;
    struct MonoDomain * domain;
    int i;
    char * name;
    gboolean ignore_case;
    struct GPtrArray * res_classes;
    struct GPtrArray * res_domains;
    struct MonoTypeNameParse info;

    try
      {
        p.95 = p;
        name = decode_string (p.95, &p, end);
        p.95 = p;
        ignore_case = decode_byte (p.95, &p, end);
        D.28831 = mono_reflection_parse_type (name, &info);
        if (D.28831 == 0) goto <D.28832>; else goto <D.28833>;
        <D.28832>:
        monoeg_g_free (name);
        mono_reflection_free_type_info (&info);
        D.28707 = 102;
        return D.28707;
        <D.28833>:
        res_classes = monoeg_g_ptr_array_new ();
        res_domains = monoeg_g_ptr_array_new ();
        mono_loader_lock ();
        domains.110 = domains;
        monoeg_g_hash_table_iter_init (&iter, domains.110);
        goto <D.26783>;
        <D.26782>:
        {
          struct MonoAssembly * ass;
          gboolean type_resolve;
          struct MonoType * t;
          struct GSList * tmp;

          try
            {
              {
                int ret;

                domain.115 = domain;
                D.28835 = &domain.115->assemblies_lock.mutex;
                ret = pthread_mutex_lock (D.28835);
                if (ret != 0) goto <D.28836>; else goto <D.28837>;
                <D.28836>:
                monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
                <D.28837>:
                D.28838 = ret != 0;
                D.28839 = (long int) D.28838;
                D.28840 = __builtin_expect (D.28839, 0);
                if (D.28840 != 0) goto <D.28841>; else goto <D.28842>;
                <D.28841>:
                monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 6927, "ret == 0");
                <D.28842>:
              }
              domain.115 = domain;
              tmp = domain.115->domain_assemblies;
              goto <D.26779>;
              <D.26778>:
              ass = tmp->data;
              D.28843 = ass->image;
              if (D.28843 != 0B) goto <D.28844>; else goto <D.28845>;
              <D.28844>:
              type_resolve = 1;
              D.28843 = ass->image;
              t = mono_reflection_get_type (D.28843, &info, ignore_case, &type_resolve);
              if (t != 0B) goto <D.28846>; else goto <D.28847>;
              <D.28846>:
              D.28848 = mono_type_get_class (t);
              monoeg_g_ptr_array_add (res_classes, D.28848);
              domain.115 = domain;
              monoeg_g_ptr_array_add (res_domains, domain.115);
              <D.28847>:
              <D.28845>:
              tmp = tmp->next;
              <D.26779>:
              if (tmp != 0B) goto <D.26778>; else goto <D.26780>;
              <D.26780>:
              {
                int ret;

                domain.115 = domain;
                D.28835 = &domain.115->assemblies_lock.mutex;
                ret = pthread_mutex_unlock (D.28835);
                if (ret != 0) goto <D.28849>; else goto <D.28850>;
                <D.28849>:
                monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
                <D.28850>:
                D.28851 = ret != 0;
                D.28852 = (long int) D.28851;
                D.28853 = __builtin_expect (D.28852, 0);
                if (D.28853 != 0) goto <D.28854>; else goto <D.28855>;
                <D.28854>:
                monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 6940, "ret == 0");
                <D.28855>:
              }
            }
          finally
            {
              type_resolve = {CLOBBER};
            }
        }
        <D.26783>:
        D.28856 = monoeg_g_hash_table_iter_next (&iter, 0B, &domain);
        if (D.28856 != 0) goto <D.26782>; else goto <D.26784>;
        <D.26784>:
        mono_loader_unlock ();
        monoeg_g_free (name);
        mono_reflection_free_type_info (&info);
        D.28857 = res_classes->len;
        buffer_add_int (buf, D.28857);
        i = 0;
        goto <D.26786>;
        <D.26785>:
        D.28858 = res_domains->pdata;
        D.28859 = (long unsigned int) i;
        D.28860 = D.28859 * 8;
        D.28861 = D.28858 + D.28860;
        D.28862 = *D.28861;
        D.28863 = res_classes->pdata;
        D.28859 = (long unsigned int) i;
        D.28860 = D.28859 * 8;
        D.28864 = D.28863 + D.28860;
        D.28865 = *D.28864;
        buffer_add_typeid (buf, D.28862, D.28865);
        i = i + 1;
        <D.26786>:
        D.28857 = res_classes->len;
        i.116 = (unsigned int) i;
        if (D.28857 > i.116) goto <D.26785>; else goto <D.26787>;
        <D.26787>:
        monoeg_g_ptr_array_free (res_classes, 1);
        monoeg_g_ptr_array_free (res_domains, 1);
        goto <D.26679>;
      }
    finally
      {
        iter = {CLOBBER};
        domain = {CLOBBER};
        info = {CLOBBER};
      }
  }
  <D.26788>:
  D.28707 = 100;
  return D.28707;
  <D.26679>:
  D.28707 = 0;
  return D.28707;
}


is_really_suspended (void * key, void * value, void * user_data)
{
  struct MonoGHashTable * thread_to_tls.117;
  _Bool D.28876;
  long int D.28877;
  long int D.28878;
  gboolean D.28881;
  struct MonoThread * thread;
  struct DebuggerTlsData * tls;
  gboolean res;

  thread = value;
  mono_loader_lock ();
  thread_to_tls.117 = thread_to_tls;
  tls = mono_g_hash_table_lookup (thread_to_tls.117, thread);
  D.28876 = tls == 0B;
  D.28877 = (long int) D.28876;
  D.28878 = __builtin_expect (D.28877, 0);
  if (D.28878 != 0) goto <D.28879>; else goto <D.28880>;
  <D.28879>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 6512, "tls");
  <D.28880>:
  res = tls->really_suspended;
  mono_loader_unlock ();
  D.28881 = res;
  return D.28881;
}


add_thread (void * key, void * value, void * user_data)
{
  struct MonoInternalThread * thread;
  struct Buffer * buf;

  thread = value;
  buf = user_data;
  buffer_add_objid (buf, thread);
}


clear_suspended_objs ()
{
  struct MonoGHashTable * suspended_objs.118;

  mono_loader_lock ();
  suspended_objs.118 = suspended_objs;
  mono_g_hash_table_foreach_remove (suspended_objs.118, true_pred, 0B);
  mono_loader_unlock ();
}


true_pred (void * key, void * value, void * user_data)
{
  gboolean D.28884;

  D.28884 = 1;
  return D.28884;
}


clear_event_request (int req_id, int etype)
{
  struct GPtrArray * event_requests.119;
  void * * D.28887;
  long unsigned int D.28888;
  long unsigned int D.28889;
  void * * D.28890;
  int D.28891;
  int D.28894;
  void * D.28899;
  unsigned int i.120;
  unsigned int D.28907;
  int i;

  mono_loader_lock ();
  i = 0;
  goto <D.26551>;
  <D.26550>:
  {
    struct EventRequest * req;

    event_requests.119 = event_requests;
    D.28887 = event_requests.119->pdata;
    D.28888 = (long unsigned int) i;
    D.28889 = D.28888 * 8;
    D.28890 = D.28887 + D.28889;
    req = *D.28890;
    D.28891 = req->id;
    if (D.28891 == req_id) goto <D.28892>; else goto <D.28893>;
    <D.28892>:
    D.28894 = req->event_kind;
    if (D.28894 == etype) goto <D.28895>; else goto <D.28896>;
    <D.28895>:
    D.28894 = req->event_kind;
    if (D.28894 == 10) goto <D.28897>; else goto <D.28898>;
    <D.28897>:
    D.28899 = req->info;
    clear_breakpoint (D.28899);
    <D.28898>:
    D.28894 = req->event_kind;
    if (D.28894 == 11) goto <D.28900>; else goto <D.28901>;
    <D.28900>:
    D.28899 = req->info;
    ss_destroy (D.28899);
    <D.28901>:
    D.28894 = req->event_kind;
    if (D.28894 == 6) goto <D.28902>; else goto <D.28903>;
    <D.28902>:
    D.28899 = req->info;
    clear_breakpoint (D.28899);
    <D.28903>:
    D.28894 = req->event_kind;
    if (D.28894 == 7) goto <D.28904>; else goto <D.28905>;
    <D.28904>:
    D.28899 = req->info;
    clear_breakpoint (D.28899);
    <D.28905>:
    event_requests.119 = event_requests;
    i.120 = (unsigned int) i;
    monoeg_g_ptr_array_remove_index_fast (event_requests.119, i.120);
    monoeg_g_free (req);
    goto <D.26549>;
    <D.28896>:
    <D.28893>:
  }
  i = i + 1;
  <D.26551>:
  event_requests.119 = event_requests;
  D.28907 = event_requests.119->len;
  i.120 = (unsigned int) i;
  if (D.28907 > i.120) goto <D.26550>; else goto <D.26549>;
  <D.26549>:
  mono_loader_unlock ();
}


transport_close2 ()
{
  struct DebuggerTransport * transport.121;
  void (*<T8f1>) (void) D.28909;

  transport.121 = transport;
  D.28909 = transport.121->close2;
  D.28909 ();
}


wait_for_suspend ()
{
  struct MonoGHashTable * thread_to_tls.122;
  unsigned int D.28911;
  int log_level.123;
  _Bool D.28914;
  long int D.28915;
  long int D.28916;
  struct FILE * log_file.124;
  _Bool D.28920;
  long int D.28921;
  long int D.28922;
  int nthreads;
  int nwait;
  int err;
  gboolean waited;

  waited = 0;
  mono_loader_lock ();
  thread_to_tls.122 = thread_to_tls;
  D.28911 = mono_g_hash_table_size (thread_to_tls.122);
  nthreads = (int) D.28911;
  mono_loader_unlock ();
  <D.25620>:
  nwait = count_threads_to_wait_for ();
  if (nwait != 0) goto <D.28912>; else goto <D.25619>;
  <D.28912>:
  log_level.123 = log_level;
  D.28914 = log_level.123 > 0;
  D.28915 = (long int) D.28914;
  D.28916 = __builtin_expect (D.28915, 0);
  if (D.28916 != 0) goto <D.28917>; else goto <D.28918>;
  <D.28917>:
  log_file.124 = log_file;
  fprintf (log_file.124, "Waiting for %d(%d) threads to suspend...\n", nwait, nthreads);
  log_file.124 = log_file;
  fflush (log_file.124);
  <D.28918>:
  err = mono_sem_wait (&suspend_sem, 0);
  D.28920 = err != 0;
  D.28921 = (long int) D.28920;
  D.28922 = __builtin_expect (D.28921, 0);
  if (D.28922 != 0) goto <D.28923>; else goto <D.28924>;
  <D.28923>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 2962, "err == 0");
  <D.28924>:
  waited = 1;
  goto <D.25620>;
  <D.25619>:
  if (waited != 0) goto <D.28925>; else goto <D.28926>;
  <D.28925>:
  log_level.123 = log_level;
  D.28914 = log_level.123 > 0;
  D.28915 = (long int) D.28914;
  D.28916 = __builtin_expect (D.28915, 0);
  if (D.28916 != 0) goto <D.28927>; else goto <D.28928>;
  <D.28927>:
  log_file.124 = log_file;
  fprintf (log_file.124, "%d threads suspended.\n", nthreads);
  log_file.124 = log_file;
  fflush (log_file.124);
  <D.28928>:
  <D.28926>:
}


count_threads_to_wait_for ()
{
  struct MonoGHashTable * thread_to_tls.125;
  int D.28930;
  int count;

  try
    {
      count = 0;
      mono_loader_lock ();
      thread_to_tls.125 = thread_to_tls;
      mono_g_hash_table_foreach (thread_to_tls.125, count_thread, &count);
      mono_loader_unlock ();
      D.28930 = count;
      return D.28930;
    }
  finally
    {
      count = {CLOBBER};
    }
}


count_thread (void * key, void * value, void * user_data)
{
  int D.28933;
  int D.28936;
  int D.28939;
  int D.28940;
  struct DebuggerTlsData * tls;

  tls = value;
  D.28933 = tls->suspended;
  if (D.28933 == 0) goto <D.28934>; else goto <D.28935>;
  <D.28934>:
  D.28936 = tls->terminated;
  if (D.28936 == 0) goto <D.28937>; else goto <D.28938>;
  <D.28937>:
  D.28939 = MEM[(int *)user_data];
  D.28940 = D.28939 + 1;
  MEM[(int *)user_data] = D.28940;
  <D.28938>:
  <D.28935>:
}


is_suspended ()
{
  gboolean D.28941;
  int D.28942;
  _Bool D.28943;

  D.28942 = count_threads_to_wait_for ();
  D.28943 = D.28942 == 0;
  D.28941 = (gboolean) D.28943;
  return D.28941;
}


resume_thread (struct MonoInternalThread * thread)
{
  long unsigned int D.28945;
  long unsigned int debugger_thread_id.126;
  _Bool D.28947;
  long int D.28948;
  long int D.28949;
  struct MonoGHashTable * thread_to_tls.127;
  _Bool D.28953;
  long int D.28954;
  long int D.28955;
  int suspend_count.128;
  _Bool D.28959;
  long int D.28960;
  long int D.28961;
  int log_level.129;
  _Bool D.28965;
  long int D.28966;
  long int D.28967;
  struct FILE * log_file.130;
  long unsigned int D.28971;
  void * D.28972;
  unsigned int D.28973;
  unsigned int suspend_count.131;
  unsigned int D.28975;
  _Bool D.28976;
  long int D.28977;
  long int D.28978;
  int err;
  struct DebuggerTlsData * tls;

  D.28945 = GetCurrentThreadId ();
  debugger_thread_id.126 = debugger_thread_id;
  D.28947 = D.28945 != debugger_thread_id.126;
  D.28948 = (long int) D.28947;
  D.28949 = __builtin_expect (D.28948, 0);
  if (D.28949 != 0) goto <D.28950>; else goto <D.28951>;
  <D.28950>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 2796, "debugger_thread_id == GetCurrentThreadId ()");
  <D.28951>:
  mono_loader_lock ();
  thread_to_tls.127 = thread_to_tls;
  tls = mono_g_hash_table_lookup (thread_to_tls.127, thread);
  D.28953 = tls == 0B;
  D.28954 = (long int) D.28953;
  D.28955 = __builtin_expect (D.28954, 0);
  if (D.28955 != 0) goto <D.28956>; else goto <D.28957>;
  <D.28956>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 2801, "tls");
  <D.28957>:
  pthread_mutex_lock (&suspend_mutex);
  suspend_count.128 = suspend_count;
  D.28959 = suspend_count.128 <= 0;
  D.28960 = (long int) D.28959;
  D.28961 = __builtin_expect (D.28960, 0);
  if (D.28961 != 0) goto <D.28962>; else goto <D.28963>;
  <D.28962>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 2805, "suspend_count > 0");
  <D.28963>:
  log_level.129 = log_level;
  D.28965 = log_level.129 > 0;
  D.28966 = (long int) D.28965;
  D.28967 = __builtin_expect (D.28966, 0);
  if (D.28967 != 0) goto <D.28968>; else goto <D.28969>;
  <D.28968>:
  log_file.130 = log_file;
  D.28971 = thread->tid;
  D.28972 = (void *) D.28971;
  fprintf (log_file.130, "[%p] Resuming thread...\n", D.28972);
  log_file.130 = log_file;
  fflush (log_file.130);
  <D.28969>:
  D.28973 = tls->resume_count;
  suspend_count.128 = suspend_count;
  suspend_count.131 = (unsigned int) suspend_count.128;
  D.28975 = D.28973 + suspend_count.131;
  tls->resume_count = D.28975;
  err = pthread_cond_broadcast (&suspend_cond);
  D.28976 = err != 0;
  D.28977 = (long int) D.28976;
  D.28978 = __builtin_expect (D.28977, 0);
  if (D.28978 != 0) goto <D.28979>; else goto <D.28980>;
  <D.28979>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 2816, "err == 0");
  <D.28980>:
  pthread_mutex_unlock (&suspend_mutex);
  mono_loader_unlock ();
}


resume_vm ()
{
  long unsigned int D.28981;
  long unsigned int debugger_thread_id.132;
  _Bool D.28983;
  long int D.28984;
  long int D.28985;
  int suspend_count.133;
  _Bool D.28989;
  long int D.28990;
  long int D.28991;
  int D.28994;
  int log_level.134;
  _Bool D.28996;
  long int D.28997;
  long int D.28998;
  struct FILE * log_file.135;
  long unsigned int D.29002;
  void * D.29003;
  struct MonoGHashTable * thread_to_tls.136;
  _Bool D.29007;
  long int D.29008;
  long int D.29009;
  int err;

  D.28981 = GetCurrentThreadId ();
  debugger_thread_id.132 = debugger_thread_id;
  D.28983 = D.28981 != debugger_thread_id.132;
  D.28984 = (long int) D.28983;
  D.28985 = __builtin_expect (D.28984, 0);
  if (D.28985 != 0) goto <D.28986>; else goto <D.28987>;
  <D.28986>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 2755, "debugger_thread_id == GetCurrentThreadId ()");
  <D.28987>:
  mono_loader_lock ();
  pthread_mutex_lock (&suspend_mutex);
  suspend_count.133 = suspend_count;
  D.28989 = suspend_count.133 <= 0;
  D.28990 = (long int) D.28989;
  D.28991 = __builtin_expect (D.28990, 0);
  if (D.28991 != 0) goto <D.28992>; else goto <D.28993>;
  <D.28992>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 2761, "suspend_count > 0");
  <D.28993>:
  suspend_count.133 = suspend_count;
  D.28994 = suspend_count.133 + -1;
  suspend_count = D.28994;
  log_level.134 = log_level;
  D.28996 = log_level.134 > 0;
  D.28997 = (long int) D.28996;
  D.28998 = __builtin_expect (D.28997, 0);
  if (D.28998 != 0) goto <D.28999>; else goto <D.29000>;
  <D.28999>:
  log_file.135 = log_file;
  D.29002 = GetCurrentThreadId ();
  D.29003 = (void *) D.29002;
  suspend_count.133 = suspend_count;
  fprintf (log_file.135, "[%p] Resuming vm, suspend count=%d...\n", D.29003, suspend_count.133);
  log_file.135 = log_file;
  fflush (log_file.135);
  <D.29000>:
  suspend_count.133 = suspend_count;
  if (suspend_count.133 == 0) goto <D.29004>; else goto <D.29005>;
  <D.29004>:
  stop_single_stepping ();
  thread_to_tls.136 = thread_to_tls;
  mono_g_hash_table_foreach (thread_to_tls.136, reset_native_thread_suspend_state, 0B);
  <D.29005>:
  err = pthread_cond_broadcast (&suspend_cond);
  D.29007 = err != 0;
  D.29008 = (long int) D.29007;
  D.29009 = __builtin_expect (D.29008, 0);
  if (D.29009 != 0) goto <D.29010>; else goto <D.29011>;
  <D.29010>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 2774, "err == 0");
  <D.29011>:
  pthread_mutex_unlock (&suspend_mutex);
  suspend_count.133 = suspend_count;
  if (suspend_count.133 == 0) goto <D.29012>; else goto <D.29013>;
  <D.29012>:
  mono_thread_pool_resume ();
  <D.29013>:
  mono_loader_unlock ();
}


reset_native_thread_suspend_state (void * key, void * value, void * user_data)
{
  int D.29014;
  int D.29017;
  struct DebuggerTlsData * tls;

  tls = value;
  D.29014 = tls->really_suspended;
  if (D.29014 == 0) goto <D.29015>; else goto <D.29016>;
  <D.29015>:
  D.29017 = tls->suspended;
  if (D.29017 != 0) goto <D.29018>; else goto <D.29019>;
  <D.29018>:
  tls->suspended = 0;
  tls->context.valid = 0;
  tls->async_state.valid = 0;
  invalidate_frames (tls);
  <D.29019>:
  <D.29016>:
}


invalidate_frames (struct DebuggerTlsData * tls)
{
  unsigned int debugger_tls_id.137;
  _Bool D.29023;
  long int D.29024;
  long int D.29025;
  struct StackFrame * * D.29028;
  long unsigned int D.29029;
  long unsigned int D.29030;
  struct StackFrame * * D.29031;
  struct StackFrame * D.29032;
  struct MonoDebugMethodJitInfo * D.29033;
  int D.29036;
  int i;

  if (tls == 0B) goto <D.29020>; else goto <D.29021>;
  <D.29020>:
  debugger_tls_id.137 = debugger_tls_id;
  tls = pthread_getspecific (debugger_tls_id.137);
  <D.29021>:
  D.29023 = tls == 0B;
  D.29024 = (long int) D.29023;
  D.29025 = __builtin_expect (D.29024, 0);
  if (D.29025 != 0) goto <D.29026>; else goto <D.29027>;
  <D.29026>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 2831, "tls");
  <D.29027>:
  i = 0;
  goto <D.25592>;
  <D.25591>:
  D.29028 = tls->frames;
  D.29029 = (long unsigned int) i;
  D.29030 = D.29029 * 8;
  D.29031 = D.29028 + D.29030;
  D.29032 = *D.29031;
  D.29033 = D.29032->jit;
  if (D.29033 != 0B) goto <D.29034>; else goto <D.29035>;
  <D.29034>:
  D.29028 = tls->frames;
  D.29029 = (long unsigned int) i;
  D.29030 = D.29029 * 8;
  D.29031 = D.29028 + D.29030;
  D.29032 = *D.29031;
  D.29033 = D.29032->jit;
  mono_debug_free_method_jit_info (D.29033);
  <D.29035>:
  D.29028 = tls->frames;
  D.29029 = (long unsigned int) i;
  D.29030 = D.29029 * 8;
  D.29031 = D.29028 + D.29030;
  D.29032 = *D.29031;
  monoeg_g_free (D.29032);
  i = i + 1;
  <D.25592>:
  D.29036 = tls->frame_count;
  if (D.29036 > i) goto <D.25591>; else goto <D.25593>;
  <D.25593>:
  D.29028 = tls->frames;
  monoeg_g_free (D.29028);
  tls->frame_count = 0;
  tls->frames = 0B;
}


decode_objid (guint8 * buf, guint8 * * endbuf, guint8 * limit)
{
  int D.29037;

  D.29037 = decode_id (buf, endbuf, limit);
  return D.29037;
}


decode_id (guint8 * buf, guint8 * * endbuf, guint8 * limit)
{
  int D.29039;

  D.29039 = decode_int (buf, endbuf, limit);
  return D.29039;
}


get_object (int objid, struct MonoObject * * obj)
{
  <unnamed type> D.29041;
  ErrorCode D.29044;
  struct MonoObject * D.29045;
  int err;

  D.29041 = get_object_allow_null (objid, obj);
  err = (int) D.29041;
  if (err != 0) goto <D.29042>; else goto <D.29043>;
  <D.29042>:
  D.29044 = (ErrorCode) err;
  return D.29044;
  <D.29043>:
  D.29045 = *obj;
  if (D.29045 == 0B) goto <D.29046>; else goto <D.29047>;
  <D.29046>:
  D.29044 = 20;
  return D.29044;
  <D.29047>:
  D.29044 = 0;
  return D.29044;
}


get_object_allow_null (int objid, struct MonoObject * * obj)
{
  ErrorCode D.29051;
  struct GHashTable * objrefs.138;
  long int D.29055;
  const void * D.29056;
  unsigned int D.29059;
  struct MonoObject * D.29060;
  struct MonoObject * D.29061;
  struct ObjRef * ref;

  if (objid == 0) goto <D.29049>; else goto <D.29050>;
  <D.29049>:
  *obj = 0B;
  D.29051 = 0;
  return D.29051;
  <D.29050>:
  objrefs.138 = objrefs;
  if (objrefs.138 == 0B) goto <D.29053>; else goto <D.29054>;
  <D.29053>:
  D.29051 = 20;
  return D.29051;
  <D.29054>:
  mono_loader_lock ();
  objrefs.138 = objrefs;
  D.29055 = (long int) objid;
  D.29056 = (const void *) D.29055;
  ref = monoeg_g_hash_table_lookup (objrefs.138, D.29056);
  if (ref != 0B) goto <D.29057>; else goto <D.29058>;
  <D.29057>:
  D.29059 = ref->handle;
  D.29060 = mono_gchandle_get_target (D.29059);
  *obj = D.29060;
  mono_loader_unlock ();
  D.29061 = *obj;
  if (D.29061 == 0B) goto <D.29062>; else goto <D.29063>;
  <D.29062>:
  D.29051 = 20;
  return D.29051;
  <D.29063>:
  D.29051 = 0;
  return D.29051;
  <D.29058>:
  mono_loader_unlock ();
  D.29051 = 20;
  return D.29051;
}


get_source_files_for_type (struct MonoClass * klass)
{
  struct GPtrArray * source_file_list.139;
  void * * D.29068;
  long unsigned int D.29069;
  long unsigned int D.29070;
  void * * D.29071;
  void * * D.29072;
  long unsigned int D.29073;
  long unsigned int D.29074;
  void * * D.29075;
  void * D.29076;
  char * D.29077;
  int D.29078;
  unsigned int D.29080;
  unsigned int i.140;
  gchar * D.29084;
  unsigned int D.29085;
  unsigned int j.141;
  struct GPtrArray * D.29087;
  void * iter;
  struct MonoMethod * method;
  struct MonoDebugSourceInfo * sinfo;
  struct GPtrArray * files;
  int i;
  int j;

  try
    {
      iter = 0B;
      files = monoeg_g_ptr_array_new ();
      goto <D.26667>;
      <D.26666>:
      {
        struct MonoDebugMethodInfo * minfo;
        struct GPtrArray * source_file_list;

        try
          {
            minfo = mono_debug_lookup_method (method);
            if (minfo != 0B) goto <D.29065>; else goto <D.29066>;
            <D.29065>:
            mono_debug_symfile_get_line_numbers_full (minfo, 0B, &source_file_list, 0B, 0B, 0B, 0B, 0B);
            j = 0;
            goto <D.26664>;
            <D.26663>:
            source_file_list.139 = source_file_list;
            D.29068 = source_file_list.139->pdata;
            D.29069 = (long unsigned int) j;
            D.29070 = D.29069 * 8;
            D.29071 = D.29068 + D.29070;
            sinfo = *D.29071;
            i = 0;
            goto <D.26662>;
            <D.26661>:
            D.29072 = files->pdata;
            D.29073 = (long unsigned int) i;
            D.29074 = D.29073 * 8;
            D.29075 = D.29072 + D.29074;
            D.29076 = *D.29075;
            D.29077 = sinfo->source_file;
            D.29078 = strcmp (D.29076, D.29077);
            if (D.29078 == 0) goto <D.26660>; else goto <D.29079>;
            <D.29079>:
            i = i + 1;
            <D.26662>:
            D.29080 = files->len;
            i.140 = (unsigned int) i;
            if (D.29080 > i.140) goto <D.26661>; else goto <D.26660>;
            <D.26660>:
            D.29080 = files->len;
            i.140 = (unsigned int) i;
            if (D.29080 == i.140) goto <D.29082>; else goto <D.29083>;
            <D.29082>:
            D.29077 = sinfo->source_file;
            D.29084 = monoeg_strdup (D.29077);
            monoeg_g_ptr_array_add (files, D.29084);
            <D.29083>:
            j = j + 1;
            <D.26664>:
            source_file_list.139 = source_file_list;
            D.29085 = source_file_list.139->len;
            j.141 = (unsigned int) j;
            if (D.29085 > j.141) goto <D.26663>; else goto <D.26665>;
            <D.26665>:
            source_file_list.139 = source_file_list;
            monoeg_g_ptr_array_free (source_file_list.139, 1);
            <D.29066>:
          }
        finally
          {
            source_file_list = {CLOBBER};
          }
      }
      <D.26667>:
      method = mono_class_get_methods (klass, &iter);
      if (method != 0B) goto <D.26666>; else goto <D.26668>;
      <D.26668>:
      D.29087 = files;
      return D.29087;
    }
  finally
    {
      iter = {CLOBBER};
    }
}


decode_string (guint8 * buf, guint8 * * endbuf, guint8 * limit)
{
  guint8 * buf.142;
  char * D.29093;
  int D.29094;
  long unsigned int D.29095;
  _Bool D.29096;
  long int D.29097;
  long int D.29098;
  long unsigned int D.29101;
  sizetype D.29102;
  char * D.29103;
  guint8 * buf.143;
  int len;
  char * s;

  buf.142 = buf;
  len = decode_int (buf.142, &buf, limit);
  if (len < 0) goto <D.29091>; else goto <D.29092>;
  <D.29091>:
  buf.142 = buf;
  *endbuf = buf.142;
  D.29093 = 0B;
  return D.29093;
  <D.29092>:
  D.29094 = len + 1;
  D.29095 = (long unsigned int) D.29094;
  s = monoeg_malloc (D.29095);
  D.29096 = s == 0B;
  D.29097 = (long int) D.29096;
  D.29098 = __builtin_expect (D.29097, 0);
  if (D.29098 != 0) goto <D.29099>; else goto <D.29100>;
  <D.29099>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 1633, "s");
  <D.29100>:
  buf.142 = buf;
  D.29101 = (long unsigned int) len;
  memcpy (s, buf.142, D.29101);
  D.29102 = (sizetype) len;
  D.29103 = s + D.29102;
  *D.29103 = 0;
  buf.142 = buf;
  D.29102 = (sizetype) len;
  buf.143 = buf.142 + D.29102;
  buf = buf.143;
  buf.142 = buf;
  *endbuf = buf.142;
  D.29093 = s;
  return D.29093;
}


event_commands (int command, guint8 * p, guint8 * end, struct Buffer * buf)
{
  guint8 * p.144;
  long unsigned int D.29107;
  long unsigned int D.29108;
  long unsigned int D.29109;
  int D.29110;
  <unnamed type> mod.145;
  int D.29114;
  int err.146;
  ErrorCode D.29121;
  int protocol_version_set.147;
  int major_version.148;
  int minor_version.149;
  <unnamed type> filter.150;
  <unnamed type> D.29140;
  unsigned int D.29141;
  unsigned int D.29144;
  struct MonoInternalThread * * D.29148;
  <unnamed type> D.29149;
  int err.151;
  int D.29158;
  int D.29159;
  int D.29166;
  int log_level.152;
  _Bool D.29168;
  long int D.29169;
  long int D.29170;
  struct FILE * log_file.153;
  const char * iftmp.154;
  const char * iftmp.155;
  int D.29179;
  const char * iftmp.156;
  int D.29184;
  const char * iftmp.157;
  int D.29189;
  struct MonoClass * D.29195;
  int D.29196;
  long unsigned int D.29202;
  long unsigned int D.29203;
  void * D.29204;
  struct MonoAssembly * * D.29205;
  long unsigned int D.29206;
  long unsigned int D.29207;
  struct MonoAssembly * * D.29208;
  struct MonoAssembly * D.29209;
  struct GHashTable * D.29215;
  struct GHashTable * D.29218;
  struct GHashTable * D.29222;
  struct GHashTable * D.29225;
  int D.29227;
  _Bool D.29230;
  long int D.29231;
  long int D.29232;
  struct MonoBreakpoint * D.29235;
  int D.29236;
  const char * D.29241;
  _Bool D.29245;
  long int D.29246;
  long int D.29247;
  <unnamed type> D.29250;
  int err.158;
  struct MonoThread * step_thread.159;
  struct _MonoInternalThread * D.29255;
  <unnamed type> size.160;
  <unnamed type> depth.161;
  <unnamed type> D.29258;
  int err.162;
  struct MonoBreakpoint * D.29265;
  struct MonoBreakpoint * D.29269;
  int D.29277;
  struct GPtrArray * event_requests.163;
  int D.29281;
  struct GHashTable * domains.164;
  struct MonoGHashTable * tid_to_thread.165;
  int D.29286;
  unsigned int D.29287;
  void * * D.29288;
  long unsigned int D.29289;
  long unsigned int D.29290;
  void * * D.29291;
  int D.29292;
  void * D.29295;
  unsigned int i.166;
  unsigned int D.29298;
  int err;
  struct MonoError error;

  try
    {
      switch (command) <default: <D.26852>, case 1: <D.26797>, case 2: <D.26843>, case 3: <D.26846>>
      <D.26797>:
      {
        struct EventRequest * req;
        int i;
        int event_kind;
        int suspend_policy;
        int nmodifiers;
        int mod;
        struct MonoMethod * method;
        long int location;
        struct MonoThread * step_thread;
        int size;
        int depth;
        int filter;
        int step_thread_id;
        struct MonoDomain * domain;
        struct Modifier * modifier;

        try
          {
            location = 0;
            size = 0;
            depth = 0;
            filter = 0;
            step_thread_id = 0;
            p.144 = p;
            event_kind = decode_byte (p.144, &p, end);
            p.144 = p;
            suspend_policy = decode_byte (p.144, &p, end);
            p.144 = p;
            nmodifiers = decode_byte (p.144, &p, end);
            D.29107 = (long unsigned int) nmodifiers;
            D.29108 = D.29107 * 32;
            D.29109 = D.29108 + 24;
            req = monoeg_malloc0 (D.29109);
            D.29110 = InterlockedIncrement (&event_request_id);
            req->id = D.29110;
            req->event_kind = event_kind;
            req->suspend_policy = suspend_policy;
            req->nmodifiers = nmodifiers;
            method = 0B;
            i = 0;
            goto <D.26834>;
            <D.26833>:
            p.144 = p;
            mod = decode_byte (p.144, &p, end);
            mod.145 = (<unnamed type>) mod;
            req->modifiers[i].kind = mod.145;
            if (mod == 1) goto <D.29112>; else goto <D.29113>;
            <D.29112>:
            p.144 = p;
            D.29114 = decode_int (p.144, &p, end);
            req->modifiers[i].data.count = D.29114;
            goto <D.29115>;
            <D.29113>:
            if (mod == 7) goto <D.29116>; else goto <D.29117>;
            <D.29116>:
            p.144 = p;
            method = decode_methodid (p.144, &p, end, &domain, &err);
            err.146 = err;
            if (err.146 != 0) goto <D.29119>; else goto <D.29120>;
            <D.29119>:
            err.146 = err;
            D.29121 = (ErrorCode) err.146;
            return D.29121;
            <D.29120>:
            p.144 = p;
            location = decode_long (p.144, &p, end);
            goto <D.29122>;
            <D.29117>:
            if (mod == 10) goto <D.29123>; else goto <D.29124>;
            <D.29123>:
            p.144 = p;
            step_thread_id = decode_id (p.144, &p, end);
            p.144 = p;
            size = decode_int (p.144, &p, end);
            p.144 = p;
            depth = decode_int (p.144, &p, end);
            protocol_version_set.147 = protocol_version_set;
            if (protocol_version_set.147 != 0) goto <D.29128>; else goto <D.29129>;
            <D.29128>:
            major_version.148 = major_version;
            if (major_version.148 > 2) goto <D.29125>; else goto <D.29131>;
            <D.29131>:
            major_version.148 = major_version;
            if (major_version.148 == 2) goto <D.29132>; else goto <D.29126>;
            <D.29132>:
            minor_version.149 = minor_version;
            if (minor_version.149 > 15) goto <D.29125>; else goto <D.29126>;
            <D.29125>:
            p.144 = p;
            filter = decode_int (p.144, &p, end);
            <D.29126>:
            <D.29129>:
            filter.150 = (<unnamed type>) filter;
            req->modifiers[i].data.filter = filter.150;
            protocol_version_set.147 = protocol_version_set;
            if (protocol_version_set.147 == 0) goto <D.29135>; else goto <D.29137>;
            <D.29137>:
            major_version.148 = major_version;
            if (major_version.148 <= 2) goto <D.29138>; else goto <D.29136>;
            <D.29138>:
            major_version.148 = major_version;
            if (major_version.148 != 2) goto <D.29135>; else goto <D.29139>;
            <D.29139>:
            minor_version.149 = minor_version;
            if (minor_version.149 <= 25) goto <D.29135>; else goto <D.29136>;
            <D.29135>:
            D.29140 = req->modifiers[i].data.filter;
            D.29141 = D.29140 & 2;
            if (D.29141 != 0) goto <D.29142>; else goto <D.29143>;
            <D.29142>:
            D.29140 = req->modifiers[i].data.filter;
            D.29144 = D.29140 | 4;
            req->modifiers[i].data.filter = D.29144;
            <D.29143>:
            <D.29136>:
            goto <D.29145>;
            <D.29124>:
            if (mod == 3) goto <D.29146>; else goto <D.29147>;
            <D.29146>:
            {
              int id;

              p.144 = p;
              id = decode_id (p.144, &p, end);
              D.29148 = &req->modifiers[i].data.thread;
              D.29149 = get_object (id, D.29148);
              err.151 = (int) D.29149;
              err = err.151;
              err.146 = err;
              if (err.146 != 0) goto <D.29151>; else goto <D.29152>;
              <D.29151>:
              monoeg_g_free (req);
              err.146 = err;
              D.29121 = (ErrorCode) err.146;
              return D.29121;
              <D.29152>:
            }
            goto <D.29153>;
            <D.29147>:
            if (mod == 8) goto <D.29154>; else goto <D.29155>;
            <D.29154>:
            {
              struct MonoClass * exc_class;

              p.144 = p;
              exc_class = decode_typeid (p.144, &p, end, &domain, &err);
              err.146 = err;
              if (err.146 != 0) goto <D.29156>; else goto <D.29157>;
              <D.29156>:
              err.146 = err;
              D.29121 = (ErrorCode) err.146;
              return D.29121;
              <D.29157>:
              p.144 = p;
              D.29158 = decode_byte (p.144, &p, end);
              req->modifiers[i].caught = D.29158;
              p.144 = p;
              D.29159 = decode_byte (p.144, &p, end);
              req->modifiers[i].uncaught = D.29159;
              protocol_version_set.147 = protocol_version_set;
              if (protocol_version_set.147 != 0) goto <D.29163>; else goto <D.29160>;
              <D.29163>:
              major_version.148 = major_version;
              if (major_version.148 > 2) goto <D.29161>; else goto <D.29164>;
              <D.29164>:
              major_version.148 = major_version;
              if (major_version.148 == 2) goto <D.29165>; else goto <D.29160>;
              <D.29165>:
              minor_version.149 = minor_version;
              if (minor_version.149 > 24) goto <D.29161>; else goto <D.29160>;
              <D.29161>:
              p.144 = p;
              D.29166 = decode_byte (p.144, &p, end);
              req->modifiers[i].subclasses = D.29166;
              goto <D.29162>;
              <D.29160>:
              req->modifiers[i].subclasses = 1;
              <D.29162>:
              log_level.152 = log_level;
              D.29168 = log_level.152 > 0;
              D.29169 = (long int) D.29168;
              D.29170 = __builtin_expect (D.29169, 0);
              if (D.29170 != 0) goto <D.29171>; else goto <D.29172>;
              <D.29171>:
              log_file.153 = log_file;
              if (exc_class != 0B) goto <D.29175>; else goto <D.29176>;
              <D.29175>:
              iftmp.154 = exc_class->name;
              goto <D.29177>;
              <D.29176>:
              iftmp.154 = "all";
              <D.29177>:
              D.29179 = req->modifiers[i].caught;
              if (D.29179 != 0) goto <D.29180>; else goto <D.29181>;
              <D.29180>:
              iftmp.155 = ", caught";
              goto <D.29182>;
              <D.29181>:
              iftmp.155 = "";
              <D.29182>:
              D.29184 = req->modifiers[i].uncaught;
              if (D.29184 != 0) goto <D.29185>; else goto <D.29186>;
              <D.29185>:
              iftmp.156 = ", uncaught";
              goto <D.29187>;
              <D.29186>:
              iftmp.156 = "";
              <D.29187>:
              D.29189 = req->modifiers[i].subclasses;
              if (D.29189 != 0) goto <D.29190>; else goto <D.29191>;
              <D.29190>:
              iftmp.157 = ", include-subclasses";
              goto <D.29192>;
              <D.29191>:
              iftmp.157 = "";
              <D.29192>:
              fprintf (log_file.153, "[dbg] \tEXCEPTION_ONLY filter (%s%s%s%s).\n", iftmp.154, iftmp.155, iftmp.156, iftmp.157);
              log_file.153 = log_file;
              fflush (log_file.153);
              <D.29172>:
              if (exc_class != 0B) goto <D.29193>; else goto <D.29194>;
              <D.29193>:
              req->modifiers[i].data.exc_class = exc_class;
              D.29195 = mono_defaults.exception_class;
              D.29196 = mono_class_is_assignable_from (D.29195, exc_class);
              if (D.29196 == 0) goto <D.29197>; else goto <D.29198>;
              <D.29197>:
              monoeg_g_free (req);
              D.29121 = 102;
              return D.29121;
              <D.29198>:
              <D.29194>:
            }
            goto <D.29199>;
            <D.29155>:
            if (mod == 11) goto <D.29200>; else goto <D.29201>;
            <D.29200>:
            {
              int n;
              int j;

              p.144 = p;
              n = decode_int (p.144, &p, end);
              D.29202 = (long unsigned int) n;
              D.29203 = D.29202 * 8;
              D.29204 = monoeg_malloc0 (D.29203);
              req->modifiers[i].data.assemblies = D.29204;
              j = 0;
              goto <D.26818>;
              <D.26817>:
              D.29205 = req->modifiers[i].data.assemblies;
              D.29206 = (long unsigned int) j;
              D.29207 = D.29206 * 8;
              D.29208 = D.29205 + D.29207;
              p.144 = p;
              D.29209 = decode_assemblyid (p.144, &p, end, &domain, &err);
              *D.29208 = D.29209;
              err.146 = err;
              if (err.146 != 0) goto <D.29210>; else goto <D.29211>;
              <D.29210>:
              D.29205 = req->modifiers[i].data.assemblies;
              monoeg_g_free (D.29205);
              err.146 = err;
              D.29121 = (ErrorCode) err.146;
              return D.29121;
              <D.29211>:
              j = j + 1;
              <D.26818>:
              if (j < n) goto <D.26817>; else goto <D.26819>;
              <D.26819>:
            }
            goto <D.29212>;
            <D.29201>:
            if (mod == 12) goto <D.29213>; else goto <D.29214>;
            <D.29213>:
            {
              int n;
              int j;

              p.144 = p;
              n = decode_int (p.144, &p, end);
              modifier = &req->modifiers[i];
              D.29215 = monoeg_g_hash_table_new (monoeg_g_str_hash, monoeg_g_str_equal);
              modifier->data.source_files = D.29215;
              j = 0;
              goto <D.26825>;
              <D.26824>:
              {
                char * s;
                char * s2;

                p.144 = p;
                s = decode_string (p.144, &p, end);
                if (s != 0B) goto <D.29216>; else goto <D.29217>;
                <D.29216>:
                s2 = strdup_tolower (s);
                D.29218 = modifier->data.source_files;
                monoeg_g_hash_table_insert_replace (D.29218, s2, s2, 0);
                monoeg_g_free (s);
                <D.29217>:
              }
              j = j + 1;
              <D.26825>:
              if (j < n) goto <D.26824>; else goto <D.26826>;
              <D.26826>:
            }
            goto <D.29219>;
            <D.29214>:
            if (mod == 13) goto <D.29220>; else goto <D.29221>;
            <D.29220>:
            {
              int n;
              int j;

              p.144 = p;
              n = decode_int (p.144, &p, end);
              modifier = &req->modifiers[i];
              D.29222 = monoeg_g_hash_table_new (monoeg_g_str_hash, monoeg_g_str_equal);
              modifier->data.type_names = D.29222;
              j = 0;
              goto <D.26831>;
              <D.26830>:
              {
                char * s;

                p.144 = p;
                s = decode_string (p.144, &p, end);
                if (s != 0B) goto <D.29223>; else goto <D.29224>;
                <D.29223>:
                D.29225 = modifier->data.type_names;
                monoeg_g_hash_table_insert_replace (D.29225, s, s, 0);
                <D.29224>:
              }
              j = j + 1;
              <D.26831>:
              if (j < n) goto <D.26830>; else goto <D.26832>;
              <D.26832>:
            }
            goto <D.29226>;
            <D.29221>:
            monoeg_g_free (req);
            D.29121 = 100;
            return D.29121;
            <D.29226>:
            <D.29219>:
            <D.29212>:
            <D.29199>:
            <D.29153>:
            <D.29145>:
            <D.29122>:
            <D.29115>:
            i = i + 1;
            <D.26834>:
            if (i < nmodifiers) goto <D.26833>; else goto <D.26835>;
            <D.26835>:
            D.29227 = req->event_kind;
            if (D.29227 == 10) goto <D.29228>; else goto <D.29229>;
            <D.29228>:
            D.29230 = method == 0B;
            D.29231 = (long int) D.29230;
            D.29232 = __builtin_expect (D.29231, 0);
            if (D.29232 != 0) goto <D.29233>; else goto <D.29234>;
            <D.29233>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 7086, "method");
            <D.29234>:
            D.29235 = set_breakpoint (method, location, req, &error);
            req->info = D.29235;
            D.29236 = mono_error_ok (&error);
            if (D.29236 == 0) goto <D.29237>; else goto <D.29238>;
            <D.29237>:
            monoeg_g_free (req);
            log_level.152 = log_level;
            D.29168 = log_level.152 > 0;
            D.29169 = (long int) D.29168;
            D.29170 = __builtin_expect (D.29169, 0);
            if (D.29170 != 0) goto <D.29239>; else goto <D.29240>;
            <D.29239>:
            log_file.153 = log_file;
            D.29241 = mono_error_get_message (&error);
            fprintf (log_file.153, "[dbg] Failed to set breakpoint: %s\n", D.29241);
            log_file.153 = log_file;
            fflush (log_file.153);
            <D.29240>:
            mono_error_cleanup (&error);
            D.29121 = 106;
            return D.29121;
            <D.29238>:
            goto <D.29242>;
            <D.29229>:
            D.29227 = req->event_kind;
            if (D.29227 == 11) goto <D.29243>; else goto <D.29244>;
            <D.29243>:
            D.29245 = step_thread_id == 0;
            D.29246 = (long int) D.29245;
            D.29247 = __builtin_expect (D.29246, 0);
            if (D.29247 != 0) goto <D.29248>; else goto <D.29249>;
            <D.29248>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 7096, "step_thread_id");
            <D.29249>:
            D.29250 = get_object (step_thread_id, &step_thread);
            err.158 = (int) D.29250;
            err = err.158;
            err.146 = err;
            if (err.146 != 0) goto <D.29252>; else goto <D.29253>;
            <D.29252>:
            monoeg_g_free (req);
            err.146 = err;
            D.29121 = (ErrorCode) err.146;
            return D.29121;
            <D.29253>:
            step_thread.159 = step_thread;
            D.29255 = step_thread.159->internal_thread;
            size.160 = (<unnamed type>) size;
            depth.161 = (<unnamed type>) depth;
            D.29258 = ss_create (D.29255, size.160, depth.161, req);
            err.162 = (int) D.29258;
            err = err.162;
            err.146 = err;
            if (err.146 != 0) goto <D.29260>; else goto <D.29261>;
            <D.29260>:
            monoeg_g_free (req);
            err.146 = err;
            D.29121 = (ErrorCode) err.146;
            return D.29121;
            <D.29261>:
            goto <D.29262>;
            <D.29244>:
            D.29227 = req->event_kind;
            if (D.29227 == 6) goto <D.29263>; else goto <D.29264>;
            <D.29263>:
            D.29265 = set_breakpoint (0B, -1, req, 0B);
            req->info = D.29265;
            goto <D.29266>;
            <D.29264>:
            D.29227 = req->event_kind;
            if (D.29227 == 7) goto <D.29267>; else goto <D.29268>;
            <D.29267>:
            D.29269 = set_breakpoint (0B, 16777215, req, 0B);
            req->info = D.29269;
            goto <D.29270>;
            <D.29268>:
            D.29227 = req->event_kind;
            if (D.29227 == 13) goto <D.29271>; else goto <D.29272>;
            <D.29271>:
            goto <D.29273>;
            <D.29272>:
            D.29227 = req->event_kind;
            if (D.29227 == 12) goto <D.29274>; else goto <D.29275>;
            <D.29274>:
            goto <D.29276>;
            <D.29275>:
            D.29277 = req->nmodifiers;
            if (D.29277 != 0) goto <D.29278>; else goto <D.29279>;
            <D.29278>:
            monoeg_g_free (req);
            D.29121 = 100;
            return D.29121;
            <D.29279>:
            <D.29276>:
            <D.29273>:
            <D.29270>:
            <D.29266>:
            <D.29262>:
            <D.29242>:
            mono_loader_lock ();
            event_requests.163 = event_requests;
            monoeg_g_ptr_array_add (event_requests.163, req);
            D.29281 = agent_config.defer;
            if (D.29281 != 0) goto <D.29282>; else goto <D.29283>;
            <D.29282>:
            D.29227 = req->event_kind;
            switch (D.29227) <default: <D.26841>, case 2: <D.26839>, case 4: <D.26836>, case 8: <D.26838>, case 12: <D.26840>>
            <D.26836>:
            domains.164 = domains;
            monoeg_g_hash_table_foreach (domains.164, emit_appdomain_load, 0B);
            goto <D.26837>;
            <D.26838>:
            mono_assembly_foreach (emit_assembly_load, 0B);
            goto <D.26837>;
            <D.26839>:
            tid_to_thread.165 = tid_to_thread;
            mono_g_hash_table_foreach (tid_to_thread.165, emit_thread_start, 0B);
            goto <D.26837>;
            <D.26840>:
            mono_domain_foreach (send_types_for_domain, 0B);
            goto <D.26837>;
            <D.26841>:
            goto <D.26837>;
            <D.26837>:
            <D.29283>:
            mono_loader_unlock ();
            D.29286 = req->id;
            D.29287 = (unsigned int) D.29286;
            buffer_add_int (buf, D.29287);
            goto <D.26842>;
          }
        finally
          {
            step_thread = {CLOBBER};
            domain = {CLOBBER};
          }
      }
      <D.26843>:
      {
        int etype;
        int req_id;

        p.144 = p;
        etype = decode_byte (p.144, &p, end);
        p.144 = p;
        req_id = decode_int (p.144, &p, end);
        mono_loader_lock ();
        clear_event_request (req_id, etype);
        mono_loader_unlock ();
        goto <D.26842>;
      }
      <D.26846>:
      {
        int i;

        mono_loader_lock ();
        i = 0;
        goto <D.26850>;
        <D.26849>:
        {
          struct EventRequest * req;

          event_requests.163 = event_requests;
          D.29288 = event_requests.163->pdata;
          D.29289 = (long unsigned int) i;
          D.29290 = D.29289 * 8;
          D.29291 = D.29288 + D.29290;
          req = *D.29291;
          D.29292 = req->event_kind;
          if (D.29292 == 10) goto <D.29293>; else goto <D.29294>;
          <D.29293>:
          D.29295 = req->info;
          clear_breakpoint (D.29295);
          event_requests.163 = event_requests;
          i.166 = (unsigned int) i;
          monoeg_g_ptr_array_remove_index_fast (event_requests.163, i.166);
          monoeg_g_free (req);
          goto <D.29297>;
          <D.29294>:
          i = i + 1;
          <D.29297>:
        }
        <D.26850>:
        event_requests.163 = event_requests;
        D.29298 = event_requests.163->len;
        i.166 = (unsigned int) i;
        if (D.29298 > i.166) goto <D.26849>; else goto <D.26851>;
        <D.26851>:
        mono_loader_unlock ();
        goto <D.26842>;
      }
      <D.26852>:
      D.29121 = 100;
      return D.29121;
      <D.26842>:
      D.29121 = 0;
      return D.29121;
    }
  finally
    {
      err = {CLOBBER};
      error = {CLOBBER};
    }
}


send_types_for_domain (struct MonoDomain * domain, void * user_data)
{
  union mono_mutex_t * D.29304;
  _Bool D.29307;
  long int D.29308;
  long int D.29309;
  _Bool D.29312;
  long int D.29313;
  long int D.29314;
  struct GHashTable * D.29317;
  _Bool D.29320;
  long int D.29321;
  long int D.29322;
  struct AgentDomainInfo * info;

  info = 0B;
  mono_loader_lock ();
  {
    int ret;

    D.29304 = &domain->lock.mutex;
    ret = pthread_mutex_lock (D.29304);
    if (ret != 0) goto <D.29305>; else goto <D.29306>;
    <D.29305>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.29306>:
    D.29307 = ret != 0;
    D.29308 = (long int) D.29307;
    D.29309 = __builtin_expect (D.29308, 0);
    if (D.29309 != 0) goto <D.29310>; else goto <D.29311>;
    <D.29310>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 4009, "ret == 0");
    <D.29311>:
  }
  info = get_agent_domain_info (domain);
  D.29312 = info == 0B;
  D.29313 = (long int) D.29312;
  D.29314 = __builtin_expect (D.29313, 0);
  if (D.29314 != 0) goto <D.29315>; else goto <D.29316>;
  <D.29315>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 4011, "info");
  <D.29316>:
  D.29317 = info->loaded_classes;
  monoeg_g_hash_table_foreach (D.29317, emit_type_load, 0B);
  {
    int ret;

    D.29304 = &domain->lock.mutex;
    ret = pthread_mutex_unlock (D.29304);
    if (ret != 0) goto <D.29318>; else goto <D.29319>;
    <D.29318>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.29319>:
    D.29320 = ret != 0;
    D.29321 = (long int) D.29320;
    D.29322 = __builtin_expect (D.29321, 0);
    if (D.29322 != 0) goto <D.29323>; else goto <D.29324>;
    <D.29323>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 4013, "ret == 0");
    <D.29324>:
  }
  mono_loader_unlock ();
}


emit_type_load (void * key, void * value, void * user_data)
{
  process_profiler_event (12, value);
}


emit_thread_start (void * key, void * value, void * user_data)
{
  long int key.167;
  int D.29326;
  long unsigned int D.29327;
  long unsigned int debugger_thread_id.168;

  key.167 = (long int) key;
  D.29326 = (int) key.167;
  D.29327 = (long unsigned int) D.29326;
  debugger_thread_id.168 = debugger_thread_id;
  if (D.29327 != debugger_thread_id.168) goto <D.29329>; else goto <D.29330>;
  <D.29329>:
  process_profiler_event (2, value);
  <D.29330>:
}


emit_assembly_load (void * value, void * user_data)
{
  process_profiler_event (8, value);
}


emit_appdomain_load (void * key, void * value, void * user_data)
{
  struct AgentDomainInfo * D.29331;
  struct GHashTable * D.29332;

  process_profiler_event (4, value);
  D.29331 = get_agent_domain_info (value);
  D.29332 = D.29331->loaded_classes;
  monoeg_g_hash_table_foreach (D.29332, emit_type_load, 0B);
}


InterlockedIncrement (volatile gint32 * val)
{
  gint32 D.29333;
  unsigned int D.29334;

  D.29334 = __sync_add_and_fetch_4 (val, 1);
  D.29333 = (gint32) D.29334;
  return D.29333;
}


decode_methodid (guint8 * buf, guint8 * * endbuf, guint8 * limit, struct MonoDomain * * domain, int * err)
{
  int log_level.169;
  _Bool D.29337;
  long int D.29338;
  long int D.29339;
  struct FILE * log_file.170;
  struct MonoMethod * D.29347;
  struct MonoMethod * m;

  m = decode_ptr_id (buf, endbuf, limit, 3, domain, err);
  log_level.169 = log_level;
  D.29337 = log_level.169 > 1;
  D.29338 = (long int) D.29337;
  D.29339 = __builtin_expect (D.29338, 0);
  if (D.29339 != 0) goto <D.29340>; else goto <D.29341>;
  <D.29340>:
  if (m != 0B) goto <D.29342>; else goto <D.29343>;
  <D.29342>:
  {
    char * s;

    s = mono_method_full_name (m, 1);
    log_level.169 = log_level;
    D.29337 = log_level.169 > 1;
    D.29338 = (long int) D.29337;
    D.29339 = __builtin_expect (D.29338, 0);
    if (D.29339 != 0) goto <D.29344>; else goto <D.29345>;
    <D.29344>:
    log_file.170 = log_file;
    fprintf (log_file.170, "[dbg]   recv method [%s]\n", s);
    log_file.170 = log_file;
    fflush (log_file.170);
    <D.29345>:
    monoeg_g_free (s);
  }
  <D.29343>:
  <D.29341>:
  D.29347 = m;
  return D.29347;
}


decode_ptr_id (guint8 * buf, guint8 * * endbuf, guint8 * limit, IdType type, struct MonoDomain * * domain, int * err)
{
  void * D.29353;
  int iftmp.171;
  struct GPtrArray * D.29359;
  unsigned int D.29360;
  unsigned int id.172;
  _Bool D.29362;
  long int D.29363;
  long int D.29364;
  void * * D.29367;
  long unsigned int D.29368;
  long unsigned int D.29369;
  sizetype D.29370;
  void * * D.29371;
  struct MonoDomain * D.29372;
  struct Id * res;
  int id;

  id = decode_id (buf, endbuf, limit);
  *err = 0;
  if (domain != 0B) goto <D.29349>; else goto <D.29350>;
  <D.29349>:
  *domain = 0B;
  <D.29350>:
  if (id == 0) goto <D.29351>; else goto <D.29352>;
  <D.29351>:
  D.29353 = 0B;
  return D.29353;
  <D.29352>:
  mono_loader_lock ();
  if (id <= 0) goto <D.29355>; else goto <D.29358>;
  <D.29358>:
  D.29359 = ids[type];
  D.29360 = D.29359->len;
  id.172 = (unsigned int) id;
  if (D.29360 < id.172) goto <D.29355>; else goto <D.29356>;
  <D.29355>:
  iftmp.171 = 1;
  goto <D.29357>;
  <D.29356>:
  iftmp.171 = 0;
  <D.29357>:
  D.29362 = iftmp.171 != 0;
  D.29363 = (long int) D.29362;
  D.29364 = __builtin_expect (D.29363, 0);
  if (D.29364 != 0) goto <D.29365>; else goto <D.29366>;
  <D.29365>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 2196, "id > 0 && id <= ids [type]->len");
  <D.29366>:
  D.29359 = ids[type];
  D.29367 = D.29359->pdata;
  D.29368 = (long unsigned int) id;
  D.29369 = D.29368 * 8;
  D.29370 = D.29369 + 18446744073709551608;
  D.29371 = D.29367 + D.29370;
  res = *D.29371;
  mono_loader_unlock ();
  D.29372 = res->domain;
  if (D.29372 == 0B) goto <D.29373>; else goto <D.29374>;
  <D.29373>:
  *err = 103;
  D.29353 = 0B;
  return D.29353;
  <D.29374>:
  if (domain != 0B) goto <D.29375>; else goto <D.29376>;
  <D.29375>:
  D.29372 = res->domain;
  *domain = D.29372;
  <D.29376>:
  D.29353 = res->data.val;
  return D.29353;
}


decode_long (guint8 * buf, guint8 * * endbuf, guint8 * limit)
{
  guint8 * buf.173;
  int D.29379;
  int D.29380;
  gint64 D.29381;
  long unsigned int D.29382;
  long unsigned int D.29383;
  long unsigned int D.29384;
  long unsigned int D.29385;
  guint32 high;
  guint32 low;

  buf.173 = buf;
  D.29379 = decode_int (buf.173, &buf, limit);
  high = (guint32) D.29379;
  buf.173 = buf;
  D.29380 = decode_int (buf.173, &buf, limit);
  low = (guint32) D.29380;
  buf.173 = buf;
  *endbuf = buf.173;
  D.29382 = (long unsigned int) high;
  D.29383 = D.29382 << 32;
  D.29384 = (long unsigned int) low;
  D.29385 = D.29383 | D.29384;
  D.29381 = (gint64) D.29385;
  return D.29381;
}


decode_typeid (guint8 * buf, guint8 * * endbuf, guint8 * limit, struct MonoDomain * * domain, int * err)
{
  int log_level.174;
  _Bool D.29388;
  long int D.29389;
  long int D.29390;
  struct MonoType * D.29395;
  struct FILE * log_file.175;
  struct MonoClass * D.29399;
  struct MonoClass * klass;

  klass = decode_ptr_id (buf, endbuf, limit, 2, domain, err);
  log_level.174 = log_level;
  D.29388 = log_level.174 > 1;
  D.29389 = (long int) D.29388;
  D.29390 = __builtin_expect (D.29389, 0);
  if (D.29390 != 0) goto <D.29391>; else goto <D.29392>;
  <D.29391>:
  if (klass != 0B) goto <D.29393>; else goto <D.29394>;
  <D.29393>:
  {
    char * s;

    D.29395 = &klass->byval_arg;
    s = mono_type_full_name (D.29395);
    log_level.174 = log_level;
    D.29388 = log_level.174 > 1;
    D.29389 = (long int) D.29388;
    D.29390 = __builtin_expect (D.29389, 0);
    if (D.29390 != 0) goto <D.29396>; else goto <D.29397>;
    <D.29396>:
    log_file.175 = log_file;
    fprintf (log_file.175, "[dbg]   recv class [%s]\n", s);
    log_file.175 = log_file;
    fflush (log_file.175);
    <D.29397>:
    monoeg_g_free (s);
  }
  <D.29394>:
  <D.29392>:
  D.29399 = klass;
  return D.29399;
}


decode_assemblyid (guint8 * buf, guint8 * * endbuf, guint8 * limit, struct MonoDomain * * domain, int * err)
{
  struct MonoAssembly * D.29401;

  D.29401 = decode_ptr_id (buf, endbuf, limit, 0, domain, err);
  return D.29401;
}


ss_create (struct MonoInternalThread * thread, StepSize size, StepDepth depth, struct EventRequest * req)
{
  int suspend_count.176;
  ErrorCode D.29406;
  struct SingleStepReq * ss_req.177;
  int log_level.178;
  _Bool D.29411;
  long int D.29412;
  long int D.29413;
  struct FILE * log_file.179;
  _Bool D.29417;
  long int D.29418;
  long int D.29419;
  const char * D.29422;
  void * D.29423;
  struct MonoGHashTable * thread_to_tls.180;
  _Bool D.29425;
  long int D.29426;
  long int D.29427;
  int D.29430;
  _Bool D.29431;
  long int D.29432;
  long int D.29433;
  long unsigned int D.29436;
  void * D.29437;
  void * D.29438;
  int D.29439;
  void * D.29442;
  void * D.29443;
  struct MonoContext * D.29444;
  _Bool D.29445;
  long int D.29446;
  long int D.29447;
  <unnamed type> D.29450;
  _Bool D.29451;
  long int D.29452;
  long int D.29453;
  struct MonoDomain * D.29456;
  struct MonoMethod * D.29457;
  int D.29458;
  _Bool D.29461;
  long int D.29462;
  long int D.29463;
  <unnamed type> D.29468;
  int D.29471;
  struct StackFrame * * D.29474;
  struct MonoMethod * D.29475;
  unsigned int D.29478;
  unsigned int D.29483;
  int D.29484;
  unsigned int D.29491;
  struct MonoDomain * D.29494;
  struct MonoMethod * D.29495;
  unsigned int D.29496;
  int D.29497;
  struct MonoSeqPointInfo * info.181;
  struct MonoContext * D.29503;
  struct DebuggerTlsData * tls;
  struct MonoSeqPointInfo * info;
  struct SeqPoint * sp;
  struct MonoMethod * method;
  struct MonoDebugMethodInfo * minfo;
  gboolean step_to_catch;

  try
    {
      info = 0B;
      sp = 0B;
      method = 0B;
      step_to_catch = 0;
      suspend_count.176 = suspend_count;
      if (suspend_count.176 == 0) goto <D.29404>; else goto <D.29405>;
      <D.29404>:
      D.29406 = 101;
      return D.29406;
      <D.29405>:
      wait_for_suspend ();
      ss_req.177 = ss_req;
      if (ss_req.177 != 0B) goto <D.29408>; else goto <D.29409>;
      <D.29408>:
      log_level.178 = log_level;
      D.29411 = log_level.178 >= 0;
      D.29412 = (long int) D.29411;
      D.29413 = __builtin_expect (D.29412, 0);
      if (D.29413 != 0) goto <D.29414>; else goto <D.29415>;
      <D.29414>:
      log_file.179 = log_file;
      fprintf (log_file.179, "Received a single step request while the previous one was still active.\n");
      log_file.179 = log_file;
      fflush (log_file.179);
      <D.29415>:
      D.29406 = 100;
      return D.29406;
      <D.29409>:
      log_level.178 = log_level;
      D.29417 = log_level.178 > 0;
      D.29418 = (long int) D.29417;
      D.29419 = __builtin_expect (D.29418, 0);
      if (D.29419 != 0) goto <D.29420>; else goto <D.29421>;
      <D.29420>:
      log_file.179 = log_file;
      D.29422 = ss_depth_to_string (depth);
      fprintf (log_file.179, "[dbg] Starting single step of thread %p (depth=%s).\n", thread, D.29422);
      log_file.179 = log_file;
      fflush (log_file.179);
      <D.29421>:
      D.29423 = monoeg_malloc0 (80);
      ss_req = D.29423;
      ss_req.177 = ss_req;
      ss_req.177->req = req;
      ss_req.177 = ss_req;
      ss_req.177->thread = thread;
      ss_req.177 = ss_req;
      ss_req.177->size = size;
      ss_req.177 = ss_req;
      ss_req.177->depth = depth;
      ss_req.177 = ss_req;
      req->info = ss_req.177;
      mono_loader_lock ();
      thread_to_tls.180 = thread_to_tls;
      tls = mono_g_hash_table_lookup (thread_to_tls.180, thread);
      mono_loader_unlock ();
      D.29425 = tls == 0B;
      D.29426 = (long int) D.29425;
      D.29427 = __builtin_expect (D.29426, 0);
      if (D.29427 != 0) goto <D.29428>; else goto <D.29429>;
      <D.29428>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 5168, "tls");
      <D.29429>:
      D.29430 = tls->context.valid;
      D.29431 = D.29430 == 0;
      D.29432 = (long int) D.29431;
      D.29433 = __builtin_expect (D.29432, 0);
      if (D.29433 != 0) goto <D.29434>; else goto <D.29435>;
      <D.29434>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 5169, "tls->context.valid");
      <D.29435>:
      ss_req.177 = ss_req;
      ss_req.177 = ss_req;
      D.29436 = tls->context.ctx.uc_mcontext.gregs[15];
      D.29437 = (void *) D.29436;
      ss_req.177->last_sp = D.29437;
      D.29438 = ss_req.177->last_sp;
      ss_req.177->start_sp = D.29438;
      D.29439 = tls->catch_state.valid;
      if (D.29439 != 0) goto <D.29440>; else goto <D.29441>;
      <D.29440>:
      {
        gboolean res;
        struct StackFrameInfo frame;
        struct MonoContext new_ctx;
        struct MonoLMF * lmf;

        try
          {
            lmf = 0B;
            D.29442 = tls->catch_state.unwind_data[0];
            D.29443 = thread->jit_data;
            D.29444 = &tls->catch_state.ctx;
            res = mono_find_jit_info_ext (D.29442, D.29443, 0B, D.29444, &new_ctx, 0B, &lmf, 0B, &frame);
            D.29445 = res == 0;
            D.29446 = (long int) D.29445;
            D.29447 = __builtin_expect (D.29446, 0);
            if (D.29447 != 0) goto <D.29448>; else goto <D.29449>;
            <D.29448>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 5184, "res");
            <D.29449>:
            D.29450 = frame.type;
            D.29451 = D.29450 != 0;
            D.29452 = (long int) D.29451;
            D.29453 = __builtin_expect (D.29452, 0);
            if (D.29453 != 0) goto <D.29454>; else goto <D.29455>;
            <D.29454>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 5185, "frame.type == FRAME_TYPE_MANAGED");
            <D.29455>:
            D.29456 = frame.domain;
            D.29457 = frame.method;
            D.29458 = frame.native_offset;
            sp = find_next_seq_point_for_native_offset (D.29456, D.29457, D.29458, &info);
            if (sp == 0B) goto <D.29459>; else goto <D.29460>;
            <D.29459>:
            D.29457 = frame.method;
            no_seq_points_found (D.29457);
            <D.29460>:
            D.29461 = sp == 0B;
            D.29462 = (long int) D.29461;
            D.29463 = __builtin_expect (D.29462, 0);
            if (D.29463 != 0) goto <D.29464>; else goto <D.29465>;
            <D.29464>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 5194, "sp");
            <D.29465>:
            method = frame.method;
            step_to_catch = 1;
            ss_req.177 = ss_req;
            ss_req.177->last_sp = 0B;
          }
        finally
          {
            frame = {CLOBBER};
            new_ctx = {CLOBBER};
            lmf = {CLOBBER};
          }
      }
      <D.29441>:
      if (step_to_catch == 0) goto <D.29466>; else goto <D.29467>;
      <D.29466>:
      ss_req.177 = ss_req;
      D.29468 = ss_req.177->size;
      if (D.29468 == 1) goto <D.29469>; else goto <D.29470>;
      <D.29469>:
      {
        struct StackFrame * frame;

        compute_frame_info (thread, tls);
        D.29471 = tls->frame_count;
        if (D.29471 != 0) goto <D.29472>; else goto <D.29473>;
        <D.29472>:
        D.29474 = tls->frames;
        frame = *D.29474;
        ss_req.177 = ss_req;
        D.29475 = frame->method;
        ss_req.177->last_method = D.29475;
        ss_req.177 = ss_req;
        ss_req.177->last_line = -1;
        D.29475 = frame->method;
        minfo = mono_debug_lookup_method (D.29475);
        if (minfo != 0B) goto <D.29476>; else goto <D.29477>;
        <D.29476>:
        D.29478 = frame->il_offset;
        if (D.29478 != 4294967295) goto <D.29479>; else goto <D.29480>;
        <D.29479>:
        {
          struct MonoDebugSourceLocation * loc;

          D.29478 = frame->il_offset;
          loc = mono_debug_symfile_lookup_location (minfo, D.29478);
          if (loc != 0B) goto <D.29481>; else goto <D.29482>;
          <D.29481>:
          ss_req.177 = ss_req;
          D.29483 = loc->row;
          D.29484 = (int) D.29483;
          ss_req.177->last_line = D.29484;
          monoeg_g_free (loc);
          <D.29482>:
        }
        <D.29480>:
        <D.29477>:
        <D.29473>:
      }
      <D.29470>:
      <D.29467>:
      if (step_to_catch == 0) goto <D.29485>; else goto <D.29486>;
      <D.29485>:
      {
        struct StackFrame * frame;

        compute_frame_info (thread, tls);
        D.29471 = tls->frame_count;
        if (D.29471 != 0) goto <D.29487>; else goto <D.29488>;
        <D.29487>:
        D.29474 = tls->frames;
        frame = *D.29474;
        if (method == 0B) goto <D.29489>; else goto <D.29490>;
        <D.29489>:
        D.29491 = frame->il_offset;
        if (D.29491 != 4294967295) goto <D.29492>; else goto <D.29493>;
        <D.29492>:
        D.29494 = frame->domain;
        D.29495 = frame->method;
        D.29496 = frame->native_offset;
        D.29497 = (int) D.29496;
        sp = find_prev_seq_point_for_native_offset (D.29494, D.29495, D.29497, &info);
        if (sp == 0B) goto <D.29498>; else goto <D.29499>;
        <D.29498>:
        D.29495 = frame->method;
        no_seq_points_found (D.29495);
        <D.29499>:
        D.29461 = sp == 0B;
        D.29462 = (long int) D.29461;
        D.29463 = __builtin_expect (D.29462, 0);
        if (D.29463 != 0) goto <D.29500>; else goto <D.29501>;
        <D.29500>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 5240, "sp");
        <D.29501>:
        method = frame->method;
        <D.29493>:
        <D.29490>:
        <D.29488>:
      }
      <D.29486>:
      ss_req.177 = ss_req;
      info.181 = info;
      D.29503 = &tls->context.ctx;
      ss_start (ss_req.177, method, sp, info.181, D.29503, tls, step_to_catch);
      D.29406 = 0;
      return D.29406;
    }
  finally
    {
      info = {CLOBBER};
    }
}


ss_depth_to_string (StepDepth depth)
{
  const char * D.29506;

  switch (depth) <default: <D.26169>, case 0: <D.26168>, case 1: <D.26166>, case 2: <D.26167>>
  <D.26166>:
  D.29506 = "over";
  return D.29506;
  <D.26167>:
  D.29506 = "out";
  return D.29506;
  <D.26168>:
  D.29506 = "into";
  return D.29506;
  <D.26169>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "debugger-agent.c", 4770);
  D.29506 = 0B;
  return D.29506;
}


find_next_seq_point_for_native_offset (struct MonoDomain * domain, struct MonoMethod * method, gint32 native_offset, struct MonoSeqPointInfo * * info)
{
  struct SeqPoint * D.29512;
  _Bool D.29513;
  long int D.29514;
  long int D.29515;
  int D.29520;
  int D.29523;
  struct MonoSeqPointInfo * seq_points;
  int i;

  seq_points = get_seq_points (domain, method);
  if (seq_points == 0B) goto <D.29508>; else goto <D.29509>;
  <D.29508>:
  if (info != 0B) goto <D.29510>; else goto <D.29511>;
  <D.29510>:
  *info = 0B;
  <D.29511>:
  D.29512 = 0B;
  return D.29512;
  <D.29509>:
  D.29513 = seq_points == 0B;
  D.29514 = (long int) D.29513;
  D.29515 = __builtin_expect (D.29514, 0);
  if (D.29515 != 0) goto <D.29516>; else goto <D.29517>;
  <D.29516>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 3028, "seq_points");
  <D.29517>:
  if (info != 0B) goto <D.29518>; else goto <D.29519>;
  <D.29518>:
  *info = seq_points;
  <D.29519>:
  i = 0;
  goto <D.25643>;
  <D.25642>:
  D.29520 = seq_points->seq_points[i].native_offset;
  if (D.29520 >= native_offset) goto <D.29521>; else goto <D.29522>;
  <D.29521>:
  D.29512 = &seq_points->seq_points[i];
  return D.29512;
  <D.29522>:
  i = i + 1;
  <D.25643>:
  D.29523 = seq_points->len;
  if (D.29523 > i) goto <D.25642>; else goto <D.25644>;
  <D.25644>:
  D.29512 = 0B;
  return D.29512;
}


get_seq_points (struct MonoDomain * domain, struct MonoMethod * method)
{
  union mono_mutex_t * D.29525;
  _Bool D.29528;
  long int D.29529;
  long int D.29530;
  void * D.29533;
  struct GHashTable * D.29534;
  long unsigned int D.29537;
  long unsigned int D.29538;
  struct MonoMethod * D.29541;
  struct MonoMethod * D.29544;
  _Bool D.29547;
  long int D.29548;
  long int D.29549;
  struct MonoSeqPointInfo * D.29552;
  struct MonoSeqPointInfo * seq_points;

  {
    int ret;

    D.29525 = &domain->lock.mutex;
    ret = pthread_mutex_lock (D.29525);
    if (ret != 0) goto <D.29526>; else goto <D.29527>;
    <D.29526>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.29527>:
    D.29528 = ret != 0;
    D.29529 = (long int) D.29528;
    D.29530 = __builtin_expect (D.29529, 0);
    if (D.29530 != 0) goto <D.29531>; else goto <D.29532>;
    <D.29531>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 2989, "ret == 0");
    <D.29532>:
  }
  D.29533 = domain->runtime_info;
  D.29534 = MEM[(struct MonoJitDomainInfo *)D.29533].seq_points;
  seq_points = monoeg_g_hash_table_lookup (D.29534, method);
  if (seq_points == 0B) goto <D.29535>; else goto <D.29536>;
  <D.29535>:
  D.29537 = BIT_FIELD_REF <*method, 64, 256>;
  D.29538 = D.29537 & 2251799813685248;
  if (D.29538 != 0) goto <D.29539>; else goto <D.29540>;
  <D.29539>:
  D.29533 = domain->runtime_info;
  D.29534 = MEM[(struct MonoJitDomainInfo *)D.29533].seq_points;
  D.29541 = mono_method_get_declaring_generic_method (method);
  seq_points = monoeg_g_hash_table_lookup (D.29534, D.29541);
  if (seq_points == 0B) goto <D.29542>; else goto <D.29543>;
  <D.29542>:
  D.29533 = domain->runtime_info;
  D.29534 = MEM[(struct MonoJitDomainInfo *)D.29533].seq_points;
  D.29544 = mini_get_shared_method (method);
  seq_points = monoeg_g_hash_table_lookup (D.29534, D.29544);
  <D.29543>:
  <D.29540>:
  <D.29536>:
  {
    int ret;

    D.29525 = &domain->lock.mutex;
    ret = pthread_mutex_unlock (D.29525);
    if (ret != 0) goto <D.29545>; else goto <D.29546>;
    <D.29545>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.29546>:
    D.29547 = ret != 0;
    D.29548 = (long int) D.29547;
    D.29549 = __builtin_expect (D.29548, 0);
    if (D.29549 != 0) goto <D.29550>; else goto <D.29551>;
    <D.29550>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 2997, "ret == 0");
    <D.29551>:
  }
  D.29552 = seq_points;
  return D.29552;
}


compute_frame_info (struct MonoInternalThread * thread, struct DebuggerTlsData * tls)
{
  struct StackFrame * * D.29554;
  int D.29557;
  int log_level.182;
  _Bool D.29561;
  long int D.29562;
  long int D.29563;
  struct FILE * log_file.183;
  long unsigned int D.29567;
  long int D.29568;
  int D.29569;
  int D.29574;
  int D.29576;
  struct StackFrameInfo * D.29578;
  struct MonoThreadUnwindState * D.29579;
  int D.29580;
  int D.29583;
  struct MonoThreadUnwindState * D.29586;
  struct MonoThreadUnwindState * D.29587;
  struct GSList * D.29592;
  unsigned int D.29593;
  long unsigned int D.29594;
  long unsigned int D.29595;
  long unsigned int D.29596;
  long unsigned int D.29597;
  struct StackFrame * * D.29598;
  struct StackFrame * D.29599;
  long unsigned int D.29600;
  void * D.29601;
  long unsigned int D.29602;
  void * D.29603;
  int D.29606;
  int D.29607;
  int D.29610;
  int findex.184;
  long unsigned int D.29612;
  long unsigned int D.29613;
  struct StackFrame * * D.29614;
  struct ComputeFramesUserData user_data;
  struct GSList * tmp;
  int i;
  int findex;
  int new_frame_count;
  struct StackFrame * * new_frames;
  struct StackFrame * f;
  MonoUnwindOptions opts;

  try
    {
      opts = 6;
      D.29554 = tls->frames;
      if (D.29554 != 0B) goto <D.29555>; else goto <D.29556>;
      <D.29555>:
      D.29557 = tls->frames_up_to_date;
      if (D.29557 != 0) goto <D.29558>; else goto <D.29559>;
      <D.29558>:
      return;
      <D.29559>:
      <D.29556>:
      log_level.182 = log_level;
      D.29561 = log_level.182 > 0;
      D.29562 = (long int) D.29561;
      D.29563 = __builtin_expect (D.29562, 0);
      if (D.29563 != 0) goto <D.29564>; else goto <D.29565>;
      <D.29564>:
      log_file.183 = log_file;
      D.29567 = thread->tid;
      D.29568 = (long int) D.29567;
      fprintf (log_file.183, "Frames for %p(tid=%lx):\n", thread, D.29568);
      log_file.183 = log_file;
      fflush (log_file.183);
      <D.29565>:
      user_data.tls = tls;
      user_data.frames = 0B;
      D.29569 = tls->terminated;
      if (D.29569 != 0) goto <D.29570>; else goto <D.29571>;
      <D.29570>:
      tls->frame_count = 0;
      return;
      <D.29571>:
      D.29574 = tls->really_suspended;
      if (D.29574 == 0) goto <D.29575>; else goto <D.29572>;
      <D.29575>:
      D.29576 = tls->async_state.valid;
      if (D.29576 != 0) goto <D.29577>; else goto <D.29572>;
      <D.29577>:
      D.29578 = &tls->async_last_frame;
      process_frame (D.29578, 0B, &user_data);
      D.29579 = &tls->async_state;
      mono_walk_stack_with_state (process_frame, D.29579, opts, &user_data);
      goto <D.29573>;
      <D.29572>:
      D.29580 = tls->filter_state.valid;
      if (D.29580 != 0) goto <D.29581>; else goto <D.29582>;
      <D.29581>:
      D.29583 = tls->context.valid;
      if (D.29583 != 0) goto <D.29584>; else goto <D.29585>;
      <D.29584>:
      D.29586 = &tls->context;
      mono_walk_stack_with_state (process_filter_frame, D.29586, opts, &user_data);
      <D.29585>:
      D.29587 = &tls->filter_state;
      mono_walk_stack_with_state (process_frame, D.29587, opts, &user_data);
      goto <D.29588>;
      <D.29582>:
      D.29583 = tls->context.valid;
      if (D.29583 != 0) goto <D.29589>; else goto <D.29590>;
      <D.29589>:
      D.29586 = &tls->context;
      mono_walk_stack_with_state (process_frame, D.29586, opts, &user_data);
      goto <D.29591>;
      <D.29590>:
      tls->frame_count = 0;
      return;
      <D.29591>:
      <D.29588>:
      <D.29573>:
      D.29592 = user_data.frames;
      D.29593 = monoeg_g_slist_length (D.29592);
      new_frame_count = (int) D.29593;
      D.29594 = (long unsigned int) new_frame_count;
      D.29595 = D.29594 * 8;
      new_frames = monoeg_malloc0 (D.29595);
      findex = 0;
      tmp = user_data.frames;
      goto <D.25705>;
      <D.25704>:
      f = tmp->data;
      i = 0;
      goto <D.25703>;
      <D.25702>:
      D.29554 = tls->frames;
      D.29596 = (long unsigned int) i;
      D.29597 = D.29596 * 8;
      D.29598 = D.29554 + D.29597;
      D.29599 = *D.29598;
      D.29600 = D.29599->ctx.uc_mcontext.gregs[15];
      D.29601 = (void *) D.29600;
      D.29602 = f->ctx.uc_mcontext.gregs[15];
      D.29603 = (void *) D.29602;
      if (D.29601 == D.29603) goto <D.29604>; else goto <D.29605>;
      <D.29604>:
      D.29554 = tls->frames;
      D.29596 = (long unsigned int) i;
      D.29597 = D.29596 * 8;
      D.29598 = D.29554 + D.29597;
      D.29599 = *D.29598;
      D.29606 = D.29599->id;
      f->id = D.29606;
      goto <D.25701>;
      <D.29605>:
      i = i + 1;
      <D.25703>:
      D.29607 = tls->frame_count;
      if (D.29607 > i) goto <D.25702>; else goto <D.25701>;
      <D.25701>:
      D.29607 = tls->frame_count;
      if (D.29607 <= i) goto <D.29608>; else goto <D.29609>;
      <D.29608>:
      D.29610 = InterlockedIncrement (&frame_id);
      f->id = D.29610;
      <D.29609>:
      findex.184 = findex;
      findex = findex.184 + 1;
      D.29612 = (long unsigned int) findex.184;
      D.29613 = D.29612 * 8;
      D.29614 = new_frames + D.29613;
      *D.29614 = f;
      tmp = tmp->next;
      <D.25705>:
      if (tmp != 0B) goto <D.25704>; else goto <D.25706>;
      <D.25706>:
      D.29592 = user_data.frames;
      monoeg_g_slist_free (D.29592);
      invalidate_frames (tls);
      tls->frames = new_frames;
      tls->frame_count = new_frame_count;
      tls->frames_up_to_date = 1;
    }
  finally
    {
      user_data = {CLOBBER};
    }
}


process_filter_frame (struct StackFrameInfo * info, struct MonoContext * ctx, void * user_data)
{
  long unsigned int D.29618;
  void * D.29619;
  struct DebuggerTlsData * D.29620;
  long unsigned int D.29621;
  void * D.29622;
  gboolean D.29625;
  struct ComputeFramesUserData * ud;

  ud = user_data;
  D.29618 = ctx->uc_mcontext.gregs[15];
  D.29619 = (void *) D.29618;
  D.29620 = ud->tls;
  D.29621 = D.29620->filter_state.ctx.uc_mcontext.gregs[15];
  D.29622 = (void *) D.29621;
  if (D.29619 >= D.29622) goto <D.29623>; else goto <D.29624>;
  <D.29623>:
  D.29625 = 1;
  return D.29625;
  <D.29624>:
  D.29625 = process_frame (info, ctx, user_data);
  return D.29625;
}


process_frame (struct StackFrameInfo * info, struct MonoContext * ctx, void * user_data)
{
  <unnamed type> D.29627;
  struct GSList * D.29632;
  struct GSList * D.29635;
  void * D.29636;
  int D.29637;
  int D.29638;
  gboolean D.29639;
  struct MonoJitInfo * D.29640;
  long unsigned int D.29649;
  long unsigned int D.29650;
  int D.29653;
  struct MonoDomain * D.29658;
  int D.29659;
  int D.29662;
  unsigned int D.29665;
  int D.29666;
  int log_level.185;
  _Bool D.29668;
  long int D.29669;
  long int D.29670;
  struct FILE * log_file.186;
  char * D.29674;
  int D.29675;
  int protocol_version_set.187;
  int major_version.188;
  int minor_version.189;
  unsigned int D.29688;
  unsigned int D.29689;
  mgreg_t * * D.29690;
  mgreg_t *[16] * D.29693;
  struct GSList * D.29696;
  struct ComputeFramesUserData * ud;
  struct StackFrame * frame;
  struct MonoMethod * method;
  struct MonoMethod * actual_method;
  struct MonoMethod * api_method;
  struct SeqPoint * sp;
  int flags;

  ud = user_data;
  flags = 0;
  D.29627 = info->type;
  if (D.29627 != 0) goto <D.29628>; else goto <D.29629>;
  <D.29628>:
  D.29627 = info->type;
  if (D.29627 == 1) goto <D.29630>; else goto <D.29631>;
  <D.29630>:
  D.29632 = ud->frames;
  if (D.29632 != 0B) goto <D.29633>; else goto <D.29634>;
  <D.29633>:
  D.29632 = ud->frames;
  D.29635 = monoeg_g_slist_last (D.29632);
  D.29636 = D.29635->data;
  D.29637 = MEM[(struct StackFrame *)D.29636].flags;
  D.29638 = D.29637 | 1;
  MEM[(struct StackFrame *)D.29636].flags = D.29638;
  <D.29634>:
  <D.29631>:
  D.29639 = 0;
  return D.29639;
  <D.29629>:
  D.29640 = info->ji;
  if (D.29640 != 0B) goto <D.29641>; else goto <D.29642>;
  <D.29641>:
  D.29640 = info->ji;
  method = jinfo_get_method (D.29640);
  goto <D.29643>;
  <D.29642>:
  method = info->method;
  <D.29643>:
  actual_method = info->actual_method;
  api_method = method;
  if (method == 0B) goto <D.29644>; else goto <D.29645>;
  <D.29644>:
  D.29639 = 0;
  return D.29639;
  <D.29645>:
  if (method == 0B) goto <D.29646>; else goto <D.29648>;
  <D.29648>:
  D.29649 = BIT_FIELD_REF <*method, 64, 256>;
  D.29650 = D.29649 & 4467570830351532032;
  if (D.29650 != 0) goto <D.29651>; else goto <D.29647>;
  <D.29651>:
  D.29649 = BIT_FIELD_REF <*method, 64, 256>;
  D.29650 = D.29649 & 4467570830351532032;
  if (D.29650 != 2449958197289549824) goto <D.29652>; else goto <D.29647>;
  <D.29652>:
  D.29649 = BIT_FIELD_REF <*method, 64, 256>;
  D.29650 = D.29649 & 4467570830351532032;
  if (D.29650 != 864691128455135232) goto <D.29646>; else goto <D.29647>;
  <D.29646>:
  D.29639 = 0;
  return D.29639;
  <D.29647>:
  D.29653 = info->il_offset;
  if (D.29653 == -1) goto <D.29654>; else goto <D.29655>;
  <D.29654>:
  D.29632 = ud->frames;
  if (D.29632 == 0B) goto <D.29656>; else goto <D.29657>;
  <D.29656>:
  D.29658 = info->domain;
  D.29659 = info->native_offset;
  sp = find_prev_seq_point_for_native_offset (D.29658, method, D.29659, 0B);
  if (sp != 0B) goto <D.29660>; else goto <D.29661>;
  <D.29660>:
  D.29662 = sp->il_offset;
  info->il_offset = D.29662;
  <D.29661>:
  <D.29657>:
  D.29653 = info->il_offset;
  if (D.29653 == -1) goto <D.29663>; else goto <D.29664>;
  <D.29663>:
  D.29658 = info->domain;
  D.29659 = info->native_offset;
  D.29665 = (unsigned int) D.29659;
  D.29666 = mono_debug_il_offset_from_address (method, D.29658, D.29665);
  info->il_offset = D.29666;
  <D.29664>:
  <D.29655>:
  log_level.185 = log_level;
  D.29668 = log_level.185 > 0;
  D.29669 = (long int) D.29668;
  D.29670 = __builtin_expect (D.29669, 0);
  if (D.29670 != 0) goto <D.29671>; else goto <D.29672>;
  <D.29671>:
  log_file.186 = log_file;
  D.29674 = mono_method_full_name (method, 1);
  D.29653 = info->il_offset;
  D.29659 = info->native_offset;
  D.29675 = info->managed;
  fprintf (log_file.186, "\tFrame: %s:%x(%x) %d\n", D.29674, D.29653, D.29659, D.29675);
  log_file.186 = log_file;
  fflush (log_file.186);
  <D.29672>:
  D.29649 = BIT_FIELD_REF <*method, 64, 256>;
  D.29650 = D.29649 & 4467570830351532032;
  if (D.29650 == 864691128455135232) goto <D.29676>; else goto <D.29677>;
  <D.29676>:
  protocol_version_set.187 = protocol_version_set;
  if (protocol_version_set.187 == 0) goto <D.29678>; else goto <D.29681>;
  <D.29681>:
  major_version.188 = major_version;
  if (major_version.188 <= 2) goto <D.29683>; else goto <D.29679>;
  <D.29683>:
  major_version.188 = major_version;
  if (major_version.188 != 2) goto <D.29678>; else goto <D.29684>;
  <D.29684>:
  minor_version.189 = minor_version;
  if (minor_version.189 <= 16) goto <D.29678>; else goto <D.29679>;
  <D.29678>:
  D.29639 = 0;
  return D.29639;
  <D.29679>:
  api_method = mono_marshal_method_from_wrapper (method);
  if (api_method == 0B) goto <D.29686>; else goto <D.29687>;
  <D.29686>:
  D.29639 = 0;
  return D.29639;
  <D.29687>:
  actual_method = api_method;
  flags = flags | 2;
  <D.29677>:
  frame = monoeg_malloc0 (720);
  frame->method = method;
  frame->actual_method = actual_method;
  frame->api_method = api_method;
  D.29653 = info->il_offset;
  D.29688 = (unsigned int) D.29653;
  frame->il_offset = D.29688;
  D.29659 = info->native_offset;
  D.29689 = (unsigned int) D.29659;
  frame->native_offset = D.29689;
  frame->flags = flags;
  D.29640 = info->ji;
  frame->ji = D.29640;
  D.29690 = info->reg_locations;
  if (D.29690 != 0B) goto <D.29691>; else goto <D.29692>;
  <D.29691>:
  D.29693 = &frame->reg_locations;
  D.29690 = info->reg_locations;
  memcpy (D.29693, D.29690, 128);
  <D.29692>:
  if (ctx != 0B) goto <D.29694>; else goto <D.29695>;
  <D.29694>:
  frame->ctx = *ctx;
  frame->has_ctx = 1;
  <D.29695>:
  D.29658 = info->domain;
  frame->domain = D.29658;
  D.29632 = ud->frames;
  D.29696 = monoeg_g_slist_append (D.29632, frame);
  ud->frames = D.29696;
  D.29639 = 0;
  return D.29639;
}


find_prev_seq_point_for_native_offset (struct MonoDomain * domain, struct MonoMethod * method, gint32 native_offset, struct MonoSeqPointInfo * * info)
{
  struct SeqPoint * D.29702;
  int D.29703;
  int D.29704;
  struct MonoSeqPointInfo * seq_points;
  int i;

  seq_points = get_seq_points (domain, method);
  if (info != 0B) goto <D.29698>; else goto <D.29699>;
  <D.29698>:
  *info = seq_points;
  <D.29699>:
  if (seq_points == 0B) goto <D.29700>; else goto <D.29701>;
  <D.29700>:
  D.29702 = 0B;
  return D.29702;
  <D.29701>:
  D.29703 = seq_points->len;
  i = D.29703 + -1;
  goto <D.25654>;
  <D.25653>:
  D.29704 = seq_points->seq_points[i].native_offset;
  if (D.29704 <= native_offset) goto <D.29705>; else goto <D.29706>;
  <D.29705>:
  D.29702 = &seq_points->seq_points[i];
  return D.29702;
  <D.29706>:
  i = i + -1;
  <D.25654>:
  if (i >= 0) goto <D.25653>; else goto <D.25655>;
  <D.25655>:
  D.29702 = 0B;
  return D.29702;
}


no_seq_points_found (struct MonoMethod * method)
{
  char * D.29708;

  D.29708 = mono_method_full_name (method, 1);
  printf ("Unable to find seq points for method \'%s\'.\n", D.29708);
}


__attribute__((__artificial__, __gnu_inline__, __always_inline__))
printf (const char * restrict __fmt)
{
  int D.29709;

  D.29709 = __printf_chk (1, __fmt, __builtin_va_arg_pack ());
  return D.29709;
}


ss_start (struct SingleStepReq * ss_req, struct MonoMethod * method, struct SeqPoint * sp, struct MonoSeqPointInfo * info, struct MonoContext * ctx, struct DebuggerTlsData * tls, gboolean step_to_catch)
{
  int D.29713;
  long int D.29714;
  struct EventRequest * D.29715;
  struct GSList * D.29716;
  struct GSList * D.29717;
  int D.29722;
  <unnamed type> D.29724;
  int D.29728;
  struct MonoThreadUnwindState * D.29731;
  struct MonoInternalThread * D.29732;
  struct StackFrame * * D.29735;
  long unsigned int D.29736;
  long unsigned int D.29737;
  struct StackFrame * * D.29738;
  struct MonoDomain * D.29739;
  struct MonoMethod * D.29740;
  unsigned int D.29741;
  int D.29742;
  int D.29746;
  struct MonoDomain * D.29752;
  struct MonoMethod * D.29753;
  unsigned int D.29754;
  int D.29755;
  struct MonoSeqPointInfo * info.190;
  int * D.29764;
  long unsigned int D.29765;
  long unsigned int D.29766;
  int * D.29767;
  int D.29768;
  int D.29769;
  long int D.29770;
  struct GSList * D.29771;
  int D.29774;
  long unsigned int D.29777;
  struct StackFrame * * D.29778;
  struct MonoJitInfo * D.29779;
  struct MonoDomain * D.29782;
  struct MonoMethod * D.29783;
  void * D.29784;
  long int D.29785;
  void * D.29786;
  long int D.29787;
  long int D.29788;
  int D.29789;
  struct GSList * D.29792;
  <unnamed-unsigned:15> D.29793;
  int D.29794;
  int log_level.191;
  _Bool D.29800;
  long int D.29801;
  long int D.29802;
  struct FILE * log_file.192;
  int i;
  int j;
  int frame_index;
  struct SeqPoint * next_sp;
  struct MonoBreakpoint * bp;
  gboolean enable_global;

  enable_global = 0;
  ss_stop (ss_req);
  if (step_to_catch != 0) goto <D.29711>; else goto <D.29712>;
  <D.29711>:
  D.29713 = sp->il_offset;
  D.29714 = (long int) D.29713;
  D.29715 = ss_req->req;
  bp = set_breakpoint (method, D.29714, D.29715, 0B);
  D.29716 = ss_req->bps;
  D.29717 = monoeg_g_slist_append (D.29716, bp);
  ss_req->bps = D.29717;
  goto <D.29718>;
  <D.29712>:
  frame_index = 1;
  if (sp == 0B) goto <D.29719>; else goto <D.29721>;
  <D.29721>:
  D.29722 = sp->next_len;
  if (D.29722 == 0) goto <D.29719>; else goto <D.29723>;
  <D.29723>:
  D.29724 = ss_req->depth;
  if (D.29724 == 2) goto <D.29719>; else goto <D.29725>;
  <D.29725>:
  D.29724 = ss_req->depth;
  if (D.29724 == 1) goto <D.29719>; else goto <D.29720>;
  <D.29719>:
  if (ctx != 0B) goto <D.29726>; else goto <D.29727>;
  <D.29726>:
  D.29728 = tls->context.valid;
  if (D.29728 == 0) goto <D.29729>; else goto <D.29730>;
  <D.29729>:
  D.29731 = &tls->context;
  mono_thread_state_init_from_monoctx (D.29731, ctx);
  <D.29730>:
  D.29732 = tls->thread;
  compute_frame_info (D.29732, tls);
  <D.29727>:
  <D.29720>:
  D.29724 = ss_req->depth;
  if (D.29724 == 2) goto <D.29733>; else goto <D.29734>;
  <D.29733>:
  goto <D.26235>;
  <D.26234>:
  {
    struct StackFrame * frame;

    D.29735 = tls->frames;
    D.29736 = (long unsigned int) frame_index;
    D.29737 = D.29736 * 8;
    D.29738 = D.29735 + D.29737;
    frame = *D.29738;
    method = frame->method;
    D.29739 = frame->domain;
    D.29740 = frame->method;
    D.29741 = frame->native_offset;
    D.29742 = (int) D.29741;
    sp = find_prev_seq_point_for_native_offset (D.29739, D.29740, D.29742, &info);
    frame_index = frame_index + 1;
    if (sp != 0B) goto <D.29743>; else goto <D.29744>;
    <D.29743>:
    D.29722 = sp->next_len;
    if (D.29722 != 0) goto <D.26233>; else goto <D.29745>;
    <D.29745>:
    <D.29744>:
  }
  <D.26235>:
  D.29746 = tls->frame_count;
  if (D.29746 > frame_index) goto <D.26234>; else goto <D.26233>;
  <D.26233>:
  goto <D.29747>;
  <D.29734>:
  if (sp != 0B) goto <D.29748>; else goto <D.29749>;
  <D.29748>:
  D.29722 = sp->next_len;
  if (D.29722 == 0) goto <D.29750>; else goto <D.29751>;
  <D.29750>:
  sp = 0B;
  goto <D.26239>;
  <D.26238>:
  {
    struct StackFrame * frame;

    D.29735 = tls->frames;
    D.29736 = (long unsigned int) frame_index;
    D.29737 = D.29736 * 8;
    D.29738 = D.29735 + D.29737;
    frame = *D.29738;
    method = frame->method;
    D.29752 = frame->domain;
    D.29753 = frame->method;
    D.29754 = frame->native_offset;
    D.29755 = (int) D.29754;
    sp = find_prev_seq_point_for_native_offset (D.29752, D.29753, D.29755, &info);
    if (sp != 0B) goto <D.29756>; else goto <D.29757>;
    <D.29756>:
    D.29722 = sp->next_len;
    if (D.29722 != 0) goto <D.26237>; else goto <D.29758>;
    <D.29758>:
    <D.29757>:
    sp = 0B;
    frame_index = frame_index + 1;
  }
  <D.26239>:
  D.29746 = tls->frame_count;
  if (D.29746 > frame_index) goto <D.26238>; else goto <D.26237>;
  <D.26237>:
  <D.29751>:
  <D.29749>:
  <D.29747>:
  if (sp != 0B) goto <D.29759>; else goto <D.29760>;
  <D.29759>:
  D.29722 = sp->next_len;
  if (D.29722 > 0) goto <D.29761>; else goto <D.29762>;
  <D.29761>:
  i = 0;
  goto <D.26241>;
  <D.26240>:
  info.190 = info;
  D.29764 = sp->next;
  D.29765 = (long unsigned int) i;
  D.29766 = D.29765 * 4;
  D.29767 = D.29764 + D.29766;
  D.29768 = *D.29767;
  next_sp = &info.190->seq_points[D.29768];
  D.29769 = next_sp->il_offset;
  D.29770 = (long int) D.29769;
  D.29715 = ss_req->req;
  bp = set_breakpoint (method, D.29770, D.29715, 0B);
  D.29716 = ss_req->bps;
  D.29771 = monoeg_g_slist_append (D.29716, bp);
  ss_req->bps = D.29771;
  i = i + 1;
  <D.26241>:
  D.29722 = sp->next_len;
  if (D.29722 > i) goto <D.26240>; else goto <D.26242>;
  <D.26242>:
  <D.29762>:
  <D.29760>:
  D.29724 = ss_req->depth;
  if (D.29724 == 1) goto <D.29772>; else goto <D.29773>;
  <D.29772>:
  D.29774 = ss_req->nframes;
  if (D.29774 == 0) goto <D.29775>; else goto <D.29776>;
  <D.29775>:
  D.29746 = tls->frame_count;
  ss_req->nframes = D.29746;
  <D.29776>:
  i = 0;
  goto <D.26250>;
  <D.26249>:
  {
    struct StackFrame * frame;

    D.29735 = tls->frames;
    D.29765 = (long unsigned int) i;
    D.29777 = D.29765 * 8;
    D.29778 = D.29735 + D.29777;
    frame = *D.29778;
    D.29779 = frame->ji;
    if (D.29779 != 0B) goto <D.29780>; else goto <D.29781>;
    <D.29780>:
    {
      struct MonoJitInfo * jinfo;

      jinfo = frame->ji;
      j = 0;
      goto <D.26247>;
      <D.26246>:
      {
        struct MonoJitExceptionInfo * ei;

        ei = &jinfo->clauses[j];
        D.29782 = frame->domain;
        D.29783 = frame->method;
        D.29784 = ei->handler_start;
        D.29785 = (long int) D.29784;
        D.29786 = jinfo->code_start;
        D.29787 = (long int) D.29786;
        D.29788 = D.29785 - D.29787;
        D.29789 = (int) D.29788;
        sp = find_next_seq_point_for_native_offset (D.29782, D.29783, D.29789, 0B);
        if (sp != 0B) goto <D.29790>; else goto <D.29791>;
        <D.29790>:
        D.29783 = frame->method;
        D.29713 = sp->il_offset;
        D.29714 = (long int) D.29713;
        D.29715 = ss_req->req;
        bp = set_breakpoint (D.29783, D.29714, D.29715, 0B);
        D.29716 = ss_req->bps;
        D.29792 = monoeg_g_slist_append (D.29716, bp);
        ss_req->bps = D.29792;
        <D.29791>:
      }
      j = j + 1;
      <D.26247>:
      D.29793 = jinfo->num_clauses;
      D.29794 = (int) D.29793;
      if (D.29794 > j) goto <D.26246>; else goto <D.26248>;
      <D.26248>:
    }
    <D.29781>:
  }
  i = i + 1;
  <D.26250>:
  D.29746 = tls->frame_count;
  if (D.29746 > i) goto <D.26249>; else goto <D.26251>;
  <D.26251>:
  <D.29773>:
  D.29724 = ss_req->depth;
  if (D.29724 == 0) goto <D.29795>; else goto <D.29796>;
  <D.29795>:
  enable_global = 1;
  <D.29796>:
  tls->context.valid = 0;
  tls->async_state.valid = 0;
  invalidate_frames (tls);
  <D.29718>:
  if (enable_global != 0) goto <D.29797>; else goto <D.29798>;
  <D.29797>:
  log_level.191 = log_level;
  D.29800 = log_level.191 > 0;
  D.29801 = (long int) D.29800;
  D.29802 = __builtin_expect (D.29801, 0);
  if (D.29802 != 0) goto <D.29803>; else goto <D.29804>;
  <D.29803>:
  log_file.192 = log_file;
  fprintf (log_file.192, "[dbg] Turning on global single stepping.\n");
  log_file.192 = log_file;
  fflush (log_file.192);
  <D.29804>:
  ss_req->global = 1;
  start_single_stepping ();
  goto <D.29806>;
  <D.29798>:
  D.29716 = ss_req->bps;
  if (D.29716 == 0B) goto <D.29807>; else goto <D.29808>;
  <D.29807>:
  log_level.191 = log_level;
  D.29800 = log_level.191 > 0;
  D.29801 = (long int) D.29800;
  D.29802 = __builtin_expect (D.29801, 0);
  if (D.29802 != 0) goto <D.29809>; else goto <D.29810>;
  <D.29809>:
  log_file.192 = log_file;
  fprintf (log_file.192, "[dbg] Turning on global single stepping.\n");
  log_file.192 = log_file;
  fflush (log_file.192);
  <D.29810>:
  ss_req->global = 1;
  start_single_stepping ();
  goto <D.29811>;
  <D.29808>:
  ss_req->global = 0;
  <D.29811>:
  <D.29806>:
}


start_single_stepping ()
{
  struct SingleStepReq * ss_req.193;
  void * ss_invoke_addr.194;
  struct MonoGHashTable * thread_to_tls.195;
  struct MonoInternalThread * D.29821;
  void * D.29822;
  int val;

  val = InterlockedIncrement (&ss_count);
  if (val == 1) goto <D.29812>; else goto <D.29813>;
  <D.29812>:
  mono_arch_start_single_stepping ();
  <D.29813>:
  ss_req.193 = ss_req;
  if (ss_req.193 != 0B) goto <D.29815>; else goto <D.29816>;
  <D.29815>:
  ss_invoke_addr.194 = ss_invoke_addr;
  if (ss_invoke_addr.194 == 0B) goto <D.29818>; else goto <D.29819>;
  <D.29818>:
  {
    struct DebuggerTlsData * tls;

    mono_loader_lock ();
    thread_to_tls.195 = thread_to_tls;
    ss_req.193 = ss_req;
    D.29821 = ss_req.193->thread;
    tls = mono_g_hash_table_lookup (thread_to_tls.195, D.29821);
    D.29822 = tls->invoke_addr;
    ss_invoke_addr = D.29822;
    mono_loader_unlock ();
  }
  <D.29819>:
  <D.29816>:
}


set_breakpoint (struct MonoMethod * method, long int il_offset, struct EventRequest * req, struct MonoError * error)
{
  struct GPtrArray * D.29825;
  int log_level.196;
  _Bool D.29827;
  long int D.29828;
  long int D.29829;
  struct FILE * log_file.197;
  const char * iftmp.198;
  int D.29834;
  const char * iftmp.199;
  int D.29842;
  struct GHashTable * domains.200;
  struct MonoDomain * domain.201;
  union mono_mutex_t * D.29845;
  _Bool D.29848;
  long int D.29849;
  long int D.29850;
  void * D.29853;
  struct GHashTable * D.29854;
  struct MonoMethod * m.202;
  int D.29856;
  struct MonoSeqPointInfo * seq_points.203;
  int D.29860;
  _Bool D.29863;
  long int D.29864;
  long int D.29865;
  int D.29868;
  struct GPtrArray * breakpoints.204;
  int D.29872;
  struct MonoBreakpoint * D.29875;
  struct MonoBreakpoint * bp;
  struct GHashTableIter iter;
  struct GHashTableIter iter2;
  struct MonoDomain * domain;
  struct MonoMethod * m;
  struct MonoSeqPointInfo * seq_points;

  try
    {
      if (error != 0B) goto <D.29823>; else goto <D.29824>;
      <D.29823>:
      mono_error_init (error);
      <D.29824>:
      bp = monoeg_malloc0 (32);
      bp->method = method;
      bp->il_offset = il_offset;
      bp->req = req;
      D.29825 = monoeg_g_ptr_array_new ();
      bp->children = D.29825;
      log_level.196 = log_level;
      D.29827 = log_level.196 > 0;
      D.29828 = (long int) D.29827;
      D.29829 = __builtin_expect (D.29828, 0);
      if (D.29829 != 0) goto <D.29830>; else goto <D.29831>;
      <D.29830>:
      log_file.197 = log_file;
      D.29834 = req->event_kind;
      if (D.29834 == 11) goto <D.29835>; else goto <D.29836>;
      <D.29835>:
      iftmp.198 = "single step ";
      goto <D.29837>;
      <D.29836>:
      iftmp.198 = "";
      <D.29837>:
      if (method != 0B) goto <D.29839>; else goto <D.29840>;
      <D.29839>:
      iftmp.199 = mono_method_full_name (method, 1);
      goto <D.29841>;
      <D.29840>:
      iftmp.199 = "<all>";
      <D.29841>:
      D.29842 = (int) il_offset;
      fprintf (log_file.197, "[dbg] Setting %sbreakpoint at %s:0x%x.\n", iftmp.198, iftmp.199, D.29842);
      log_file.197 = log_file;
      fflush (log_file.197);
      <D.29831>:
      mono_loader_lock ();
      domains.200 = domains;
      monoeg_g_hash_table_iter_init (&iter, domains.200);
      goto <D.26048>;
      <D.26047>:
      {
        int ret;

        domain.201 = domain;
        D.29845 = &domain.201->lock.mutex;
        ret = pthread_mutex_lock (D.29845);
        if (ret != 0) goto <D.29846>; else goto <D.29847>;
        <D.29846>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
        <D.29847>:
        D.29848 = ret != 0;
        D.29849 = (long int) D.29848;
        D.29850 = __builtin_expect (D.29849, 0);
        if (D.29850 != 0) goto <D.29851>; else goto <D.29852>;
        <D.29851>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 4353, "ret == 0");
        <D.29852>:
      }
      domain.201 = domain;
      D.29853 = domain.201->runtime_info;
      D.29854 = MEM[(struct MonoJitDomainInfo *)D.29853].seq_points;
      monoeg_g_hash_table_iter_init (&iter2, D.29854);
      goto <D.26044>;
      <D.26043>:
      m.202 = m;
      D.29856 = bp_matches_method (bp, m.202);
      if (D.29856 != 0) goto <D.29857>; else goto <D.29858>;
      <D.29857>:
      domain.201 = domain;
      m.202 = m;
      seq_points.203 = seq_points;
      set_bp_in_method (domain.201, m.202, seq_points.203, bp, error);
      <D.29858>:
      <D.26044>:
      D.29860 = monoeg_g_hash_table_iter_next (&iter2, &m, &seq_points);
      if (D.29860 != 0) goto <D.26043>; else goto <D.26045>;
      <D.26045>:
      {
        int ret;

        domain.201 = domain;
        D.29845 = &domain.201->lock.mutex;
        ret = pthread_mutex_unlock (D.29845);
        if (ret != 0) goto <D.29861>; else goto <D.29862>;
        <D.29861>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.29862>:
        D.29863 = ret != 0;
        D.29864 = (long int) D.29863;
        D.29865 = __builtin_expect (D.29864, 0);
        if (D.29865 != 0) goto <D.29866>; else goto <D.29867>;
        <D.29866>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 4361, "ret == 0");
        <D.29867>:
      }
      <D.26048>:
      D.29868 = monoeg_g_hash_table_iter_next (&iter, &domain, 0B);
      if (D.29868 != 0) goto <D.26047>; else goto <D.26049>;
      <D.26049>:
      mono_loader_unlock ();
      mono_loader_lock ();
      breakpoints.204 = breakpoints;
      monoeg_g_ptr_array_add (breakpoints.204, bp);
      mono_loader_unlock ();
      if (error != 0B) goto <D.29870>; else goto <D.29871>;
      <D.29870>:
      D.29872 = mono_error_ok (error);
      if (D.29872 == 0) goto <D.29873>; else goto <D.29874>;
      <D.29873>:
      clear_breakpoint (bp);
      D.29875 = 0B;
      return D.29875;
      <D.29874>:
      <D.29871>:
      D.29875 = bp;
      return D.29875;
    }
  finally
    {
      iter = {CLOBBER};
      iter2 = {CLOBBER};
      domain = {CLOBBER};
      m = {CLOBBER};
      seq_points = {CLOBBER};
    }
}


bp_matches_method (struct MonoBreakpoint * bp, struct MonoMethod * method)
{
  struct MonoMethod * D.29878;
  gboolean D.29881;
  long unsigned int D.29884;
  long unsigned int D.29885;
  struct MonoMethod * D.29888;
  long unsigned int D.29891;
  long unsigned int D.29892;
  struct MonoMethod * D.29897;
  struct MonoMethod * D.29898;
  struct MonoGenericInst * D.29901;
  struct MonoGenericInst * D.29902;
  struct MonoGenericInst * D.29905;
  long unsigned int D.29908;
  long unsigned int D.29909;
  unsigned char D.29912;
  <unnamed-unsigned:22> D.29915;
  int D.29916;
  int i;

  D.29878 = bp->method;
  if (D.29878 == 0B) goto <D.29879>; else goto <D.29880>;
  <D.29879>:
  D.29881 = 1;
  return D.29881;
  <D.29880>:
  D.29878 = bp->method;
  if (D.29878 == method) goto <D.29882>; else goto <D.29883>;
  <D.29882>:
  D.29881 = 1;
  return D.29881;
  <D.29883>:
  D.29884 = BIT_FIELD_REF <*method, 64, 256>;
  D.29885 = D.29884 & 2251799813685248;
  if (D.29885 != 0) goto <D.29886>; else goto <D.29887>;
  <D.29886>:
  D.29888 = MEM[(struct MonoMethodInflated *)method].declaring;
  D.29878 = bp->method;
  if (D.29888 == D.29878) goto <D.29889>; else goto <D.29890>;
  <D.29889>:
  D.29881 = 1;
  return D.29881;
  <D.29890>:
  <D.29887>:
  D.29878 = bp->method;
  D.29891 = BIT_FIELD_REF <*D.29878, 64, 256>;
  D.29892 = D.29891 & 2251799813685248;
  if (D.29892 != 0) goto <D.29893>; else goto <D.29894>;
  <D.29893>:
  D.29884 = BIT_FIELD_REF <*method, 64, 256>;
  D.29885 = D.29884 & 2251799813685248;
  if (D.29885 != 0) goto <D.29895>; else goto <D.29896>;
  <D.29895>:
  {
    struct MonoMethodInflated * bpimethod;
    struct MonoMethodInflated * imethod;

    bpimethod = bp->method;
    imethod = method;
    D.29897 = bpimethod->declaring;
    D.29898 = imethod->declaring;
    if (D.29897 == D.29898) goto <D.29899>; else goto <D.29900>;
    <D.29899>:
    D.29901 = bpimethod->context.class_inst;
    D.29902 = imethod->context.class_inst;
    if (D.29901 == D.29902) goto <D.29903>; else goto <D.29904>;
    <D.29903>:
    D.29905 = bpimethod->context.method_inst;
    if (D.29905 != 0B) goto <D.29906>; else goto <D.29907>;
    <D.29906>:
    D.29905 = bpimethod->context.method_inst;
    D.29908 = BIT_FIELD_REF <*D.29905, 64, 0>;
    D.29909 = D.29908 & 512;
    if (D.29909 != 0) goto <D.29910>; else goto <D.29911>;
    <D.29910>:
    i = 0;
    goto <D.25996>;
    <D.25995>:
    {
      struct MonoType * t1;

      D.29905 = bpimethod->context.method_inst;
      t1 = D.29905->type_argv[i];
      D.29912 = t1->type;
      if (D.29912 != 30) goto <D.29913>; else goto <D.29914>;
      <D.29913>:
      D.29881 = 0;
      return D.29881;
      <D.29914>:
    }
    i = i + 1;
    <D.25996>:
    D.29905 = bpimethod->context.method_inst;
    D.29915 = D.29905->type_argc;
    D.29916 = (int) D.29915;
    if (D.29916 > i) goto <D.25995>; else goto <D.25997>;
    <D.25997>:
    D.29881 = 1;
    return D.29881;
    <D.29911>:
    <D.29907>:
    <D.29904>:
    <D.29900>:
  }
  <D.29896>:
  <D.29894>:
  D.29881 = 0;
  return D.29881;
}


set_bp_in_method (struct MonoDomain * domain, struct MonoMethod * method, struct MonoSeqPointInfo * seq_points, struct MonoBreakpoint * bp, struct MonoError * error)
{
  _Bool D.29922;
  long int D.29923;
  long int D.29924;
  struct MonoJitInfo * ji.205;
  struct MonoJitInfo * ji.206;
  _Bool D.29929;
  long int D.29930;
  long int D.29931;
  void * code;
  struct MonoJitInfo * ji;

  try
    {
      if (error != 0B) goto <D.29918>; else goto <D.29919>;
      <D.29918>:
      mono_error_init (error);
      <D.29919>:
      code = mono_jit_find_compiled_method_with_jit_info (domain, method, &ji);
      if (code == 0B) goto <D.29920>; else goto <D.29921>;
      <D.29920>:
      code = mono_aot_get_method (domain, method);
      D.29922 = code == 0B;
      D.29923 = (long int) D.29922;
      D.29924 = __builtin_expect (D.29923, 0);
      if (D.29924 != 0) goto <D.29925>; else goto <D.29926>;
      <D.29925>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 4301, "code");
      <D.29926>:
      ji.205 = mono_jit_info_table_find (domain, code);
      ji = ji.205;
      ji.206 = ji;
      D.29929 = ji.206 == 0B;
      D.29930 = (long int) D.29929;
      D.29931 = __builtin_expect (D.29930, 0);
      if (D.29931 != 0) goto <D.29932>; else goto <D.29933>;
      <D.29932>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 4303, "ji");
      <D.29933>:
      <D.29921>:
      D.29922 = code == 0B;
      D.29923 = (long int) D.29922;
      D.29924 = __builtin_expect (D.29923, 0);
      if (D.29924 != 0) goto <D.29934>; else goto <D.29935>;
      <D.29934>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 4305, "code");
      <D.29935>:
      ji.206 = ji;
      insert_breakpoint (seq_points, domain, ji.206, bp, error);
    }
  finally
    {
      ji = {CLOBBER};
    }
}


insert_breakpoint (struct MonoSeqPointInfo * seq_points, struct MonoDomain * domain, struct MonoJitInfo * ji, struct MonoBreakpoint * bp, struct MonoError * error)
{
  int D.29938;
  long int D.29939;
  long int D.29940;
  int D.29942;
  int D.29949;
  long int D.29950;
  struct MonoMethod * D.29954;
  char * D.29955;
  int log_level.207;
  _Bool D.29957;
  long int D.29958;
  long int D.29959;
  struct FILE * log_file.208;
  int D.29963;
  int D.29966;
  long int D.29967;
  void * D.29968;
  sizetype D.29969;
  guint8 * D.29970;
  struct GPtrArray * D.29971;
  struct GHashTable * bp_locs.209;
  guint8 * D.29973;
  void * D.29974;
  long int D.29975;
  int D.29976;
  long int D.29977;
  void * D.29978;
  int D.29983;
  struct MonoMethod * D.29989;
  char * D.29990;
  int i;
  int count;
  struct BreakpointInstance * inst;
  struct SeqPoint * sp;

  sp = 0B;
  if (error != 0B) goto <D.29936>; else goto <D.29937>;
  <D.29936>:
  mono_error_init (error);
  <D.29937>:
  i = 0;
  goto <D.25973>;
  <D.25972>:
  sp = &seq_points->seq_points[i];
  D.29938 = sp->il_offset;
  D.29939 = (long int) D.29938;
  D.29940 = bp->il_offset;
  if (D.29939 == D.29940) goto <D.25971>; else goto <D.29941>;
  <D.29941>:
  i = i + 1;
  <D.25973>:
  D.29942 = seq_points->len;
  if (D.29942 > i) goto <D.25972>; else goto <D.25971>;
  <D.25971>:
  D.29942 = seq_points->len;
  if (D.29942 == i) goto <D.29943>; else goto <D.29944>;
  <D.29943>:
  i = 0;
  goto <D.25976>;
  <D.25975>:
  sp = &seq_points->seq_points[i];
  D.29938 = sp->il_offset;
  if (D.29938 != -1) goto <D.29945>; else goto <D.29946>;
  <D.29945>:
  D.29938 = sp->il_offset;
  if (D.29938 != 16777215) goto <D.29947>; else goto <D.29948>;
  <D.29947>:
  D.29938 = sp->il_offset;
  D.29949 = D.29938 + 1;
  D.29950 = (long int) D.29949;
  D.29940 = bp->il_offset;
  if (D.29950 == D.29940) goto <D.25974>; else goto <D.29951>;
  <D.29951>:
  <D.29948>:
  <D.29946>:
  i = i + 1;
  <D.25976>:
  D.29942 = seq_points->len;
  if (D.29942 > i) goto <D.25975>; else goto <D.25974>;
  <D.25974>:
  <D.29944>:
  D.29942 = seq_points->len;
  if (D.29942 == i) goto <D.29952>; else goto <D.29953>;
  <D.29952>:
  {
    char * s;

    D.29954 = jinfo_get_method (ji);
    D.29955 = mono_method_full_name (D.29954, 1);
    D.29940 = bp->il_offset;
    D.29942 = seq_points->len;
    s = monoeg_g_strdup_printf ("Unable to insert breakpoint at %s:%d, seq_points=%d\n", D.29955, D.29940, D.29942);
    i = 0;
    goto <D.25979>;
    <D.25978>:
    log_level.207 = log_level;
    D.29957 = log_level.207 > 0;
    D.29958 = (long int) D.29957;
    D.29959 = __builtin_expect (D.29958, 0);
    if (D.29959 != 0) goto <D.29960>; else goto <D.29961>;
    <D.29960>:
    log_file.208 = log_file;
    D.29963 = seq_points->seq_points[i].il_offset;
    fprintf (log_file.208, "%d\n", D.29963);
    log_file.208 = log_file;
    fflush (log_file.208);
    <D.29961>:
    i = i + 1;
    <D.25979>:
    D.29942 = seq_points->len;
    if (D.29942 > i) goto <D.25978>; else goto <D.25980>;
    <D.25980>:
    if (error != 0B) goto <D.29964>; else goto <D.29965>;
    <D.29964>:
    mono_error_set_error (error, 9, "%s", s);
    monoeg_g_log (0B, 16, "%s", s);
    monoeg_g_free (s);
    return;
    <D.29965>:
    monoeg_g_log (0B, 16, "%s", s);
    monoeg_g_free (s);
    return;
  }
  <D.29953>:
  inst = monoeg_malloc0 (48);
  inst->sp = sp;
  D.29966 = sp->native_offset;
  D.29967 = (long int) D.29966;
  inst->native_offset = D.29967;
  D.29968 = ji->code_start;
  D.29966 = sp->native_offset;
  D.29969 = (sizetype) D.29966;
  D.29970 = D.29968 + D.29969;
  inst->ip = D.29970;
  inst->ji = ji;
  inst->domain = domain;
  mono_loader_lock ();
  D.29971 = bp->children;
  monoeg_g_ptr_array_add (D.29971, inst);
  bp_locs.209 = bp_locs;
  D.29973 = inst->ip;
  D.29974 = monoeg_g_hash_table_lookup (bp_locs.209, D.29973);
  D.29975 = (long int) D.29974;
  count = (int) D.29975;
  bp_locs.209 = bp_locs;
  D.29973 = inst->ip;
  D.29976 = count + 1;
  D.29977 = (long int) D.29976;
  D.29978 = (void *) D.29977;
  monoeg_g_hash_table_insert_replace (bp_locs.209, D.29973, D.29978, 0);
  mono_loader_unlock ();
  D.29966 = sp->native_offset;
  if (D.29966 == -1) goto <D.29979>; else goto <D.29980>;
  <D.29979>:
  log_level.207 = log_level;
  D.29957 = log_level.207 > 0;
  D.29958 = (long int) D.29957;
  D.29959 = __builtin_expect (D.29958, 0);
  if (D.29959 != 0) goto <D.29981>; else goto <D.29982>;
  <D.29981>:
  log_file.208 = log_file;
  D.29940 = bp->il_offset;
  D.29983 = (int) D.29940;
  fprintf (log_file.208, "[dbg] Attempting to insert seq point at dead IL offset %d, ignoring.\n", D.29983);
  log_file.208 = log_file;
  fflush (log_file.208);
  <D.29982>:
  goto <D.29984>;
  <D.29980>:
  if (count == 0) goto <D.29985>; else goto <D.29986>;
  <D.29985>:
  D.29973 = inst->ip;
  mono_arch_set_breakpoint (ji, D.29973);
  <D.29986>:
  <D.29984>:
  log_level.207 = log_level;
  D.29957 = log_level.207 > 0;
  D.29958 = (long int) D.29957;
  D.29959 = __builtin_expect (D.29958, 0);
  if (D.29959 != 0) goto <D.29987>; else goto <D.29988>;
  <D.29987>:
  log_file.208 = log_file;
  D.29989 = jinfo_get_method (ji);
  D.29990 = mono_method_full_name (D.29989, 1);
  D.29938 = sp->il_offset;
  fprintf (log_file.208, "[dbg] Inserted breakpoint at %s:0x%x.\n", D.29990, D.29938);
  log_file.208 = log_file;
  fflush (log_file.208);
  <D.29988>:
}


domain_commands (int command, guint8 * p, guint8 * end, struct Buffer * buf)
{
  struct MonoDomain * D.29992;
  guint8 * p.210;
  int err.211;
  ErrorCode D.29997;
  char * D.29998;
  unsigned int count.212;
  struct MonoAssembly * D.30004;
  struct MonoAppDomain * D.30007;
  struct MonoVTable * D.30008;
  struct MonoClass * D.30009;
  struct MonoImage * D.30010;
  struct MonoAssembly * D.30011;
  struct MonoDomain * domain2.213;
  _Bool D.30019;
  long int D.30020;
  long int D.30021;
  struct MonoType * D.30024;
  void * D.30025;
  <unnamed type> D.30026;
  int err.214;
  int err;
  struct MonoDomain * domain;

  try
    {
      switch (command) <default: <D.26883>, case 1: <D.26861>, case 2: <D.26863>, case 3: <D.26864>, case 4: <D.26874>, case 5: <D.26876>, case 6: <D.26875>, case 7: <D.26879>>
      <D.26861>:
      D.29992 = mono_get_root_domain ();
      buffer_add_domainid (buf, D.29992);
      goto <D.26862>;
      <D.26863>:
      p.210 = p;
      domain = decode_domainid (p.210, &p, end, 0B, &err);
      err.211 = err;
      if (err.211 != 0) goto <D.29995>; else goto <D.29996>;
      <D.29995>:
      err.211 = err;
      D.29997 = (ErrorCode) err.211;
      return D.29997;
      <D.29996>:
      D.29998 = domain->friendly_name;
      buffer_add_string (buf, D.29998);
      goto <D.26862>;
      <D.26864>:
      {
        struct GSList * tmp;
        struct MonoAssembly * ass;
        int count;

        p.210 = p;
        domain = decode_domainid (p.210, &p, end, 0B, &err);
        err.211 = err;
        if (err.211 != 0) goto <D.29999>; else goto <D.30000>;
        <D.29999>:
        err.211 = err;
        D.29997 = (ErrorCode) err.211;
        return D.29997;
        <D.30000>:
        mono_loader_lock ();
        count = 0;
        tmp = domain->domain_assemblies;
        goto <D.26869>;
        <D.26868>:
        count = count + 1;
        tmp = tmp->next;
        <D.26869>:
        if (tmp != 0B) goto <D.26868>; else goto <D.26870>;
        <D.26870>:
        count.212 = (unsigned int) count;
        buffer_add_int (buf, count.212);
        tmp = domain->domain_assemblies;
        goto <D.26872>;
        <D.26871>:
        ass = tmp->data;
        buffer_add_assemblyid (buf, domain, ass);
        tmp = tmp->next;
        <D.26872>:
        if (tmp != 0B) goto <D.26871>; else goto <D.26873>;
        <D.26873>:
        mono_loader_unlock ();
        goto <D.26862>;
      }
      <D.26874>:
      p.210 = p;
      domain = decode_domainid (p.210, &p, end, 0B, &err);
      err.211 = err;
      if (err.211 != 0) goto <D.30002>; else goto <D.30003>;
      <D.30002>:
      err.211 = err;
      D.29997 = (ErrorCode) err.211;
      return D.29997;
      <D.30003>:
      D.30004 = domain->entry_assembly;
      buffer_add_assemblyid (buf, domain, D.30004);
      goto <D.26862>;
      <D.26875>:
      p.210 = p;
      domain = decode_domainid (p.210, &p, end, 0B, &err);
      err.211 = err;
      if (err.211 != 0) goto <D.30005>; else goto <D.30006>;
      <D.30005>:
      err.211 = err;
      D.29997 = (ErrorCode) err.211;
      return D.29997;
      <D.30006>:
      D.30007 = domain->domain;
      D.30008 = D.30007->mbr.obj.vtable;
      D.30009 = D.30008->klass;
      D.30010 = D.30009->image;
      D.30011 = D.30010->assembly;
      buffer_add_assemblyid (buf, domain, D.30011);
      goto <D.26862>;
      <D.26876>:
      {
        char * s;
        struct MonoString * o;

        p.210 = p;
        domain = decode_domainid (p.210, &p, end, 0B, &err);
        err.211 = err;
        if (err.211 != 0) goto <D.30012>; else goto <D.30013>;
        <D.30012>:
        err.211 = err;
        D.29997 = (ErrorCode) err.211;
        return D.29997;
        <D.30013>:
        p.210 = p;
        s = decode_string (p.210, &p, end);
        o = mono_string_new (domain, s);
        buffer_add_objid (buf, o);
        goto <D.26862>;
      }
      <D.26879>:
      {
        struct MonoClass * klass;
        struct MonoDomain * domain2;
        struct MonoObject * o;

        try
          {
            p.210 = p;
            domain = decode_domainid (p.210, &p, end, 0B, &err);
            err.211 = err;
            if (err.211 != 0) goto <D.30014>; else goto <D.30015>;
            <D.30014>:
            err.211 = err;
            D.29997 = (ErrorCode) err.211;
            return D.29997;
            <D.30015>:
            p.210 = p;
            klass = decode_typeid (p.210, &p, end, &domain2, &err);
            err.211 = err;
            if (err.211 != 0) goto <D.30016>; else goto <D.30017>;
            <D.30016>:
            err.211 = err;
            D.29997 = (ErrorCode) err.211;
            return D.29997;
            <D.30017>:
            domain2.213 = domain2;
            D.30019 = domain != domain2.213;
            D.30020 = (long int) D.30019;
            D.30021 = __builtin_expect (D.30020, 0);
            if (D.30021 != 0) goto <D.30022>; else goto <D.30023>;
            <D.30022>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 7271, "domain == domain2");
            <D.30023>:
            o = mono_object_new (domain, klass);
            D.30024 = &klass->byval_arg;
            D.30025 = mono_object_unbox (o);
            p.210 = p;
            D.30026 = decode_value (D.30024, domain, D.30025, p.210, &p, end);
            err.214 = (int) D.30026;
            err = err.214;
            err.211 = err;
            if (err.211 != 0) goto <D.30028>; else goto <D.30029>;
            <D.30028>:
            err.211 = err;
            D.29997 = (ErrorCode) err.211;
            return D.29997;
            <D.30029>:
            buffer_add_objid (buf, o);
            goto <D.26862>;
          }
        finally
          {
            domain2 = {CLOBBER};
          }
      }
      <D.26883>:
      D.29997 = 100;
      return D.29997;
      <D.26862>:
      D.29997 = 0;
      return D.29997;
    }
  finally
    {
      err = {CLOBBER};
    }
}


decode_domainid (guint8 * buf, guint8 * * endbuf, guint8 * limit, struct MonoDomain * * domain, int * err)
{
  struct MonoDomain * D.30034;

  D.30034 = decode_ptr_id (buf, endbuf, limit, 5, domain, err);
  return D.30034;
}


decode_value (struct MonoType * t, struct MonoDomain * domain, guint8 * addr, guint8 * buf, guint8 * * endbuf, guint8 * limit)
{
  guint8 * buf.215;
  unsigned char D.30037;
  struct MonoClass * D.30040;
  int D.30041;
  struct MonoGenericClass * D.30044;
  struct MonoGenericInst * D.30045;
  <unnamed type> D.30046;
  ErrorCode D.30049;
  unsigned char D.30050;
  int D.30051;
  struct MonoClass * D.30054;
  int D.30055;
  long unsigned int D.30056;
  <unnamed type> D.30057;
  struct MonoClass * D.30060;
  struct MonoObject * D.30061;
  struct MonoClass * D.30062;
  struct MonoClass * D.30065;
  int err;
  int type;

  buf.215 = buf;
  type = decode_byte (buf.215, &buf, limit);
  D.30037 = t->type;
  if (D.30037 == 21) goto <D.30038>; else goto <D.30039>;
  <D.30038>:
  D.30040 = mono_class_from_mono_type (t);
  D.30041 = mono_class_is_nullable (D.30040);
  if (D.30041 != 0) goto <D.30042>; else goto <D.30043>;
  <D.30042>:
  {
    struct MonoType * targ;
    guint8 * nullable_buf;

    D.30044 = t->data.generic_class;
    D.30045 = D.30044->context.class_inst;
    targ = D.30045->type_argv[0];
    buf.215 = buf;
    D.30046 = decode_value_internal (t, type, domain, addr, buf.215, endbuf, limit);
    err = (int) D.30046;
    if (err == 0) goto <D.30047>; else goto <D.30048>;
    <D.30047>:
    D.30049 = (ErrorCode) err;
    return D.30049;
    <D.30048>:
    D.30050 = targ->type;
    D.30051 = (int) D.30050;
    if (D.30051 == type) goto <D.30052>; else goto <D.30053>;
    <D.30052>:
    D.30054 = mono_class_from_mono_type (targ);
    D.30055 = mono_class_instance_size (D.30054);
    D.30056 = (long unsigned int) D.30055;
    nullable_buf = monoeg_malloc (D.30056);
    buf.215 = buf;
    D.30057 = decode_value_internal (targ, type, domain, nullable_buf, buf.215, endbuf, limit);
    err = (int) D.30057;
    if (err != 0) goto <D.30058>; else goto <D.30059>;
    <D.30058>:
    monoeg_g_free (nullable_buf);
    D.30049 = (ErrorCode) err;
    return D.30049;
    <D.30059>:
    D.30060 = mono_class_from_mono_type (targ);
    D.30061 = mono_value_box (domain, D.30060, nullable_buf);
    D.30062 = mono_class_from_mono_type (t);
    mono_nullable_init (addr, D.30061, D.30062);
    monoeg_g_free (nullable_buf);
    buf.215 = buf;
    *endbuf = buf.215;
    D.30049 = 0;
    return D.30049;
    <D.30053>:
    if (type == 240) goto <D.30063>; else goto <D.30064>;
    <D.30063>:
    D.30065 = mono_class_from_mono_type (t);
    mono_nullable_init (addr, 0B, D.30065);
    buf.215 = buf;
    *endbuf = buf.215;
    D.30049 = 0;
    return D.30049;
    <D.30064>:
  }
  <D.30043>:
  <D.30039>:
  buf.215 = buf;
  D.30049 = decode_value_internal (t, type, domain, addr, buf.215, endbuf, limit);
  return D.30049;
}


decode_value_internal (struct MonoType * t, int type, struct MonoDomain * domain, guint8 * addr, guint8 * buf, guint8 * * endbuf, guint8 * limit)
{
  unsigned char D.30072;
  int D.30073;
  int D.30076;
  int log_level.216;
  _Bool D.30084;
  long int D.30085;
  long int D.30086;
  struct FILE * log_file.217;
  long unsigned int D.30090;
  void * D.30091;
  ErrorCode D.30092;
  guint8 * buf.218;
  int D.30094;
  unsigned char D.30095;
  int D.30096;
  short unsigned int D.30097;
  int D.30098;
  signed char D.30099;
  int D.30100;
  unsigned char D.30101;
  int D.30102;
  short int D.30103;
  int D.30104;
  short unsigned int D.30105;
  int D.30106;
  int D.30107;
  unsigned int D.30108;
  long int D.30109;
  long int D.30110;
  long unsigned int D.30111;
  int D.30112;
  unsigned int D.30113;
  long int D.30114;
  long unsigned int D.30115;
  _Bool D.30116;
  long int D.30117;
  long int D.30118;
  long int D.30121;
  int D.30122;
  _Bool D.30123;
  long int D.30124;
  long int D.30125;
  <unnamed type> D.30128;
  int err.219;
  int err.220;
  int D.30133;
  <unnamed type> D.30138;
  struct MonoObject * obj.221;
  int D.30144;
  char * D.30149;
  struct MonoVTable * D.30150;
  struct MonoClass * D.30151;
  const char * D.30152;
  struct MonoDomain * D.30155;
  long unsigned int D.30168;
  _Bool D.30169;
  long int D.30170;
  long int D.30171;
  <unnamed type> D.30174;
  int err.222;
  struct MonoDomain * d.223;
  struct MonoObject * D.30179;
  long unsigned int D.30183;
  void * D.30184;
  int err;
  void handle_vtype = <<< error >>>;
  void handle_ref = <<< error >>>;

  try
    {
      D.30072 = t->type;
      D.30073 = (int) D.30072;
      if (D.30073 != type) goto <D.30074>; else goto <D.30075>;
      <D.30074>:
      D.30076 = mono_type_is_reference (t);
      if (D.30076 == 0) goto <D.30077>; else goto <D.30078>;
      <D.30077>:
      D.30072 = t->type;
      if (D.30072 != 24) goto <D.30071>; else goto <D.30079>;
      <D.30079>:
      if (type != 17) goto <D.30071>; else goto <D.30068>;
      <D.30071>:
      D.30072 = t->type;
      if (D.30072 != 25) goto <D.30070>; else goto <D.30080>;
      <D.30080>:
      if (type != 17) goto <D.30070>; else goto <D.30068>;
      <D.30070>:
      D.30072 = t->type;
      if (D.30072 != 15) goto <D.30069>; else goto <D.30081>;
      <D.30081>:
      if (type != 10) goto <D.30069>; else goto <D.30068>;
      <D.30069>:
      D.30072 = t->type;
      if (D.30072 != 21) goto <D.30067>; else goto <D.30082>;
      <D.30082>:
      if (type != 17) goto <D.30067>; else goto <D.30068>;
      <D.30067>:
      {
        char * name;

        name = mono_type_full_name (t);
        log_level.216 = log_level;
        D.30084 = log_level.216 > 0;
        D.30085 = (long int) D.30084;
        D.30086 = __builtin_expect (D.30085, 0);
        if (D.30086 != 0) goto <D.30087>; else goto <D.30088>;
        <D.30087>:
        log_file.217 = log_file;
        D.30090 = GetCurrentThreadId ();
        D.30091 = (void *) D.30090;
        fprintf (log_file.217, "[%p] Expected value of type %s, got 0x%0x.\n", D.30091, name, type);
        log_file.217 = log_file;
        fflush (log_file.217);
        <D.30088>:
        monoeg_g_free (name);
        D.30092 = 102;
        return D.30092;
      }
      <D.30068>:
      <D.30078>:
      <D.30075>:
      D.30072 = t->type;
      D.30073 = (int) D.30072;
      switch (D.30073) <default: <D.26465>, case 2: <D.26445>, case 3: <D.26447>, case 4: <D.26448>, case 5: <D.26449>, case 6: <D.26450>, case 7: <D.26451>, case 8: <D.26452>, case 9: <D.26453>, case 10: <D.26454>, case 11: <D.26455>, case 12: <D.26456>, case 13: <D.26457>, case 15: <D.26458>, case 17: <D.26464>, case 21: <D.26459>, case 24: <D.26462>, case 25: <D.26463>>
      <D.26445>:
      buf.218 = buf;
      D.30094 = decode_int (buf.218, &buf, limit);
      D.30095 = (unsigned char) D.30094;
      *addr = D.30095;
      goto <D.26446>;
      <D.26447>:
      buf.218 = buf;
      D.30096 = decode_int (buf.218, &buf, limit);
      D.30097 = (short unsigned int) D.30096;
      MEM[(gunichar2 *)addr] = D.30097;
      goto <D.26446>;
      <D.26448>:
      buf.218 = buf;
      D.30098 = decode_int (buf.218, &buf, limit);
      D.30099 = (signed char) D.30098;
      MEM[(gint8 *)addr] = D.30099;
      goto <D.26446>;
      <D.26449>:
      buf.218 = buf;
      D.30100 = decode_int (buf.218, &buf, limit);
      D.30101 = (unsigned char) D.30100;
      *addr = D.30101;
      goto <D.26446>;
      <D.26450>:
      buf.218 = buf;
      D.30102 = decode_int (buf.218, &buf, limit);
      D.30103 = (short int) D.30102;
      MEM[(gint16 *)addr] = D.30103;
      goto <D.26446>;
      <D.26451>:
      buf.218 = buf;
      D.30104 = decode_int (buf.218, &buf, limit);
      D.30105 = (short unsigned int) D.30104;
      MEM[(guint16 *)addr] = D.30105;
      goto <D.26446>;
      <D.26452>:
      buf.218 = buf;
      D.30106 = decode_int (buf.218, &buf, limit);
      MEM[(gint32 *)addr] = D.30106;
      goto <D.26446>;
      <D.26453>:
      buf.218 = buf;
      D.30107 = decode_int (buf.218, &buf, limit);
      D.30108 = (unsigned int) D.30107;
      MEM[(guint32 *)addr] = D.30108;
      goto <D.26446>;
      <D.26454>:
      buf.218 = buf;
      D.30109 = decode_long (buf.218, &buf, limit);
      MEM[(gint64 *)addr] = D.30109;
      goto <D.26446>;
      <D.26455>:
      buf.218 = buf;
      D.30110 = decode_long (buf.218, &buf, limit);
      D.30111 = (long unsigned int) D.30110;
      MEM[(guint64 *)addr] = D.30111;
      goto <D.26446>;
      <D.26456>:
      buf.218 = buf;
      D.30112 = decode_int (buf.218, &buf, limit);
      D.30113 = (unsigned int) D.30112;
      MEM[(guint32 *)addr] = D.30113;
      goto <D.26446>;
      <D.26457>:
      buf.218 = buf;
      D.30114 = decode_long (buf.218, &buf, limit);
      D.30115 = (long unsigned int) D.30114;
      MEM[(guint64 *)addr] = D.30115;
      goto <D.26446>;
      <D.26458>:
      D.30116 = type != 10;
      D.30117 = (long int) D.30116;
      D.30118 = __builtin_expect (D.30117, 0);
      if (D.30118 != 0) goto <D.30119>; else goto <D.30120>;
      <D.30119>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 5775, "type == MONO_TYPE_I8");
      <D.30120>:
      buf.218 = buf;
      D.30121 = decode_long (buf.218, &buf, limit);
      MEM[(gssize *)addr] = D.30121;
      goto <D.26446>;
      <D.26459>:
      D.30122 = mono_type_is_struct (t);
      if (D.30122 != 0) goto handle_vtype; else goto handle_ref;
      <D.26462>:
      <D.26463>:
      D.30123 = type != 17;
      D.30124 = (long int) D.30123;
      D.30125 = __builtin_expect (D.30124, 0);
      if (D.30125 != 0) goto <D.30126>; else goto <D.30127>;
      <D.30126>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 5789, "type == MONO_TYPE_VALUETYPE");
      <D.30127>:
      handle_vtype:
      <D.26464>:
      buf.218 = buf;
      D.30128 = decode_vtype (t, domain, addr, buf.218, &buf, limit);
      err.219 = (int) D.30128;
      err = err.219;
      err.220 = err;
      if (err.220 != 0) goto <D.30131>; else goto <D.30132>;
      <D.30131>:
      err.220 = err;
      D.30092 = (ErrorCode) err.220;
      return D.30092;
      <D.30132>:
      goto <D.26446>;
      handle_ref:
      <D.26465>:
      D.30133 = mono_type_is_reference (t);
      if (D.30133 != 0) goto <D.30134>; else goto <D.30135>;
      <D.30134>:
      if (type == 28) goto <D.30136>; else goto <D.30137>;
      <D.30136>:
      {
        int objid;
        int err;
        struct MonoObject * obj;

        try
          {
            buf.218 = buf;
            objid = decode_objid (buf.218, &buf, limit);
            D.30138 = get_object (objid, &obj);
            err = (int) D.30138;
            if (err != 0) goto <D.30139>; else goto <D.30140>;
            <D.30139>:
            D.30092 = (ErrorCode) err;
            return D.30092;
            <D.30140>:
            obj.221 = obj;
            if (obj.221 != 0B) goto <D.30142>; else goto <D.30143>;
            <D.30142>:
            obj.221 = obj;
            D.30144 = obj_is_of_type (obj.221, t);
            if (D.30144 == 0) goto <D.30145>; else goto <D.30146>;
            <D.30145>:
            log_level.216 = log_level;
            D.30084 = log_level.216 > 0;
            D.30085 = (long int) D.30084;
            D.30086 = __builtin_expect (D.30085, 0);
            if (D.30086 != 0) goto <D.30147>; else goto <D.30148>;
            <D.30147>:
            log_file.217 = log_file;
            D.30149 = mono_type_full_name (t);
            obj.221 = obj;
            D.30150 = obj.221->vtable;
            D.30151 = D.30150->klass;
            D.30152 = D.30151->name;
            fprintf (log_file.217, "Expected type \'%s\', got \'%s\'\n", D.30149, D.30152);
            log_file.217 = log_file;
            fflush (log_file.217);
            <D.30148>:
            D.30092 = 102;
            return D.30092;
            <D.30146>:
            <D.30143>:
            obj.221 = obj;
            if (obj.221 != 0B) goto <D.30153>; else goto <D.30154>;
            <D.30153>:
            obj.221 = obj;
            D.30150 = obj.221->vtable;
            D.30155 = D.30150->domain;
            if (D.30155 != domain) goto <D.30156>; else goto <D.30157>;
            <D.30156>:
            D.30092 = 102;
            return D.30092;
            <D.30157>:
            <D.30154>:
            obj.221 = obj;
            mono_gc_wbarrier_generic_store (addr, obj.221);
          }
        finally
          {
            obj = {CLOBBER};
          }
      }
      goto <D.30158>;
      <D.30137>:
      if (type == 240) goto <D.30159>; else goto <D.30160>;
      <D.30159>:
      MEM[(struct MonoObject * *)addr] = 0B;
      goto <D.30161>;
      <D.30160>:
      if (type == 17) goto <D.30162>; else goto <D.30163>;
      <D.30162>:
      {
        guint8 * buf2;
        gboolean is_enum;
        struct MonoClass * klass;
        struct MonoDomain * d;
        guint8 * vtype_buf;
        int vtype_buf_size;

        try
          {
            buf2 = buf;
            buf.218 = buf;
            is_enum = decode_byte (buf.218, &buf, limit);
            if (is_enum != 0) goto <D.30164>; else goto <D.30165>;
            <D.30164>:
            D.30092 = 100;
            return D.30092;
            <D.30165>:
            buf.218 = buf;
            klass = decode_typeid (buf.218, &buf, limit, &d, &err);
            err.220 = err;
            if (err.220 != 0) goto <D.30166>; else goto <D.30167>;
            <D.30166>:
            err.220 = err;
            D.30092 = (ErrorCode) err.220;
            return D.30092;
            <D.30167>:
            vtype_buf_size = mono_class_value_size (klass, 0B);
            D.30168 = (long unsigned int) vtype_buf_size;
            vtype_buf = monoeg_malloc0 (D.30168);
            D.30169 = vtype_buf == 0B;
            D.30170 = (long int) D.30169;
            D.30171 = __builtin_expect (D.30170, 0);
            if (D.30171 != 0) goto <D.30172>; else goto <D.30173>;
            <D.30172>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 5845, "vtype_buf");
            <D.30173>:
            buf = buf2;
            buf.218 = buf;
            D.30174 = decode_vtype (0B, domain, vtype_buf, buf.218, &buf, limit);
            err.222 = (int) D.30174;
            err = err.222;
            err.220 = err;
            if (err.220 != 0) goto <D.30176>; else goto <D.30177>;
            <D.30176>:
            monoeg_g_free (vtype_buf);
            err.220 = err;
            D.30092 = (ErrorCode) err.220;
            return D.30092;
            <D.30177>:
            d.223 = d;
            D.30179 = mono_value_box (d.223, klass, vtype_buf);
            MEM[(struct MonoObject * *)addr] = D.30179;
            monoeg_g_free (vtype_buf);
          }
        finally
          {
            d = {CLOBBER};
          }
      }
      goto <D.30180>;
      <D.30163>:
      {
        char * name;

        name = mono_type_full_name (t);
        log_level.216 = log_level;
        D.30084 = log_level.216 > 0;
        D.30085 = (long int) D.30084;
        D.30086 = __builtin_expect (D.30085, 0);
        if (D.30086 != 0) goto <D.30181>; else goto <D.30182>;
        <D.30181>:
        log_file.217 = log_file;
        D.30183 = GetCurrentThreadId ();
        D.30184 = (void *) D.30183;
        fprintf (log_file.217, "[%p] Expected value of type %s, got 0x%0x.\n", D.30184, name, type);
        log_file.217 = log_file;
        fflush (log_file.217);
        <D.30182>:
        monoeg_g_free (name);
        D.30092 = 102;
        return D.30092;
      }
      <D.30180>:
      <D.30161>:
      <D.30158>:
      goto <D.30185>;
      <D.30135>:
      monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "debugger-agent.c", 5862);
      <D.30185>:
      goto <D.26446>;
      <D.26446>:
      buf.218 = buf;
      *endbuf = buf.218;
      D.30092 = 0;
      return D.30092;
    }
  finally
    {
      err = {CLOBBER};
    }
}


obj_is_of_type (struct MonoObject * obj, struct MonoType * t)
{
  struct MonoVTable * D.30192;
  struct MonoClass * D.30193;
  int D.30194;
  struct MonoClass * D.30197;
  struct MonoRemoteClass * D.30200;
  struct MonoClass * D.30201;
  int D.30202;
  gboolean D.30205;
  struct MonoClass * klass;

  D.30192 = obj->vtable;
  klass = D.30192->klass;
  D.30193 = mono_class_from_mono_type (t);
  D.30194 = mono_class_is_assignable_from (D.30193, klass);
  if (D.30194 == 0) goto <D.30195>; else goto <D.30196>;
  <D.30195>:
  D.30197 = mono_defaults.transparent_proxy_class;
  if (D.30197 == klass) goto <D.30198>; else goto <D.30199>;
  <D.30198>:
  D.30200 = MEM[(struct MonoTransparentProxy *)obj].remote_class;
  klass = D.30200->proxy_class;
  D.30201 = mono_class_from_mono_type (t);
  D.30202 = mono_class_is_assignable_from (D.30201, klass);
  if (D.30202 != 0) goto <D.30203>; else goto <D.30204>;
  <D.30203>:
  D.30205 = 1;
  return D.30205;
  <D.30204>:
  <D.30199>:
  D.30205 = 0;
  return D.30205;
  <D.30196>:
  D.30205 = 1;
  return D.30205;
}


decode_vtype (struct MonoType * t, struct MonoDomain * domain, guint8 * addr, guint8 * buf, guint8 * * endbuf, guint8 * limit)
{
  guint8 * buf.224;
  ErrorCode D.30210;
  int err.225;
  struct MonoClass * D.30216;
  struct MonoType * D.30219;
  int log_level.226;
  _Bool D.30221;
  long int D.30222;
  long int D.30223;
  struct FILE * log_file.227;
  long unsigned int D.30227;
  void * D.30228;
  struct MonoType * D.30229;
  short unsigned int D.30230;
  int D.30231;
  int D.30232;
  int D.30235;
  const char * D.30238;
  int D.30239;
  int D.30242;
  sizetype D.30243;
  sizetype D.30244;
  guint8 * D.30245;
  <unnamed type> D.30246;
  int err.228;
  _Bool D.30250;
  long int D.30251;
  long int D.30252;
  gboolean is_enum;
  struct MonoClass * klass;
  struct MonoClassField * f;
  int nfields;
  void * iter;
  struct MonoDomain * d;
  int err;

  try
    {
      iter = 0B;
      buf.224 = buf;
      is_enum = decode_byte (buf.224, &buf, limit);
      if (is_enum != 0) goto <D.30208>; else goto <D.30209>;
      <D.30208>:
      D.30210 = 100;
      return D.30210;
      <D.30209>:
      buf.224 = buf;
      klass = decode_typeid (buf.224, &buf, limit, &d, &err);
      err.225 = err;
      if (err.225 != 0) goto <D.30212>; else goto <D.30213>;
      <D.30212>:
      err.225 = err;
      D.30210 = (ErrorCode) err.225;
      return D.30210;
      <D.30213>:
      if (t != 0B) goto <D.30214>; else goto <D.30215>;
      <D.30214>:
      D.30216 = mono_class_from_mono_type (t);
      if (D.30216 != klass) goto <D.30217>; else goto <D.30218>;
      <D.30217>:
      {
        char * name;
        char * name2;

        name = mono_type_full_name (t);
        D.30219 = &klass->byval_arg;
        name2 = mono_type_full_name (D.30219);
        log_level.226 = log_level;
        D.30221 = log_level.226 > 0;
        D.30222 = (long int) D.30221;
        D.30223 = __builtin_expect (D.30222, 0);
        if (D.30223 != 0) goto <D.30224>; else goto <D.30225>;
        <D.30224>:
        log_file.227 = log_file;
        D.30227 = GetCurrentThreadId ();
        D.30228 = (void *) D.30227;
        fprintf (log_file.227, "[%p] Expected value of type %s, got %s.\n", D.30228, name, name2);
        log_file.227 = log_file;
        fflush (log_file.227);
        <D.30225>:
        monoeg_g_free (name);
        monoeg_g_free (name2);
        D.30210 = 102;
        return D.30210;
      }
      <D.30218>:
      <D.30215>:
      buf.224 = buf;
      nfields = decode_int (buf.224, &buf, limit);
      goto <D.26431>;
      <D.26432>:
      D.30229 = f->type;
      D.30230 = D.30229->attrs;
      D.30231 = (int) D.30230;
      D.30232 = D.30231 & 16;
      if (D.30232 != 0) goto <D.30233>; else goto <D.30234>;
      <D.30233>:
      // predicted unlikely by continue predictor.
      goto <D.26431>;
      <D.30234>:
      D.30229 = f->type;
      D.30230 = D.30229->attrs;
      D.30231 = (int) D.30230;
      D.30235 = D.30231 & 1536;
      if (D.30235 != 0) goto <D.30236>; else goto <D.30237>;
      <D.30236>:
      D.30238 = mono_field_get_name (f);
      D.30239 = strcmp (D.30238, "_Deleted");
      if (D.30239 == 0) goto <D.30240>; else goto <D.30241>;
      <D.30240>:
      // predicted unlikely by continue predictor.
      goto <D.26431>;
      <D.30241>:
      <D.30237>:
      D.30229 = f->type;
      D.30242 = f->offset;
      D.30243 = (sizetype) D.30242;
      D.30244 = D.30243 + 18446744073709551600;
      D.30245 = addr + D.30244;
      buf.224 = buf;
      D.30246 = decode_value (D.30229, domain, D.30245, buf.224, &buf, limit);
      err.228 = (int) D.30246;
      err = err.228;
      err.225 = err;
      if (err.225 != 0) goto <D.30248>; else goto <D.30249>;
      <D.30248>:
      err.225 = err;
      D.30210 = (ErrorCode) err.225;
      return D.30210;
      <D.30249>:
      nfields = nfields + -1;
      <D.26431>:
      f = mono_class_get_fields (klass, &iter);
      if (f != 0B) goto <D.26432>; else goto <D.26433>;
      <D.26433>:
      D.30250 = nfields != 0;
      D.30251 = (long int) D.30250;
      D.30252 = __builtin_expect (D.30251, 0);
      if (D.30252 != 0) goto <D.30253>; else goto <D.30254>;
      <D.30253>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 5713, "nfields == 0");
      <D.30254>:
      buf.224 = buf;
      *endbuf = buf.224;
      D.30210 = 0;
      return D.30210;
    }
  finally
    {
      iter = {CLOBBER};
      d = {CLOBBER};
      err = {CLOBBER};
    }
}


assembly_commands (int command, guint8 * p, guint8 * end, struct Buffer * buf)
{
  guint8 * p.229;
  int err.230;
  ErrorCode D.30261;
  struct MonoImage * D.30262;
  const char * D.30263;
  long unsigned int D.30264;
  long unsigned int D.30265;
  struct MonoDomain * domain.231;
  _Bool D.30273;
  long int D.30274;
  long int D.30275;
  int D.30278;
  const char * D.30282;
  struct MonoClass * iftmp.232;
  const char * D.30289;
  short unsigned int D.30290;
  int D.30291;
  short unsigned int D.30292;
  int D.30293;
  short unsigned int D.30294;
  int D.30295;
  short unsigned int D.30296;
  int D.30297;
  const char * iftmp.233;
  const char * D.30301;
  char D.30303;
  const char * iftmp.234;
  unsigned char D.30306;
  const char * iftmp.235;
  unsigned int D.30311;
  unsigned int D.30312;
  int err;
  struct MonoAssembly * ass;
  struct MonoDomain * domain;

  try
    {
      p.229 = p;
      ass = decode_assemblyid (p.229, &p, end, &domain, &err);
      err.230 = err;
      if (err.230 != 0) goto <D.30259>; else goto <D.30260>;
      <D.30259>:
      err.230 = err;
      D.30261 = (ErrorCode) err.230;
      return D.30261;
      <D.30260>:
      switch (command) <default: <D.26912>, case 1: <D.26893>, case 2: <D.26895>, case 3: <D.26898>, case 4: <D.26899>, case 5: <D.26901>, case 6: <D.26909>>
      <D.26893>:
      D.30262 = ass->image;
      D.30263 = mono_image_get_filename (D.30262);
      buffer_add_string (buf, D.30263);
      goto <D.26894>;
      <D.26895>:
      {
        guint32 token;
        struct MonoMethod * m;

        D.30262 = ass->image;
        D.30264 = BIT_FIELD_REF <*D.30262, 64, 192>;
        D.30265 = D.30264 & 268435456;
        if (D.30265 != 0) goto <D.30266>; else goto <D.30267>;
        <D.30266>:
        buffer_add_id (buf, 0);
        goto <D.30268>;
        <D.30267>:
        D.30262 = ass->image;
        token = mono_image_get_entry_point (D.30262);
        if (token == 0) goto <D.30269>; else goto <D.30270>;
        <D.30269>:
        buffer_add_id (buf, 0);
        goto <D.30271>;
        <D.30270>:
        D.30262 = ass->image;
        m = mono_get_method (D.30262, token, 0B);
        domain.231 = domain;
        buffer_add_methodid (buf, domain.231, m);
        <D.30271>:
        <D.30268>:
        goto <D.26894>;
      }
      <D.26898>:
      domain.231 = domain;
      D.30262 = ass->image;
      buffer_add_moduleid (buf, domain.231, D.30262);
      goto <D.26894>;
      <D.26899>:
      {
        struct MonoObject * o;

        domain.231 = domain;
        o = mono_assembly_get_object (domain.231, ass);
        buffer_add_objid (buf, o);
        goto <D.26894>;
      }
      <D.26901>:
      {
        char * s;
        gboolean ignorecase;
        struct MonoTypeNameParse info;
        struct MonoType * t;
        gboolean type_resolve;
        gboolean res;
        struct MonoDomain * d;

        try
          {
            p.229 = p;
            s = decode_string (p.229, &p, end);
            p.229 = p;
            ignorecase = decode_byte (p.229, &p, end);
            d = mono_domain_get ();
            domain.231 = domain;
            res = mono_domain_set (domain.231, 0);
            D.30273 = res == 0;
            D.30274 = (long int) D.30273;
            D.30275 = __builtin_expect (D.30274, 0);
            if (D.30275 != 0) goto <D.30276>; else goto <D.30277>;
            <D.30276>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 7341, "res");
            <D.30277>:
            D.30278 = mono_reflection_parse_type (s, &info);
            if (D.30278 == 0) goto <D.30279>; else goto <D.30280>;
            <D.30279>:
            t = 0B;
            goto <D.30281>;
            <D.30280>:
            D.30282 = info.assembly.name;
            if (D.30282 != 0B) goto <D.30283>; else goto <D.30284>;
            <D.30283>:
            monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "debugger-agent.c", 7347);
            <D.30284>:
            D.30262 = ass->image;
            t = mono_reflection_get_type (D.30262, &info, ignorecase, &type_resolve);
            <D.30281>:
            domain.231 = domain;
            if (t != 0B) goto <D.30286>; else goto <D.30287>;
            <D.30286>:
            iftmp.232 = mono_class_from_mono_type (t);
            goto <D.30288>;
            <D.30287>:
            iftmp.232 = 0B;
            <D.30288>:
            buffer_add_typeid (buf, domain.231, iftmp.232);
            mono_reflection_free_type_info (&info);
            monoeg_g_free (s);
            mono_domain_set (d, 1);
            goto <D.26894>;
          }
        finally
          {
            info = {CLOBBER};
            type_resolve = {CLOBBER};
          }
      }
      <D.26909>:
      {
        gchar * name;
        struct MonoAssembly * mass;

        mass = ass;
        D.30289 = mass->aname.name;
        D.30290 = mass->aname.major;
        D.30291 = (int) D.30290;
        D.30292 = mass->aname.minor;
        D.30293 = (int) D.30292;
        D.30294 = mass->aname.build;
        D.30295 = (int) D.30294;
        D.30296 = mass->aname.revision;
        D.30297 = (int) D.30296;
        D.30301 = mass->aname.culture;
        if (D.30301 != 0B) goto <D.30302>; else goto <D.30299>;
        <D.30302>:
        D.30301 = mass->aname.culture;
        D.30303 = *D.30301;
        if (D.30303 != 0) goto <D.30304>; else goto <D.30299>;
        <D.30304>:
        iftmp.233 = mass->aname.culture;
        goto <D.30300>;
        <D.30299>:
        iftmp.233 = "neutral";
        <D.30300>:
        D.30306 = mass->aname.public_key_token[0];
        if (D.30306 != 0) goto <D.30307>; else goto <D.30308>;
        <D.30307>:
        iftmp.234 = &mass->aname.public_key_token;
        goto <D.30309>;
        <D.30308>:
        iftmp.234 = "null";
        <D.30309>:
        D.30311 = mass->aname.flags;
        D.30312 = D.30311 & 256;
        if (D.30312 != 0) goto <D.30313>; else goto <D.30314>;
        <D.30313>:
        iftmp.235 = ", Retargetable=Yes";
        goto <D.30315>;
        <D.30314>:
        iftmp.235 = "";
        <D.30315>:
        name = monoeg_g_strdup_printf ("%s, Version=%d.%d.%d.%d, Culture=%s, PublicKeyToken=%s%s", D.30289, D.30291, D.30293, D.30295, D.30297, iftmp.233, iftmp.234, iftmp.235);
        buffer_add_string (buf, name);
        monoeg_g_free (name);
        goto <D.26894>;
      }
      <D.26912>:
      D.30261 = 100;
      return D.30261;
      <D.26894>:
      D.30261 = 0;
      return D.30261;
    }
  finally
    {
      err = {CLOBBER};
      domain = {CLOBBER};
    }
}


buffer_add_moduleid (struct Buffer * buf, struct MonoDomain * domain, struct MonoImage * image)
{
  buffer_add_ptr_id (buf, domain, 1, image);
}


module_commands (int command, guint8 * p, guint8 * end, struct Buffer * buf)
{
  guint8 * p.236;
  char * D.30320;
  const char * D.30321;
  const char * D.30322;
  struct MonoDomain * domain.237;
  struct MonoAssembly * D.30324;
  ErrorCode D.30325;
  int err;
  struct MonoDomain * domain;

  try
    {
      switch (command) <default: <D.26925>, case 1: <D.26921>>
      <D.26921>:
      {
        struct MonoImage * image;
        char * basename;

        p.236 = p;
        image = decode_moduleid (p.236, &p, end, &domain, &err);
        D.30320 = image->name;
        basename = monoeg_g_path_get_basename (D.30320);
        buffer_add_string (buf, basename);
        D.30321 = image->module_name;
        buffer_add_string (buf, D.30321);
        D.30320 = image->name;
        buffer_add_string (buf, D.30320);
        D.30322 = mono_image_get_guid (image);
        buffer_add_string (buf, D.30322);
        domain.237 = domain;
        D.30324 = image->assembly;
        buffer_add_assemblyid (buf, domain.237, D.30324);
        monoeg_g_free (basename);
        goto <D.26924>;
      }
      <D.26925>:
      D.30325 = 100;
      return D.30325;
      <D.26924>:
      D.30325 = 0;
      return D.30325;
    }
  finally
    {
      err = {CLOBBER};
      domain = {CLOBBER};
    }
}


decode_moduleid (guint8 * buf, guint8 * * endbuf, guint8 * limit, struct MonoDomain * * domain, int * err)
{
  struct MonoImage * D.30328;

  D.30328 = decode_ptr_id (buf, endbuf, limit, 1, domain, err);
  return D.30328;
}


type_commands (int command, guint8 * p, guint8 * end, struct Buffer * buf)
{
  guint8 * p.238;
  int err.239;
  ErrorCode D.30334;
  struct MonoDomain * domain.240;
  <unnamed type> D.30336;
  int err.241;
  struct MonoClass * klass;
  struct MonoDomain * old_domain;
  struct MonoDomain * domain;
  int err;

  try
    {
      p.238 = p;
      klass = decode_typeid (p.238, &p, end, &domain, &err);
      err.239 = err;
      if (err.239 != 0) goto <D.30332>; else goto <D.30333>;
      <D.30332>:
      err.239 = err;
      D.30334 = (ErrorCode) err.239;
      return D.30334;
      <D.30333>:
      old_domain = mono_domain_get ();
      domain.240 = domain;
      mono_domain_set (domain.240, 1);
      domain.240 = domain;
      p.238 = p;
      D.30336 = type_commands_internal (command, klass, domain.240, p.238, end, buf);
      err.241 = (int) D.30336;
      err = err.241;
      mono_domain_set (old_domain, 1);
      err.239 = err;
      D.30334 = (ErrorCode) err.239;
      return D.30334;
    }
  finally
    {
      domain = {CLOBBER};
      err = {CLOBBER};
    }
}


type_commands_internal (int command, struct MonoClass * klass, struct MonoDomain * domain, guint8 * p, guint8 * end, struct Buffer * buf)
{
  const char * D.30340;
  const char * D.30341;
  struct MonoType * D.30342;
  struct MonoImage * D.30343;
  struct MonoAssembly * D.30344;
  struct MonoClass * D.30345;
  unsigned char D.30349;
  unsigned char D.30351;
  struct MonoClass * D.30352;
  unsigned int D.30353;
  unsigned int D.30354;
  unsigned char D.30357;
  long unsigned int D.30362;
  long unsigned int D.30363;
  unsigned char D.30366;
  long unsigned int D.30371;
  long unsigned int D.30372;
  struct MonoGenericContainer * D.30375;
  struct MonoGenericClass * D.30381;
  unsigned int nnested.242;
  int protocol_version_set.243;
  int major_version.244;
  int minor_version.245;
  struct MonoClass * D.30397;
  <unnamed-unsigned:22> D.30407;
  unsigned int count.246;
  struct MonoType * D.30409;
  struct MonoClass * D.30410;
  <unnamed-signed:31> D.30414;
  struct MonoGenericParamFull * D.30415;
  long unsigned int D.30416;
  long unsigned int D.30417;
  struct MonoGenericParamFull * D.30418;
  unsigned int nmethods.247;
  _Bool D.30421;
  long int D.30422;
  long int D.30423;
  unsigned int nfields.248;
  const char * D.30427;
  struct MonoType * D.30428;
  struct MonoClass * D.30429;
  short unsigned int D.30430;
  unsigned int D.30431;
  _Bool D.30432;
  long int D.30433;
  long int D.30434;
  unsigned int nprops.249;
  const char * D.30438;
  struct MonoMethod * D.30439;
  struct MonoMethod * D.30440;
  unsigned int D.30441;
  _Bool D.30442;
  long int D.30443;
  long int D.30444;
  guint8 * p.250;
  int err.251;
  ErrorCode D.30451;
  <unnamed type> D.30462;
  struct MonoThread * thread_obj.252;
  struct MonoType * D.30468;
  short unsigned int D.30469;
  int D.30470;
  int D.30471;
  struct MonoClass * D.30479;
  struct MonoClass * D.30484;
  int D.30485;
  long unsigned int D.30486;
  struct MonoInternalThread * iftmp.253;
  struct MonoType * D.30493;
  short unsigned int D.30494;
  int D.30495;
  int D.30496;
  int D.30499;
  struct MonoClass * D.30502;
  struct MonoClass * D.30507;
  int D.30508;
  long unsigned int D.30509;
  <unnamed type> D.30510;
  int err.254;
  int D.30514;
  void * D.30517;
  unsigned int D.30519;
  void * * D.30520;
  long unsigned int D.30521;
  long unsigned int D.30522;
  void * * D.30523;
  unsigned int i.255;
  int D.30530;
  unsigned int flags.256;
  unsigned int D.30535;
  int D.30536;
  _Bool D.30537;
  int D.30538;
  unsigned int D.30541;
  void * * D.30542;
  long unsigned int D.30543;
  long unsigned int D.30544;
  void * * D.30545;
  unsigned int i.257;
  int D.30547;
  int D.30550;
  unsigned int D.30553;
  struct MonoClass * iface.258;
  int D.30555;
  unsigned int nmethods.259;
  struct MonoMethod * * D.30561;
  int D.30562;
  long unsigned int D.30563;
  long unsigned int D.30564;
  struct MonoMethod * * D.30565;
  struct MonoMethod * D.30566;
  long unsigned int D.30569;
  long unsigned int D.30570;
  _Bool D.30571;
  unsigned int D.30572;
  struct MonoClass * nested;
  struct MonoType * type;
  void * iter;
  guint8 b;
  int err;
  int nnested;
  char * name;

  try
    {
      switch (command) <default: <D.27132>, case 1: <D.26987>, case 2: <D.27006>, case 3: <D.27014>, case 4: <D.27041>, case 5: <D.27075>, case 6: <D.27077>, case 7: <D.27061>, case 8: <D.27086>, case 9: <D.27022>, case 10: <D.27030>, case 11: <D.27033>, case 12: <D.27037>, case 13: <D.27078>, case 14: <D.27042>, case 15: <D.27088>, case 16: <D.27098>, case 17: <D.27111>, case 18: <D.27130>>
      <D.26987>:
      D.30340 = klass->name_space;
      buffer_add_string (buf, D.30340);
      D.30341 = klass->name;
      buffer_add_string (buf, D.30341);
      D.30342 = &klass->byval_arg;
      name = mono_type_get_name_full (D.30342, 2);
      buffer_add_string (buf, name);
      monoeg_g_free (name);
      D.30343 = klass->image;
      D.30344 = D.30343->assembly;
      buffer_add_assemblyid (buf, domain, D.30344);
      D.30343 = klass->image;
      buffer_add_moduleid (buf, domain, D.30343);
      D.30345 = klass->parent;
      buffer_add_typeid (buf, domain, D.30345);
      D.30349 = klass->rank;
      if (D.30349 != 0) goto <D.30346>; else goto <D.30350>;
      <D.30350>:
      D.30351 = klass->byval_arg.type;
      if (D.30351 == 15) goto <D.30346>; else goto <D.30347>;
      <D.30346>:
      D.30352 = klass->element_class;
      buffer_add_typeid (buf, domain, D.30352);
      goto <D.30348>;
      <D.30347>:
      buffer_add_id (buf, 0);
      <D.30348>:
      D.30353 = klass->type_token;
      buffer_add_int (buf, D.30353);
      D.30349 = klass->rank;
      buffer_add_byte (buf, D.30349);
      D.30354 = klass->flags;
      buffer_add_int (buf, D.30354);
      b = 0;
      type = &klass->byval_arg;
      if (0 != 0) goto <D.30355>; else goto <D.30356>;
      <D.30355>:
      b = b | 1;
      <D.30356>:
      D.30357 = type->type;
      if (D.30357 == 15) goto <D.30358>; else goto <D.30359>;
      <D.30358>:
      b = b | 2;
      <D.30359>:
      D.30362 = BIT_FIELD_REF <*type, 64, 64>;
      D.30363 = D.30362 & 8589934592;
      if (D.30363 == 0) goto <D.30364>; else goto <D.30365>;
      <D.30364>:
      D.30357 = type->type;
      D.30366 = D.30357 + 254;
      if (D.30366 <= 11) goto <D.30360>; else goto <D.30367>;
      <D.30367>:
      D.30357 = type->type;
      if (D.30357 == 24) goto <D.30360>; else goto <D.30368>;
      <D.30368>:
      D.30357 = type->type;
      if (D.30357 == 25) goto <D.30360>; else goto <D.30361>;
      <D.30360>:
      b = b | 4;
      <D.30361>:
      <D.30365>:
      D.30357 = type->type;
      if (D.30357 == 17) goto <D.30369>; else goto <D.30370>;
      <D.30369>:
      b = b | 8;
      <D.30370>:
      D.30371 = BIT_FIELD_REF <*klass, 64, 256>;
      D.30372 = D.30371 & 576460752303423488;
      if (D.30372 != 0) goto <D.30373>; else goto <D.30374>;
      <D.30373>:
      b = b | 16;
      <D.30374>:
      D.30375 = klass->generic_container;
      if (D.30375 != 0B) goto <D.30376>; else goto <D.30377>;
      <D.30376>:
      b = b | 32;
      <D.30377>:
      D.30375 = klass->generic_container;
      if (D.30375 != 0B) goto <D.30378>; else goto <D.30380>;
      <D.30380>:
      D.30381 = klass->generic_class;
      if (D.30381 != 0B) goto <D.30378>; else goto <D.30379>;
      <D.30378>:
      b = b | 64;
      <D.30379>:
      buffer_add_byte (buf, b);
      nnested = 0;
      iter = 0B;
      goto <D.26989>;
      <D.26988>:
      nnested = nnested + 1;
      <D.26989>:
      nested = mono_class_get_nested_types (klass, &iter);
      if (nested != 0B) goto <D.26988>; else goto <D.26990>;
      <D.26990>:
      nnested.242 = (unsigned int) nnested;
      buffer_add_int (buf, nnested.242);
      iter = 0B;
      goto <D.26992>;
      <D.26991>:
      buffer_add_typeid (buf, domain, nested);
      <D.26992>:
      nested = mono_class_get_nested_types (klass, &iter);
      if (nested != 0B) goto <D.26991>; else goto <D.26993>;
      <D.26993>:
      protocol_version_set.243 = protocol_version_set;
      if (protocol_version_set.243 != 0) goto <D.30386>; else goto <D.30387>;
      <D.30386>:
      major_version.244 = major_version;
      if (major_version.244 > 2) goto <D.30383>; else goto <D.30389>;
      <D.30389>:
      major_version.244 = major_version;
      if (major_version.244 == 2) goto <D.30390>; else goto <D.30384>;
      <D.30390>:
      minor_version.245 = minor_version;
      if (minor_version.245 > 11) goto <D.30383>; else goto <D.30384>;
      <D.30383>:
      D.30375 = klass->generic_container;
      if (D.30375 != 0B) goto <D.30392>; else goto <D.30393>;
      <D.30392>:
      buffer_add_typeid (buf, domain, klass);
      goto <D.30394>;
      <D.30393>:
      D.30381 = klass->generic_class;
      if (D.30381 != 0B) goto <D.30395>; else goto <D.30396>;
      <D.30395>:
      D.30381 = klass->generic_class;
      D.30397 = D.30381->container_class;
      buffer_add_typeid (buf, domain, D.30397);
      goto <D.30398>;
      <D.30396>:
      buffer_add_id (buf, 0);
      <D.30398>:
      <D.30394>:
      <D.30384>:
      <D.30387>:
      protocol_version_set.243 = protocol_version_set;
      if (protocol_version_set.243 != 0) goto <D.30401>; else goto <D.30402>;
      <D.30401>:
      major_version.244 = major_version;
      if (major_version.244 > 2) goto <D.30399>; else goto <D.30403>;
      <D.30403>:
      major_version.244 = major_version;
      if (major_version.244 == 2) goto <D.30404>; else goto <D.30400>;
      <D.30404>:
      minor_version.245 = minor_version;
      if (minor_version.245 > 14) goto <D.30399>; else goto <D.30400>;
      <D.30399>:
      {
        int count;
        int i;

        D.30381 = klass->generic_class;
        if (D.30381 != 0B) goto <D.30405>; else goto <D.30406>;
        <D.30405>:
        {
          struct MonoGenericInst * inst;

          D.30381 = klass->generic_class;
          inst = D.30381->context.class_inst;
          D.30407 = inst->type_argc;
          count = (int) D.30407;
          count.246 = (unsigned int) count;
          buffer_add_int (buf, count.246);
          i = 0;
          goto <D.26998>;
          <D.26997>:
          D.30409 = inst->type_argv[i];
          D.30410 = mono_class_from_mono_type (D.30409);
          buffer_add_typeid (buf, domain, D.30410);
          i = i + 1;
          <D.26998>:
          if (i < count) goto <D.26997>; else goto <D.26999>;
          <D.26999>:
        }
        goto <D.30411>;
        <D.30406>:
        D.30375 = klass->generic_container;
        if (D.30375 != 0B) goto <D.30412>; else goto <D.30413>;
        <D.30412>:
        {
          struct MonoGenericContainer * container;
          struct MonoClass * pklass;

          container = klass->generic_container;
          D.30414 = container->type_argc;
          count = (int) D.30414;
          count.246 = (unsigned int) count;
          buffer_add_int (buf, count.246);
          i = 0;
          goto <D.27003>;
          <D.27002>:
          D.30415 = container->type_params;
          D.30416 = (long unsigned int) i;
          D.30417 = D.30416 * 56;
          D.30418 = D.30415 + D.30417;
          D.30343 = klass->image;
          pklass = mono_class_from_generic_parameter (D.30418, D.30343, 0);
          buffer_add_typeid (buf, domain, pklass);
          i = i + 1;
          <D.27003>:
          if (i < count) goto <D.27002>; else goto <D.27004>;
          <D.27004>:
        }
        goto <D.30419>;
        <D.30413>:
        buffer_add_int (buf, 0);
        <D.30419>:
        <D.30411>:
      }
      <D.30400>:
      <D.30402>:
      goto <D.27005>;
      <D.27006>:
      {
        int nmethods;
        int i;
        void * iter;
        struct MonoMethod * m;

        try
          {
            i = 0;
            iter = 0B;
            mono_class_setup_methods (klass);
            nmethods = mono_class_num_methods (klass);
            nmethods.247 = (unsigned int) nmethods;
            buffer_add_int (buf, nmethods.247);
            goto <D.27012>;
            <D.27011>:
            buffer_add_methodid (buf, domain, m);
            i = i + 1;
            <D.27012>:
            m = mono_class_get_methods (klass, &iter);
            if (m != 0B) goto <D.27011>; else goto <D.27013>;
            <D.27013>:
            D.30421 = i != nmethods;
            D.30422 = (long int) D.30421;
            D.30423 = __builtin_expect (D.30422, 0);
            if (D.30423 != 0) goto <D.30424>; else goto <D.30425>;
            <D.30424>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 7618, "i == nmethods");
            <D.30425>:
            goto <D.27005>;
          }
        finally
          {
            iter = {CLOBBER};
          }
      }
      <D.27014>:
      {
        int nfields;
        int i;
        void * iter;
        struct MonoClassField * f;

        try
          {
            i = 0;
            iter = 0B;
            nfields = mono_class_num_fields (klass);
            nfields.248 = (unsigned int) nfields;
            buffer_add_int (buf, nfields.248);
            goto <D.27020>;
            <D.27019>:
            buffer_add_fieldid (buf, domain, f);
            D.30427 = f->name;
            buffer_add_string (buf, D.30427);
            D.30428 = f->type;
            D.30429 = mono_class_from_mono_type (D.30428);
            buffer_add_typeid (buf, domain, D.30429);
            D.30428 = f->type;
            D.30430 = D.30428->attrs;
            D.30431 = (unsigned int) D.30430;
            buffer_add_int (buf, D.30431);
            i = i + 1;
            <D.27020>:
            f = mono_class_get_fields (klass, &iter);
            if (f != 0B) goto <D.27019>; else goto <D.27021>;
            <D.27021>:
            D.30432 = i != nfields;
            D.30433 = (long int) D.30432;
            D.30434 = __builtin_expect (D.30433, 0);
            if (D.30434 != 0) goto <D.30435>; else goto <D.30436>;
            <D.30435>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 7638, "i == nfields");
            <D.30436>:
            goto <D.27005>;
          }
        finally
          {
            iter = {CLOBBER};
          }
      }
      <D.27022>:
      {
        int nprops;
        int i;
        void * iter;
        struct MonoProperty * p;

        try
          {
            i = 0;
            iter = 0B;
            nprops = mono_class_num_properties (klass);
            nprops.249 = (unsigned int) nprops;
            buffer_add_int (buf, nprops.249);
            goto <D.27028>;
            <D.27027>:
            buffer_add_propertyid (buf, domain, p);
            D.30438 = p->name;
            buffer_add_string (buf, D.30438);
            D.30439 = p->get;
            buffer_add_methodid (buf, domain, D.30439);
            D.30440 = p->set;
            buffer_add_methodid (buf, domain, D.30440);
            D.30441 = p->attrs;
            buffer_add_int (buf, D.30441);
            i = i + 1;
            <D.27028>:
            p = mono_class_get_properties (klass, &iter);
            if (p != 0B) goto <D.27027>; else goto <D.27029>;
            <D.27029>:
            D.30442 = i != nprops;
            D.30443 = (long int) D.30442;
            D.30444 = __builtin_expect (D.30443, 0);
            if (D.30444 != 0) goto <D.30445>; else goto <D.30446>;
            <D.30445>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 7659, "i == nprops");
            <D.30446>:
            goto <D.27005>;
          }
        finally
          {
            iter = {CLOBBER};
          }
      }
      <D.27030>:
      {
        struct MonoClass * attr_klass;
        struct MonoCustomAttrInfo * cinfo;

        p.250 = p;
        attr_klass = decode_typeid (p.250, &p, end, 0B, &err);
        err.251 = err;
        if (err.251 != 0) goto <D.30449>; else goto <D.30450>;
        <D.30449>:
        err.251 = err;
        D.30451 = (ErrorCode) err.251;
        return D.30451;
        <D.30450>:
        cinfo = mono_custom_attrs_from_class (klass);
        D.30343 = klass->image;
        buffer_add_cattrs (buf, domain, D.30343, attr_klass, cinfo);
        goto <D.27005>;
      }
      <D.27033>:
      {
        struct MonoClass * attr_klass;
        struct MonoCustomAttrInfo * cinfo;
        struct MonoClassField * field;

        p.250 = p;
        field = decode_fieldid (p.250, &p, end, 0B, &err);
        err.251 = err;
        if (err.251 != 0) goto <D.30452>; else goto <D.30453>;
        <D.30452>:
        err.251 = err;
        D.30451 = (ErrorCode) err.251;
        return D.30451;
        <D.30453>:
        p.250 = p;
        attr_klass = decode_typeid (p.250, &p, end, 0B, &err);
        err.251 = err;
        if (err.251 != 0) goto <D.30454>; else goto <D.30455>;
        <D.30454>:
        err.251 = err;
        D.30451 = (ErrorCode) err.251;
        return D.30451;
        <D.30455>:
        cinfo = mono_custom_attrs_from_field (klass, field);
        D.30343 = klass->image;
        buffer_add_cattrs (buf, domain, D.30343, attr_klass, cinfo);
        goto <D.27005>;
      }
      <D.27037>:
      {
        struct MonoClass * attr_klass;
        struct MonoCustomAttrInfo * cinfo;
        struct MonoProperty * prop;

        p.250 = p;
        prop = decode_propertyid (p.250, &p, end, 0B, &err);
        err.251 = err;
        if (err.251 != 0) goto <D.30456>; else goto <D.30457>;
        <D.30456>:
        err.251 = err;
        D.30451 = (ErrorCode) err.251;
        return D.30451;
        <D.30457>:
        p.250 = p;
        attr_klass = decode_typeid (p.250, &p, end, 0B, &err);
        err.251 = err;
        if (err.251 != 0) goto <D.30458>; else goto <D.30459>;
        <D.30458>:
        err.251 = err;
        D.30451 = (ErrorCode) err.251;
        return D.30451;
        <D.30459>:
        cinfo = mono_custom_attrs_from_property (klass, prop);
        D.30343 = klass->image;
        buffer_add_cattrs (buf, domain, D.30343, attr_klass, cinfo);
        goto <D.27005>;
      }
      <D.27041>:
      <D.27042>:
      {
        guint8 * val;
        struct MonoClassField * f;
        struct MonoVTable * vtable;
        struct MonoClass * k;
        int len;
        int i;
        gboolean found;
        struct MonoThread * thread_obj;
        struct MonoInternalThread * thread;
        guint32 special_static_type;

        try
          {
            thread = 0B;
            if (command == 14) goto <D.30460>; else goto <D.30461>;
            <D.30460>:
            {
              int objid;
              int err;

              p.250 = p;
              objid = decode_objid (p.250, &p, end);
              D.30462 = get_object (objid, &thread_obj);
              err = (int) D.30462;
              if (err != 0) goto <D.30463>; else goto <D.30464>;
              <D.30463>:
              D.30451 = (ErrorCode) err;
              return D.30451;
              <D.30464>:
              thread_obj.252 = thread_obj;
              thread = thread_obj.252->internal_thread;
            }
            <D.30461>:
            p.250 = p;
            len = decode_int (p.250, &p, end);
            i = 0;
            goto <D.27059>;
            <D.27058>:
            p.250 = p;
            f = decode_fieldid (p.250, &p, end, 0B, &err);
            err.251 = err;
            if (err.251 != 0) goto <D.30466>; else goto <D.30467>;
            <D.30466>:
            err.251 = err;
            D.30451 = (ErrorCode) err.251;
            return D.30451;
            <D.30467>:
            D.30468 = f->type;
            D.30469 = D.30468->attrs;
            D.30470 = (int) D.30469;
            D.30471 = D.30470 & 16;
            if (D.30471 == 0) goto <D.30472>; else goto <D.30473>;
            <D.30472>:
            D.30451 = 25;
            return D.30451;
            <D.30473>:
            special_static_type = mono_class_field_get_special_static_type (f);
            if (special_static_type != 0) goto <D.30474>; else goto <D.30475>;
            <D.30474>:
            if (thread == 0B) goto <D.30476>; else goto <D.30478>;
            <D.30478>:
            if (special_static_type != 1) goto <D.30476>; else goto <D.30477>;
            <D.30476>:
            D.30451 = 25;
            return D.30451;
            <D.30477>:
            <D.30475>:
            found = 0;
            k = klass;
            goto <D.27057>;
            <D.27056>:
            D.30479 = f->parent;
            if (D.30479 == k) goto <D.30480>; else goto <D.30481>;
            <D.30480>:
            found = 1;
            goto <D.27055>;
            <D.30481>:
            k = k->parent;
            <D.27057>:
            if (k != 0B) goto <D.27056>; else goto <D.27055>;
            <D.27055>:
            if (found == 0) goto <D.30482>; else goto <D.30483>;
            <D.30482>:
            D.30451 = 25;
            return D.30451;
            <D.30483>:
            D.30479 = f->parent;
            vtable = mono_class_vtable (domain, D.30479);
            D.30468 = f->type;
            D.30484 = mono_class_from_mono_type (D.30468);
            D.30485 = mono_class_instance_size (D.30484);
            D.30486 = (long unsigned int) D.30485;
            val = monoeg_malloc (D.30486);
            if (thread == 0B) goto <D.30488>; else goto <D.30489>;
            <D.30488>:
            iftmp.253 = mono_thread_internal_current ();
            goto <D.30490>;
            <D.30489>:
            iftmp.253 = thread;
            <D.30490>:
            mono_field_static_get_value_for_thread (iftmp.253, vtable, f, val);
            D.30468 = f->type;
            buffer_add_value (buf, D.30468, val, domain);
            monoeg_g_free (val);
            i = i + 1;
            <D.27059>:
            if (i < len) goto <D.27058>; else goto <D.27060>;
            <D.27060>:
            goto <D.27005>;
          }
        finally
          {
            thread_obj = {CLOBBER};
          }
      }
      <D.27061>:
      {
        guint8 * val;
        struct MonoClassField * f;
        struct MonoVTable * vtable;
        struct MonoClass * k;
        int len;
        int i;
        gboolean found;

        p.250 = p;
        len = decode_int (p.250, &p, end);
        i = 0;
        goto <D.27073>;
        <D.27072>:
        p.250 = p;
        f = decode_fieldid (p.250, &p, end, 0B, &err);
        err.251 = err;
        if (err.251 != 0) goto <D.30491>; else goto <D.30492>;
        <D.30491>:
        err.251 = err;
        D.30451 = (ErrorCode) err.251;
        return D.30451;
        <D.30492>:
        D.30493 = f->type;
        D.30494 = D.30493->attrs;
        D.30495 = (int) D.30494;
        D.30496 = D.30495 & 16;
        if (D.30496 == 0) goto <D.30497>; else goto <D.30498>;
        <D.30497>:
        D.30451 = 25;
        return D.30451;
        <D.30498>:
        D.30499 = mono_class_field_is_special_static (f);
        if (D.30499 != 0) goto <D.30500>; else goto <D.30501>;
        <D.30500>:
        D.30451 = 25;
        return D.30451;
        <D.30501>:
        found = 0;
        k = klass;
        goto <D.27071>;
        <D.27070>:
        D.30502 = f->parent;
        if (D.30502 == k) goto <D.30503>; else goto <D.30504>;
        <D.30503>:
        found = 1;
        goto <D.27069>;
        <D.30504>:
        k = k->parent;
        <D.27071>:
        if (k != 0B) goto <D.27070>; else goto <D.27069>;
        <D.27069>:
        if (found == 0) goto <D.30505>; else goto <D.30506>;
        <D.30505>:
        D.30451 = 25;
        return D.30451;
        <D.30506>:
        D.30502 = f->parent;
        vtable = mono_class_vtable (domain, D.30502);
        D.30493 = f->type;
        D.30507 = mono_class_from_mono_type (D.30493);
        D.30508 = mono_class_instance_size (D.30507);
        D.30509 = (long unsigned int) D.30508;
        val = monoeg_malloc (D.30509);
        D.30493 = f->type;
        p.250 = p;
        D.30510 = decode_value (D.30493, domain, val, p.250, &p, end);
        err.254 = (int) D.30510;
        err = err.254;
        err.251 = err;
        if (err.251 != 0) goto <D.30512>; else goto <D.30513>;
        <D.30512>:
        monoeg_g_free (val);
        err.251 = err;
        D.30451 = (ErrorCode) err.251;
        return D.30451;
        <D.30513>:
        D.30493 = f->type;
        D.30514 = mono_type_is_reference (D.30493);
        if (D.30514 != 0) goto <D.30515>; else goto <D.30516>;
        <D.30515>:
        D.30517 = MEM[(void * *)val];
        mono_field_static_set_value (vtable, f, D.30517);
        goto <D.30518>;
        <D.30516>:
        mono_field_static_set_value (vtable, f, val);
        <D.30518>:
        monoeg_g_free (val);
        i = i + 1;
        <D.27073>:
        if (i < len) goto <D.27072>; else goto <D.27074>;
        <D.27074>:
        goto <D.27005>;
      }
      <D.27075>:
      {
        struct MonoObject * o;

        D.30342 = &klass->byval_arg;
        o = mono_type_get_object (domain, D.30342);
        buffer_add_objid (buf, o);
        goto <D.27005>;
      }
      <D.27077>:
      <D.27078>:
      {
        char * source_file;
        char * base;
        struct GPtrArray * files;
        int i;

        files = get_source_files_for_type (klass);
        D.30519 = files->len;
        buffer_add_int (buf, D.30519);
        i = 0;
        goto <D.27084>;
        <D.27083>:
        D.30520 = files->pdata;
        D.30521 = (long unsigned int) i;
        D.30522 = D.30521 * 8;
        D.30523 = D.30520 + D.30522;
        source_file = *D.30523;
        if (command == 13) goto <D.30524>; else goto <D.30525>;
        <D.30524>:
        buffer_add_string (buf, source_file);
        goto <D.30526>;
        <D.30525>:
        base = monoeg_g_path_get_basename (source_file);
        buffer_add_string (buf, base);
        monoeg_g_free (base);
        <D.30526>:
        monoeg_g_free (source_file);
        i = i + 1;
        <D.27084>:
        D.30519 = files->len;
        i.255 = (unsigned int) i;
        if (D.30519 > i.255) goto <D.27083>; else goto <D.27085>;
        <D.27085>:
        monoeg_g_ptr_array_free (files, 1);
        goto <D.27005>;
      }
      <D.27086>:
      {
        struct MonoClass * oklass;

        p.250 = p;
        oklass = decode_typeid (p.250, &p, end, 0B, &err);
        err.251 = err;
        if (err.251 != 0) goto <D.30528>; else goto <D.30529>;
        <D.30528>:
        err.251 = err;
        D.30451 = (ErrorCode) err.251;
        return D.30451;
        <D.30529>:
        D.30530 = mono_class_is_assignable_from (klass, oklass);
        if (D.30530 != 0) goto <D.30531>; else goto <D.30532>;
        <D.30531>:
        buffer_add_byte (buf, 1);
        goto <D.30533>;
        <D.30532>:
        buffer_add_byte (buf, 0);
        <D.30533>:
        goto <D.27005>;
      }
      <D.27088>:
      {
        char * name;
        int i;
        int flags;
        struct MonoException * ex;
        struct GPtrArray * array;

        try
          {
            p.250 = p;
            name = decode_string (p.250, &p, end);
            p.250 = p;
            flags = decode_int (p.250, &p, end);
            ex = 0B;
            flags.256 = (unsigned int) flags;
            D.30535 = flags.256 & 2415919103;
            D.30536 = flags & 1879048192;
            D.30537 = D.30536 != 0;
            D.30538 = (int) D.30537;
            array = mono_class_get_methods_by_name (klass, name, D.30535, D.30538, 1, &ex);
            if (array == 0B) goto <D.30539>; else goto <D.30540>;
            <D.30539>:
            D.30451 = 200;
            return D.30451;
            <D.30540>:
            D.30541 = array->len;
            buffer_add_int (buf, D.30541);
            i = 0;
            goto <D.27096>;
            <D.27095>:
            {
              struct MonoMethod * method;

              D.30542 = array->pdata;
              D.30543 = (long unsigned int) i;
              D.30544 = D.30543 * 8;
              D.30545 = D.30542 + D.30544;
              method = *D.30545;
              buffer_add_methodid (buf, domain, method);
            }
            i = i + 1;
            <D.27096>:
            D.30541 = array->len;
            i.257 = (unsigned int) i;
            if (D.30541 > i.257) goto <D.27095>; else goto <D.27097>;
            <D.27097>:
            monoeg_g_ptr_array_free (array, 1);
            monoeg_g_free (name);
            goto <D.27005>;
          }
        finally
          {
            ex = {CLOBBER};
          }
      }
      <D.27098>:
      {
        struct MonoClass * parent;
        struct GHashTable * iface_hash;
        struct MonoError error;
        struct MonoClass * tclass;
        struct MonoClass * iface;
        struct GHashTableIter iter;

        try
          {
            iface_hash = monoeg_g_hash_table_new (0B, 0B);
            tclass = klass;
            parent = tclass;
            goto <D.27106>;
            <D.27105>:
            mono_class_setup_interfaces (parent, &error);
            D.30547 = mono_error_ok (&error);
            if (D.30547 == 0) goto <D.30548>; else goto <D.30549>;
            <D.30548>:
            D.30451 = 200;
            return D.30451;
            <D.30549>:
            collect_interfaces (parent, iface_hash, &error);
            D.30550 = mono_error_ok (&error);
            if (D.30550 == 0) goto <D.30551>; else goto <D.30552>;
            <D.30551>:
            D.30451 = 200;
            return D.30451;
            <D.30552>:
            parent = parent->parent;
            <D.27106>:
            if (parent != 0B) goto <D.27105>; else goto <D.27107>;
            <D.27107>:
            D.30553 = monoeg_g_hash_table_size (iface_hash);
            buffer_add_int (buf, D.30553);
            monoeg_g_hash_table_iter_init (&iter, iface_hash);
            goto <D.27109>;
            <D.27108>:
            iface.258 = iface;
            buffer_add_typeid (buf, domain, iface.258);
            <D.27109>:
            D.30555 = monoeg_g_hash_table_iter_next (&iter, 0B, &iface);
            if (D.30555 != 0) goto <D.27108>; else goto <D.27110>;
            <D.27110>:
            monoeg_g_hash_table_destroy (iface_hash);
            goto <D.27005>;
          }
        finally
          {
            error = {CLOBBER};
            iface = {CLOBBER};
            iter = {CLOBBER};
          }
      }
      <D.27111>:
      {
        int tindex;
        int ioffset;
        gboolean variance_used;
        struct MonoClass * iclass;
        int len;
        int nmethods;
        int i;
        void * iter;
        struct MonoMethod * method;

        try
          {
            p.250 = p;
            len = decode_int (p.250, &p, end);
            mono_class_setup_vtable (klass);
            tindex = 0;
            goto <D.27128>;
            <D.27127>:
            p.250 = p;
            iclass = decode_typeid (p.250, &p, end, 0B, &err);
            err.251 = err;
            if (err.251 != 0) goto <D.30556>; else goto <D.30557>;
            <D.30556>:
            err.251 = err;
            D.30451 = (ErrorCode) err.251;
            return D.30451;
            <D.30557>:
            ioffset = mono_class_interface_offset_with_variance (klass, iclass, &variance_used);
            if (ioffset == -1) goto <D.30558>; else goto <D.30559>;
            <D.30558>:
            D.30451 = 102;
            return D.30451;
            <D.30559>:
            nmethods = mono_class_num_methods (iclass);
            nmethods.259 = (unsigned int) nmethods;
            buffer_add_int (buf, nmethods.259);
            iter = 0B;
            goto <D.27122>;
            <D.27121>:
            buffer_add_methodid (buf, domain, method);
            <D.27122>:
            method = mono_class_get_methods (iclass, &iter);
            if (method != 0B) goto <D.27121>; else goto <D.27123>;
            <D.27123>:
            i = 0;
            goto <D.27125>;
            <D.27124>:
            D.30561 = klass->vtable;
            D.30562 = i + ioffset;
            D.30563 = (long unsigned int) D.30562;
            D.30564 = D.30563 * 8;
            D.30565 = D.30561 + D.30564;
            D.30566 = *D.30565;
            buffer_add_methodid (buf, domain, D.30566);
            i = i + 1;
            <D.27125>:
            if (i < nmethods) goto <D.27124>; else goto <D.27126>;
            <D.27126>:
            tindex = tindex + 1;
            <D.27128>:
            if (tindex < len) goto <D.27127>; else goto <D.27129>;
            <D.27129>:
            goto <D.27005>;
          }
        finally
          {
            variance_used = {CLOBBER};
            iter = {CLOBBER};
          }
      }
      <D.27130>:
      {
        struct MonoVTable * vtable;

        vtable = mono_class_vtable (domain, klass);
        if (vtable != 0B) goto <D.30567>; else goto <D.30568>;
        <D.30567>:
        D.30569 = BIT_FIELD_REF <*vtable, 64, 320>;
        D.30570 = D.30569 & 412316860416;
        D.30571 = D.30570 != 0;
        D.30572 = (unsigned int) D.30571;
        buffer_add_int (buf, D.30572);
        goto <D.30573>;
        <D.30568>:
        buffer_add_int (buf, 0);
        <D.30573>:
        goto <D.27005>;
      }
      <D.27132>:
      D.30451 = 100;
      return D.30451;
      <D.27005>:
      D.30451 = 0;
      return D.30451;
    }
  finally
    {
      iter = {CLOBBER};
      err = {CLOBBER};
    }
}


buffer_add_fieldid (struct Buffer * buf, struct MonoDomain * domain, struct MonoClassField * field)
{
  buffer_add_ptr_id (buf, domain, 4, field);
}


buffer_add_propertyid (struct Buffer * buf, struct MonoDomain * domain, struct MonoProperty * property)
{
  buffer_add_ptr_id (buf, domain, 6, property);
}


decode_propertyid (guint8 * buf, guint8 * * endbuf, guint8 * limit, struct MonoDomain * * domain, int * err)
{
  struct MonoProperty * D.30587;

  D.30587 = decode_ptr_id (buf, endbuf, limit, 6, domain, err);
  return D.30587;
}


buffer_add_cattrs (struct Buffer * buf, struct MonoDomain * domain, struct MonoImage * image, struct MonoClass * attr_klass, struct MonoCustomAttrInfo * cinfo)
{
  struct MonoMethod * D.30594;
  struct MonoClass * D.30595;
  int D.30596;
  int D.30597;
  unsigned int nattrs.260;
  struct MonoMethod * D.30602;
  struct MonoClass * D.30603;
  int D.30604;
  const mono_byte * D.30605;
  unsigned int D.30606;
  int D.30607;
  _Bool D.30608;
  long int D.30609;
  long int D.30610;
  struct MonoArray * typed_args.261;
  long unsigned int D.30616;
  unsigned int D.30617;
  long unsigned int D.30618;
  char * D.30619;
  struct MonoMethodSignature * D.30620;
  long unsigned int D.30621;
  struct MonoArray * named_args.262;
  long unsigned int D.30626;
  unsigned int D.30627;
  char * D.30628;
  struct CattrNamedArg * arginfo.263;
  long unsigned int D.30630;
  long unsigned int D.30631;
  struct CattrNamedArg * D.30632;
  struct MonoProperty * D.30633;
  struct MonoClassField * D.30637;
  struct MonoType * D.30641;
  long unsigned int D.30642;
  int i;
  int j;
  int nattrs;

  nattrs = 0;
  if (cinfo == 0B) goto <D.30589>; else goto <D.30590>;
  <D.30589>:
  buffer_add_int (buf, 0);
  return;
  <D.30590>:
  i = 0;
  goto <D.26943>;
  <D.26942>:
  if (attr_klass == 0B) goto <D.30591>; else goto <D.30593>;
  <D.30593>:
  D.30594 = cinfo->attrs[i].ctor;
  D.30595 = D.30594->klass;
  D.30596 = mono_class_has_parent (D.30595, attr_klass);
  if (D.30596 != 0) goto <D.30591>; else goto <D.30592>;
  <D.30591>:
  nattrs = nattrs + 1;
  <D.30592>:
  i = i + 1;
  <D.26943>:
  D.30597 = cinfo->num_attrs;
  if (D.30597 > i) goto <D.26942>; else goto <D.26944>;
  <D.26944>:
  nattrs.260 = (unsigned int) nattrs;
  buffer_add_int (buf, nattrs.260);
  i = 0;
  goto <D.26960>;
  <D.26959>:
  {
    struct MonoCustomAttrEntry * attr;

    attr = &cinfo->attrs[i];
    if (attr_klass == 0B) goto <D.30599>; else goto <D.30601>;
    <D.30601>:
    D.30602 = attr->ctor;
    D.30603 = D.30602->klass;
    D.30604 = mono_class_has_parent (D.30603, attr_klass);
    if (D.30604 != 0) goto <D.30599>; else goto <D.30600>;
    <D.30599>:
    {
      struct MonoArray * typed_args;
      struct MonoArray * named_args;
      struct MonoType * t;
      struct CattrNamedArg * arginfo;
      struct MonoError error;

      try
        {
          arginfo = 0B;
          D.30602 = attr->ctor;
          D.30605 = attr->data;
          D.30606 = attr->data_size;
          mono_reflection_create_custom_attr_data_args (image, D.30602, D.30605, D.30606, &typed_args, &named_args, &arginfo, &error);
          D.30607 = mono_error_ok (&error);
          D.30608 = D.30607 == 0;
          D.30609 = (long int) D.30608;
          D.30610 = __builtin_expect (D.30609, 0);
          if (D.30610 != 0) goto <D.30611>; else goto <D.30612>;
          <D.30611>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 7448, "mono_error_ok (&error)");
          <D.30612>:
          D.30602 = attr->ctor;
          buffer_add_methodid (buf, domain, D.30602);
          typed_args.261 = typed_args;
          if (typed_args.261 != 0B) goto <D.30614>; else goto <D.30615>;
          <D.30614>:
          typed_args.261 = typed_args;
          D.30616 = mono_array_length (typed_args.261);
          D.30617 = (unsigned int) D.30616;
          buffer_add_int (buf, D.30617);
          j = 0;
          goto <D.26953>;
          <D.26952>:
          {
            struct MonoObject * val;

            typed_args.261 = typed_args;
            D.30618 = (long unsigned int) j;
            D.30619 = mono_array_addr_with_size (typed_args.261, 8, D.30618);
            val = MEM[(struct MonoObject * *)D.30619];
            D.30602 = attr->ctor;
            D.30620 = mono_method_signature (D.30602);
            t = D.30620->params[j];
            buffer_add_cattr_arg (buf, t, domain, val);
          }
          j = j + 1;
          <D.26953>:
          D.30618 = (long unsigned int) j;
          typed_args.261 = typed_args;
          D.30621 = mono_array_length (typed_args.261);
          if (D.30618 < D.30621) goto <D.26952>; else goto <D.26954>;
          <D.26954>:
          goto <D.30622>;
          <D.30615>:
          buffer_add_int (buf, 0);
          <D.30622>:
          named_args.262 = named_args;
          if (named_args.262 != 0B) goto <D.30624>; else goto <D.30625>;
          <D.30624>:
          named_args.262 = named_args;
          D.30626 = mono_array_length (named_args.262);
          D.30627 = (unsigned int) D.30626;
          buffer_add_int (buf, D.30627);
          j = 0;
          goto <D.26957>;
          <D.26956>:
          {
            struct MonoObject * val;

            named_args.262 = named_args;
            D.30618 = (long unsigned int) j;
            D.30628 = mono_array_addr_with_size (named_args.262, 8, D.30618);
            val = MEM[(struct MonoObject * *)D.30628];
            arginfo.263 = arginfo;
            D.30630 = (long unsigned int) j;
            D.30631 = D.30630 * 24;
            D.30632 = arginfo.263 + D.30631;
            D.30633 = D.30632->prop;
            if (D.30633 != 0B) goto <D.30634>; else goto <D.30635>;
            <D.30634>:
            buffer_add_byte (buf, 84);
            arginfo.263 = arginfo;
            D.30630 = (long unsigned int) j;
            D.30631 = D.30630 * 24;
            D.30632 = arginfo.263 + D.30631;
            D.30633 = D.30632->prop;
            buffer_add_propertyid (buf, domain, D.30633);
            goto <D.30636>;
            <D.30635>:
            arginfo.263 = arginfo;
            D.30630 = (long unsigned int) j;
            D.30631 = D.30630 * 24;
            D.30632 = arginfo.263 + D.30631;
            D.30637 = D.30632->field;
            if (D.30637 != 0B) goto <D.30638>; else goto <D.30639>;
            <D.30638>:
            buffer_add_byte (buf, 83);
            arginfo.263 = arginfo;
            D.30630 = (long unsigned int) j;
            D.30631 = D.30630 * 24;
            D.30632 = arginfo.263 + D.30631;
            D.30637 = D.30632->field;
            buffer_add_fieldid (buf, domain, D.30637);
            goto <D.30640>;
            <D.30639>:
            monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "debugger-agent.c", 7480);
            <D.30640>:
            <D.30636>:
            arginfo.263 = arginfo;
            D.30630 = (long unsigned int) j;
            D.30631 = D.30630 * 24;
            D.30632 = arginfo.263 + D.30631;
            D.30641 = D.30632->type;
            buffer_add_cattr_arg (buf, D.30641, domain, val);
          }
          j = j + 1;
          <D.26957>:
          D.30618 = (long unsigned int) j;
          named_args.262 = named_args;
          D.30642 = mono_array_length (named_args.262);
          if (D.30618 < D.30642) goto <D.26956>; else goto <D.26958>;
          <D.26958>:
          goto <D.30643>;
          <D.30625>:
          buffer_add_int (buf, 0);
          <D.30643>:
          arginfo.263 = arginfo;
          monoeg_g_free (arginfo.263);
        }
      finally
        {
          typed_args = {CLOBBER};
          named_args = {CLOBBER};
          arginfo = {CLOBBER};
          error = {CLOBBER};
        }
    }
    <D.30600>:
  }
  i = i + 1;
  <D.26960>:
  D.30597 = cinfo->num_attrs;
  if (D.30597 > i) goto <D.26959>; else goto <D.26961>;
  <D.26961>:
}


mono_class_has_parent (struct MonoClass * klass, struct MonoClass * parent)
{
  struct MonoClass * * D.30645;
  _Bool D.30646;
  long int D.30647;
  long int D.30648;
  struct MonoClass * * D.30651;
  _Bool D.30652;
  long int D.30653;
  long int D.30654;
  gboolean D.30657;

  D.30645 = klass->supertypes;
  D.30646 = D.30645 == 0B;
  D.30647 = (long int) D.30646;
  D.30648 = __builtin_expect (D.30647, 0);
  if (D.30648 != 0) goto <D.30649>; else goto <D.30650>;
  <D.30649>:
  mono_class_setup_supertypes (klass);
  <D.30650>:
  D.30651 = parent->supertypes;
  D.30652 = D.30651 == 0B;
  D.30653 = (long int) D.30652;
  D.30654 = __builtin_expect (D.30653, 0);
  if (D.30654 != 0) goto <D.30655>; else goto <D.30656>;
  <D.30655>:
  mono_class_setup_supertypes (parent);
  <D.30656>:
  D.30657 = mono_class_has_parent_fast (klass, parent);
  return D.30657;
}


mono_class_has_parent_fast (struct MonoClass * klass, struct MonoClass * parent)
{
  gboolean D.30659;
  int iftmp.264;
  short unsigned int D.30663;
  short unsigned int D.30664;
  struct MonoClass * * D.30666;
  long unsigned int D.30667;
  long unsigned int D.30668;
  sizetype D.30669;
  struct MonoClass * * D.30670;
  struct MonoClass * D.30671;

  D.30663 = klass->idepth;
  D.30664 = parent->idepth;
  if (D.30663 >= D.30664) goto <D.30665>; else goto <D.30661>;
  <D.30665>:
  D.30666 = klass->supertypes;
  D.30664 = parent->idepth;
  D.30667 = (long unsigned int) D.30664;
  D.30668 = D.30667 * 8;
  D.30669 = D.30668 + 18446744073709551608;
  D.30670 = D.30666 + D.30669;
  D.30671 = *D.30670;
  if (D.30671 == parent) goto <D.30672>; else goto <D.30661>;
  <D.30672>:
  iftmp.264 = 1;
  goto <D.30662>;
  <D.30661>:
  iftmp.264 = 0;
  <D.30662>:
  D.30659 = iftmp.264;
  return D.30659;
}


buffer_add_cattr_arg (struct Buffer * buf, struct MonoType * t, struct MonoDomain * domain, struct MonoObject * val)
{
  struct MonoObject * val.265;
  struct MonoVTable * D.30678;
  struct MonoClass * D.30679;
  struct MonoClass * D.30680;
  struct MonoType * D.30682;
  struct MonoClass * D.30683;
  int D.30684;
  void * D.30688;

  val.265 = val;
  if (val.265 != 0B) goto <D.30677>; else goto <D.30674>;
  <D.30677>:
  val.265 = val;
  D.30678 = val.265->vtable;
  D.30679 = D.30678->klass;
  D.30680 = mono_defaults.monotype_class;
  if (D.30679 == D.30680) goto <D.30681>; else goto <D.30674>;
  <D.30681>:
  buffer_add_byte (buf, 241);
  val.265 = val;
  D.30682 = MEM[(struct MonoReflectionType *)val.265].type;
  D.30683 = mono_class_from_mono_type (D.30682);
  buffer_add_typeid (buf, domain, D.30683);
  goto <D.30675>;
  <D.30674>:
  D.30684 = mono_type_is_reference (t);
  if (D.30684 != 0) goto <D.30685>; else goto <D.30686>;
  <D.30685>:
  buffer_add_value (buf, t, &val, domain);
  goto <D.30687>;
  <D.30686>:
  val.265 = val;
  D.30688 = mono_object_unbox (val.265);
  buffer_add_value (buf, t, D.30688, domain);
  <D.30687>:
  <D.30675>:
}


buffer_add_value (struct Buffer * buf, struct MonoType * t, void * addr, struct MonoDomain * domain)
{
  buffer_add_value_full (buf, t, addr, domain, 0);
}


buffer_add_value_full (struct Buffer * buf, struct MonoType * t, void * addr, struct MonoDomain * domain, gboolean as_vtype)
{
  long unsigned int D.30689;
  long unsigned int D.30690;
  void * D.30693;
  _Bool D.30696;
  long int D.30697;
  long int D.30698;
  unsigned char D.30703;
  int D.30704;
  signed char D.30705;
  unsigned int D.30706;
  short int D.30707;
  unsigned int D.30708;
  int D.30709;
  unsigned int D.30710;
  long int D.30711;
  long unsigned int D.30712;
  long unsigned int val.266;
  struct MonoVTable * D.30717;
  struct MonoClass * D.30718;
  long unsigned int D.30719;
  long unsigned int D.30720;
  unsigned char D.30723;
  unsigned char D.30726;
  <unnamed-unsigned:1> D.30731;
  unsigned char D.30732;
  struct MonoType * D.30733;
  short unsigned int D.30734;
  int D.30735;
  int D.30736;
  int D.30739;
  const char * D.30742;
  int D.30743;
  unsigned int nfields.267;
  const char * D.30751;
  int D.30752;
  int D.30755;
  sizetype D.30756;
  sizetype D.30757;
  void * D.30758;
  int D.30759;
  struct MonoObject * obj;
  void handle_vtype = <<< error >>>;
  void handle_ref = <<< error >>>;

  D.30689 = BIT_FIELD_REF <*t, 64, 64>;
  D.30690 = D.30689 & 8589934592;
  if (D.30690 != 0) goto <D.30691>; else goto <D.30692>;
  <D.30691>:
  D.30693 = MEM[(void * *)addr];
  if (D.30693 == 0B) goto <D.30694>; else goto <D.30695>;
  <D.30694>:
  buffer_add_byte (buf, 240);
  return;
  <D.30695>:
  D.30693 = MEM[(void * *)addr];
  D.30696 = D.30693 == 0B;
  D.30697 = (long int) D.30696;
  D.30698 = __builtin_expect (D.30697, 0);
  if (D.30698 != 0) goto <D.30699>; else goto <D.30700>;
  <D.30699>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 5513, "*(void**)addr");
  <D.30700>:
  addr = MEM[(void * *)addr];
  <D.30692>:
  if (as_vtype != 0) goto <D.30701>; else goto <D.30702>;
  <D.30701>:
  D.30703 = t->type;
  D.30704 = (int) D.30703;
  switch (D.30704) <default: <D.26357>, case 2: <D.26341>, case 3: <D.26344>, case 4: <D.26342>, case 5: <D.26343>, case 6: <D.26345>, case 7: <D.26346>, case 8: <D.26347>, case 9: <D.26348>, case 10: <D.26350>, case 11: <D.26351>, case 12: <D.26349>, case 13: <D.26352>, case 15: <D.26355>, case 24: <D.26353>, case 25: <D.26354>>
  <D.26341>:
  <D.26342>:
  <D.26343>:
  <D.26344>:
  <D.26345>:
  <D.26346>:
  <D.26347>:
  <D.26348>:
  <D.26349>:
  <D.26350>:
  <D.26351>:
  <D.26352>:
  <D.26353>:
  <D.26354>:
  <D.26355>:
  goto handle_vtype;
  <D.26357>:
  goto <D.26358>;
  <D.26358>:
  <D.30702>:
  D.30703 = t->type;
  D.30704 = (int) D.30703;
  switch (D.30704) <default: <D.26395>, case 1: <D.26359>, case 2: <D.26361>, case 3: <D.26364>, case 4: <D.26362>, case 5: <D.26363>, case 6: <D.26365>, case 7: <D.26366>, case 8: <D.26367>, case 9: <D.26368>, case 10: <D.26370>, case 11: <D.26371>, case 12: <D.26369>, case 13: <D.26372>, case 14: <D.26378>, case 15: <D.26375>, case 17: <D.26383>, case 18: <D.26381>, case 20: <D.26382>, case 21: <D.26394>, case 24: <D.26373>, case 25: <D.26374>, case 28: <D.26380>, case 29: <D.26379>>
  <D.26359>:
  D.30703 = t->type;
  buffer_add_byte (buf, D.30703);
  goto <D.26360>;
  <D.26361>:
  <D.26362>:
  <D.26363>:
  D.30703 = t->type;
  buffer_add_byte (buf, D.30703);
  D.30705 = MEM[(gint8 *)addr];
  D.30706 = (unsigned int) D.30705;
  buffer_add_int (buf, D.30706);
  goto <D.26360>;
  <D.26364>:
  <D.26365>:
  <D.26366>:
  D.30703 = t->type;
  buffer_add_byte (buf, D.30703);
  D.30707 = MEM[(gint16 *)addr];
  D.30708 = (unsigned int) D.30707;
  buffer_add_int (buf, D.30708);
  goto <D.26360>;
  <D.26367>:
  <D.26368>:
  <D.26369>:
  D.30703 = t->type;
  buffer_add_byte (buf, D.30703);
  D.30709 = MEM[(gint32 *)addr];
  D.30710 = (unsigned int) D.30709;
  buffer_add_int (buf, D.30710);
  goto <D.26360>;
  <D.26370>:
  <D.26371>:
  <D.26372>:
  D.30703 = t->type;
  buffer_add_byte (buf, D.30703);
  D.30711 = MEM[(gint64 *)addr];
  D.30712 = (long unsigned int) D.30711;
  buffer_add_long (buf, D.30712);
  goto <D.26360>;
  <D.26373>:
  <D.26374>:
  goto handle_vtype;
  <D.26375>:
  {
    gssize val;

    val = MEM[(gssize *)addr];
    D.30703 = t->type;
    buffer_add_byte (buf, D.30703);
    val.266 = (long unsigned int) val;
    buffer_add_long (buf, val.266);
    goto <D.26360>;
  }
  handle_ref:
  <D.26378>:
  <D.26379>:
  <D.26380>:
  <D.26381>:
  <D.26382>:
  obj = MEM[(struct MonoObject * *)addr];
  if (obj == 0B) goto <D.30714>; else goto <D.30715>;
  <D.30714>:
  buffer_add_byte (buf, 240);
  goto <D.30716>;
  <D.30715>:
  D.30717 = obj->vtable;
  D.30718 = D.30717->klass;
  D.30719 = BIT_FIELD_REF <*D.30718, 64, 256>;
  D.30720 = D.30719 & 1152921504606846976;
  if (D.30720 != 0) goto <D.30721>; else goto <D.30722>;
  <D.30721>:
  D.30717 = obj->vtable;
  D.30718 = D.30717->klass;
  t = &D.30718->byval_arg;
  addr = mono_object_unbox (obj);
  goto handle_vtype;
  <D.30722>:
  D.30717 = obj->vtable;
  D.30718 = D.30717->klass;
  D.30723 = D.30718->rank;
  if (D.30723 != 0) goto <D.30724>; else goto <D.30725>;
  <D.30724>:
  D.30717 = obj->vtable;
  D.30718 = D.30717->klass;
  D.30726 = D.30718->byval_arg.type;
  buffer_add_byte (buf, D.30726);
  goto <D.30727>;
  <D.30725>:
  D.30717 = obj->vtable;
  D.30718 = D.30717->klass;
  D.30726 = D.30718->byval_arg.type;
  if (D.30726 == 21) goto <D.30728>; else goto <D.30729>;
  <D.30728>:
  buffer_add_byte (buf, 18);
  goto <D.30730>;
  <D.30729>:
  D.30717 = obj->vtable;
  D.30718 = D.30717->klass;
  D.30726 = D.30718->byval_arg.type;
  buffer_add_byte (buf, D.30726);
  <D.30730>:
  <D.30727>:
  buffer_add_objid (buf, obj);
  <D.30716>:
  goto <D.26360>;
  handle_vtype:
  <D.26383>:
  {
    int nfields;
    void * iter;
    struct MonoClassField * f;
    struct MonoClass * klass;

    try
      {
        klass = mono_class_from_mono_type (t);
        buffer_add_byte (buf, 17);
        D.30731 = klass->enumtype;
        D.30732 = (unsigned char) D.30731;
        buffer_add_byte (buf, D.30732);
        buffer_add_typeid (buf, domain, klass);
        nfields = 0;
        iter = 0B;
        goto <D.26388>;
        <D.26389>:
        D.30733 = f->type;
        D.30734 = D.30733->attrs;
        D.30735 = (int) D.30734;
        D.30736 = D.30735 & 16;
        if (D.30736 != 0) goto <D.30737>; else goto <D.30738>;
        <D.30737>:
        // predicted unlikely by continue predictor.
        goto <D.26388>;
        <D.30738>:
        D.30733 = f->type;
        D.30734 = D.30733->attrs;
        D.30735 = (int) D.30734;
        D.30739 = D.30735 & 1536;
        if (D.30739 != 0) goto <D.30740>; else goto <D.30741>;
        <D.30740>:
        D.30742 = mono_field_get_name (f);
        D.30743 = strcmp (D.30742, "_Deleted");
        if (D.30743 == 0) goto <D.30744>; else goto <D.30745>;
        <D.30744>:
        // predicted unlikely by continue predictor.
        goto <D.26388>;
        <D.30745>:
        <D.30741>:
        nfields = nfields + 1;
        <D.26388>:
        f = mono_class_get_fields (klass, &iter);
        if (f != 0B) goto <D.26389>; else goto <D.26390>;
        <D.26390>:
        nfields.267 = (unsigned int) nfields;
        buffer_add_int (buf, nfields.267);
        iter = 0B;
        goto <D.26391>;
        <D.26392>:
        D.30733 = f->type;
        D.30734 = D.30733->attrs;
        D.30735 = (int) D.30734;
        D.30736 = D.30735 & 16;
        if (D.30736 != 0) goto <D.30747>; else goto <D.30748>;
        <D.30747>:
        // predicted unlikely by continue predictor.
        goto <D.26391>;
        <D.30748>:
        D.30733 = f->type;
        D.30734 = D.30733->attrs;
        D.30735 = (int) D.30734;
        D.30739 = D.30735 & 1536;
        if (D.30739 != 0) goto <D.30749>; else goto <D.30750>;
        <D.30749>:
        D.30751 = mono_field_get_name (f);
        D.30752 = strcmp (D.30751, "_Deleted");
        if (D.30752 == 0) goto <D.30753>; else goto <D.30754>;
        <D.30753>:
        // predicted unlikely by continue predictor.
        goto <D.26391>;
        <D.30754>:
        <D.30750>:
        D.30733 = f->type;
        D.30755 = f->offset;
        D.30756 = (sizetype) D.30755;
        D.30757 = D.30756 + 18446744073709551600;
        D.30758 = addr + D.30757;
        buffer_add_value_full (buf, D.30733, D.30758, domain, 0);
        <D.26391>:
        f = mono_class_get_fields (klass, &iter);
        if (f != 0B) goto <D.26392>; else goto <D.26393>;
        <D.26393>:
        goto <D.26360>;
      }
    finally
      {
        iter = {CLOBBER};
      }
  }
  <D.26394>:
  D.30759 = mono_type_generic_inst_is_valuetype (t);
  if (D.30759 != 0) goto handle_vtype; else goto handle_ref;
  <D.26395>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "debugger-agent.c", 5645);
  <D.26360>:
}


decode_fieldid (guint8 * buf, guint8 * * endbuf, guint8 * limit, struct MonoDomain * * domain, int * err)
{
  struct MonoClassField * D.30763;

  D.30763 = decode_ptr_id (buf, endbuf, limit, 4, domain, err);
  return D.30763;
}


collect_interfaces (struct MonoClass * klass, struct GHashTable * ifaces, struct MonoError * error)
{
  int D.30765;
  struct MonoClass * * D.30768;
  long unsigned int D.30769;
  long unsigned int D.30770;
  struct MonoClass * * D.30771;
  int D.30772;
  short unsigned int D.30775;
  int D.30776;
  int i;
  struct MonoClass * ic;

  mono_class_setup_interfaces (klass, error);
  D.30765 = mono_error_ok (error);
  if (D.30765 == 0) goto <D.30766>; else goto <D.30767>;
  <D.30766>:
  return;
  <D.30767>:
  i = 0;
  goto <D.26970>;
  <D.26969>:
  D.30768 = klass->interfaces;
  D.30769 = (long unsigned int) i;
  D.30770 = D.30769 * 8;
  D.30771 = D.30768 + D.30770;
  ic = *D.30771;
  monoeg_g_hash_table_insert_replace (ifaces, ic, ic, 0);
  collect_interfaces (ic, ifaces, error);
  D.30772 = mono_error_ok (error);
  if (D.30772 == 0) goto <D.30773>; else goto <D.30774>;
  <D.30773>:
  return;
  <D.30774>:
  i = i + 1;
  <D.26970>:
  D.30775 = klass->interface_count;
  D.30776 = (int) D.30775;
  if (D.30776 > i) goto <D.26969>; else goto <D.26971>;
  <D.26971>:
}


method_commands (int command, guint8 * p, guint8 * end, struct Buffer * buf)
{
  guint8 * p.268;
  int err.269;
  ErrorCode D.30782;
  struct MonoDomain * domain.270;
  <unnamed type> D.30784;
  int err.271;
  int err;
  struct MonoDomain * old_domain;
  struct MonoDomain * domain;
  struct MonoMethod * method;

  try
    {
      p.268 = p;
      method = decode_methodid (p.268, &p, end, &domain, &err);
      err.269 = err;
      if (err.269 != 0) goto <D.30780>; else goto <D.30781>;
      <D.30780>:
      err.269 = err;
      D.30782 = (ErrorCode) err.269;
      return D.30782;
      <D.30781>:
      old_domain = mono_domain_get ();
      domain.270 = domain;
      mono_domain_set (domain.270, 1);
      domain.270 = domain;
      p.268 = p;
      D.30784 = method_commands_internal (command, method, domain.270, p.268, end, buf);
      err.271 = (int) D.30784;
      err = err.271;
      mono_domain_set (old_domain, 1);
      err.269 = err;
      D.30782 = (ErrorCode) err.269;
      return D.30782;
    }
  finally
    {
      err = {CLOBBER};
      domain = {CLOBBER};
    }
}


method_commands_internal (int command, struct MonoMethod * method, struct MonoDomain * domain, guint8 * p, guint8 * end, struct Buffer * buf)
{
  const char * D.30788;
  struct MonoClass * D.30789;
  unsigned int D.30794;
  int protocol_version_set.272;
  int major_version.273;
  int minor_version.274;
  struct GPtrArray * source_file_list.275;
  unsigned int D.30805;
  void * * D.30806;
  long unsigned int D.30807;
  long unsigned int D.30808;
  void * * D.30809;
  char * D.30810;
  guint8 * D.30816;
  sizetype D.30817;
  guint8 * D.30818;
  unsigned char D.30819;
  unsigned int i.276;
  char * source_file.277;
  int n_il_offsets.278;
  unsigned int n_il_offsets.279;
  int log_level.280;
  _Bool D.30825;
  long int D.30826;
  long int D.30827;
  struct FILE * log_file.281;
  char * D.30831;
  int * source_files.282;
  long unsigned int D.30833;
  int * D.30834;
  int D.30835;
  long unsigned int D.30838;
  long unsigned int D.30839;
  void * * D.30840;
  int * il_offsets.283;
  int * D.30844;
  int D.30845;
  int * line_numbers.284;
  int * D.30847;
  int D.30848;
  int iftmp.285;
  int * column_numbers.286;
  int * D.30853;
  unsigned int D.30855;
  unsigned int D.30856;
  unsigned int D.30863;
  guint32 iftmp.287;
  int D.30873;
  <unnamed-unsigned:6> D.30875;
  unsigned int D.30876;
  short unsigned int D.30877;
  unsigned int D.30878;
  short unsigned int D.30879;
  unsigned int D.30880;
  struct MonoType * D.30881;
  struct MonoClass * D.30882;
  struct MonoType * D.30883;
  struct MonoClass * D.30884;
  long unsigned int D.30885;
  long unsigned int D.30886;
  long unsigned int D.30887;
  long unsigned int D.30888;
  char * * D.30889;
  char * D.30890;
  ErrorCode D.30893;
  short unsigned int D.30894;
  unsigned int D.30895;
  struct MonoType * D.30896;
  struct MonoClass * D.30897;
  int D.30898;
  struct MonoDebugLocalVar * D.30902;
  long unsigned int D.30903;
  long unsigned int D.30904;
  struct MonoDebugLocalVar * D.30905;
  int D.30906;
  char * D.30910;
  struct MonoDebugCodeBlock * D.30916;
  int D.30918;
  unsigned int D.30919;
  int D.30920;
  unsigned int D.30921;
  short unsigned int D.30924;
  unsigned int D.30925;
  short unsigned int D.30926;
  unsigned int D.30927;
  unsigned int D.30928;
  long unsigned int D.30935;
  long unsigned int D.30936;
  struct MonoMethodSignature * D.30939;
  short unsigned int D.30940;
  long unsigned int D.30943;
  struct MonoGenericInst * D.30949;
  struct MonoGenericContext * D.30952;
  struct MonoGenericContext * D.30955;
  struct MonoMethodSignature * D.30963;
  short unsigned int D.30964;
  long unsigned int D.30967;
  struct MonoGenericContext * D.30970;
  <unnamed-unsigned:22> D.30973;
  unsigned int count.288;
  struct MonoType * D.30975;
  struct MonoClass * D.30976;
  struct MonoMethodSignature * D.30981;
  short unsigned int D.30982;
  struct MonoGenericParamFull * D.30983;
  long unsigned int D.30984;
  long unsigned int D.30985;
  struct MonoImage * D.30986;
  const unsigned char * D.30998;
  sizetype D.30999;
  const unsigned char * D.31000;
  unsigned char D.31001;
  unsigned int i.289;
  <unnamed-unsigned:15> D.31008;
  unsigned int D.31009;
  struct MonoExceptionClause * D.31010;
  long unsigned int D.31011;
  long unsigned int D.31012;
  unsigned int D.31013;
  unsigned int D.31014;
  unsigned int D.31015;
  unsigned int D.31016;
  unsigned int D.31017;
  struct MonoClass * D.31020;
  unsigned int D.31024;
  int D.31025;
  guint8 * p.290;
  int D.31027;
  unsigned int D.31028;
  unsigned int D.31029;
  _Bool D.31030;
  long int D.31031;
  long int D.31032;
  long unsigned int D.31035;
  unsigned int D.31038;
  void * handle_class.291;
  struct MonoClass * handle_class.292;
  _Bool D.31044;
  long int D.31045;
  long int D.31046;
  struct MonoClass * D.31049;
  struct MonoClass * D.31055;
  struct MonoClass * D.31057;
  struct MonoClass * D.31061;
  struct MonoClass * D.31065;
  int err.293;
  long unsigned int D.31072;
  long unsigned int D.31073;
  struct MonoDomain * d.294;
  long unsigned int D.31079;
  long unsigned int D.31080;
  struct MonoType * * D.31081;
  struct MonoType * D.31082;
  struct MonoGenericInst * iftmp.295;
  struct MonoGenericClass * D.31084;
  int D.31088;
  struct MonoMethodHeader * header;
  int err;

  try
    {
      switch (command) <default: <D.27260>, case 1: <D.27153>, case 2: <D.27155>, case 3: <D.27156>, case 4: <D.27179>, case 5: <D.27189>, case 6: <D.27209>, case 7: <D.27226>, case 8: <D.27235>, case 9: <D.27245>, case 10: <D.27248>>
      <D.27153>:
      D.30788 = method->name;
      buffer_add_string (buf, D.30788);
      goto <D.27154>;
      <D.27155>:
      D.30789 = method->klass;
      buffer_add_typeid (buf, domain, D.30789);
      goto <D.27154>;
      <D.27156>:
      {
        struct MonoDebugMethodInfo * minfo;
        char * source_file;
        int i;
        int j;
        int n_il_offsets;
        int * il_offsets;
        int * line_numbers;
        int * column_numbers;
        int * source_files;
        struct GPtrArray * source_file_list;

        try
          {
            header = mono_method_get_header (method);
            if (header == 0B) goto <D.30790>; else goto <D.30791>;
            <D.30790>:
            buffer_add_int (buf, 0);
            buffer_add_string (buf, "");
            buffer_add_int (buf, 0);
            goto <D.27154>;
            <D.30791>:
            minfo = mono_debug_lookup_method (method);
            if (minfo == 0B) goto <D.30792>; else goto <D.30793>;
            <D.30792>:
            D.30794 = header->code_size;
            buffer_add_int (buf, D.30794);
            buffer_add_string (buf, "");
            buffer_add_int (buf, 0);
            mono_metadata_free_mh (header);
            goto <D.27154>;
            <D.30793>:
            mono_debug_symfile_get_line_numbers_full (minfo, &source_file, &source_file_list, &n_il_offsets, &il_offsets, &line_numbers, &column_numbers, &source_files);
            D.30794 = header->code_size;
            buffer_add_int (buf, D.30794);
            protocol_version_set.272 = protocol_version_set;
            if (protocol_version_set.272 != 0) goto <D.30799>; else goto <D.30795>;
            <D.30799>:
            major_version.273 = major_version;
            if (major_version.273 > 2) goto <D.30796>; else goto <D.30801>;
            <D.30801>:
            major_version.273 = major_version;
            if (major_version.273 == 2) goto <D.30802>; else goto <D.30795>;
            <D.30802>:
            minor_version.274 = minor_version;
            if (minor_version.274 > 12) goto <D.30796>; else goto <D.30795>;
            <D.30796>:
            source_file_list.275 = source_file_list;
            D.30805 = source_file_list.275->len;
            buffer_add_int (buf, D.30805);
            i = 0;
            goto <D.27172>;
            <D.27171>:
            {
              struct MonoDebugSourceInfo * sinfo;

              source_file_list.275 = source_file_list;
              D.30806 = source_file_list.275->pdata;
              D.30807 = (long unsigned int) i;
              D.30808 = D.30807 * 8;
              D.30809 = D.30806 + D.30808;
              sinfo = *D.30809;
              D.30810 = sinfo->source_file;
              buffer_add_string (buf, D.30810);
              protocol_version_set.272 = protocol_version_set;
              if (protocol_version_set.272 != 0) goto <D.30812>; else goto <D.30813>;
              <D.30812>:
              major_version.273 = major_version;
              if (major_version.273 > 2) goto <D.30811>; else goto <D.30814>;
              <D.30814>:
              major_version.273 = major_version;
              if (major_version.273 == 2) goto <D.30815>; else goto <D.27170>;
              <D.30815>:
              minor_version.274 = minor_version;
              if (minor_version.274 > 13) goto <D.30811>; else goto <D.27170>;
              <D.30811>:
              j = 0;
              goto <D.27169>;
              <D.27168>:
              D.30816 = sinfo->hash;
              D.30817 = (sizetype) j;
              D.30818 = D.30816 + D.30817;
              D.30819 = *D.30818;
              buffer_add_byte (buf, D.30819);
              j = j + 1;
              <D.27169>:
              if (j <= 15) goto <D.27168>; else goto <D.27170>;
              <D.27170>:
              <D.30813>:
            }
            i = i + 1;
            <D.27172>:
            source_file_list.275 = source_file_list;
            D.30805 = source_file_list.275->len;
            i.276 = (unsigned int) i;
            if (D.30805 > i.276) goto <D.27171>; else goto <D.27173>;
            <D.27173>:
            goto <D.30797>;
            <D.30795>:
            source_file.277 = source_file;
            buffer_add_string (buf, source_file.277);
            <D.30797>:
            n_il_offsets.278 = n_il_offsets;
            n_il_offsets.279 = (unsigned int) n_il_offsets.278;
            buffer_add_int (buf, n_il_offsets.279);
            log_level.280 = log_level;
            D.30825 = log_level.280 > 9;
            D.30826 = (long int) D.30825;
            D.30827 = __builtin_expect (D.30826, 0);
            if (D.30827 != 0) goto <D.30828>; else goto <D.30829>;
            <D.30828>:
            log_file.281 = log_file;
            D.30831 = mono_method_full_name (method, 1);
            fprintf (log_file.281, "Line number table for method %s:\n", D.30831);
            log_file.281 = log_file;
            fflush (log_file.281);
            <D.30829>:
            i = 0;
            goto <D.27177>;
            <D.27176>:
            {
              const char * srcfile;

              srcfile = "";
              source_files.282 = source_files;
              D.30807 = (long unsigned int) i;
              D.30833 = D.30807 * 4;
              D.30834 = source_files.282 + D.30833;
              D.30835 = *D.30834;
              if (D.30835 != -1) goto <D.30836>; else goto <D.30837>;
              <D.30836>:
              {
                struct MonoDebugSourceInfo * sinfo;

                source_file_list.275 = source_file_list;
                D.30806 = source_file_list.275->pdata;
                source_files.282 = source_files;
                D.30807 = (long unsigned int) i;
                D.30833 = D.30807 * 4;
                D.30834 = source_files.282 + D.30833;
                D.30835 = *D.30834;
                D.30838 = (long unsigned int) D.30835;
                D.30839 = D.30838 * 8;
                D.30840 = D.30806 + D.30839;
                sinfo = *D.30840;
                srcfile = sinfo->source_file;
              }
              <D.30837>:
              log_level.280 = log_level;
              D.30825 = log_level.280 > 9;
              D.30826 = (long int) D.30825;
              D.30827 = __builtin_expect (D.30826, 0);
              if (D.30827 != 0) goto <D.30841>; else goto <D.30842>;
              <D.30841>:
              log_file.281 = log_file;
              il_offsets.283 = il_offsets;
              D.30807 = (long unsigned int) i;
              D.30833 = D.30807 * 4;
              D.30844 = il_offsets.283 + D.30833;
              D.30845 = *D.30844;
              line_numbers.284 = line_numbers;
              D.30807 = (long unsigned int) i;
              D.30833 = D.30807 * 4;
              D.30847 = line_numbers.284 + D.30833;
              D.30848 = *D.30847;
              column_numbers.286 = column_numbers;
              if (column_numbers.286 != 0B) goto <D.30851>; else goto <D.30852>;
              <D.30851>:
              column_numbers.286 = column_numbers;
              D.30807 = (long unsigned int) i;
              D.30833 = D.30807 * 4;
              D.30853 = column_numbers.286 + D.30833;
              iftmp.285 = *D.30853;
              goto <D.30854>;
              <D.30852>:
              iftmp.285 = -1;
              <D.30854>:
              fprintf (log_file.281, "IL%x -> %s:%d %d\n", D.30845, srcfile, D.30848, iftmp.285);
              log_file.281 = log_file;
              fflush (log_file.281);
              <D.30842>:
              il_offsets.283 = il_offsets;
              D.30807 = (long unsigned int) i;
              D.30833 = D.30807 * 4;
              D.30844 = il_offsets.283 + D.30833;
              D.30845 = *D.30844;
              D.30855 = (unsigned int) D.30845;
              buffer_add_int (buf, D.30855);
              line_numbers.284 = line_numbers;
              D.30807 = (long unsigned int) i;
              D.30833 = D.30807 * 4;
              D.30847 = line_numbers.284 + D.30833;
              D.30848 = *D.30847;
              D.30856 = (unsigned int) D.30848;
              buffer_add_int (buf, D.30856);
              protocol_version_set.272 = protocol_version_set;
              if (protocol_version_set.272 != 0) goto <D.30859>; else goto <D.30860>;
              <D.30859>:
              major_version.273 = major_version;
              if (major_version.273 > 2) goto <D.30857>; else goto <D.30861>;
              <D.30861>:
              major_version.273 = major_version;
              if (major_version.273 == 2) goto <D.30862>; else goto <D.30858>;
              <D.30862>:
              minor_version.274 = minor_version;
              if (minor_version.274 > 12) goto <D.30857>; else goto <D.30858>;
              <D.30857>:
              source_files.282 = source_files;
              D.30807 = (long unsigned int) i;
              D.30833 = D.30807 * 4;
              D.30834 = source_files.282 + D.30833;
              D.30835 = *D.30834;
              D.30863 = (unsigned int) D.30835;
              buffer_add_int (buf, D.30863);
              <D.30858>:
              <D.30860>:
              protocol_version_set.272 = protocol_version_set;
              if (protocol_version_set.272 != 0) goto <D.30866>; else goto <D.30867>;
              <D.30866>:
              major_version.273 = major_version;
              if (major_version.273 > 2) goto <D.30864>; else goto <D.30868>;
              <D.30868>:
              major_version.273 = major_version;
              if (major_version.273 == 2) goto <D.30869>; else goto <D.30865>;
              <D.30869>:
              minor_version.274 = minor_version;
              if (minor_version.274 > 18) goto <D.30864>; else goto <D.30865>;
              <D.30864>:
              column_numbers.286 = column_numbers;
              if (column_numbers.286 != 0B) goto <D.30871>; else goto <D.30872>;
              <D.30871>:
              column_numbers.286 = column_numbers;
              D.30807 = (long unsigned int) i;
              D.30833 = D.30807 * 4;
              D.30853 = column_numbers.286 + D.30833;
              D.30873 = *D.30853;
              iftmp.287 = (guint32) D.30873;
              goto <D.30874>;
              <D.30872>:
              iftmp.287 = 4294967295;
              <D.30874>:
              buffer_add_int (buf, iftmp.287);
              <D.30865>:
              <D.30867>:
            }
            i = i + 1;
            <D.27177>:
            n_il_offsets.278 = n_il_offsets;
            if (i < n_il_offsets.278) goto <D.27176>; else goto <D.27178>;
            <D.27178>:
            source_file.277 = source_file;
            monoeg_g_free (source_file.277);
            il_offsets.283 = il_offsets;
            monoeg_g_free (il_offsets.283);
            line_numbers.284 = line_numbers;
            monoeg_g_free (line_numbers.284);
            source_files.282 = source_files;
            monoeg_g_free (source_files.282);
            source_file_list.275 = source_file_list;
            monoeg_g_ptr_array_free (source_file_list.275, 1);
            mono_metadata_free_mh (header);
            goto <D.27154>;
          }
        finally
          {
            source_file = {CLOBBER};
            n_il_offsets = {CLOBBER};
            il_offsets = {CLOBBER};
            line_numbers = {CLOBBER};
            column_numbers = {CLOBBER};
            source_files = {CLOBBER};
            source_file_list = {CLOBBER};
          }
      }
      <D.27179>:
      {
        struct MonoMethodSignature * sig;
        guint32 i;
        char * * names;

        sig = mono_method_signature (method);
        D.30875 = sig->call_convention;
        D.30876 = (unsigned int) D.30875;
        buffer_add_int (buf, D.30876);
        D.30877 = sig->param_count;
        D.30878 = (unsigned int) D.30877;
        buffer_add_int (buf, D.30878);
        D.30879 = sig->generic_param_count;
        D.30880 = (unsigned int) D.30879;
        buffer_add_int (buf, D.30880);
        D.30881 = sig->ret;
        D.30882 = mono_class_from_mono_type (D.30881);
        buffer_add_typeid (buf, domain, D.30882);
        i = 0;
        goto <D.27184>;
        <D.27183>:
        D.30883 = sig->params[i];
        D.30884 = mono_class_from_mono_type (D.30883);
        buffer_add_typeid (buf, domain, D.30884);
        i = i + 1;
        <D.27184>:
        D.30877 = sig->param_count;
        D.30878 = (unsigned int) D.30877;
        if (D.30878 > i) goto <D.27183>; else goto <D.27185>;
        <D.27185>:
        D.30877 = sig->param_count;
        D.30885 = (long unsigned int) D.30877;
        D.30886 = D.30885 * 8;
        names = monoeg_malloc (D.30886);
        mono_method_get_param_names (method, names);
        i = 0;
        goto <D.27187>;
        <D.27186>:
        D.30887 = (long unsigned int) i;
        D.30888 = D.30887 * 8;
        D.30889 = names + D.30888;
        D.30890 = *D.30889;
        buffer_add_string (buf, D.30890);
        i = i + 1;
        <D.27187>:
        D.30877 = sig->param_count;
        D.30878 = (unsigned int) D.30877;
        if (D.30878 > i) goto <D.27186>; else goto <D.27188>;
        <D.27188>:
        monoeg_g_free (names);
        goto <D.27154>;
      }
      <D.27189>:
      {
        int i;
        int j;
        int num_locals;
        struct MonoDebugLocalsInfo * locals;

        header = mono_method_get_header (method);
        if (header == 0B) goto <D.30891>; else goto <D.30892>;
        <D.30891>:
        D.30893 = 102;
        return D.30893;
        <D.30892>:
        D.30894 = header->num_locals;
        D.30895 = (unsigned int) D.30894;
        buffer_add_int (buf, D.30895);
        i = 0;
        goto <D.27195>;
        <D.27194>:
        D.30896 = header->locals[i];
        D.30897 = mono_class_from_mono_type (D.30896);
        buffer_add_typeid (buf, domain, D.30897);
        i = i + 1;
        <D.27195>:
        D.30894 = header->num_locals;
        D.30898 = (int) D.30894;
        if (D.30898 > i) goto <D.27194>; else goto <D.27196>;
        <D.27196>:
        locals = mono_debug_lookup_locals (method);
        if (locals != 0B) goto <D.30899>; else goto <D.30900>;
        <D.30899>:
        num_locals = locals->num_locals;
        goto <D.30901>;
        <D.30900>:
        num_locals = 0;
        <D.30901>:
        i = 0;
        goto <D.27201>;
        <D.27200>:
        j = 0;
        goto <D.27199>;
        <D.27198>:
        D.30902 = locals->locals;
        D.30903 = (long unsigned int) j;
        D.30904 = D.30903 * 24;
        D.30905 = D.30902 + D.30904;
        D.30906 = D.30905->index;
        if (D.30906 == i) goto <D.27197>; else goto <D.30907>;
        <D.30907>:
        j = j + 1;
        <D.27199>:
        if (j < num_locals) goto <D.27198>; else goto <D.27197>;
        <D.27197>:
        if (j < num_locals) goto <D.30908>; else goto <D.30909>;
        <D.30908>:
        D.30902 = locals->locals;
        D.30903 = (long unsigned int) j;
        D.30904 = D.30903 * 24;
        D.30905 = D.30902 + D.30904;
        D.30910 = D.30905->name;
        buffer_add_string (buf, D.30910);
        goto <D.30911>;
        <D.30909>:
        buffer_add_string (buf, "");
        <D.30911>:
        i = i + 1;
        <D.27201>:
        D.30894 = header->num_locals;
        D.30898 = (int) D.30894;
        if (D.30898 > i) goto <D.27200>; else goto <D.27202>;
        <D.27202>:
        i = 0;
        goto <D.27207>;
        <D.27206>:
        j = 0;
        goto <D.27205>;
        <D.27204>:
        D.30902 = locals->locals;
        D.30903 = (long unsigned int) j;
        D.30904 = D.30903 * 24;
        D.30905 = D.30902 + D.30904;
        D.30906 = D.30905->index;
        if (D.30906 == i) goto <D.27203>; else goto <D.30912>;
        <D.30912>:
        j = j + 1;
        <D.27205>:
        if (j < num_locals) goto <D.27204>; else goto <D.27203>;
        <D.27203>:
        if (j < num_locals) goto <D.30915>; else goto <D.30913>;
        <D.30915>:
        D.30902 = locals->locals;
        D.30903 = (long unsigned int) j;
        D.30904 = D.30903 * 24;
        D.30905 = D.30902 + D.30904;
        D.30916 = D.30905->block;
        if (D.30916 != 0B) goto <D.30917>; else goto <D.30913>;
        <D.30917>:
        D.30902 = locals->locals;
        D.30903 = (long unsigned int) j;
        D.30904 = D.30903 * 24;
        D.30905 = D.30902 + D.30904;
        D.30916 = D.30905->block;
        D.30918 = D.30916->start_offset;
        D.30919 = (unsigned int) D.30918;
        buffer_add_int (buf, D.30919);
        D.30902 = locals->locals;
        D.30903 = (long unsigned int) j;
        D.30904 = D.30903 * 24;
        D.30905 = D.30902 + D.30904;
        D.30916 = D.30905->block;
        D.30920 = D.30916->end_offset;
        D.30921 = (unsigned int) D.30920;
        buffer_add_int (buf, D.30921);
        goto <D.30914>;
        <D.30913>:
        buffer_add_int (buf, 0);
        D.30794 = header->code_size;
        buffer_add_int (buf, D.30794);
        <D.30914>:
        i = i + 1;
        <D.27207>:
        D.30894 = header->num_locals;
        D.30898 = (int) D.30894;
        if (D.30898 > i) goto <D.27206>; else goto <D.27208>;
        <D.27208>:
        mono_metadata_free_mh (header);
        if (locals != 0B) goto <D.30922>; else goto <D.30923>;
        <D.30922>:
        mono_debug_symfile_free_locals (locals);
        <D.30923>:
        goto <D.27154>;
      }
      <D.27209>:
      D.30924 = method->flags;
      D.30925 = (unsigned int) D.30924;
      buffer_add_int (buf, D.30925);
      D.30926 = method->iflags;
      D.30927 = (unsigned int) D.30926;
      buffer_add_int (buf, D.30927);
      D.30928 = method->token;
      buffer_add_int (buf, D.30928);
      protocol_version_set.272 = protocol_version_set;
      if (protocol_version_set.272 != 0) goto <D.30931>; else goto <D.30932>;
      <D.30931>:
      major_version.273 = major_version;
      if (major_version.273 > 2) goto <D.30929>; else goto <D.30933>;
      <D.30933>:
      major_version.273 = major_version;
      if (major_version.273 == 2) goto <D.30934>; else goto <D.30930>;
      <D.30934>:
      minor_version.274 = minor_version;
      if (minor_version.274 > 11) goto <D.30929>; else goto <D.30930>;
      <D.30929>:
      {
        guint8 attrs;

        attrs = 0;
        D.30935 = BIT_FIELD_REF <*method, 64, 256>;
        D.30936 = D.30935 & 4503599627370496;
        if (D.30936 != 0) goto <D.30937>; else goto <D.30938>;
        <D.30937>:
        attrs = attrs | 1;
        <D.30938>:
        D.30939 = mono_method_signature (method);
        D.30940 = D.30939->generic_param_count;
        if (D.30940 != 0) goto <D.30941>; else goto <D.30942>;
        <D.30941>:
        attrs = attrs | 2;
        <D.30942>:
        buffer_add_byte (buf, attrs);
        D.30935 = BIT_FIELD_REF <*method, 64, 256>;
        D.30943 = D.30935 & 6755399441055744;
        if (D.30943 != 0) goto <D.30944>; else goto <D.30945>;
        <D.30944>:
        {
          struct MonoMethod * result;

          D.30935 = BIT_FIELD_REF <*method, 64, 256>;
          D.30936 = D.30935 & 4503599627370496;
          if (D.30936 != 0) goto <D.30946>; else goto <D.30947>;
          <D.30946>:
          result = method;
          goto <D.30948>;
          <D.30947>:
          {
            struct MonoMethodInflated * imethod;

            imethod = method;
            result = imethod->declaring;
            D.30949 = imethod->context.class_inst;
            if (D.30949 != 0B) goto <D.30950>; else goto <D.30951>;
            <D.30950>:
            {
              struct MonoClass * klass;

              klass = MEM[(struct MonoMethod *)imethod].klass;
              D.30952 = mono_class_get_context (klass);
              if (D.30952 != 0B) goto <D.30953>; else goto <D.30954>;
              <D.30953>:
              D.30955 = mono_class_get_context (klass);
              result = mono_class_inflate_generic_method_full (result, klass, D.30955);
              <D.30954>:
            }
            <D.30951>:
          }
          <D.30948>:
          buffer_add_methodid (buf, domain, result);
        }
        goto <D.30956>;
        <D.30945>:
        buffer_add_id (buf, 0);
        <D.30956>:
        protocol_version_set.272 = protocol_version_set;
        if (protocol_version_set.272 != 0) goto <D.30959>; else goto <D.30960>;
        <D.30959>:
        major_version.273 = major_version;
        if (major_version.273 > 2) goto <D.30957>; else goto <D.30961>;
        <D.30961>:
        major_version.273 = major_version;
        if (major_version.273 == 2) goto <D.30962>; else goto <D.30958>;
        <D.30962>:
        minor_version.274 = minor_version;
        if (minor_version.274 > 14) goto <D.30957>; else goto <D.30958>;
        <D.30957>:
        D.30963 = mono_method_signature (method);
        D.30964 = D.30963->generic_param_count;
        if (D.30964 != 0) goto <D.30965>; else goto <D.30966>;
        <D.30965>:
        {
          int count;
          int i;

          D.30935 = BIT_FIELD_REF <*method, 64, 256>;
          D.30967 = D.30935 & 2251799813685248;
          if (D.30967 != 0) goto <D.30968>; else goto <D.30969>;
          <D.30968>:
          {
            struct MonoGenericInst * inst;

            D.30970 = mono_method_get_context (method);
            inst = D.30970->method_inst;
            if (inst != 0B) goto <D.30971>; else goto <D.30972>;
            <D.30971>:
            D.30973 = inst->type_argc;
            count = (int) D.30973;
            count.288 = (unsigned int) count;
            buffer_add_int (buf, count.288);
            i = 0;
            goto <D.27218>;
            <D.27217>:
            D.30975 = inst->type_argv[i];
            D.30976 = mono_class_from_mono_type (D.30975);
            buffer_add_typeid (buf, domain, D.30976);
            i = i + 1;
            <D.27218>:
            if (i < count) goto <D.27217>; else goto <D.27219>;
            <D.27219>:
            goto <D.30977>;
            <D.30972>:
            buffer_add_int (buf, 0);
            <D.30977>:
          }
          goto <D.30978>;
          <D.30969>:
          D.30935 = BIT_FIELD_REF <*method, 64, 256>;
          D.30936 = D.30935 & 4503599627370496;
          if (D.30936 != 0) goto <D.30979>; else goto <D.30980>;
          <D.30979>:
          {
            struct MonoGenericContainer * container;

            container = mono_method_get_generic_container (method);
            D.30981 = mono_method_signature (method);
            D.30982 = D.30981->generic_param_count;
            count = (int) D.30982;
            count.288 = (unsigned int) count;
            buffer_add_int (buf, count.288);
            i = 0;
            goto <D.27224>;
            <D.27223>:
            {
              struct MonoGenericParam * param;
              struct MonoClass * pklass;

              D.30983 = container->type_params;
              D.30984 = (long unsigned int) i;
              D.30985 = D.30984 * 56;
              param = D.30983 + D.30985;
              D.30789 = method->klass;
              D.30986 = D.30789->image;
              pklass = mono_class_from_generic_parameter (param, D.30986, 1);
              buffer_add_typeid (buf, domain, pklass);
            }
            i = i + 1;
            <D.27224>:
            if (i < count) goto <D.27223>; else goto <D.27225>;
            <D.27225>:
          }
          goto <D.30987>;
          <D.30980>:
          buffer_add_int (buf, 0);
          <D.30987>:
          <D.30978>:
        }
        goto <D.30988>;
        <D.30966>:
        buffer_add_int (buf, 0);
        <D.30988>:
        <D.30958>:
        <D.30960>:
      }
      <D.30930>:
      <D.30932>:
      goto <D.27154>;
      <D.27226>:
      {
        int i;

        header = mono_method_get_header (method);
        if (header == 0B) goto <D.30989>; else goto <D.30990>;
        <D.30989>:
        buffer_add_int (buf, 0);
        protocol_version_set.272 = protocol_version_set;
        if (protocol_version_set.272 != 0) goto <D.30993>; else goto <D.30994>;
        <D.30993>:
        major_version.273 = major_version;
        if (major_version.273 > 2) goto <D.30991>; else goto <D.30995>;
        <D.30995>:
        major_version.273 = major_version;
        if (major_version.273 == 2) goto <D.30996>; else goto <D.30992>;
        <D.30996>:
        minor_version.274 = minor_version;
        if (minor_version.274 > 17) goto <D.30991>; else goto <D.30992>;
        <D.30991>:
        buffer_add_int (buf, 0);
        <D.30992>:
        <D.30994>:
        goto <D.30997>;
        <D.30990>:
        D.30794 = header->code_size;
        buffer_add_int (buf, D.30794);
        i = 0;
        goto <D.27229>;
        <D.27228>:
        D.30998 = header->code;
        D.30999 = (sizetype) i;
        D.31000 = D.30998 + D.30999;
        D.31001 = *D.31000;
        buffer_add_byte (buf, D.31001);
        i = i + 1;
        <D.27229>:
        D.30794 = header->code_size;
        i.289 = (unsigned int) i;
        if (D.30794 > i.289) goto <D.27228>; else goto <D.27230>;
        <D.27230>:
        protocol_version_set.272 = protocol_version_set;
        if (protocol_version_set.272 != 0) goto <D.31004>; else goto <D.31005>;
        <D.31004>:
        major_version.273 = major_version;
        if (major_version.273 > 2) goto <D.31003>; else goto <D.31006>;
        <D.31006>:
        major_version.273 = major_version;
        if (major_version.273 == 2) goto <D.31007>; else goto <D.27234>;
        <D.31007>:
        minor_version.274 = minor_version;
        if (minor_version.274 > 17) goto <D.31003>; else goto <D.27234>;
        <D.31003>:
        D.31008 = header->num_clauses;
        D.31009 = (unsigned int) D.31008;
        buffer_add_int (buf, D.31009);
        i = 0;
        goto <D.27233>;
        <D.27232>:
        {
          struct MonoExceptionClause * clause;

          D.31010 = header->clauses;
          D.31011 = (long unsigned int) i;
          D.31012 = D.31011 * 32;
          clause = D.31010 + D.31012;
          D.31013 = clause->flags;
          buffer_add_int (buf, D.31013);
          D.31014 = clause->try_offset;
          buffer_add_int (buf, D.31014);
          D.31015 = clause->try_len;
          buffer_add_int (buf, D.31015);
          D.31016 = clause->handler_offset;
          buffer_add_int (buf, D.31016);
          D.31017 = clause->handler_len;
          buffer_add_int (buf, D.31017);
          D.31013 = clause->flags;
          if (D.31013 == 0) goto <D.31018>; else goto <D.31019>;
          <D.31018>:
          D.31020 = clause->data.catch_class;
          buffer_add_typeid (buf, domain, D.31020);
          goto <D.31021>;
          <D.31019>:
          D.31013 = clause->flags;
          if (D.31013 == 1) goto <D.31022>; else goto <D.31023>;
          <D.31022>:
          D.31024 = clause->data.filter_offset;
          buffer_add_int (buf, D.31024);
          <D.31023>:
          <D.31021>:
        }
        i = i + 1;
        <D.27233>:
        D.31008 = header->num_clauses;
        D.31025 = (int) D.31008;
        if (D.31025 > i) goto <D.27232>; else goto <D.27234>;
        <D.27234>:
        <D.31005>:
        mono_metadata_free_mh (header);
        <D.30997>:
        goto <D.27154>;
      }
      <D.27235>:
      {
        guint32 token;

        p.290 = p;
        D.31027 = decode_int (p.290, &p, end);
        token = (guint32) D.31027;
        D.31028 = token & 4278190080;
        switch (D.31028) <default: <D.27241>, case 1879048192: <D.27237>>
        <D.27237>:
        {
          struct MonoString * s;
          char * s2;

          D.30789 = method->klass;
          D.30986 = D.30789->image;
          D.31029 = token & 16777215;
          s = mono_ldstr (domain, D.30986, D.31029);
          D.31030 = s == 0B;
          D.31031 = (long int) D.31030;
          D.31032 = __builtin_expect (D.31031, 0);
          if (D.31032 != 0) goto <D.31033>; else goto <D.31034>;
          <D.31033>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 8237, "s");
          <D.31034>:
          s2 = mono_string_to_utf8 (s);
          buffer_add_byte (buf, 0);
          buffer_add_string (buf, s2);
          monoeg_g_free (s2);
          goto <D.27240>;
        }
        <D.27241>:
        {
          void * val;
          struct MonoClass * handle_class;

          try
            {
              D.30935 = BIT_FIELD_REF <*method, 64, 256>;
              D.31035 = D.30935 & 4467570830351532032;
              if (D.31035 == 2449958197289549824) goto <D.31036>; else goto <D.31037>;
              <D.31036>:
              val = mono_method_get_wrapper_data (method, token);
              D.31038 = token + 1;
              handle_class.291 = mono_method_get_wrapper_data (method, D.31038);
              handle_class = handle_class.291;
              handle_class.292 = handle_class;
              if (handle_class.292 == 0B) goto <D.31041>; else goto <D.31042>;
              <D.31041>:
              buffer_add_byte (buf, 4);
              goto <D.27240>;
              <D.31042>:
              goto <D.31043>;
              <D.31037>:
              D.30789 = method->klass;
              D.30986 = D.30789->image;
              val = mono_ldtoken (D.30986, token, &handle_class, 0B);
              D.31044 = val == 0B;
              D.31045 = (long int) D.31044;
              D.31046 = __builtin_expect (D.31045, 0);
              if (D.31046 != 0) goto <D.31047>; else goto <D.31048>;
              <D.31047>:
              monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 8261, "val");
              <D.31048>:
              <D.31043>:
              D.31049 = mono_defaults.typehandle_class;
              handle_class.292 = handle_class;
              if (D.31049 == handle_class.292) goto <D.31050>; else goto <D.31051>;
              <D.31050>:
              buffer_add_byte (buf, 1);
              D.30935 = BIT_FIELD_REF <*method, 64, 256>;
              D.31035 = D.30935 & 4467570830351532032;
              if (D.31035 == 2449958197289549824) goto <D.31052>; else goto <D.31053>;
              <D.31052>:
              buffer_add_typeid (buf, domain, val);
              goto <D.31054>;
              <D.31053>:
              D.31055 = mono_class_from_mono_type (val);
              buffer_add_typeid (buf, domain, D.31055);
              <D.31054>:
              goto <D.31056>;
              <D.31051>:
              D.31057 = mono_defaults.fieldhandle_class;
              handle_class.292 = handle_class;
              if (D.31057 == handle_class.292) goto <D.31058>; else goto <D.31059>;
              <D.31058>:
              buffer_add_byte (buf, 2);
              buffer_add_fieldid (buf, domain, val);
              goto <D.31060>;
              <D.31059>:
              D.31061 = mono_defaults.methodhandle_class;
              handle_class.292 = handle_class;
              if (D.31061 == handle_class.292) goto <D.31062>; else goto <D.31063>;
              <D.31062>:
              buffer_add_byte (buf, 3);
              buffer_add_methodid (buf, domain, val);
              goto <D.31064>;
              <D.31063>:
              D.31065 = mono_defaults.string_class;
              handle_class.292 = handle_class;
              if (D.31065 == handle_class.292) goto <D.31066>; else goto <D.31067>;
              <D.31066>:
              {
                char * s;

                s = mono_string_to_utf8 (val);
                buffer_add_byte (buf, 0);
                buffer_add_string (buf, s);
                monoeg_g_free (s);
              }
              goto <D.31068>;
              <D.31067>:
              monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "debugger-agent.c", 8284);
              <D.31068>:
              <D.31064>:
              <D.31060>:
              <D.31056>:
              goto <D.27240>;
            }
          finally
            {
              handle_class = {CLOBBER};
            }
        }
        <D.27240>:
        goto <D.27154>;
      }
      <D.27245>:
      {
        struct MonoClass * attr_klass;
        struct MonoCustomAttrInfo * cinfo;

        p.290 = p;
        attr_klass = decode_typeid (p.290, &p, end, 0B, &err);
        err.293 = err;
        if (err.293 != 0) goto <D.31070>; else goto <D.31071>;
        <D.31070>:
        err.293 = err;
        D.30893 = (ErrorCode) err.293;
        return D.30893;
        <D.31071>:
        cinfo = mono_custom_attrs_from_method (method);
        D.30789 = method->klass;
        D.30986 = D.30789->image;
        buffer_add_cattrs (buf, domain, D.30986, attr_klass, cinfo);
        goto <D.27154>;
      }
      <D.27248>:
      {
        struct MonoType * * type_argv;
        int i;
        int type_argc;
        struct MonoDomain * d;
        struct MonoClass * klass;
        struct MonoGenericInst * ginst;
        struct MonoGenericContext tmp_context;
        struct MonoMethod * inflated;

        try
          {
            p.290 = p;
            type_argc = decode_int (p.290, &p, end);
            D.31072 = (long unsigned int) type_argc;
            D.31073 = D.31072 * 8;
            type_argv = monoeg_malloc0 (D.31073);
            i = 0;
            goto <D.27258>;
            <D.27257>:
            p.290 = p;
            klass = decode_typeid (p.290, &p, end, &d, &err);
            err.293 = err;
            if (err.293 != 0) goto <D.31074>; else goto <D.31075>;
            <D.31074>:
            monoeg_g_free (type_argv);
            err.293 = err;
            D.30893 = (ErrorCode) err.293;
            return D.30893;
            <D.31075>:
            d.294 = d;
            if (domain != d.294) goto <D.31077>; else goto <D.31078>;
            <D.31077>:
            monoeg_g_free (type_argv);
            D.30893 = 102;
            return D.30893;
            <D.31078>:
            D.31079 = (long unsigned int) i;
            D.31080 = D.31079 * 8;
            D.31081 = type_argv + D.31080;
            D.31082 = &klass->byval_arg;
            *D.31081 = D.31082;
            i = i + 1;
            <D.27258>:
            if (i < type_argc) goto <D.27257>; else goto <D.27259>;
            <D.27259>:
            ginst = mono_metadata_get_generic_inst (type_argc, type_argv);
            monoeg_g_free (type_argv);
            D.30789 = method->klass;
            D.31084 = D.30789->generic_class;
            if (D.31084 != 0B) goto <D.31085>; else goto <D.31086>;
            <D.31085>:
            D.30789 = method->klass;
            D.31084 = D.30789->generic_class;
            iftmp.295 = D.31084->context.class_inst;
            goto <D.31087>;
            <D.31086>:
            iftmp.295 = 0B;
            <D.31087>:
            tmp_context.class_inst = iftmp.295;
            tmp_context.method_inst = ginst;
            inflated = mono_class_inflate_generic_method (method, &tmp_context);
            D.31088 = mono_verifier_is_method_valid_generic_instantiation (inflated);
            if (D.31088 == 0) goto <D.31089>; else goto <D.31090>;
            <D.31089>:
            D.30893 = 102;
            return D.30893;
            <D.31090>:
            buffer_add_methodid (buf, domain, inflated);
            goto <D.27154>;
          }
        finally
          {
            d = {CLOBBER};
            tmp_context = {CLOBBER};
          }
      }
      <D.27260>:
      D.30893 = 100;
      return D.30893;
      <D.27154>:
      D.30893 = 0;
      return D.30893;
    }
  finally
    {
      err = {CLOBBER};
    }
}


thread_commands (int command, guint8 * p, guint8 * end, struct Buffer * buf)
{
  guint8 * p.296;
  <unnamed type> D.31098;
  ErrorCode D.31101;
  struct MonoThread * thread_obj.297;
  unsigned int name_len.298;
  long int D.31107;
  _Bool D.31108;
  long int D.31109;
  long int D.31110;
  long int len.299;
  unsigned int D.31114;
  int D.31115;
  int suspend_count.300;
  int D.31119;
  struct MonoGHashTable * thread_to_tls.301;
  _Bool D.31124;
  long int D.31125;
  long int D.31126;
  int D.31129;
  unsigned int D.31130;
  struct StackFrame * * D.31131;
  long unsigned int D.31132;
  long unsigned int D.31133;
  struct StackFrame * * D.31134;
  struct StackFrame * D.31135;
  int D.31136;
  unsigned int D.31137;
  struct MonoDomain * D.31138;
  struct MonoMethod * D.31139;
  unsigned int D.31140;
  int D.31141;
  unsigned char D.31142;
  unsigned int D.31143;
  unsigned char D.31144;
  long unsigned int thread.302;
  long unsigned int D.31146;
  int objid;
  int err;
  struct MonoThread * thread_obj;
  struct MonoInternalThread * thread;

  try
    {
      p.296 = p;
      objid = decode_objid (p.296, &p, end);
      D.31098 = get_object (objid, &thread_obj);
      err = (int) D.31098;
      if (err != 0) goto <D.31099>; else goto <D.31100>;
      <D.31099>:
      D.31101 = (ErrorCode) err;
      return D.31101;
      <D.31100>:
      thread_obj.297 = thread_obj;
      thread = thread_obj.297->internal_thread;
      switch (command) <default: <D.27302>, case 1: <D.27287>, case 2: <D.27281>, case 3: <D.27298>, case 4: <D.27299>, case 5: <D.27300>, case 6: <D.27301>>
      <D.27281>:
      {
        guint32 name_len;
        gunichar2 * s;

        try
          {
            s = mono_thread_get_name (thread, &name_len);
            if (s == 0B) goto <D.31103>; else goto <D.31104>;
            <D.31103>:
            buffer_add_int (buf, 0);
            goto <D.31105>;
            <D.31104>:
            {
              char * name;
              glong len;

              try
                {
                  name_len.298 = name_len;
                  D.31107 = (long int) name_len.298;
                  name = monoeg_g_utf16_to_utf8 (s, D.31107, 0B, &len, 0B);
                  D.31108 = name == 0B;
                  D.31109 = (long int) D.31108;
                  D.31110 = __builtin_expect (D.31109, 0);
                  if (D.31110 != 0) goto <D.31111>; else goto <D.31112>;
                  <D.31111>:
                  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 8395, "name");
                  <D.31112>:
                  len.299 = len;
                  D.31114 = (unsigned int) len.299;
                  buffer_add_int (buf, D.31114);
                  len.299 = len;
                  D.31115 = (int) len.299;
                  buffer_add_data (buf, name, D.31115);
                  monoeg_g_free (s);
                }
              finally
                {
                  len = {CLOBBER};
                }
            }
            <D.31105>:
            goto <D.27286>;
          }
        finally
          {
            name_len = {CLOBBER};
          }
      }
      <D.27287>:
      {
        struct DebuggerTlsData * tls;
        int i;
        int start_frame;
        int length;

        goto <D.27293>;
        <D.27292>:
        suspend_count.300 = suspend_count;
        if (suspend_count.300 != 0) goto <D.31117>; else goto <D.31118>;
        <D.31117>:
        wait_for_suspend ();
        <D.31118>:
        <D.27293>:
        D.31119 = is_suspended ();
        if (D.31119 == 0) goto <D.27292>; else goto <D.27294>;
        <D.27294>:
        p.296 = p;
        start_frame = decode_int (p.296, &p, end);
        p.296 = p;
        length = decode_int (p.296, &p, end);
        if (start_frame != 0) goto <D.31120>; else goto <D.31122>;
        <D.31122>:
        if (length != -1) goto <D.31120>; else goto <D.31121>;
        <D.31120>:
        D.31101 = 100;
        return D.31101;
        <D.31121>:
        mono_loader_lock ();
        thread_to_tls.301 = thread_to_tls;
        tls = mono_g_hash_table_lookup (thread_to_tls.301, thread);
        mono_loader_unlock ();
        D.31124 = tls == 0B;
        D.31125 = (long int) D.31124;
        D.31126 = __builtin_expect (D.31125, 0);
        if (D.31126 != 0) goto <D.31127>; else goto <D.31128>;
        <D.31127>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 8428, "tls");
        <D.31128>:
        compute_frame_info (thread, tls);
        D.31129 = tls->frame_count;
        D.31130 = (unsigned int) D.31129;
        buffer_add_int (buf, D.31130);
        i = 0;
        goto <D.27296>;
        <D.27295>:
        D.31131 = tls->frames;
        D.31132 = (long unsigned int) i;
        D.31133 = D.31132 * 8;
        D.31134 = D.31131 + D.31133;
        D.31135 = *D.31134;
        D.31136 = D.31135->id;
        D.31137 = (unsigned int) D.31136;
        buffer_add_int (buf, D.31137);
        D.31131 = tls->frames;
        D.31132 = (long unsigned int) i;
        D.31133 = D.31132 * 8;
        D.31134 = D.31131 + D.31133;
        D.31135 = *D.31134;
        D.31138 = D.31135->domain;
        D.31131 = tls->frames;
        D.31132 = (long unsigned int) i;
        D.31133 = D.31132 * 8;
        D.31134 = D.31131 + D.31133;
        D.31135 = *D.31134;
        D.31139 = D.31135->actual_method;
        buffer_add_methodid (buf, D.31138, D.31139);
        D.31131 = tls->frames;
        D.31132 = (long unsigned int) i;
        D.31133 = D.31132 * 8;
        D.31134 = D.31131 + D.31133;
        D.31135 = *D.31134;
        D.31140 = D.31135->il_offset;
        buffer_add_int (buf, D.31140);
        D.31131 = tls->frames;
        D.31132 = (long unsigned int) i;
        D.31133 = D.31132 * 8;
        D.31134 = D.31131 + D.31133;
        D.31135 = *D.31134;
        D.31141 = D.31135->flags;
        D.31142 = (unsigned char) D.31141;
        buffer_add_byte (buf, D.31142);
        i = i + 1;
        <D.27296>:
        D.31129 = tls->frame_count;
        if (D.31129 > i) goto <D.27295>; else goto <D.27297>;
        <D.27297>:
        goto <D.27286>;
      }
      <D.27298>:
      D.31143 = thread->state;
      buffer_add_int (buf, D.31143);
      goto <D.27286>;
      <D.27299>:
      D.31144 = thread->threadpool_thread;
      buffer_add_byte (buf, D.31144);
      goto <D.27286>;
      <D.27300>:
      thread.302 = (long unsigned int) thread;
      buffer_add_long (buf, thread.302);
      goto <D.27286>;
      <D.27301>:
      D.31146 = thread->tid;
      buffer_add_long (buf, D.31146);
      goto <D.27286>;
      <D.27302>:
      D.31101 = 100;
      return D.31101;
      <D.27286>:
      D.31101 = 0;
      return D.31101;
    }
  finally
    {
      thread_obj = {CLOBBER};
    }
}


frame_commands (int command, guint8 * p, guint8 * end, struct Buffer * buf)
{
  guint8 * p.303;
  <unnamed type> D.31152;
  ErrorCode D.31155;
  struct MonoThread * thread_obj.304;
  int D.31157;
  struct MonoGHashTable * thread_to_tls.305;
  _Bool D.31159;
  long int D.31160;
  long int D.31161;
  struct StackFrame * * D.31164;
  long unsigned int D.31165;
  long unsigned int D.31166;
  struct StackFrame * * D.31167;
  struct StackFrame * D.31168;
  int D.31169;
  long int D.31170;
  int D.31172;
  long unsigned int D.31175;
  long unsigned int D.31176;
  struct StackFrame * * D.31177;
  int D.31178;
  struct MonoDebugMethodJitInfo * D.31181;
  struct MonoMethod * D.31184;
  struct MonoDomain * D.31185;
  struct MonoDebugMethodJitInfo * D.31186;
  long unsigned int D.31189;
  long unsigned int D.31190;
  struct MonoMethod * D.31193;
  struct MonoDebugMethodJitInfo * D.31194;
  int log_level.306;
  _Bool D.31198;
  long int D.31199;
  long int D.31200;
  struct FILE * log_file.307;
  struct MonoMethod * D.31204;
  struct MonoSeqPointInfo * D.31205;
  int iftmp.308;
  unsigned int D.31215;
  unsigned int pos.309;
  _Bool D.31217;
  long int D.31218;
  long int D.31219;
  struct MonoDebugVarInfo * D.31222;
  long unsigned int D.31223;
  long unsigned int D.31224;
  struct MonoType * D.31225;
  struct MonoDebugVarInfo * D.31226;
  struct MonoContext * D.31227;
  int iftmp.310;
  unsigned int D.31234;
  _Bool D.31235;
  long int D.31236;
  long int D.31237;
  struct MonoDebugVarInfo * D.31240;
  struct MonoType * D.31241;
  struct MonoDebugVarInfo * D.31242;
  struct MonoClass * D.31243;
  long unsigned int D.31244;
  long unsigned int D.31245;
  long unsigned int D.31248;
  long unsigned int D.31249;
  struct MonoClass * D.31252;
  struct MonoType * D.31253;
  struct MonoClass * D.31255;
  struct MonoType * D.31256;
  struct MonoDebugVarInfo * D.31257;
  struct MonoType * D.31261;
  struct MonoType * D.31263;
  int iftmp.311;
  _Bool D.31271;
  long int D.31272;
  long int D.31273;
  int iftmp.312;
  _Bool D.31282;
  long int D.31283;
  long int D.31284;
  int D.31287;
  struct MonoClass * D.31291;
  int D.31292;
  long unsigned int D.31293;
  <unnamed type> D.31294;
  mgreg_t *[16] * D.31297;
  struct MonoContext * D.31298;
  int objid;
  int err;
  struct MonoThread * thread_obj;
  struct MonoInternalThread * thread;
  int pos;
  int i;
  int len;
  int frame_idx;
  struct DebuggerTlsData * tls;
  struct StackFrame * frame;
  struct MonoDebugMethodJitInfo * jit;
  struct MonoDebugVarInfo * var;
  struct MonoMethodSignature * sig;
  gssize id;
  struct MonoMethodHeader * header;

  try
    {
      p.303 = p;
      objid = decode_objid (p.303, &p, end);
      D.31152 = get_object (objid, &thread_obj);
      err = (int) D.31152;
      if (err != 0) goto <D.31153>; else goto <D.31154>;
      <D.31153>:
      D.31155 = (ErrorCode) err;
      return D.31155;
      <D.31154>:
      thread_obj.304 = thread_obj;
      thread = thread_obj.304->internal_thread;
      p.303 = p;
      D.31157 = decode_id (p.303, &p, end);
      id = (gssize) D.31157;
      mono_loader_lock ();
      thread_to_tls.305 = thread_to_tls;
      tls = mono_g_hash_table_lookup (thread_to_tls.305, thread);
      mono_loader_unlock ();
      D.31159 = tls == 0B;
      D.31160 = (long int) D.31159;
      D.31161 = __builtin_expect (D.31160, 0);
      if (D.31161 != 0) goto <D.31162>; else goto <D.31163>;
      <D.31162>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 8495, "tls");
      <D.31163>:
      i = 0;
      goto <D.27326>;
      <D.27325>:
      D.31164 = tls->frames;
      D.31165 = (long unsigned int) i;
      D.31166 = D.31165 * 8;
      D.31167 = D.31164 + D.31166;
      D.31168 = *D.31167;
      D.31169 = D.31168->id;
      D.31170 = (long int) D.31169;
      if (D.31170 == id) goto <D.27324>; else goto <D.31171>;
      <D.31171>:
      i = i + 1;
      <D.27326>:
      D.31172 = tls->frame_count;
      if (D.31172 > i) goto <D.27325>; else goto <D.27324>;
      <D.27324>:
      D.31172 = tls->frame_count;
      if (D.31172 == i) goto <D.31173>; else goto <D.31174>;
      <D.31173>:
      D.31155 = 30;
      return D.31155;
      <D.31174>:
      frame_idx = i;
      D.31164 = tls->frames;
      D.31175 = (long unsigned int) frame_idx;
      D.31176 = D.31175 * 8;
      D.31177 = D.31164 + D.31176;
      frame = *D.31177;
      D.31178 = frame->has_ctx;
      if (D.31178 == 0) goto <D.31179>; else goto <D.31180>;
      <D.31179>:
      D.31155 = 105;
      return D.31155;
      <D.31180>:
      D.31181 = frame->jit;
      if (D.31181 == 0B) goto <D.31182>; else goto <D.31183>;
      <D.31182>:
      D.31184 = frame->api_method;
      D.31185 = frame->domain;
      D.31186 = mono_debug_find_method (D.31184, D.31185);
      frame->jit = D.31186;
      D.31181 = frame->jit;
      if (D.31181 == 0B) goto <D.31187>; else goto <D.31188>;
      <D.31187>:
      D.31184 = frame->api_method;
      D.31189 = BIT_FIELD_REF <*D.31184, 64, 256>;
      D.31190 = D.31189 & 2251799813685248;
      if (D.31190 != 0) goto <D.31191>; else goto <D.31192>;
      <D.31191>:
      D.31184 = frame->api_method;
      D.31193 = mono_method_get_declaring_generic_method (D.31184);
      D.31185 = frame->domain;
      D.31194 = mono_debug_find_method (D.31193, D.31185);
      frame->jit = D.31194;
      <D.31192>:
      <D.31188>:
      D.31181 = frame->jit;
      if (D.31181 == 0B) goto <D.31195>; else goto <D.31196>;
      <D.31195>:
      {
        char * s;

        D.31184 = frame->api_method;
        s = mono_method_full_name (D.31184, 1);
        log_level.306 = log_level;
        D.31198 = log_level.306 > 0;
        D.31199 = (long int) D.31198;
        D.31200 = __builtin_expect (D.31199, 0);
        if (D.31200 != 0) goto <D.31201>; else goto <D.31202>;
        <D.31201>:
        log_file.307 = log_file;
        fprintf (log_file.307, "[dbg] No debug information found for \'%s\'.\n", s);
        log_file.307 = log_file;
        fflush (log_file.307);
        <D.31202>:
        monoeg_g_free (s);
        D.31155 = 105;
        return D.31155;
      }
      <D.31196>:
      <D.31183>:
      jit = frame->jit;
      D.31204 = frame->actual_method;
      sig = mono_method_signature (D.31204);
      D.31185 = frame->domain;
      D.31204 = frame->actual_method;
      D.31205 = get_seq_points (D.31185, D.31204);
      if (D.31205 == 0B) goto <D.31206>; else goto <D.31207>;
      <D.31206>:
      D.31155 = 105;
      return D.31155;
      <D.31207>:
      switch (command) <default: <D.27343>, case 1: <D.27328>, case 2: <D.27333>, case 3: <D.27336>>
      <D.27328>:
      p.303 = p;
      len = decode_int (p.303, &p, end);
      D.31204 = frame->actual_method;
      header = mono_method_get_header (D.31204);
      i = 0;
      goto <D.27330>;
      <D.27329>:
      p.303 = p;
      pos = decode_int (p.303, &p, end);
      if (pos < 0) goto <D.31208>; else goto <D.31209>;
      <D.31208>:
      pos = ~pos;
      if (pos < 0) goto <D.31211>; else goto <D.31214>;
      <D.31214>:
      D.31215 = jit->num_params;
      pos.309 = (unsigned int) pos;
      if (D.31215 <= pos.309) goto <D.31211>; else goto <D.31212>;
      <D.31211>:
      iftmp.308 = 1;
      goto <D.31213>;
      <D.31212>:
      iftmp.308 = 0;
      <D.31213>:
      D.31217 = iftmp.308 != 0;
      D.31218 = (long int) D.31217;
      D.31219 = __builtin_expect (D.31218, 0);
      if (D.31219 != 0) goto <D.31220>; else goto <D.31221>;
      <D.31220>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 8545, "pos >= 0 && pos < jit->num_params");
      <D.31221>:
      D.31222 = jit->params;
      D.31223 = (long unsigned int) pos;
      D.31224 = D.31223 * 32;
      var = D.31222 + D.31224;
      D.31225 = sig->params[pos];
      D.31222 = jit->params;
      D.31223 = (long unsigned int) pos;
      D.31224 = D.31223 * 32;
      D.31226 = D.31222 + D.31224;
      D.31227 = &frame->ctx;
      D.31185 = frame->domain;
      add_var (buf, jit, D.31225, D.31226, D.31227, D.31185, 0);
      goto <D.31228>;
      <D.31209>:
      if (pos < 0) goto <D.31230>; else goto <D.31233>;
      <D.31233>:
      D.31234 = jit->num_locals;
      pos.309 = (unsigned int) pos;
      if (D.31234 <= pos.309) goto <D.31230>; else goto <D.31231>;
      <D.31230>:
      iftmp.310 = 1;
      goto <D.31232>;
      <D.31231>:
      iftmp.310 = 0;
      <D.31232>:
      D.31235 = iftmp.310 != 0;
      D.31236 = (long int) D.31235;
      D.31237 = __builtin_expect (D.31236, 0);
      if (D.31237 != 0) goto <D.31238>; else goto <D.31239>;
      <D.31238>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 8551, "pos >= 0 && pos < jit->num_locals");
      <D.31239>:
      D.31240 = jit->locals;
      D.31223 = (long unsigned int) pos;
      D.31224 = D.31223 * 32;
      var = D.31240 + D.31224;
      D.31241 = header->locals[pos];
      D.31240 = jit->locals;
      D.31223 = (long unsigned int) pos;
      D.31224 = D.31223 * 32;
      D.31242 = D.31240 + D.31224;
      D.31227 = &frame->ctx;
      D.31185 = frame->domain;
      add_var (buf, jit, D.31241, D.31242, D.31227, D.31185, 0);
      <D.31228>:
      i = i + 1;
      <D.27330>:
      if (i < len) goto <D.27329>; else goto <D.27331>;
      <D.27331>:
      mono_metadata_free_mh (header);
      goto <D.27332>;
      <D.27333>:
      D.31184 = frame->api_method;
      D.31243 = D.31184->klass;
      D.31244 = BIT_FIELD_REF <*D.31243, 64, 256>;
      D.31245 = D.31244 & 1152921504606846976;
      if (D.31245 != 0) goto <D.31246>; else goto <D.31247>;
      <D.31246>:
      D.31248 = BIT_FIELD_REF <*sig, 64, 64>;
      D.31249 = D.31248 & 512;
      if (D.31249 == 0) goto <D.31250>; else goto <D.31251>;
      <D.31250>:
      {
        struct MonoObject * p;

        try
          {
            p = 0B;
            D.31252 = mono_defaults.object_class;
            D.31253 = &D.31252->byval_arg;
            D.31185 = frame->domain;
            buffer_add_value (buf, D.31253, &p, D.31185);
          }
        finally
          {
            p = {CLOBBER};
          }
      }
      goto <D.31254>;
      <D.31251>:
      D.31204 = frame->actual_method;
      D.31255 = D.31204->klass;
      D.31256 = &D.31255->this_arg;
      D.31257 = jit->this_var;
      D.31227 = &frame->ctx;
      D.31185 = frame->domain;
      add_var (buf, jit, D.31256, D.31257, D.31227, D.31185, 1);
      <D.31254>:
      goto <D.31258>;
      <D.31247>:
      D.31248 = BIT_FIELD_REF <*sig, 64, 64>;
      D.31249 = D.31248 & 512;
      if (D.31249 == 0) goto <D.31259>; else goto <D.31260>;
      <D.31259>:
      {
        struct MonoObject * p;

        try
          {
            p = 0B;
            D.31204 = frame->actual_method;
            D.31255 = D.31204->klass;
            D.31261 = &D.31255->byval_arg;
            D.31185 = frame->domain;
            buffer_add_value (buf, D.31261, &p, D.31185);
          }
        finally
          {
            p = {CLOBBER};
          }
      }
      goto <D.31262>;
      <D.31260>:
      D.31184 = frame->api_method;
      D.31243 = D.31184->klass;
      D.31263 = &D.31243->byval_arg;
      D.31257 = jit->this_var;
      D.31227 = &frame->ctx;
      D.31185 = frame->domain;
      add_var (buf, jit, D.31263, D.31257, D.31227, D.31185, 1);
      <D.31262>:
      <D.31258>:
      goto <D.27332>;
      <D.27336>:
      {
        guint8 * val_buf;
        struct MonoType * t;
        struct MonoDebugVarInfo * var;

        p.303 = p;
        len = decode_int (p.303, &p, end);
        D.31204 = frame->actual_method;
        header = mono_method_get_header (D.31204);
        i = 0;
        goto <D.27341>;
        <D.27340>:
        p.303 = p;
        pos = decode_int (p.303, &p, end);
        if (pos < 0) goto <D.31264>; else goto <D.31265>;
        <D.31264>:
        pos = ~pos;
        if (pos < 0) goto <D.31267>; else goto <D.31270>;
        <D.31270>:
        D.31215 = jit->num_params;
        pos.309 = (unsigned int) pos;
        if (D.31215 <= pos.309) goto <D.31267>; else goto <D.31268>;
        <D.31267>:
        iftmp.311 = 1;
        goto <D.31269>;
        <D.31268>:
        iftmp.311 = 0;
        <D.31269>:
        D.31271 = iftmp.311 != 0;
        D.31272 = (long int) D.31271;
        D.31273 = __builtin_expect (D.31272, 0);
        if (D.31273 != 0) goto <D.31274>; else goto <D.31275>;
        <D.31274>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 8593, "pos >= 0 && pos < jit->num_params");
        <D.31275>:
        t = sig->params[pos];
        D.31222 = jit->params;
        D.31223 = (long unsigned int) pos;
        D.31224 = D.31223 * 32;
        var = D.31222 + D.31224;
        goto <D.31276>;
        <D.31265>:
        if (pos < 0) goto <D.31278>; else goto <D.31281>;
        <D.31281>:
        D.31234 = jit->num_locals;
        pos.309 = (unsigned int) pos;
        if (D.31234 <= pos.309) goto <D.31278>; else goto <D.31279>;
        <D.31278>:
        iftmp.312 = 1;
        goto <D.31280>;
        <D.31279>:
        iftmp.312 = 0;
        <D.31280>:
        D.31282 = iftmp.312 != 0;
        D.31283 = (long int) D.31282;
        D.31284 = __builtin_expect (D.31283, 0);
        if (D.31284 != 0) goto <D.31285>; else goto <D.31286>;
        <D.31285>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 8598, "pos >= 0 && pos < jit->num_locals");
        <D.31286>:
        t = header->locals[pos];
        D.31240 = jit->locals;
        D.31223 = (long unsigned int) pos;
        D.31224 = D.31223 * 32;
        var = D.31240 + D.31224;
        <D.31276>:
        D.31287 = mono_type_is_reference (t);
        if (D.31287 != 0) goto <D.31288>; else goto <D.31289>;
        <D.31288>:
        val_buf = __builtin_alloca (8);
        goto <D.31290>;
        <D.31289>:
        D.31291 = mono_class_from_mono_type (t);
        D.31292 = mono_class_instance_size (D.31291);
        D.31293 = (long unsigned int) D.31292;
        val_buf = __builtin_alloca (D.31293);
        <D.31290>:
        D.31185 = frame->domain;
        p.303 = p;
        D.31294 = decode_value (t, D.31185, val_buf, p.303, &p, end);
        err = (int) D.31294;
        if (err != 0) goto <D.31295>; else goto <D.31296>;
        <D.31295>:
        D.31155 = (ErrorCode) err;
        return D.31155;
        <D.31296>:
        D.31227 = &frame->ctx;
        D.31185 = frame->domain;
        D.31297 = &frame->reg_locations;
        D.31298 = &tls->restore_ctx;
        set_var (t, var, D.31227, D.31185, val_buf, D.31297, D.31298);
        i = i + 1;
        <D.27341>:
        if (i < len) goto <D.27340>; else goto <D.27342>;
        <D.27342>:
        mono_metadata_free_mh (header);
        goto <D.27332>;
      }
      <D.27343>:
      D.31155 = 100;
      return D.31155;
      <D.27332>:
      D.31155 = 0;
      return D.31155;
    }
  finally
    {
      thread_obj = {CLOBBER};
    }
}


add_var (struct Buffer * buf, struct MonoDebugMethodJitInfo * jit, struct MonoType * t, struct MonoDebugVarInfo * var, struct MonoContext * ctx, struct MonoDomain * domain, gboolean as_vtype)
{
  unsigned int D.31301;
  int D.31302;
  long int reg_val.313;
  long int D.31304;
  unsigned int D.31305;
  int D.31306;
  sizetype D.31307;
  long int D.31308;
  _Bool D.31309;
  long int D.31310;
  long int D.31311;
  _Bool D.31314;
  long int D.31315;
  long int D.31316;
  _Bool D.31319;
  long int D.31320;
  long int D.31321;
  unsigned int D.31324;
  int D.31325;
  long int D.31328;
  unsigned int D.31329;
  int D.31330;
  sizetype D.31331;
  long int D.31335;
  _Bool D.31337;
  long int D.31338;
  long int D.31339;
  unsigned int D.31342;
  int D.31343;
  long int D.31346;
  unsigned int D.31347;
  int D.31348;
  sizetype D.31349;
  long int D.31353;
  _Bool D.31355;
  long int D.31356;
  long int D.31357;
  void * D.31360;
  long int D.31361;
  int D.31362;
  sizetype D.31363;
  guint32 flags;
  int reg;
  guint8 * addr;
  guint8 * gaddr;
  mgreg_t reg_val;

  try
    {
      D.31301 = var->index;
      flags = D.31301 & 4026531840;
      D.31301 = var->index;
      D.31302 = (int) D.31301;
      reg = D.31302 & 268435455;
      switch (flags) <default: <D.26514>, case 0: <D.26502>, case 268435456: <D.26504>, case 805306368: <D.26505>, case 1073741824: <D.26506>, case 1342177280: <D.26508>, case 1610612736: <D.26507>>
      <D.26502>:
      reg_val.313 = mono_arch_context_get_int_reg (ctx, reg);
      reg_val = reg_val.313;
      buffer_add_value_full (buf, t, &reg_val, domain, as_vtype);
      goto <D.26503>;
      <D.26504>:
      D.31304 = mono_arch_context_get_int_reg (ctx, reg);
      addr = (guint8 *) D.31304;
      D.31305 = var->offset;
      D.31306 = (int) D.31305;
      D.31307 = (sizetype) D.31306;
      addr = addr + D.31307;
      buffer_add_value_full (buf, t, addr, domain, as_vtype);
      goto <D.26503>;
      <D.26505>:
      monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "debugger-agent.c", 5939);
      <D.26506>:
      <D.26507>:
      D.31308 = mono_arch_context_get_int_reg (ctx, reg);
      addr = (guint8 *) D.31308;
      D.31305 = var->offset;
      D.31306 = (int) D.31305;
      D.31307 = (sizetype) D.31306;
      addr = addr + D.31307;
      gaddr = MEM[(void * *)addr];
      D.31309 = gaddr == 0B;
      D.31310 = (long int) D.31309;
      D.31311 = __builtin_expect (D.31310, 0);
      if (D.31311 != 0) goto <D.31312>; else goto <D.31313>;
      <D.31312>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 5948, "gaddr");
      <D.31313>:
      buffer_add_value_full (buf, t, gaddr, domain, as_vtype);
      goto <D.26503>;
      <D.26508>:
      {
        struct MonoDebugVarInfo * info_var;
        struct MonoDebugVarInfo * locals_var;
        struct MonoGSharedVtMethodRuntimeInfo * info;
        guint8 * locals;
        int idx;

        info_var = jit->gsharedvt_info_var;
        locals_var = jit->gsharedvt_locals_var;
        idx = reg;
        D.31314 = info_var == 0B;
        D.31315 = (long int) D.31314;
        D.31316 = __builtin_expect (D.31315, 0);
        if (D.31316 != 0) goto <D.31317>; else goto <D.31318>;
        <D.31317>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 5960, "info_var");
        <D.31318>:
        D.31319 = locals_var == 0B;
        D.31320 = (long int) D.31319;
        D.31321 = __builtin_expect (D.31320, 0);
        if (D.31321 != 0) goto <D.31322>; else goto <D.31323>;
        <D.31322>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 5961, "locals_var");
        <D.31323>:
        D.31324 = info_var->index;
        flags = D.31324 & 4026531840;
        D.31324 = info_var->index;
        D.31325 = (int) D.31324;
        reg = D.31325 & 268435455;
        if (flags == 268435456) goto <D.31326>; else goto <D.31327>;
        <D.31326>:
        D.31328 = mono_arch_context_get_int_reg (ctx, reg);
        addr = (guint8 *) D.31328;
        D.31329 = info_var->offset;
        D.31330 = (int) D.31329;
        D.31331 = (sizetype) D.31330;
        addr = addr + D.31331;
        info = MEM[(void * *)addr];
        goto <D.31332>;
        <D.31327>:
        if (flags == 0) goto <D.31333>; else goto <D.31334>;
        <D.31333>:
        D.31335 = mono_arch_context_get_int_reg (ctx, reg);
        info = (struct MonoGSharedVtMethodRuntimeInfo *) D.31335;
        goto <D.31336>;
        <D.31334>:
        monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "debugger-agent.c", 5972);
        <D.31336>:
        <D.31332>:
        D.31337 = info == 0B;
        D.31338 = (long int) D.31337;
        D.31339 = __builtin_expect (D.31338, 0);
        if (D.31339 != 0) goto <D.31340>; else goto <D.31341>;
        <D.31340>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 5974, "info");
        <D.31341>:
        D.31342 = locals_var->index;
        flags = D.31342 & 4026531840;
        D.31342 = locals_var->index;
        D.31343 = (int) D.31342;
        reg = D.31343 & 268435455;
        if (flags == 268435456) goto <D.31344>; else goto <D.31345>;
        <D.31344>:
        D.31346 = mono_arch_context_get_int_reg (ctx, reg);
        addr = (guint8 *) D.31346;
        D.31347 = locals_var->offset;
        D.31348 = (int) D.31347;
        D.31349 = (sizetype) D.31348;
        addr = addr + D.31349;
        locals = MEM[(void * *)addr];
        goto <D.31350>;
        <D.31345>:
        if (flags == 0) goto <D.31351>; else goto <D.31352>;
        <D.31351>:
        D.31353 = mono_arch_context_get_int_reg (ctx, reg);
        locals = (guint8 *) D.31353;
        goto <D.31354>;
        <D.31352>:
        monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "debugger-agent.c", 5985);
        <D.31354>:
        <D.31350>:
        D.31355 = locals == 0B;
        D.31356 = (long int) D.31355;
        D.31357 = __builtin_expect (D.31356, 0);
        if (D.31357 != 0) goto <D.31358>; else goto <D.31359>;
        <D.31358>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 5987, "locals");
        <D.31359>:
        D.31360 = info->entries[idx];
        D.31361 = (long int) D.31360;
        D.31362 = (int) D.31361;
        D.31363 = (sizetype) D.31362;
        addr = locals + D.31363;
        buffer_add_value_full (buf, t, addr, domain, as_vtype);
        goto <D.26503>;
      }
      <D.26514>:
      monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "debugger-agent.c", 5996);
      <D.26503>:
    }
  finally
    {
      reg_val = {CLOBBER};
    }
}


set_var (struct MonoType * t, struct MonoDebugVarInfo * var, struct MonoContext * ctx, struct MonoDomain * domain, guint8 * val, mgreg_t * * reg_locations, struct MonoContext * restore_ctx)
{
  unsigned int D.31364;
  int D.31365;
  int D.31366;
  struct MonoClass * D.31370;
  long unsigned int D.31371;
  long unsigned int D.31372;
  long int D.31375;
  long unsigned int D.31378;
  unsigned char D.31383;
  mgreg_t iftmp.314;
  signed char D.31390;
  unsigned char D.31392;
  mgreg_t iftmp.315;
  short int D.31396;
  short unsigned int D.31398;
  int D.31399;
  unsigned int D.31400;
  long unsigned int D.31401;
  long unsigned int D.31402;
  mgreg_t * * D.31403;
  mgreg_t * D.31404;
  int log_level.316;
  _Bool D.31408;
  long int D.31409;
  long int D.31410;
  struct FILE * log_file.317;
  void * v.318;
  long int D.31418;
  unsigned int D.31419;
  int D.31420;
  sizetype D.31421;
  long int D.31425;
  _Bool D.31426;
  long int D.31427;
  long int D.31428;
  guint32 flags;
  int reg;
  int size;
  guint8 * addr;
  guint8 * gaddr;

  D.31364 = var->index;
  flags = D.31364 & 4026531840;
  D.31364 = var->index;
  D.31365 = (int) D.31364;
  reg = D.31365 & 268435455;
  D.31366 = mono_type_is_reference (t);
  if (D.31366 != 0) goto <D.31367>; else goto <D.31368>;
  <D.31367>:
  size = 8;
  goto <D.31369>;
  <D.31368>:
  D.31370 = mono_class_from_mono_type (t);
  size = mono_class_value_size (D.31370, 0B);
  <D.31369>:
  switch (flags) <default: <D.26542>, case 0: <D.26529>, case 268435456: <D.26539>, case 805306368: <D.26541>, case 1073741824: <D.26540>>
  <D.26529>:
  {
    mgreg_t v;
    gboolean is_signed;

    is_signed = 0;
    D.31371 = BIT_FIELD_REF <*t, 64, 64>;
    D.31372 = D.31371 & 8589934592;
    if (D.31372 != 0) goto <D.31373>; else goto <D.31374>;
    <D.31373>:
    D.31375 = mono_arch_context_get_int_reg (ctx, reg);
    addr = (guint8 *) D.31375;
    if (addr != 0B) goto <D.31376>; else goto <D.31377>;
    <D.31376>:
    D.31378 = (long unsigned int) size;
    mono_gc_memmove_atomic (addr, val, D.31378);
    <D.31377>:
    goto <D.26532>;
    <D.31374>:
    D.31371 = BIT_FIELD_REF <*t, 64, 64>;
    D.31372 = D.31371 & 8589934592;
    if (D.31372 == 0) goto <D.31381>; else goto <D.31382>;
    <D.31381>:
    D.31383 = t->type;
    if (D.31383 == 4) goto <D.31379>; else goto <D.31384>;
    <D.31384>:
    D.31383 = t->type;
    if (D.31383 == 6) goto <D.31379>; else goto <D.31385>;
    <D.31385>:
    D.31383 = t->type;
    if (D.31383 == 8) goto <D.31379>; else goto <D.31386>;
    <D.31386>:
    D.31383 = t->type;
    if (D.31383 == 10) goto <D.31379>; else goto <D.31380>;
    <D.31379>:
    is_signed = 1;
    <D.31380>:
    <D.31382>:
    switch (size) <default: <D.26538>, case 1: <D.26533>, case 2: <D.26535>, case 4: <D.26536>, case 8: <D.26537>>
    <D.26533>:
    if (is_signed != 0) goto <D.31388>; else goto <D.31389>;
    <D.31388>:
    D.31390 = MEM[(gint8 *)val];
    iftmp.314 = (mgreg_t) D.31390;
    goto <D.31391>;
    <D.31389>:
    D.31392 = *val;
    iftmp.314 = (mgreg_t) D.31392;
    <D.31391>:
    v = iftmp.314;
    goto <D.26534>;
    <D.26535>:
    if (is_signed != 0) goto <D.31394>; else goto <D.31395>;
    <D.31394>:
    D.31396 = MEM[(gint16 *)val];
    iftmp.315 = (mgreg_t) D.31396;
    goto <D.31397>;
    <D.31395>:
    D.31398 = MEM[(guint16 *)val];
    iftmp.315 = (mgreg_t) D.31398;
    <D.31397>:
    v = iftmp.315;
    goto <D.26534>;
    <D.26536>:
    D.31399 = MEM[(gint32 *)val];
    D.31400 = (unsigned int) D.31399;
    v = (mgreg_t) D.31400;
    goto <D.26534>;
    <D.26537>:
    v = MEM[(gint64 *)val];
    goto <D.26534>;
    <D.26538>:
    monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "debugger-agent.c", 6048);
    <D.26534>:
    D.31401 = (long unsigned int) reg;
    D.31402 = D.31401 * 8;
    D.31403 = reg_locations + D.31402;
    D.31404 = *D.31403;
    if (D.31404 != 0B) goto <D.31405>; else goto <D.31406>;
    <D.31405>:
    log_level.316 = log_level;
    D.31408 = log_level.316 > 0;
    D.31409 = (long int) D.31408;
    D.31410 = __builtin_expect (D.31409, 0);
    if (D.31410 != 0) goto <D.31411>; else goto <D.31412>;
    <D.31411>:
    log_file.317 = log_file;
    D.31401 = (long unsigned int) reg;
    D.31402 = D.31401 * 8;
    D.31403 = reg_locations + D.31402;
    D.31404 = *D.31403;
    v.318 = (void *) v;
    fprintf (log_file.317, "[dbg] Setting stack location %p for reg %x to %p.\n", D.31404, reg, v.318);
    log_file.317 = log_file;
    fflush (log_file.317);
    <D.31412>:
    D.31401 = (long unsigned int) reg;
    D.31402 = D.31401 * 8;
    D.31403 = reg_locations + D.31402;
    D.31404 = *D.31403;
    *D.31404 = v;
    goto <D.31415>;
    <D.31406>:
    log_level.316 = log_level;
    D.31408 = log_level.316 > 0;
    D.31409 = (long int) D.31408;
    D.31410 = __builtin_expect (D.31409, 0);
    if (D.31410 != 0) goto <D.31416>; else goto <D.31417>;
    <D.31416>:
    log_file.317 = log_file;
    v.318 = (void *) v;
    fprintf (log_file.317, "[dbg] Setting context location for reg %x to %p.\n", reg, v.318);
    log_file.317 = log_file;
    fflush (log_file.317);
    <D.31417>:
    mono_arch_context_set_int_reg (restore_ctx, reg, v);
    <D.31415>:
    mono_arch_context_set_int_reg (ctx, reg, v);
    goto <D.26532>;
  }
  <D.26539>:
  D.31418 = mono_arch_context_get_int_reg (ctx, reg);
  addr = (guint8 *) D.31418;
  D.31419 = var->offset;
  D.31420 = (int) D.31419;
  D.31421 = (sizetype) D.31420;
  addr = addr + D.31421;
  D.31371 = BIT_FIELD_REF <*t, 64, 64>;
  D.31372 = D.31371 & 8589934592;
  if (D.31372 != 0) goto <D.31422>; else goto <D.31423>;
  <D.31422>:
  addr = MEM[(guint8 * *)addr];
  if (addr == 0B) goto <D.26532>; else goto <D.31424>;
  <D.31424>:
  <D.31423>:
  D.31378 = (long unsigned int) size;
  mono_gc_memmove_atomic (addr, val, D.31378);
  goto <D.26532>;
  <D.26540>:
  D.31425 = mono_arch_context_get_int_reg (ctx, reg);
  addr = (guint8 *) D.31425;
  D.31419 = var->offset;
  D.31420 = (int) D.31419;
  D.31421 = (sizetype) D.31420;
  addr = addr + D.31421;
  gaddr = MEM[(void * *)addr];
  D.31426 = gaddr == 0B;
  D.31427 = (long int) D.31426;
  D.31428 = __builtin_expect (D.31427, 0);
  if (D.31428 != 0) goto <D.31429>; else goto <D.31430>;
  <D.31429>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 6092, "gaddr");
  <D.31430>:
  D.31378 = (long unsigned int) size;
  mono_gc_memmove_atomic (gaddr, val, D.31378);
  goto <D.26532>;
  <D.26541>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "debugger-agent.c", 6097);
  <D.26542>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "debugger-agent.c", 6100);
  <D.26532>:
}


array_commands (int command, guint8 * p, guint8 * end, struct Buffer * buf)
{
  guint8 * p.319;
  <unnamed type> D.31432;
  ErrorCode D.31435;
  struct MonoArray * arr.320;
  struct MonoVTable * D.31437;
  struct MonoClass * D.31438;
  unsigned char D.31439;
  unsigned int D.31440;
  struct MonoArrayBounds * D.31441;
  unsigned int D.31444;
  long unsigned int D.31446;
  long unsigned int D.31447;
  struct MonoArrayBounds * D.31448;
  unsigned int D.31449;
  int D.31450;
  unsigned int D.31451;
  int D.31452;
  int iftmp.321;
  _Bool D.31458;
  long int D.31459;
  long int D.31460;
  unsigned int len.322;
  unsigned int D.31464;
  unsigned int index.323;
  _Bool D.31466;
  long int D.31467;
  long int D.31468;
  double[0:] * D.31471;
  int D.31472;
  sizetype D.31473;
  struct MonoClass * D.31474;
  struct MonoType * D.31475;
  struct MonoDomain * D.31476;
  int D.31477;
  int iftmp.324;
  _Bool D.31483;
  long int D.31484;
  long int D.31485;
  struct MonoArray * arr;
  int objid;
  int err;
  int index;
  int len;
  int i;
  int esize;
  void * elem;

  try
    {
      p.319 = p;
      objid = decode_objid (p.319, &p, end);
      D.31432 = get_object (objid, &arr);
      err = (int) D.31432;
      if (err != 0) goto <D.31433>; else goto <D.31434>;
      <D.31433>:
      D.31435 = (ErrorCode) err;
      return D.31435;
      <D.31434>:
      switch (command) <default: <D.27371>, case 1: <D.27358>, case 2: <D.27363>, case 3: <D.27367>>
      <D.27358>:
      arr.320 = arr;
      D.31437 = arr.320->obj.vtable;
      D.31438 = D.31437->klass;
      D.31439 = D.31438->rank;
      D.31440 = (unsigned int) D.31439;
      buffer_add_int (buf, D.31440);
      arr.320 = arr;
      D.31441 = arr.320->bounds;
      if (D.31441 == 0B) goto <D.31442>; else goto <D.31443>;
      <D.31442>:
      arr.320 = arr;
      D.31444 = arr.320->max_length;
      buffer_add_int (buf, D.31444);
      buffer_add_int (buf, 0);
      goto <D.31445>;
      <D.31443>:
      i = 0;
      goto <D.27360>;
      <D.27359>:
      arr.320 = arr;
      D.31441 = arr.320->bounds;
      D.31446 = (long unsigned int) i;
      D.31447 = D.31446 * 8;
      D.31448 = D.31441 + D.31447;
      D.31449 = D.31448->length;
      buffer_add_int (buf, D.31449);
      arr.320 = arr;
      D.31441 = arr.320->bounds;
      D.31446 = (long unsigned int) i;
      D.31447 = D.31446 * 8;
      D.31448 = D.31441 + D.31447;
      D.31450 = D.31448->lower_bound;
      D.31451 = (unsigned int) D.31450;
      buffer_add_int (buf, D.31451);
      i = i + 1;
      <D.27360>:
      arr.320 = arr;
      D.31437 = arr.320->obj.vtable;
      D.31438 = D.31437->klass;
      D.31439 = D.31438->rank;
      D.31452 = (int) D.31439;
      if (D.31452 > i) goto <D.27359>; else goto <D.27361>;
      <D.27361>:
      <D.31445>:
      goto <D.27362>;
      <D.27363>:
      p.319 = p;
      index = decode_int (p.319, &p, end);
      p.319 = p;
      len = decode_int (p.319, &p, end);
      if (index < 0) goto <D.31454>; else goto <D.31457>;
      <D.31457>:
      if (len < 0) goto <D.31454>; else goto <D.31455>;
      <D.31454>:
      iftmp.321 = 1;
      goto <D.31456>;
      <D.31455>:
      iftmp.321 = 0;
      <D.31456>:
      D.31458 = iftmp.321 != 0;
      D.31459 = (long int) D.31458;
      D.31460 = __builtin_expect (D.31459, 0);
      if (D.31460 != 0) goto <D.31461>; else goto <D.31462>;
      <D.31461>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 8653, "index >= 0 && len >= 0");
      <D.31462>:
      arr.320 = arr;
      D.31444 = arr.320->max_length;
      len.322 = (unsigned int) len;
      D.31464 = D.31444 - len.322;
      index.323 = (unsigned int) index;
      D.31466 = D.31464 < index.323;
      D.31467 = (long int) D.31466;
      D.31468 = __builtin_expect (D.31467, 0);
      if (D.31468 != 0) goto <D.31469>; else goto <D.31470>;
      <D.31469>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 8655, "!(index > arr->max_length - len)");
      <D.31470>:
      arr.320 = arr;
      D.31437 = arr.320->obj.vtable;
      D.31438 = D.31437->klass;
      esize = mono_array_element_size (D.31438);
      i = index;
      goto <D.27365>;
      <D.27364>:
      arr.320 = arr;
      D.31471 = &arr.320->vector;
      D.31472 = i * esize;
      D.31473 = (sizetype) D.31472;
      elem = D.31471 + D.31473;
      arr.320 = arr;
      D.31437 = arr.320->obj.vtable;
      D.31438 = D.31437->klass;
      D.31474 = D.31438->element_class;
      D.31475 = &D.31474->byval_arg;
      arr.320 = arr;
      D.31437 = arr.320->obj.vtable;
      D.31476 = D.31437->domain;
      buffer_add_value (buf, D.31475, elem, D.31476);
      i = i + 1;
      <D.27365>:
      D.31477 = index + len;
      if (D.31477 > i) goto <D.27364>; else goto <D.27366>;
      <D.27366>:
      goto <D.27362>;
      <D.27367>:
      p.319 = p;
      index = decode_int (p.319, &p, end);
      p.319 = p;
      len = decode_int (p.319, &p, end);
      if (index < 0) goto <D.31479>; else goto <D.31482>;
      <D.31482>:
      if (len < 0) goto <D.31479>; else goto <D.31480>;
      <D.31479>:
      iftmp.324 = 1;
      goto <D.31481>;
      <D.31480>:
      iftmp.324 = 0;
      <D.31481>:
      D.31483 = iftmp.324 != 0;
      D.31484 = (long int) D.31483;
      D.31485 = __builtin_expect (D.31484, 0);
      if (D.31485 != 0) goto <D.31486>; else goto <D.31487>;
      <D.31486>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 8667, "index >= 0 && len >= 0");
      <D.31487>:
      arr.320 = arr;
      D.31444 = arr.320->max_length;
      len.322 = (unsigned int) len;
      D.31464 = D.31444 - len.322;
      index.323 = (unsigned int) index;
      D.31466 = D.31464 < index.323;
      D.31467 = (long int) D.31466;
      D.31468 = __builtin_expect (D.31467, 0);
      if (D.31468 != 0) goto <D.31488>; else goto <D.31489>;
      <D.31488>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 8669, "!(index > arr->max_length - len)");
      <D.31489>:
      arr.320 = arr;
      D.31437 = arr.320->obj.vtable;
      D.31438 = D.31437->klass;
      esize = mono_array_element_size (D.31438);
      i = index;
      goto <D.27369>;
      <D.27368>:
      arr.320 = arr;
      D.31471 = &arr.320->vector;
      D.31472 = i * esize;
      D.31473 = (sizetype) D.31472;
      elem = D.31471 + D.31473;
      arr.320 = arr;
      D.31437 = arr.320->obj.vtable;
      D.31438 = D.31437->klass;
      D.31474 = D.31438->element_class;
      D.31475 = &D.31474->byval_arg;
      arr.320 = arr;
      D.31437 = arr.320->obj.vtable;
      D.31476 = D.31437->domain;
      p.319 = p;
      decode_value (D.31475, D.31476, elem, p.319, &p, end);
      i = i + 1;
      <D.27369>:
      D.31477 = index + len;
      if (D.31477 > i) goto <D.27368>; else goto <D.27370>;
      <D.27370>:
      goto <D.27362>;
      <D.27371>:
      D.31435 = 100;
      return D.31435;
      <D.27362>:
      D.31435 = 0;
      return D.31435;
    }
  finally
    {
      arr = {CLOBBER};
    }
}


string_commands (int command, guint8 * p, guint8 * end, struct Buffer * buf)
{
  guint8 * p.325;
  <unnamed type> D.31493;
  ErrorCode D.31496;
  struct MonoString * str.326;
  int D.31498;
  long unsigned int D.31499;
  long int D.31500;
  long int D.31501;
  int D.31502;
  int D.31503;
  mono_unichar2 * D.31506;
  long unsigned int D.31507;
  long unsigned int D.31508;
  long unsigned int D.31509;
  long unsigned int D.31510;
  gunichar2 * D.31511;
  short unsigned int D.31512;
  unsigned int D.31513;
  int objid;
  int err;
  struct MonoString * str;
  char * s;
  int i;
  int index;
  int length;
  gunichar2 * c;

  try
    {
      p.325 = p;
      objid = decode_objid (p.325, &p, end);
      D.31493 = get_object (objid, &str);
      err = (int) D.31493;
      if (err != 0) goto <D.31494>; else goto <D.31495>;
      <D.31494>:
      D.31496 = (ErrorCode) err;
      return D.31496;
      <D.31495>:
      switch (command) <default: <D.27393>, case 1: <D.27386>, case 2: <D.27388>, case 3: <D.27389>>
      <D.27386>:
      str.326 = str;
      s = mono_string_to_utf8 (str.326);
      buffer_add_string (buf, s);
      monoeg_g_free (s);
      goto <D.27387>;
      <D.27388>:
      str.326 = str;
      D.31498 = mono_string_length (str.326);
      D.31499 = (long unsigned int) D.31498;
      buffer_add_long (buf, D.31499);
      goto <D.27387>;
      <D.27389>:
      p.325 = p;
      D.31500 = decode_long (p.325, &p, end);
      index = (int) D.31500;
      p.325 = p;
      D.31501 = decode_long (p.325, &p, end);
      length = (int) D.31501;
      str.326 = str;
      D.31502 = mono_string_length (str.326);
      D.31503 = D.31502 - length;
      if (D.31503 < index) goto <D.31504>; else goto <D.31505>;
      <D.31504>:
      D.31496 = 102;
      return D.31496;
      <D.31505>:
      str.326 = str;
      D.31506 = mono_string_chars (str.326);
      D.31507 = (long unsigned int) index;
      D.31508 = D.31507 * 2;
      c = D.31506 + D.31508;
      i = 0;
      goto <D.27391>;
      <D.27390>:
      D.31509 = (long unsigned int) i;
      D.31510 = D.31509 * 2;
      D.31511 = c + D.31510;
      D.31512 = *D.31511;
      D.31513 = (unsigned int) D.31512;
      buffer_add_short (buf, D.31513);
      i = i + 1;
      <D.27391>:
      if (i < length) goto <D.27390>; else goto <D.27392>;
      <D.27392>:
      goto <D.27387>;
      <D.27393>:
      D.31496 = 100;
      return D.31496;
      <D.27387>:
      D.31496 = 0;
      return D.31496;
    }
  finally
    {
      str = {CLOBBER};
    }
}


buffer_add_short (struct Buffer * buf, guint32 val)
{
  guint8 * D.31516;
  unsigned int D.31517;
  unsigned char D.31518;
  guint8 * D.31519;
  unsigned char D.31520;
  guint8 * D.31521;

  buffer_make_room (buf, 2);
  D.31516 = buf->p;
  D.31517 = val >> 8;
  D.31518 = (unsigned char) D.31517;
  *D.31516 = D.31518;
  D.31516 = buf->p;
  D.31519 = D.31516 + 1;
  D.31520 = (unsigned char) val;
  *D.31519 = D.31520;
  D.31516 = buf->p;
  D.31521 = D.31516 + 2;
  buf->p = D.31521;
}


object_commands (int command, guint8 * p, guint8 * end, struct Buffer * buf)
{
  guint8 * p.327;
  <unnamed type> D.31525;
  int err.328;
  int err.329;
  ErrorCode D.31531;
  <unnamed type> D.31532;
  int err.330;
  struct MonoObject * obj.331;
  struct MonoVTable * D.31537;
  struct MonoDomain * D.31538;
  void * D.31539;
  struct MonoType * D.31540;
  struct MonoClass * D.31541;
  struct MonoClass * D.31544;
  struct MonoType * D.31549;
  short unsigned int D.31550;
  int D.31551;
  int D.31552;
  int D.31555;
  _Bool D.31558;
  long int D.31559;
  long int D.31560;
  struct MonoClass * D.31563;
  int D.31564;
  long unsigned int D.31565;
  int D.31567;
  sizetype D.31568;
  void * D.31569;
  struct MonoClass * D.31572;
  struct MonoType * D.31577;
  short unsigned int D.31578;
  int D.31579;
  int D.31580;
  int D.31583;
  _Bool D.31586;
  long int D.31587;
  long int D.31588;
  struct MonoClass * D.31591;
  int D.31592;
  long unsigned int D.31593;
  <unnamed type> D.31594;
  int err.332;
  int D.31599;
  sizetype D.31600;
  guint8 * D.31601;
  <unnamed type> D.31602;
  int err.333;
  long unsigned int obj.334;
  struct MonoClass * D.31607;
  int objid;
  int err;
  struct MonoObject * obj;
  int len;
  int i;
  struct MonoClassField * f;
  struct MonoClass * k;
  gboolean found;

  try
    {
      if (command == 3) goto <D.31522>; else goto <D.31523>;
      <D.31522>:
      p.327 = p;
      objid = decode_objid (p.327, &p, end);
      D.31525 = get_object (objid, &obj);
      err.328 = (int) D.31525;
      err = err.328;
      err.329 = err;
      if (err.329 != 0) goto <D.31528>; else goto <D.31529>;
      <D.31528>:
      buffer_add_int (buf, 1);
      goto <D.31530>;
      <D.31529>:
      buffer_add_int (buf, 0);
      <D.31530>:
      D.31531 = 0;
      return D.31531;
      <D.31523>:
      p.327 = p;
      objid = decode_objid (p.327, &p, end);
      D.31532 = get_object (objid, &obj);
      err.330 = (int) D.31532;
      err = err.330;
      err.329 = err;
      if (err.329 != 0) goto <D.31534>; else goto <D.31535>;
      <D.31534>:
      err.329 = err;
      D.31531 = (ErrorCode) err.329;
      return D.31531;
      <D.31535>:
      switch (command) <default: <D.27432>, case 1: <D.27408>, case 2: <D.27410>, case 4: <D.27429>, case 5: <D.27430>, case 6: <D.27420>, case 7: <D.27431>>
      <D.27408>:
      obj.331 = obj;
      D.31537 = obj.331->vtable;
      D.31538 = D.31537->domain;
      obj.331 = obj;
      D.31537 = obj.331->vtable;
      D.31539 = D.31537->type;
      D.31540 = MEM[(struct MonoReflectionType *)D.31539].type;
      D.31541 = mono_class_from_mono_type (D.31540);
      buffer_add_typeid (buf, D.31538, D.31541);
      goto <D.27409>;
      <D.27410>:
      p.327 = p;
      len = decode_int (p.327, &p, end);
      i = 0;
      goto <D.27418>;
      <D.27417>:
      {
        struct MonoClassField * f;

        p.327 = p;
        f = decode_fieldid (p.327, &p, end, 0B, &err);
        err.329 = err;
        if (err.329 != 0) goto <D.31542>; else goto <D.31543>;
        <D.31542>:
        err.329 = err;
        D.31531 = (ErrorCode) err.329;
        return D.31531;
        <D.31543>:
        found = 0;
        obj.331 = obj;
        D.31537 = obj.331->vtable;
        k = D.31537->klass;
        goto <D.27414>;
        <D.27413>:
        D.31544 = f->parent;
        if (D.31544 == k) goto <D.31545>; else goto <D.31546>;
        <D.31545>:
        found = 1;
        goto <D.27412>;
        <D.31546>:
        k = k->parent;
        <D.27414>:
        if (k != 0B) goto <D.27413>; else goto <D.27412>;
        <D.27412>:
        if (found == 0) goto <D.31547>; else goto <D.31548>;
        <D.31547>:
        D.31531 = 25;
        return D.31531;
        <D.31548>:
        D.31549 = f->type;
        D.31550 = D.31549->attrs;
        D.31551 = (int) D.31550;
        D.31552 = D.31551 & 16;
        if (D.31552 != 0) goto <D.31553>; else goto <D.31554>;
        <D.31553>:
        {
          guint8 * val;
          struct MonoVTable * vtable;

          D.31555 = mono_class_field_is_special_static (f);
          if (D.31555 != 0) goto <D.31556>; else goto <D.31557>;
          <D.31556>:
          D.31531 = 25;
          return D.31531;
          <D.31557>:
          D.31549 = f->type;
          D.31550 = D.31549->attrs;
          D.31551 = (int) D.31550;
          D.31552 = D.31551 & 16;
          D.31558 = D.31552 == 0;
          D.31559 = (long int) D.31558;
          D.31560 = __builtin_expect (D.31559, 0);
          if (D.31560 != 0) goto <D.31561>; else goto <D.31562>;
          <D.31561>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 8780, "f->type->attrs & FIELD_ATTRIBUTE_STATIC");
          <D.31562>:
          obj.331 = obj;
          D.31537 = obj.331->vtable;
          D.31538 = D.31537->domain;
          D.31544 = f->parent;
          vtable = mono_class_vtable (D.31538, D.31544);
          D.31549 = f->type;
          D.31563 = mono_class_from_mono_type (D.31549);
          D.31564 = mono_class_instance_size (D.31563);
          D.31565 = (long unsigned int) D.31564;
          val = monoeg_malloc (D.31565);
          mono_field_static_get_value (vtable, f, val);
          D.31549 = f->type;
          obj.331 = obj;
          D.31537 = obj.331->vtable;
          D.31538 = D.31537->domain;
          buffer_add_value (buf, D.31549, val, D.31538);
          monoeg_g_free (val);
        }
        goto <D.31566>;
        <D.31554>:
        D.31549 = f->type;
        obj.331 = obj;
        D.31567 = f->offset;
        D.31568 = (sizetype) D.31567;
        D.31569 = obj.331 + D.31568;
        obj.331 = obj;
        D.31537 = obj.331->vtable;
        D.31538 = D.31537->domain;
        buffer_add_value (buf, D.31549, D.31569, D.31538);
        <D.31566>:
      }
      i = i + 1;
      <D.27418>:
      if (i < len) goto <D.27417>; else goto <D.27419>;
      <D.27419>:
      goto <D.27409>;
      <D.27420>:
      p.327 = p;
      len = decode_int (p.327, &p, end);
      i = 0;
      goto <D.27427>;
      <D.27426>:
      p.327 = p;
      f = decode_fieldid (p.327, &p, end, 0B, &err);
      err.329 = err;
      if (err.329 != 0) goto <D.31570>; else goto <D.31571>;
      <D.31570>:
      err.329 = err;
      D.31531 = (ErrorCode) err.329;
      return D.31531;
      <D.31571>:
      found = 0;
      obj.331 = obj;
      D.31537 = obj.331->vtable;
      k = D.31537->klass;
      goto <D.27423>;
      <D.27422>:
      D.31572 = f->parent;
      if (D.31572 == k) goto <D.31573>; else goto <D.31574>;
      <D.31573>:
      found = 1;
      goto <D.27421>;
      <D.31574>:
      k = k->parent;
      <D.27423>:
      if (k != 0B) goto <D.27422>; else goto <D.27421>;
      <D.27421>:
      if (found == 0) goto <D.31575>; else goto <D.31576>;
      <D.31575>:
      D.31531 = 25;
      return D.31531;
      <D.31576>:
      D.31577 = f->type;
      D.31578 = D.31577->attrs;
      D.31579 = (int) D.31578;
      D.31580 = D.31579 & 16;
      if (D.31580 != 0) goto <D.31581>; else goto <D.31582>;
      <D.31581>:
      {
        guint8 * val;
        struct MonoVTable * vtable;

        D.31583 = mono_class_field_is_special_static (f);
        if (D.31583 != 0) goto <D.31584>; else goto <D.31585>;
        <D.31584>:
        D.31531 = 25;
        return D.31531;
        <D.31585>:
        D.31577 = f->type;
        D.31578 = D.31577->attrs;
        D.31579 = (int) D.31578;
        D.31580 = D.31579 & 16;
        D.31586 = D.31580 == 0;
        D.31587 = (long int) D.31586;
        D.31588 = __builtin_expect (D.31587, 0);
        if (D.31588 != 0) goto <D.31589>; else goto <D.31590>;
        <D.31589>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 8817, "f->type->attrs & FIELD_ATTRIBUTE_STATIC");
        <D.31590>:
        obj.331 = obj;
        D.31537 = obj.331->vtable;
        D.31538 = D.31537->domain;
        D.31572 = f->parent;
        vtable = mono_class_vtable (D.31538, D.31572);
        D.31577 = f->type;
        D.31591 = mono_class_from_mono_type (D.31577);
        D.31592 = mono_class_instance_size (D.31591);
        D.31593 = (long unsigned int) D.31592;
        val = monoeg_malloc (D.31593);
        D.31577 = f->type;
        obj.331 = obj;
        D.31537 = obj.331->vtable;
        D.31538 = D.31537->domain;
        p.327 = p;
        D.31594 = decode_value (D.31577, D.31538, val, p.327, &p, end);
        err.332 = (int) D.31594;
        err = err.332;
        err.329 = err;
        if (err.329 != 0) goto <D.31596>; else goto <D.31597>;
        <D.31596>:
        monoeg_g_free (val);
        err.329 = err;
        D.31531 = (ErrorCode) err.329;
        return D.31531;
        <D.31597>:
        mono_field_static_set_value (vtable, f, val);
        monoeg_g_free (val);
      }
      goto <D.31598>;
      <D.31582>:
      D.31577 = f->type;
      obj.331 = obj;
      D.31537 = obj.331->vtable;
      D.31538 = D.31537->domain;
      obj.331 = obj;
      D.31599 = f->offset;
      D.31600 = (sizetype) D.31599;
      D.31601 = obj.331 + D.31600;
      p.327 = p;
      D.31602 = decode_value (D.31577, D.31538, D.31601, p.327, &p, end);
      err.333 = (int) D.31602;
      err = err.333;
      err.329 = err;
      if (err.329 != 0) goto <D.31604>; else goto <D.31605>;
      <D.31604>:
      err.329 = err;
      D.31531 = (ErrorCode) err.329;
      return D.31531;
      <D.31605>:
      <D.31598>:
      i = i + 1;
      <D.27427>:
      if (i < len) goto <D.27426>; else goto <D.27428>;
      <D.27428>:
      goto <D.27409>;
      <D.27429>:
      obj.331 = obj;
      obj.334 = (long unsigned int) obj.331;
      buffer_add_long (buf, obj.334);
      goto <D.27409>;
      <D.27430>:
      obj.331 = obj;
      D.31537 = obj.331->vtable;
      D.31538 = D.31537->domain;
      buffer_add_domainid (buf, D.31538);
      goto <D.27409>;
      <D.27431>:
      obj.331 = obj;
      D.31537 = obj.331->vtable;
      D.31538 = D.31537->domain;
      obj.331 = obj;
      D.31537 = obj.331->vtable;
      D.31539 = D.31537->type;
      D.31540 = MEM[(struct MonoReflectionType *)D.31539].type;
      D.31607 = mono_class_from_mono_type (D.31540);
      buffer_add_typeid (buf, D.31538, D.31607);
      obj.331 = obj;
      D.31537 = obj.331->vtable;
      D.31538 = D.31537->domain;
      buffer_add_domainid (buf, D.31538);
      goto <D.27409>;
      <D.27432>:
      D.31531 = 100;
      return D.31531;
      <D.27409>:
      D.31531 = 0;
      return D.31531;
    }
  finally
    {
      err = {CLOBBER};
      obj = {CLOBBER};
    }
}


send_reply_packet (int id, int error, struct Buffer * data)
{
  guint8 * D.31610;
  long int D.31611;
  guint8 * D.31612;
  long int D.31613;
  long int D.31614;
  unsigned int D.31615;
  unsigned int D.31616;
  unsigned int len.335;
  unsigned int id.336;
  int D.31619;
  unsigned char D.31620;
  unsigned char D.31621;
  guint8 * D.31622;
  guint8 * D.31623;
  long unsigned int D.31624;
  gboolean D.31625;
  struct Buffer buf;
  int len;
  gboolean res;

  try
    {
      D.31610 = data->p;
      D.31611 = (long int) D.31610;
      D.31612 = data->buf;
      D.31613 = (long int) D.31612;
      D.31614 = D.31611 - D.31613;
      D.31615 = (unsigned int) D.31614;
      D.31616 = D.31615 + 11;
      len = (int) D.31616;
      buffer_init (&buf, len);
      len.335 = (unsigned int) len;
      buffer_add_int (&buf, len.335);
      id.336 = (unsigned int) id;
      buffer_add_int (&buf, id.336);
      buffer_add_byte (&buf, 128);
      D.31619 = error >> 8;
      D.31620 = (unsigned char) D.31619;
      buffer_add_byte (&buf, D.31620);
      D.31621 = (unsigned char) error;
      buffer_add_byte (&buf, D.31621);
      D.31622 = buf.buf;
      D.31623 = D.31622 + 11;
      D.31612 = data->buf;
      D.31610 = data->p;
      D.31611 = (long int) D.31610;
      D.31612 = data->buf;
      D.31613 = (long int) D.31612;
      D.31614 = D.31611 - D.31613;
      D.31624 = (long unsigned int) D.31614;
      memcpy (D.31623, D.31612, D.31624);
      D.31622 = buf.buf;
      res = transport_send (D.31622, len);
      buffer_free (&buf);
      D.31625 = res;
      return D.31625;
    }
  finally
    {
      buf = {CLOBBER};
    }
}


save_thread_context (struct MonoContext * ctx)
{
  unsigned int debugger_tls_id.337;
  _Bool D.31629;
  long int D.31630;
  long int D.31631;
  struct MonoThreadUnwindState * D.31636;
  struct DebuggerTlsData * tls;

  debugger_tls_id.337 = debugger_tls_id;
  tls = pthread_getspecific (debugger_tls_id.337);
  D.31629 = tls == 0B;
  D.31630 = (long int) D.31629;
  D.31631 = __builtin_expect (D.31630, 0);
  if (D.31631 != 0) goto <D.31632>; else goto <D.31633>;
  <D.31632>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 2357, "tls");
  <D.31633>:
  if (ctx != 0B) goto <D.31634>; else goto <D.31635>;
  <D.31634>:
  D.31636 = &tls->context;
  mono_thread_state_init_from_monoctx (D.31636, ctx);
  goto <D.31637>;
  <D.31635>:
  D.31636 = &tls->context;
  mono_thread_state_init_from_current (D.31636);
  <D.31637>:
}


suspend_vm ()
{
  int suspend_count.338;
  int D.31639;
  int log_level.339;
  _Bool D.31641;
  long int D.31642;
  long int D.31643;
  struct FILE * log_file.340;
  long unsigned int D.31647;
  void * D.31648;
  struct MonoGHashTable * thread_to_tls.341;

  mono_loader_lock ();
  pthread_mutex_lock (&suspend_mutex);
  suspend_count.338 = suspend_count;
  D.31639 = suspend_count.338 + 1;
  suspend_count = D.31639;
  log_level.339 = log_level;
  D.31641 = log_level.339 > 0;
  D.31642 = (long int) D.31641;
  D.31643 = __builtin_expect (D.31642, 0);
  if (D.31643 != 0) goto <D.31644>; else goto <D.31645>;
  <D.31644>:
  log_file.340 = log_file;
  D.31647 = GetCurrentThreadId ();
  D.31648 = (void *) D.31647;
  fprintf (log_file.340, "[%p] Suspending vm...\n", D.31648);
  log_file.340 = log_file;
  fflush (log_file.340);
  <D.31645>:
  suspend_count.338 = suspend_count;
  if (suspend_count.338 == 1) goto <D.31649>; else goto <D.31650>;
  <D.31649>:
  start_single_stepping ();
  thread_to_tls.341 = thread_to_tls;
  mono_g_hash_table_foreach (thread_to_tls.341, notify_thread, 0B);
  <D.31650>:
  pthread_mutex_unlock (&suspend_mutex);
  suspend_count.338 = suspend_count;
  if (suspend_count.338 == 1) goto <D.31652>; else goto <D.31653>;
  <D.31652>:
  mono_thread_pool_suspend ();
  <D.31653>:
  mono_loader_unlock ();
}


notify_thread (void * key, void * value, void * user_data)
{
  long unsigned int D.31656;
  int D.31658;
  int log_level.342;
  _Bool D.31660;
  long int D.31661;
  long int D.31662;
  struct FILE * log_file.343;
  long unsigned int D.31666;
  void * D.31667;
  void * tid.344;
  gint32 * D.31669;
  int D.31670;
  long unsigned int D.31673;
  long unsigned int D.31678;
  void * D.31679;
  void * D.31681;
  long unsigned int D.31682;
  char * D.31683;
  long unsigned int D.31684;
  int D.31686;
  long unsigned int D.31691;
  void * D.31692;
  struct MonoInternalThread * thread;
  struct DebuggerTlsData * tls;
  gsize tid;
  int res;

  thread = key;
  tls = value;
  tid = thread->tid;
  D.31656 = GetCurrentThreadId ();
  if (D.31656 == tid) goto <D.31654>; else goto <D.31657>;
  <D.31657>:
  D.31658 = tls->terminated;
  if (D.31658 != 0) goto <D.31654>; else goto <D.31655>;
  <D.31654>:
  return;
  <D.31655>:
  log_level.342 = log_level;
  D.31660 = log_level.342 > 0;
  D.31661 = (long int) D.31660;
  D.31662 = __builtin_expect (D.31661, 0);
  if (D.31662 != 0) goto <D.31663>; else goto <D.31664>;
  <D.31663>:
  log_file.343 = log_file;
  D.31666 = GetCurrentThreadId ();
  D.31667 = (void *) D.31666;
  tid.344 = (void *) tid;
  fprintf (log_file.343, "[%p] Interrupting %p...\n", D.31667, tid.344);
  log_file.343 = log_file;
  fflush (log_file.343);
  <D.31664>:
  D.31669 = &tls->interrupt_count;
  InterlockedIncrement (D.31669);
  D.31670 = mono_thread_info_new_interrupt_enabled ();
  if (D.31670 != 0) goto <D.31671>; else goto <D.31672>;
  <D.31671>:
  {
    struct MonoThreadInfo * info;
    struct MonoJitInfo * ji;

    D.31673 = thread->tid;
    info = mono_thread_info_safe_suspend_sync (D.31673, 0);
    if (info == 0B) goto <D.31674>; else goto <D.31675>;
    <D.31674>:
    log_level.342 = log_level;
    D.31660 = log_level.342 > 0;
    D.31661 = (long int) D.31660;
    D.31662 = __builtin_expect (D.31661, 0);
    if (D.31662 != 0) goto <D.31676>; else goto <D.31677>;
    <D.31676>:
    log_file.343 = log_file;
    D.31678 = GetCurrentThreadId ();
    D.31679 = (void *) D.31678;
    tid.344 = (void *) tid;
    fprintf (log_file.343, "[%p] mono_thread_info_suspend_sync () failed for %p...\n", D.31679, tid.344);
    log_file.343 = log_file;
    fflush (log_file.343);
    <D.31677>:
    tls->terminated = 1;
    goto <D.31680>;
    <D.31675>:
    D.31681 = info->suspend_state.unwind_data[0];
    D.31682 = info->suspend_state.ctx.uc_mcontext.psw.addr;
    D.31683 = (char *) D.31682;
    ji = mono_jit_info_table_find (D.31681, D.31683);
    thread_interrupt (tls, info, 0B, ji);
    D.31684 = info->node.key;
    mono_thread_info_resume (D.31684);
    <D.31680>:
  }
  goto <D.31685>;
  <D.31672>:
  D.31686 = mono_thread_get_abort_signal ();
  res = mono_thread_kill (thread, D.31686);
  if (res != 0) goto <D.31687>; else goto <D.31688>;
  <D.31687>:
  log_level.342 = log_level;
  D.31660 = log_level.342 > 0;
  D.31661 = (long int) D.31660;
  D.31662 = __builtin_expect (D.31661, 0);
  if (D.31662 != 0) goto <D.31689>; else goto <D.31690>;
  <D.31689>:
  log_file.343 = log_file;
  D.31691 = GetCurrentThreadId ();
  D.31692 = (void *) D.31691;
  tid.344 = (void *) tid;
  fprintf (log_file.343, "[%p] mono_thread_kill () failed for %p: %d...\n", D.31692, tid.344, res);
  log_file.343 = log_file;
  fflush (log_file.343);
  <D.31690>:
  tls->terminated = 1;
  <D.31688>:
  <D.31685>:
}


thread_interrupt (struct DebuggerTlsData * tls, struct MonoThreadInfo * info, void * sigctx, struct MonoJitInfo * ji)
{
  int D.31694;
  gboolean D.31697;
  gint32 * D.31698;
  long unsigned int D.31704;
  int log_level.345;
  _Bool D.31712;
  long int D.31713;
  long int D.31714;
  struct FILE * log_file.346;
  void * tid.347;
  struct MonoMethod * D.31719;
  const char * D.31720;
  signed long D.31721;
  long unsigned int D.31722;
  long unsigned int D.31723;
  struct MonoInternalThread * D.31730;
  struct MonoRuntimeExceptionHandlingCallbacks * D.31738;
  void (*<T2969>) (gboolean (*MonoInternalStackWalk) (struct MonoStackFrameInfo *, struct MonoContext *, void *), struct MonoThreadUnwindState *, MonoUnwindOptions, void *) D.31739;
  struct MonoThreadUnwindState * D.31740;
  int D.31741;
  struct StackFrameInfo * D.31744;
  struct MonoThreadUnwindState * D.31745;
  _Bool D.31746;
  long int D.31747;
  long int D.31748;
  struct MonoThreadUnwindState * D.31751;
  struct MonoContext * D.31754;
  void * D.31755;
  void * D.31756;
  gboolean res;
  void * ip;
  MonoNativeThreadId tid;

  D.31694 = tls->interrupt_count;
  if (D.31694 == 0) goto <D.31695>; else goto <D.31696>;
  <D.31695>:
  D.31697 = 0;
  return D.31697;
  <D.31696>:
  D.31698 = &tls->interrupt_count;
  InterlockedDecrement (D.31698);
  if (sigctx != 0B) goto <D.31699>; else goto <D.31700>;
  <D.31699>:
  ip = mono_arch_ip_from_context (sigctx);
  goto <D.31701>;
  <D.31700>:
  if (info != 0B) goto <D.31702>; else goto <D.31703>;
  <D.31702>:
  D.31704 = info->suspend_state.ctx.uc_mcontext.psw.addr;
  ip = (void *) D.31704;
  goto <D.31705>;
  <D.31703>:
  ip = 0B;
  <D.31705>:
  <D.31701>:
  if (info != 0B) goto <D.31706>; else goto <D.31707>;
  <D.31706>:
  tid = info->node.key;
  goto <D.31708>;
  <D.31707>:
  tid = GetCurrentThreadId ();
  <D.31708>:
  if (ji != 0B) goto <D.31709>; else goto <D.31710>;
  <D.31709>:
  log_level.345 = log_level;
  D.31712 = log_level.345 > 0;
  D.31713 = (long int) D.31712;
  D.31714 = __builtin_expect (D.31713, 0);
  if (D.31714 != 0) goto <D.31715>; else goto <D.31716>;
  <D.31715>:
  log_file.346 = log_file;
  tid.347 = (void *) tid;
  D.31719 = jinfo_get_method (ji);
  D.31720 = D.31719->name;
  fprintf (log_file.346, "[%p] Received interrupt while at %s(%p), continuing.\n", tid.347, D.31720, ip);
  log_file.346 = log_file;
  fflush (log_file.346);
  <D.31716>:
  D.31697 = 1;
  return D.31697;
  <D.31710>:
  D.31721 = BIT_FIELD_REF <*tls, 64, 4608>;
  D.31722 = (long unsigned int) D.31721;
  D.31723 = D.31722;
  if (D.31723 == 0) goto <D.31724>; else goto <D.31725>;
  <D.31724>:
  {
    struct MonoContext ctx;
    struct GetLastFrameUserData data;

    try
      {
        if (ip != 0B) goto <D.31726>; else goto <D.31727>;
        <D.31726>:
        log_level.345 = log_level;
        D.31712 = log_level.345 > 0;
        D.31713 = (long int) D.31712;
        D.31714 = __builtin_expect (D.31713, 0);
        if (D.31714 != 0) goto <D.31728>; else goto <D.31729>;
        <D.31728>:
        log_file.346 = log_file;
        tid.347 = (void *) tid;
        fprintf (log_file.346, "[%p] Received interrupt while at %p, treating as suspended.\n", tid.347, ip);
        log_file.346 = log_file;
        fflush (log_file.346);
        <D.31729>:
        <D.31727>:
        D.31730 = tls->thread;
        if (D.31730 == 0B) goto <D.31731>; else goto <D.31732>;
        <D.31731>:
        D.31697 = 1;
        return D.31697;
        <D.31732>:
        data.last_frame_set = 0;
        if (sigctx != 0B) goto <D.31733>; else goto <D.31734>;
        <D.31733>:
        mono_arch_sigctx_to_monoctx (sigctx, &ctx);
        mono_walk_stack_with_ctx (get_last_frame, &ctx, 0, &data);
        goto <D.31735>;
        <D.31734>:
        if (info != 0B) goto <D.31736>; else goto <D.31737>;
        <D.31736>:
        D.31738 = mono_get_eh_callbacks ();
        D.31739 = D.31738->mono_walk_stack_with_state;
        D.31740 = &info->suspend_state;
        D.31739 (get_last_frame, D.31740, 0, &data);
        <D.31737>:
        <D.31735>:
        D.31741 = data.last_frame_set;
        if (D.31741 != 0) goto <D.31742>; else goto <D.31743>;
        <D.31742>:
        D.31744 = &tls->async_last_frame;
        memcpy (D.31744, &data.last_frame, 88);
        D.31745 = &tls->async_state;
        res = mono_thread_state_init_from_monoctx (D.31745, &ctx);
        D.31746 = res == 0;
        D.31747 = (long int) D.31746;
        D.31748 = __builtin_expect (D.31747, 0);
        if (D.31748 != 0) goto <D.31749>; else goto <D.31750>;
        <D.31749>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 2519, "res");
        <D.31750>:
        D.31751 = &tls->context;
        mono_thread_state_init_from_monoctx (D.31751, &ctx);
        D.31746 = res == 0;
        D.31747 = (long int) D.31746;
        D.31748 = __builtin_expect (D.31747, 0);
        if (D.31748 != 0) goto <D.31752>; else goto <D.31753>;
        <D.31752>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 2521, "res");
        <D.31753>:
        D.31754 = &tls->async_state.ctx;
        memcpy (D.31754, &data.ctx, 512);
        D.31755 = data.lmf;
        tls->async_state.unwind_data[1] = D.31755;
        D.31730 = tls->thread;
        D.31756 = D.31730->jit_data;
        tls->async_state.unwind_data[2] = D.31756;
        goto <D.31757>;
        <D.31743>:
        tls->async_state.valid = 0;
        <D.31757>:
        mono_memory_barrier ();
        tls->suspended = 1;
        mono_sem_post (&suspend_sem);
      }
    finally
      {
        ctx = {CLOBBER};
        data = {CLOBBER};
      }
  }
  <D.31725>:
  D.31697 = 1;
  return D.31697;
}


get_last_frame (struct StackFrameInfo * info, struct MonoContext * ctx, void * user_data)
{
  <unnamed type> D.31761;
  gboolean D.31764;
  int D.31765;
  struct StackFrameInfo * D.31768;
  struct MonoContext * D.31769;
  void * D.31770;
  struct GetLastFrameUserData * data;

  data = user_data;
  D.31761 = info->type;
  if (D.31761 == 2) goto <D.31762>; else goto <D.31763>;
  <D.31762>:
  D.31764 = 0;
  return D.31764;
  <D.31763>:
  D.31765 = data->last_frame_set;
  if (D.31765 == 0) goto <D.31766>; else goto <D.31767>;
  <D.31766>:
  D.31768 = &data->last_frame;
  memcpy (D.31768, info, 88);
  data->last_frame_set = 1;
  D.31764 = 0;
  return D.31764;
  <D.31767>:
  D.31769 = &data->ctx;
  memcpy (D.31769, ctx, 512);
  D.31770 = info->lmf;
  data->lmf = D.31770;
  D.31764 = 1;
  return D.31764;
}


mono_memory_barrier ()
{
  __sync_synchronize ();
}


get_objref (struct MonoObject * obj)
{
  struct ObjRef * D.31774;
  struct GHashTable * obj_to_objref.348;
  struct GHashTable * D.31778;
  struct MonoGHashTable * D.31779;
  int D.31780;
  int suspend_count.349;
  struct MonoGHashTable * suspended_objs.350;
  int D.31787;
  long int D.31790;
  const void * D.31791;
  unsigned int D.31794;
  struct MonoObject * D.31795;
  long unsigned int obj.351;
  long unsigned int D.31800;
  const void * D.31801;
  struct MonoObject * D.31804;
  int D.31807;
  unsigned int D.31808;
  struct GHashTable * objrefs.352;
  int D.31810;
  long int D.31811;
  void * D.31812;
  int D.31813;
  void * D.31816;
  void * D.31818;
  struct ObjRef * ref;
  struct GSList * reflist;
  struct GSList * l;
  int hash;

  reflist = 0B;
  hash = 0;
  if (obj == 0B) goto <D.31772>; else goto <D.31773>;
  <D.31772>:
  D.31774 = 0B;
  return D.31774;
  <D.31773>:
  mono_loader_lock ();
  obj_to_objref.348 = obj_to_objref;
  if (obj_to_objref.348 == 0B) goto <D.31776>; else goto <D.31777>;
  <D.31776>:
  D.31778 = monoeg_g_hash_table_new (0B, 0B);
  obj_to_objref = D.31778;
  D.31779 = mono_g_hash_table_new_type (0B, 0B, 1);
  suspended_objs = D.31779;
  D.31780 = mono_gc_is_moving ();
  if (D.31780 == 0) goto <D.31781>; else goto <D.31782>;
  <D.31781>:
  mono_gc_register_root (&suspended_objs, 8, 0B);
  <D.31782>:
  <D.31777>:
  suspend_count.349 = suspend_count;
  if (suspend_count.349 != 0) goto <D.31784>; else goto <D.31785>;
  <D.31784>:
  suspended_objs.350 = suspended_objs;
  mono_g_hash_table_insert (suspended_objs.350, obj, 0B);
  <D.31785>:
  D.31787 = mono_gc_is_moving ();
  if (D.31787 != 0) goto <D.31788>; else goto <D.31789>;
  <D.31788>:
  hash = mono_object_hash (obj);
  obj_to_objref.348 = obj_to_objref;
  D.31790 = (long int) hash;
  D.31791 = (const void *) D.31790;
  reflist = monoeg_g_hash_table_lookup (obj_to_objref.348, D.31791);
  l = reflist;
  goto <D.25275>;
  <D.25274>:
  ref = l->data;
  if (ref != 0B) goto <D.31792>; else goto <D.31793>;
  <D.31792>:
  D.31794 = ref->handle;
  D.31795 = mono_gchandle_get_target (D.31794);
  if (D.31795 == obj) goto <D.31796>; else goto <D.31797>;
  <D.31796>:
  mono_loader_unlock ();
  D.31774 = ref;
  return D.31774;
  <D.31797>:
  <D.31793>:
  l = l->next;
  <D.25275>:
  if (l != 0B) goto <D.25274>; else goto <D.25276>;
  <D.25276>:
  goto <D.31798>;
  <D.31789>:
  obj_to_objref.348 = obj_to_objref;
  obj.351 = (long unsigned int) obj;
  D.31800 = ~obj.351;
  D.31801 = (const void *) D.31800;
  ref = monoeg_g_hash_table_lookup (obj_to_objref.348, D.31801);
  if (ref != 0B) goto <D.31802>; else goto <D.31803>;
  <D.31802>:
  D.31794 = ref->handle;
  D.31804 = mono_gchandle_get_target (D.31794);
  if (D.31804 == obj) goto <D.31805>; else goto <D.31806>;
  <D.31805>:
  mono_loader_unlock ();
  D.31774 = ref;
  return D.31774;
  <D.31806>:
  <D.31803>:
  <D.31798>:
  ref = monoeg_malloc0 (8);
  D.31807 = InterlockedIncrement (&objref_id);
  ref->id = D.31807;
  D.31808 = mono_gchandle_new_weakref (obj, 0);
  ref->handle = D.31808;
  objrefs.352 = objrefs;
  D.31810 = ref->id;
  D.31811 = (long int) D.31810;
  D.31812 = (void *) D.31811;
  monoeg_g_hash_table_insert_replace (objrefs.352, D.31812, ref, 0);
  D.31813 = mono_gc_is_moving ();
  if (D.31813 != 0) goto <D.31814>; else goto <D.31815>;
  <D.31814>:
  reflist = monoeg_g_slist_append (reflist, ref);
  obj_to_objref.348 = obj_to_objref;
  D.31790 = (long int) hash;
  D.31816 = (void *) D.31790;
  monoeg_g_hash_table_insert_replace (obj_to_objref.348, D.31816, reflist, 0);
  goto <D.31817>;
  <D.31815>:
  obj_to_objref.348 = obj_to_objref;
  obj.351 = (long unsigned int) obj;
  D.31800 = ~obj.351;
  D.31818 = (void *) D.31800;
  monoeg_g_hash_table_insert_replace (obj_to_objref.348, D.31818, ref, 0);
  <D.31817>:
  mono_loader_unlock ();
  D.31774 = ref;
  return D.31774;
}


send_packet (int command_set, int command, struct Buffer * data)
{
  guint8 * D.31820;
  long int D.31821;
  guint8 * D.31822;
  long int D.31823;
  long int D.31824;
  unsigned int D.31825;
  unsigned int D.31826;
  unsigned int len.353;
  unsigned int id.354;
  unsigned char D.31829;
  unsigned char D.31830;
  guint8 * D.31831;
  guint8 * D.31832;
  long unsigned int D.31833;
  gboolean D.31834;
  struct Buffer buf;
  int len;
  int id;
  gboolean res;

  try
    {
      id = InterlockedIncrement (&packet_id);
      D.31820 = data->p;
      D.31821 = (long int) D.31820;
      D.31822 = data->buf;
      D.31823 = (long int) D.31822;
      D.31824 = D.31821 - D.31823;
      D.31825 = (unsigned int) D.31824;
      D.31826 = D.31825 + 11;
      len = (int) D.31826;
      buffer_init (&buf, len);
      len.353 = (unsigned int) len;
      buffer_add_int (&buf, len.353);
      id.354 = (unsigned int) id;
      buffer_add_int (&buf, id.354);
      buffer_add_byte (&buf, 0);
      D.31829 = (unsigned char) command_set;
      buffer_add_byte (&buf, D.31829);
      D.31830 = (unsigned char) command;
      buffer_add_byte (&buf, D.31830);
      D.31831 = buf.buf;
      D.31832 = D.31831 + 11;
      D.31822 = data->buf;
      D.31820 = data->p;
      D.31821 = (long int) D.31820;
      D.31822 = data->buf;
      D.31823 = (long int) D.31822;
      D.31824 = D.31821 - D.31823;
      D.31833 = (long unsigned int) D.31824;
      memcpy (D.31832, D.31822, D.31833);
      D.31831 = buf.buf;
      res = transport_send (D.31831, len);
      buffer_free (&buf);
      D.31834 = res;
      return D.31834;
    }
  finally
    {
      buf = {CLOBBER};
    }
}


buffer_free (struct Buffer * buf)
{
  guint8 * D.31837;

  D.31837 = buf->buf;
  monoeg_g_free (D.31837);
}


__attribute__((__unused__))
event_to_string (EventKind event)
{
  const char * D.31838;

  switch (event) <default: <D.25804>, case 0: <D.25787>, case 1: <D.25788>, case 2: <D.25789>, case 3: <D.25790>, case 4: <D.25791>, case 5: <D.25792>, case 6: <D.25793>, case 7: <D.25794>, case 8: <D.25795>, case 9: <D.25796>, case 10: <D.25797>, case 11: <D.25798>, case 12: <D.25799>, case 13: <D.25800>, case 14: <D.25801>, case 15: <D.25802>, case 16: <D.25803>>
  <D.25787>:
  D.31838 = "VM_START";
  return D.31838;
  <D.25788>:
  D.31838 = "VM_DEATH";
  return D.31838;
  <D.25789>:
  D.31838 = "THREAD_START";
  return D.31838;
  <D.25790>:
  D.31838 = "THREAD_DEATH";
  return D.31838;
  <D.25791>:
  D.31838 = "APPDOMAIN_CREATE";
  return D.31838;
  <D.25792>:
  D.31838 = "APPDOMAIN_UNLOAD";
  return D.31838;
  <D.25793>:
  D.31838 = "METHOD_ENTRY";
  return D.31838;
  <D.25794>:
  D.31838 = "METHOD_EXIT";
  return D.31838;
  <D.25795>:
  D.31838 = "ASSEMBLY_LOAD";
  return D.31838;
  <D.25796>:
  D.31838 = "ASSEMBLY_UNLOAD";
  return D.31838;
  <D.25797>:
  D.31838 = "BREAKPOINT";
  return D.31838;
  <D.25798>:
  D.31838 = "STEP";
  return D.31838;
  <D.25799>:
  D.31838 = "TYPE_LOAD";
  return D.31838;
  <D.25800>:
  D.31838 = "EXCEPTION";
  return D.31838;
  <D.25801>:
  D.31838 = "KEEPALIVE";
  return D.31838;
  <D.25802>:
  D.31838 = "USER_BREAK";
  return D.31838;
  <D.25803>:
  D.31838 = "USER_LOG";
  return D.31838;
  <D.25804>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "debugger-agent.c", 3535);
  D.31838 = "";
  return D.31838;
}


suspend_current ()
{
  long unsigned int D.31840;
  long unsigned int debugger_thread_id.355;
  _Bool D.31842;
  long int D.31843;
  long int D.31844;
  int D.31847;
  unsigned int debugger_tls_id.356;
  _Bool D.31851;
  long int D.31852;
  long int D.31853;
  int D.31856;
  int log_level.357;
  _Bool D.31860;
  long int D.31861;
  long int D.31862;
  struct FILE * log_file.358;
  long unsigned int D.31866;
  void * D.31867;
  _Bool D.31868;
  long int D.31869;
  long int D.31870;
  unsigned int D.31873;
  int suspend_count.359;
  unsigned int suspend_count.360;
  int threads_suspend_count.361;
  int D.31877;
  long unsigned int D.31880;
  void * D.31881;
  struct InvokeData * D.31882;
  int err;
  struct DebuggerTlsData * tls;

  D.31840 = GetCurrentThreadId ();
  debugger_thread_id.355 = debugger_thread_id;
  D.31842 = D.31840 == debugger_thread_id.355;
  D.31843 = (long int) D.31842;
  D.31844 = __builtin_expect (D.31843, 0);
  if (D.31844 != 0) goto <D.31845>; else goto <D.31846>;
  <D.31845>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 2855, "debugger_thread_id != GetCurrentThreadId ()");
  <D.31846>:
  D.31847 = mono_loader_lock_is_owned_by_self ();
  if (D.31847 != 0) goto <D.31848>; else goto <D.31849>;
  <D.31848>:
  return;
  <D.31849>:
  debugger_tls_id.356 = debugger_tls_id;
  tls = pthread_getspecific (debugger_tls_id.356);
  D.31851 = tls == 0B;
  D.31852 = (long int) D.31851;
  D.31853 = __builtin_expect (D.31852, 0);
  if (D.31853 != 0) goto <D.31854>; else goto <D.31855>;
  <D.31854>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 2866, "tls");
  <D.31855>:
  pthread_mutex_lock (&suspend_mutex);
  tls->suspending = 0;
  tls->really_suspended = 1;
  D.31856 = tls->suspended;
  if (D.31856 == 0) goto <D.31857>; else goto <D.31858>;
  <D.31857>:
  tls->suspended = 1;
  mono_sem_post (&suspend_sem);
  <D.31858>:
  log_level.357 = log_level;
  D.31860 = log_level.357 > 0;
  D.31861 = (long int) D.31860;
  D.31862 = __builtin_expect (D.31861, 0);
  if (D.31862 != 0) goto <D.31863>; else goto <D.31864>;
  <D.31863>:
  log_file.358 = log_file;
  D.31866 = GetCurrentThreadId ();
  D.31867 = (void *) D.31866;
  fprintf (log_file.358, "[%p] Suspended.\n", D.31867);
  log_file.358 = log_file;
  fflush (log_file.358);
  <D.31864>:
  goto <D.25600>;
  <D.25599>:
  err = pthread_cond_wait (&suspend_cond, &suspend_mutex);
  D.31868 = err != 0;
  D.31869 = (long int) D.31868;
  D.31870 = __builtin_expect (D.31869, 0);
  if (D.31870 != 0) goto <D.31871>; else goto <D.31872>;
  <D.31871>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 2893, "err == 0");
  <D.31872>:
  <D.25600>:
  D.31873 = tls->resume_count;
  suspend_count.359 = suspend_count;
  suspend_count.360 = (unsigned int) suspend_count.359;
  if (D.31873 != suspend_count.360) goto <D.25599>; else goto <D.25601>;
  <D.25601>:
  tls->suspended = 0;
  tls->really_suspended = 0;
  threads_suspend_count.361 = threads_suspend_count;
  D.31877 = threads_suspend_count.361 + -1;
  threads_suspend_count = D.31877;
  pthread_mutex_unlock (&suspend_mutex);
  log_level.357 = log_level;
  D.31860 = log_level.357 > 0;
  D.31861 = (long int) D.31860;
  D.31862 = __builtin_expect (D.31861, 0);
  if (D.31862 != 0) goto <D.31878>; else goto <D.31879>;
  <D.31878>:
  log_file.358 = log_file;
  D.31880 = GetCurrentThreadId ();
  D.31881 = (void *) D.31880;
  fprintf (log_file.358, "[%p] Resumed.\n", D.31881);
  log_file.358 = log_file;
  fflush (log_file.358);
  <D.31879>:
  D.31882 = tls->pending_invoke;
  if (D.31882 != 0B) goto <D.31883>; else goto <D.31884>;
  <D.31883>:
  D.31882 = tls->pending_invoke;
  D.31882->has_ctx = 1;
  D.31882 = tls->pending_invoke;
  D.31882->ctx = tls->context.ctx;
  invoke_method ();
  <D.31884>:
  tls->context.valid = 0;
  tls->async_state.valid = 0;
  invalidate_frames (tls);
}


invoke_method ()
{
  unsigned int debugger_tls_id.362;
  _Bool D.31887;
  long int D.31888;
  long int D.31889;
  _Bool D.31892;
  long int D.31893;
  long int D.31894;
  struct InvokeData * D.31897;
  guint8 * p.363;
  guint8 * p.364;
  <unnamed type> D.31903;
  int D.31904;
  int D.31905;
  int D.31908;
  int D.31909;
  unsigned int D.31912;
  unsigned int i.365;
  struct MonoContext * D.31914;
  int D.31915;
  unsigned int D.31920;
  _Bool D.31921;
  long int D.31922;
  long int D.31923;
  unsigned int D.31926;
  int log_level.366;
  _Bool D.31928;
  long int D.31929;
  long int D.31930;
  struct FILE * log_file.367;
  long unsigned int D.31934;
  void * D.31935;
  int D.31936;
  struct MonoInternalThread * D.31939;
  struct InvokeData * D.31940;
  struct DebuggerTlsData * tls;
  struct InvokeData * invoke;
  int id;
  int i;
  int err;
  int mindex;
  struct Buffer buf;
  struct MonoContext restore_ctx;
  guint8 * p;

  try
    {
      debugger_tls_id.362 = debugger_tls_id;
      tls = pthread_getspecific (debugger_tls_id.362);
      D.31887 = tls == 0B;
      D.31888 = (long int) D.31887;
      D.31889 = __builtin_expect (D.31888, 0);
      if (D.31889 != 0) goto <D.31890>; else goto <D.31891>;
      <D.31890>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 6421, "tls");
      <D.31891>:
      mono_loader_lock ();
      invoke = tls->pending_invoke;
      D.31892 = invoke == 0B;
      D.31893 = (long int) D.31892;
      D.31894 = __builtin_expect (D.31893, 0);
      if (D.31894 != 0) goto <D.31895>; else goto <D.31896>;
      <D.31895>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 6431, "invoke");
      <D.31896>:
      tls->pending_invoke = 0B;
      D.31897 = tls->invoke;
      invoke->last_invoke = D.31897;
      tls->invoke = invoke;
      mono_loader_unlock ();
      tls->frames_up_to_date = 0;
      id = invoke->id;
      p.363 = invoke->p;
      p = p.363;
      err = 0;
      mindex = 0;
      goto <D.26639>;
      <D.26638>:
      buffer_init (&buf, 128);
      if (err != 0) goto <D.31899>; else goto <D.31900>;
      <D.31899>:
      goto <D.31901>;
      <D.31900>:
      p.364 = p;
      D.31903 = do_invoke_method (tls, &buf, invoke, p.364, &p);
      err = (int) D.31903;
      <D.31901>:
      D.31904 = invoke->nmethods;
      D.31905 = D.31904 + -1;
      if (D.31905 == mindex) goto <D.31906>; else goto <D.31907>;
      <D.31906>:
      D.31908 = invoke->flags;
      D.31909 = D.31908 & 2;
      if (D.31909 == 0) goto <D.31910>; else goto <D.31911>;
      <D.31910>:
      i = 0;
      goto <D.26636>;
      <D.26635>:
      suspend_vm ();
      i = i + 1;
      <D.26636>:
      D.31912 = invoke->suspend_count;
      i.365 = (unsigned int) i;
      if (D.31912 > i.365) goto <D.26635>; else goto <D.26637>;
      <D.26637>:
      <D.31911>:
      <D.31907>:
      send_reply_packet (id, err, &buf);
      buffer_free (&buf);
      mindex = mindex + 1;
      <D.26639>:
      D.31904 = invoke->nmethods;
      if (D.31904 > mindex) goto <D.26638>; else goto <D.26640>;
      <D.26640>:
      D.31914 = &invoke->ctx;
      memcpy (&restore_ctx, D.31914, 512);
      D.31915 = invoke->has_ctx;
      if (D.31915 != 0) goto <D.31916>; else goto <D.31917>;
      <D.31916>:
      save_thread_context (&restore_ctx);
      <D.31917>:
      D.31908 = invoke->flags;
      D.31909 = D.31908 & 2;
      if (D.31909 != 0) goto <D.31918>; else goto <D.31919>;
      <D.31918>:
      D.31920 = tls->resume_count;
      D.31921 = D.31920 == 0;
      D.31922 = (long int) D.31921;
      D.31923 = __builtin_expect (D.31922, 0);
      if (D.31923 != 0) goto <D.31924>; else goto <D.31925>;
      <D.31924>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 6473, "tls->resume_count");
      <D.31925>:
      D.31920 = tls->resume_count;
      D.31912 = invoke->suspend_count;
      D.31926 = D.31920 - D.31912;
      tls->resume_count = D.31926;
      <D.31919>:
      log_level.366 = log_level;
      D.31928 = log_level.366 > 0;
      D.31929 = (long int) D.31928;
      D.31930 = __builtin_expect (D.31929, 0);
      if (D.31930 != 0) goto <D.31931>; else goto <D.31932>;
      <D.31931>:
      log_file.367 = log_file;
      D.31934 = GetCurrentThreadId ();
      D.31935 = (void *) D.31934;
      D.31920 = tls->resume_count;
      fprintf (log_file.367, "[%p] Invoke finished (%d), resume_count = %d.\n", D.31935, err, D.31920);
      log_file.367 = log_file;
      fflush (log_file.367);
      <D.31932>:
      mono_loader_lock ();
      D.31936 = tls->abort_requested;
      if (D.31936 != 0) goto <D.31937>; else goto <D.31938>;
      <D.31937>:
      D.31939 = tls->thread;
      mono_thread_internal_reset_abort (D.31939);
      <D.31938>:
      D.31897 = tls->invoke;
      D.31940 = D.31897->last_invoke;
      tls->invoke = D.31940;
      tls->abort_requested = 0;
      mono_loader_unlock ();
      p.363 = invoke->p;
      monoeg_g_free (p.363);
      monoeg_g_free (invoke);
      suspend_current ();
    }
  finally
    {
      buf = {CLOBBER};
      restore_ctx = {CLOBBER};
      p = {CLOBBER};
    }
}


do_invoke_method (struct DebuggerTlsData * tls, struct Buffer * buf, struct InvokeData * invoke, guint8 * p, guint8 * * endp)
{
  struct MonoMethod * D.31941;
  int log_level.368;
  _Bool D.31945;
  long int D.31946;
  long int D.31947;
  struct FILE * log_file.369;
  long unsigned int D.31951;
  void * D.31952;
  char * D.31953;
  const char * iftmp.370;
  struct MonoObject * this.371;
  struct MonoVTable * D.31958;
  struct MonoClass * D.31959;
  void * * D.31961;
  guint8 * p.372;
  int err.373;
  ErrorCode D.31966;
  struct MonoClass * D.31967;
  long unsigned int D.31968;
  long unsigned int D.31969;
  int D.31972;
  long unsigned int D.31973;
  short unsigned int D.31978;
  int D.31979;
  int D.31980;
  long unsigned int D.31986;
  void * D.31987;
  int D.31988;
  long unsigned int D.31989;
  struct MonoType * D.31990;
  struct MonoDomain * domain.374;
  <unnamed type> D.31992;
  int err.375;
  struct MonoObject * this.376;
  unsigned int D.32002;
  unsigned int D.32003;
  unsigned char D.32005;
  long unsigned int D.32011;
  void * D.32012;
  long unsigned int D.32015;
  void * D.32016;
  char * D.32017;
  const char * iftmp.377;
  struct MonoDomain * D.32024;
  const char * D.32033;
  int D.32034;
  unsigned int D.32037;
  struct MonoObject * this.378;
  int D.32044;
  short unsigned int D.32047;
  int D.32048;
  long unsigned int D.32051;
  long unsigned int D.32052;
  struct MonoType * D.32053;
  int D.32054;
  long unsigned int D.32057;
  long unsigned int D.32058;
  void * * D.32059;
  <unnamed type> D.32060;
  int err.379;
  void * D.32063;
  struct MonoVTable * D.32066;
  struct MonoDomain * D.32067;
  guint8 * * D.32071;
  struct MonoClass * D.32072;
  int D.32073;
  long unsigned int D.32074;
  void * D.32075;
  guint8 * D.32076;
  <unnamed type> D.32077;
  int err.380;
  int D.32082;
  int D.32083;
  int D.32087;
  struct MonoLMF * D.32090;
  struct MonoContext * D.32091;
  struct MonoObject * res.381;
  struct MonoObject * res.382;
  long unsigned int D.32099;
  void * D.32100;
  struct MonoObject * res.383;
  const char * iftmp.384;
  struct MonoObject * exc.385;
  struct MonoVTable * D.32106;
  struct MonoClass * D.32107;
  long unsigned int D.32109;
  long int D.32110;
  struct MonoClass * D.32113;
  struct MonoType * D.32114;
  struct MonoType * D.32116;
  unsigned char D.32117;
  int D.32122;
  struct MonoClass * D.32125;
  struct MonoType * D.32126;
  int D.32128;
  struct MonoClass * D.32135;
  long unsigned int D.32136;
  long unsigned int D.32137;
  struct MonoClass * D.32140;
  int D.32141;
  int D.32144;
  long unsigned int D.32145;
  _Bool D.32146;
  long int D.32147;
  long int D.32148;
  _Bool D.32152;
  long int D.32153;
  long int D.32154;
  void * D.32157;
  void * D.32160;
  long int D.32161;
  long int D.32162;
  struct MonoLMF * D.32163;
  guint8 * end;
  struct MonoMethod * m;
  int i;
  int err;
  int nargs;
  struct MonoMethodSignature * sig;
  guint8 * * arg_buf;
  void * * args;
  struct MonoObject * this;
  struct MonoObject * res;
  struct MonoObject * exc;
  struct MonoDomain * domain;
  guint8 * this_buf;
  struct MonoLMFExt ext;
  struct MonoStopwatch watch;

  try
    {
      end = invoke->endp;
      D.31941 = invoke->method;
      if (D.31941 != 0B) goto <D.31942>; else goto <D.31943>;
      <D.31942>:
      this = 0B;
      log_level.368 = log_level;
      D.31945 = log_level.368 > 0;
      D.31946 = (long int) D.31945;
      D.31947 = __builtin_expect (D.31946, 0);
      if (D.31947 != 0) goto <D.31948>; else goto <D.31949>;
      <D.31948>:
      log_file.369 = log_file;
      D.31951 = GetCurrentThreadId ();
      D.31952 = (void *) D.31951;
      D.31941 = invoke->method;
      D.31953 = mono_method_full_name (D.31941, 1);
      this.371 = this;
      if (this.371 != 0B) goto <D.31956>; else goto <D.31957>;
      <D.31956>:
      this.371 = this;
      D.31958 = this.371->vtable;
      D.31959 = D.31958->klass;
      iftmp.370 = D.31959->name;
      goto <D.31960>;
      <D.31957>:
      iftmp.370 = "<null>";
      <D.31960>:
      fprintf (log_file.369, "[%p] Invoking method \'%s\' on receiver \'%s\'.\n", D.31952, D.31953, iftmp.370);
      log_file.369 = log_file;
      fflush (log_file.369);
      <D.31949>:
      D.31941 = invoke->method;
      D.31961 = invoke->args;
      mono_runtime_invoke (D.31941, 0B, D.31961, &exc);
      monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "debugger-agent.c", 6243);
      <D.31943>:
      p.372 = p;
      m = decode_methodid (p.372, &p, end, &domain, &err);
      err.373 = err;
      if (err.373 != 0) goto <D.31964>; else goto <D.31965>;
      <D.31964>:
      err.373 = err;
      D.31966 = (ErrorCode) err.373;
      return D.31966;
      <D.31965>:
      sig = mono_method_signature (m);
      D.31967 = m->klass;
      D.31968 = BIT_FIELD_REF <*D.31967, 64, 256>;
      D.31969 = D.31968 & 1152921504606846976;
      if (D.31969 != 0) goto <D.31970>; else goto <D.31971>;
      <D.31970>:
      D.31967 = m->klass;
      D.31972 = mono_class_instance_size (D.31967);
      D.31973 = (long unsigned int) D.31972;
      this_buf = __builtin_alloca (D.31973);
      goto <D.31974>;
      <D.31971>:
      this_buf = __builtin_alloca (8);
      <D.31974>:
      D.31967 = m->klass;
      D.31968 = BIT_FIELD_REF <*D.31967, 64, 256>;
      D.31969 = D.31968 & 1152921504606846976;
      if (D.31969 != 0) goto <D.31977>; else goto <D.31975>;
      <D.31977>:
      D.31978 = m->flags;
      D.31979 = (int) D.31978;
      D.31980 = D.31979 & 16;
      if (D.31980 != 0) goto <D.31981>; else goto <D.31975>;
      <D.31981>:
      {
        int type;

        p.372 = p;
        type = decode_byte (p.372, &p, end);
        if (type != 240) goto <D.31982>; else goto <D.31983>;
        <D.31982>:
        log_level.368 = log_level;
        D.31945 = log_level.368 > 0;
        D.31946 = (long int) D.31945;
        D.31947 = __builtin_expect (D.31946, 0);
        if (D.31947 != 0) goto <D.31984>; else goto <D.31985>;
        <D.31984>:
        log_file.369 = log_file;
        D.31986 = GetCurrentThreadId ();
        D.31987 = (void *) D.31986;
        fprintf (log_file.369, "[%p] Error: Static vtype method invoked with this argument.\n", D.31987);
        log_file.369 = log_file;
        fflush (log_file.369);
        <D.31985>:
        D.31966 = 102;
        return D.31966;
        <D.31983>:
        D.31967 = m->klass;
        D.31988 = mono_class_instance_size (D.31967);
        D.31989 = (long unsigned int) D.31988;
        memset (this_buf, 0, D.31989);
      }
      goto <D.31976>;
      <D.31975>:
      D.31967 = m->klass;
      D.31990 = &D.31967->byval_arg;
      domain.374 = domain;
      p.372 = p;
      D.31992 = decode_value (D.31990, domain.374, this_buf, p.372, &p, end);
      err.375 = (int) D.31992;
      err = err.375;
      err.373 = err;
      if (err.373 != 0) goto <D.31994>; else goto <D.31995>;
      <D.31994>:
      err.373 = err;
      D.31966 = (ErrorCode) err.373;
      return D.31966;
      <D.31995>:
      <D.31976>:
      D.31967 = m->klass;
      D.31968 = BIT_FIELD_REF <*D.31967, 64, 256>;
      D.31969 = D.31968 & 1152921504606846976;
      if (D.31969 == 0) goto <D.31996>; else goto <D.31997>;
      <D.31996>:
      this.376 = MEM[(struct MonoObject * *)this_buf];
      this = this.376;
      goto <D.31999>;
      <D.31997>:
      this = 0B;
      <D.31999>:
      D.31967 = m->klass;
      D.32002 = D.31967->flags;
      D.32003 = D.32002 & 32;
      if (D.32003 != 0) goto <D.32000>; else goto <D.32004>;
      <D.32004>:
      D.31967 = m->klass;
      D.32005 = D.31967->byval_arg.type;
      if (D.32005 == 19) goto <D.32000>; else goto <D.32006>;
      <D.32006>:
      D.31967 = m->klass;
      D.32005 = D.31967->byval_arg.type;
      if (D.32005 == 30) goto <D.32000>; else goto <D.32001>;
      <D.32000>:
      this.371 = this;
      if (this.371 == 0B) goto <D.32007>; else goto <D.32008>;
      <D.32007>:
      log_level.368 = log_level;
      D.31945 = log_level.368 > 0;
      D.31946 = (long int) D.31945;
      D.31947 = __builtin_expect (D.31946, 0);
      if (D.31947 != 0) goto <D.32009>; else goto <D.32010>;
      <D.32009>:
      log_file.369 = log_file;
      D.32011 = GetCurrentThreadId ();
      D.32012 = (void *) D.32011;
      fprintf (log_file.369, "[%p] Error: Interface method invoked without this argument.\n", D.32012);
      log_file.369 = log_file;
      fflush (log_file.369);
      <D.32010>:
      D.31966 = 102;
      return D.31966;
      <D.32008>:
      this.371 = this;
      m = mono_object_get_virtual_method (this.371, m);
      <D.32001>:
      log_level.368 = log_level;
      D.31945 = log_level.368 > 0;
      D.31946 = (long int) D.31945;
      D.31947 = __builtin_expect (D.31946, 0);
      if (D.31947 != 0) goto <D.32013>; else goto <D.32014>;
      <D.32013>:
      log_file.369 = log_file;
      D.32015 = GetCurrentThreadId ();
      D.32016 = (void *) D.32015;
      D.32017 = mono_method_full_name (m, 1);
      this.371 = this;
      if (this.371 != 0B) goto <D.32019>; else goto <D.32020>;
      <D.32019>:
      this.371 = this;
      D.31958 = this.371->vtable;
      D.31959 = D.31958->klass;
      iftmp.377 = D.31959->name;
      goto <D.32021>;
      <D.32020>:
      iftmp.377 = "<null>";
      <D.32021>:
      fprintf (log_file.369, "[%p] Invoking method \'%s\' on receiver \'%s\'.\n", D.32016, D.32017, iftmp.377);
      log_file.369 = log_file;
      fflush (log_file.369);
      <D.32014>:
      this.371 = this;
      if (this.371 != 0B) goto <D.32022>; else goto <D.32023>;
      <D.32022>:
      this.371 = this;
      D.31958 = this.371->vtable;
      D.32024 = D.31958->domain;
      domain.374 = domain;
      if (D.32024 != domain.374) goto <D.32025>; else goto <D.32026>;
      <D.32025>:
      monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "debugger-agent.c", 6285);
      <D.32026>:
      <D.32023>:
      D.31967 = m->klass;
      D.31968 = BIT_FIELD_REF <*D.31967, 64, 256>;
      D.31969 = D.31968 & 1152921504606846976;
      if (D.31969 == 0) goto <D.32027>; else goto <D.32028>;
      <D.32027>:
      D.31978 = m->flags;
      D.31979 = (int) D.31978;
      D.31980 = D.31979 & 16;
      if (D.31980 == 0) goto <D.32029>; else goto <D.32030>;
      <D.32029>:
      this.371 = this;
      if (this.371 == 0B) goto <D.32031>; else goto <D.32032>;
      <D.32031>:
      D.32033 = m->name;
      D.32034 = strcmp (D.32033, ".ctor");
      if (D.32034 == 0) goto <D.32035>; else goto <D.32036>;
      <D.32035>:
      D.31967 = m->klass;
      D.32002 = D.31967->flags;
      D.32037 = D.32002 & 128;
      if (D.32037 != 0) goto <D.32038>; else goto <D.32039>;
      <D.32038>:
      D.31966 = 102;
      return D.31966;
      <D.32039>:
      domain.374 = domain;
      D.31967 = m->klass;
      this.378 = mono_object_new (domain.374, D.31967);
      this = this.378;
      goto <D.32041>;
      <D.32036>:
      D.31966 = 102;
      return D.31966;
      <D.32041>:
      <D.32032>:
      <D.32030>:
      <D.32028>:
      this.371 = this;
      if (this.371 != 0B) goto <D.32042>; else goto <D.32043>;
      <D.32042>:
      this.371 = this;
      D.31967 = m->klass;
      D.31990 = &D.31967->byval_arg;
      D.32044 = obj_is_of_type (this.371, D.31990);
      if (D.32044 == 0) goto <D.32045>; else goto <D.32046>;
      <D.32045>:
      D.31966 = 102;
      return D.31966;
      <D.32046>:
      <D.32043>:
      p.372 = p;
      nargs = decode_int (p.372, &p, end);
      D.32047 = sig->param_count;
      D.32048 = (int) D.32047;
      if (D.32048 != nargs) goto <D.32049>; else goto <D.32050>;
      <D.32049>:
      D.31966 = 102;
      return D.31966;
      <D.32050>:
      D.32051 = (long unsigned int) nargs;
      D.32052 = D.32051 * 8;
      arg_buf = __builtin_alloca (D.32052);
      D.32051 = (long unsigned int) nargs;
      D.32052 = D.32051 * 8;
      memset (arg_buf, 0, D.32052);
      D.32051 = (long unsigned int) nargs;
      D.32052 = D.32051 * 8;
      args = __builtin_alloca (D.32052);
      i = 0;
      goto <D.26619>;
      <D.26618>:
      D.32053 = sig->params[i];
      D.32054 = mono_type_is_reference (D.32053);
      if (D.32054 != 0) goto <D.32055>; else goto <D.32056>;
      <D.32055>:
      D.32053 = sig->params[i];
      domain.374 = domain;
      D.32057 = (long unsigned int) i;
      D.32058 = D.32057 * 8;
      D.32059 = args + D.32058;
      p.372 = p;
      D.32060 = decode_value (D.32053, domain.374, D.32059, p.372, &p, end);
      err.379 = (int) D.32060;
      err = err.379;
      err.373 = err;
      if (err.373 != 0) goto <D.26617>; else goto <D.32062>;
      <D.32062>:
      D.32057 = (long unsigned int) i;
      D.32058 = D.32057 * 8;
      D.32059 = args + D.32058;
      D.32063 = *D.32059;
      if (D.32063 != 0B) goto <D.32064>; else goto <D.32065>;
      <D.32064>:
      D.32057 = (long unsigned int) i;
      D.32058 = D.32057 * 8;
      D.32059 = args + D.32058;
      D.32063 = *D.32059;
      D.32066 = MEM[(struct MonoObject *)D.32063].vtable;
      D.32067 = D.32066->domain;
      domain.374 = domain;
      if (D.32067 != domain.374) goto <D.32068>; else goto <D.32069>;
      <D.32068>:
      monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "debugger-agent.c", 6315);
      <D.32069>:
      <D.32065>:
      goto <D.32070>;
      <D.32056>:
      D.32057 = (long unsigned int) i;
      D.32058 = D.32057 * 8;
      D.32071 = arg_buf + D.32058;
      D.32053 = sig->params[i];
      D.32072 = mono_class_from_mono_type (D.32053);
      D.32073 = mono_class_instance_size (D.32072);
      D.32074 = (long unsigned int) D.32073;
      D.32075 = __builtin_alloca (D.32074);
      *D.32071 = D.32075;
      D.32053 = sig->params[i];
      domain.374 = domain;
      D.32057 = (long unsigned int) i;
      D.32058 = D.32057 * 8;
      D.32071 = arg_buf + D.32058;
      D.32076 = *D.32071;
      p.372 = p;
      D.32077 = decode_value (D.32053, domain.374, D.32076, p.372, &p, end);
      err.380 = (int) D.32077;
      err = err.380;
      err.373 = err;
      if (err.373 != 0) goto <D.26617>; else goto <D.32079>;
      <D.32079>:
      D.32057 = (long unsigned int) i;
      D.32058 = D.32057 * 8;
      D.32059 = args + D.32058;
      D.32057 = (long unsigned int) i;
      D.32058 = D.32057 * 8;
      D.32071 = arg_buf + D.32058;
      D.32076 = *D.32071;
      *D.32059 = D.32076;
      <D.32070>:
      i = i + 1;
      <D.26619>:
      if (i < nargs) goto <D.26618>; else goto <D.26617>;
      <D.26617>:
      if (i < nargs) goto <D.32080>; else goto <D.32081>;
      <D.32080>:
      err.373 = err;
      D.31966 = (ErrorCode) err.373;
      return D.31966;
      <D.32081>:
      D.32082 = invoke->flags;
      D.32083 = D.32082 & 1;
      if (D.32083 != 0) goto <D.32084>; else goto <D.32085>;
      <D.32084>:
      tls->disable_breakpoints = 1;
      goto <D.32086>;
      <D.32085>:
      tls->disable_breakpoints = 0;
      <D.32086>:
      D.32087 = invoke->has_ctx;
      if (D.32087 != 0) goto <D.32088>; else goto <D.32089>;
      <D.32088>:
      {
        struct MonoLMF * * lmf_addr;

        lmf_addr = mono_get_lmf_addr ();
        memset (&ext, 0, 864);
        D.32090 = *lmf_addr;
        mono_arch_init_lmf_ext (&ext, D.32090);
        ext.debugger_invoke = 1;
        D.32091 = &invoke->ctx;
        memcpy (&ext.ctx, D.32091, 512);
        mono_set_lmf (&ext);
      }
      <D.32089>:
      mono_stopwatch_start (&watch);
      D.31967 = m->klass;
      D.31968 = BIT_FIELD_REF <*D.31967, 64, 256>;
      D.31969 = D.31968 & 1152921504606846976;
      if (D.31969 != 0) goto <D.32092>; else goto <D.32093>;
      <D.32092>:
      res.381 = mono_runtime_invoke (m, this_buf, args, &exc);
      res = res.381;
      goto <D.32095>;
      <D.32093>:
      this.371 = this;
      res.382 = mono_runtime_invoke (m, this.371, args, &exc);
      res = res.382;
      <D.32095>:
      mono_stopwatch_stop (&watch);
      log_level.368 = log_level;
      D.31945 = log_level.368 > 0;
      D.31946 = (long int) D.31945;
      D.31947 = __builtin_expect (D.31946, 0);
      if (D.31947 != 0) goto <D.32097>; else goto <D.32098>;
      <D.32097>:
      log_file.369 = log_file;
      D.32099 = GetCurrentThreadId ();
      D.32100 = (void *) D.32099;
      res.383 = res;
      exc.385 = exc;
      if (exc.385 != 0B) goto <D.32104>; else goto <D.32105>;
      <D.32104>:
      exc.385 = exc;
      D.32106 = exc.385->vtable;
      D.32107 = D.32106->klass;
      iftmp.384 = D.32107->name;
      goto <D.32108>;
      <D.32105>:
      iftmp.384 = 0B;
      <D.32108>:
      D.32109 = mono_stopwatch_elapsed_ms (&watch);
      D.32110 = (long int) D.32109;
      fprintf (log_file.369, "[%p] Invoke result: %p, exc: %s, time: %ld ms.\n", D.32100, res.383, iftmp.384, D.32110);
      log_file.369 = log_file;
      fflush (log_file.369);
      <D.32098>:
      exc.385 = exc;
      if (exc.385 != 0B) goto <D.32111>; else goto <D.32112>;
      <D.32111>:
      buffer_add_byte (buf, 0);
      D.32113 = mono_defaults.object_class;
      D.32114 = &D.32113->byval_arg;
      domain.374 = domain;
      buffer_add_value (buf, D.32114, &exc, domain.374);
      goto <D.32115>;
      <D.32112>:
      buffer_add_byte (buf, 1);
      D.32116 = sig->ret;
      D.32117 = D.32116->type;
      if (D.32117 == 1) goto <D.32118>; else goto <D.32119>;
      <D.32118>:
      D.32033 = m->name;
      D.32122 = strcmp (D.32033, ".ctor");
      if (D.32122 == 0) goto <D.32123>; else goto <D.32120>;
      <D.32123>:
      D.31967 = m->klass;
      D.31968 = BIT_FIELD_REF <*D.31967, 64, 256>;
      D.31969 = D.31968 & 1152921504606846976;
      if (D.31969 == 0) goto <D.32124>; else goto <D.32120>;
      <D.32124>:
      D.32113 = mono_defaults.object_class;
      D.32114 = &D.32113->byval_arg;
      domain.374 = domain;
      buffer_add_value (buf, D.32114, &this, domain.374);
      goto <D.32121>;
      <D.32120>:
      D.32125 = mono_defaults.void_class;
      D.32126 = &D.32125->byval_arg;
      domain.374 = domain;
      buffer_add_value (buf, D.32126, 0B, domain.374);
      <D.32121>:
      goto <D.32127>;
      <D.32119>:
      D.32116 = sig->ret;
      D.32128 = mono_type_is_reference (D.32116);
      if (D.32128 != 0) goto <D.32129>; else goto <D.32130>;
      <D.32129>:
      D.32116 = sig->ret;
      domain.374 = domain;
      buffer_add_value (buf, D.32116, &res, domain.374);
      goto <D.32131>;
      <D.32130>:
      D.32116 = sig->ret;
      D.32135 = mono_class_from_mono_type (D.32116);
      D.32136 = BIT_FIELD_REF <*D.32135, 64, 256>;
      D.32137 = D.32136 & 1152921504606846976;
      if (D.32137 != 0) goto <D.32132>; else goto <D.32138>;
      <D.32138>:
      D.32116 = sig->ret;
      D.32117 = D.32116->type;
      if (D.32117 == 15) goto <D.32132>; else goto <D.32139>;
      <D.32139>:
      D.32116 = sig->ret;
      D.32117 = D.32116->type;
      if (D.32117 == 27) goto <D.32132>; else goto <D.32133>;
      <D.32132>:
      D.32116 = sig->ret;
      D.32140 = mono_class_from_mono_type (D.32116);
      D.32141 = mono_class_is_nullable (D.32140);
      if (D.32141 != 0) goto <D.32142>; else goto <D.32143>;
      <D.32142>:
      {
        struct MonoClass * k;
        guint8 * nullable_buf;

        D.32116 = sig->ret;
        k = mono_class_from_mono_type (D.32116);
        D.32144 = mono_class_value_size (k, 0B);
        D.32145 = (long unsigned int) D.32144;
        nullable_buf = __builtin_alloca (D.32145);
        D.32146 = nullable_buf == 0B;
        D.32147 = (long int) D.32146;
        D.32148 = __builtin_expect (D.32147, 0);
        if (D.32148 != 0) goto <D.32149>; else goto <D.32150>;
        <D.32149>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 6379, "nullable_buf");
        <D.32150>:
        res.383 = res;
        mono_nullable_init (nullable_buf, res.383, k);
        D.32116 = sig->ret;
        domain.374 = domain;
        buffer_add_value (buf, D.32116, nullable_buf, domain.374);
      }
      goto <D.32151>;
      <D.32143>:
      res.383 = res;
      D.32152 = res.383 == 0B;
      D.32153 = (long int) D.32152;
      D.32154 = __builtin_expect (D.32153, 0);
      if (D.32154 != 0) goto <D.32155>; else goto <D.32156>;
      <D.32155>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 6383, "res");
      <D.32156>:
      D.32116 = sig->ret;
      res.383 = res;
      D.32157 = mono_object_unbox (res.383);
      domain.374 = domain;
      buffer_add_value (buf, D.32116, D.32157, domain.374);
      <D.32151>:
      goto <D.32134>;
      <D.32133>:
      monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "debugger-agent.c", 6387);
      <D.32134>:
      <D.32131>:
      <D.32127>:
      <D.32115>:
      tls->disable_breakpoints = 0;
      D.32087 = invoke->has_ctx;
      if (D.32087 != 0) goto <D.32158>; else goto <D.32159>;
      <D.32158>:
      D.32160 = ext.lmf.previous_lmf;
      D.32161 = (long int) D.32160;
      D.32162 = D.32161 & -4;
      D.32163 = (struct MonoLMF *) D.32162;
      mono_set_lmf (D.32163);
      <D.32159>:
      p.372 = p;
      *endp = p.372;
      D.31966 = 0;
      return D.31966;
    }
  finally
    {
      err = {CLOBBER};
      this = {CLOBBER};
      res = {CLOBBER};
      exc = {CLOBBER};
      domain = {CLOBBER};
      ext = {CLOBBER};
      watch = {CLOBBER};
    }
}


__attribute__((__artificial__, __gnu_inline__, __always_inline__, __nothrow__, __leaf__))
memset (void * __dest, int __ch, size_t __len)
{
  void * D.32166;
  long unsigned int D.32167;

  D.32167 = __builtin_object_size (__dest, 0);
  D.32166 = __builtin___memset_chk (__dest, __ch, __len, D.32167);
  return D.32166;
}


mono_stopwatch_start (struct MonoStopwatch * w)
{
  long int D.32169;

  D.32169 = mono_100ns_ticks ();
  w->start = D.32169;
  w->stop = 0;
}


mono_stopwatch_stop (struct MonoStopwatch * w)
{
  long int D.32170;

  D.32170 = mono_100ns_ticks ();
  w->stop = D.32170;
}


mono_stopwatch_elapsed_ms (struct MonoStopwatch * w)
{
  guint64 D.32171;
  long unsigned int D.32172;
  long unsigned int D.32173;

  D.32172 = mono_stopwatch_elapsed (w);
  D.32173 = D.32172 + 500;
  D.32171 = D.32173 / 1000;
  return D.32171;
}


mono_stopwatch_elapsed (struct MonoStopwatch * w)
{
  guint64 D.32175;
  long int D.32176;
  long int D.32177;
  long int D.32178;
  long int D.32179;

  D.32176 = w->stop;
  D.32177 = w->start;
  D.32178 = D.32176 - D.32177;
  D.32179 = D.32178 / 10;
  D.32175 = (guint64) D.32179;
  return D.32175;
}


send_type_load (struct MonoClass * klass)
{
  union mono_mutex_t * D.32181;
  _Bool D.32184;
  long int D.32185;
  long int D.32186;
  struct GHashTable * D.32189;
  void * D.32190;
  _Bool D.32195;
  long int D.32196;
  long int D.32197;
  gboolean type_load;
  struct MonoDomain * domain;
  struct AgentDomainInfo * info;

  type_load = 0;
  domain = mono_domain_get ();
  info = 0B;
  mono_loader_lock ();
  {
    int ret;

    D.32181 = &domain->lock.mutex;
    ret = pthread_mutex_lock (D.32181);
    if (ret != 0) goto <D.32182>; else goto <D.32183>;
    <D.32182>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.32183>:
    D.32184 = ret != 0;
    D.32185 = (long int) D.32184;
    D.32186 = __builtin_expect (D.32185, 0);
    if (D.32186 != 0) goto <D.32187>; else goto <D.32188>;
    <D.32187>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 3983, "ret == 0");
    <D.32188>:
  }
  info = get_agent_domain_info (domain);
  D.32189 = info->loaded_classes;
  D.32190 = monoeg_g_hash_table_lookup (D.32189, klass);
  if (D.32190 == 0B) goto <D.32191>; else goto <D.32192>;
  <D.32191>:
  type_load = 1;
  D.32189 = info->loaded_classes;
  monoeg_g_hash_table_insert_replace (D.32189, klass, klass, 0);
  <D.32192>:
  {
    int ret;

    D.32181 = &domain->lock.mutex;
    ret = pthread_mutex_unlock (D.32181);
    if (ret != 0) goto <D.32193>; else goto <D.32194>;
    <D.32193>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.32194>:
    D.32195 = ret != 0;
    D.32196 = (long int) D.32195;
    D.32197 = __builtin_expect (D.32196, 0);
    if (D.32197 != 0) goto <D.32198>; else goto <D.32199>;
    <D.32198>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 3992, "ret == 0");
    <D.32199>:
  }
  mono_loader_unlock ();
  if (type_load != 0) goto <D.32200>; else goto <D.32201>;
  <D.32200>:
  emit_type_load (klass, klass, 0B);
  <D.32201>:
}


add_pending_breakpoints (struct MonoMethod * method, struct MonoJitInfo * ji)
{
  struct GPtrArray * breakpoints.386;
  void * * D.32205;
  long unsigned int D.32206;
  long unsigned int D.32207;
  void * * D.32208;
  int D.32209;
  struct GPtrArray * D.32212;
  void * * D.32213;
  long unsigned int D.32214;
  long unsigned int D.32215;
  void * * D.32216;
  struct MonoJitInfo * D.32217;
  unsigned int D.32220;
  unsigned int j.387;
  union mono_mutex_t * D.32224;
  _Bool D.32227;
  long int D.32228;
  long int D.32229;
  void * D.32232;
  struct GHashTable * D.32233;
  long unsigned int D.32236;
  long unsigned int D.32237;
  struct MonoMethod * D.32240;
  _Bool D.32243;
  long int D.32244;
  long int D.32245;
  _Bool D.32250;
  long int D.32251;
  long int D.32252;
  unsigned int D.32255;
  unsigned int i.388;
  int i;
  int j;
  struct MonoSeqPointInfo * seq_points;
  struct MonoDomain * domain;
  struct MonoMethod * jmethod;

  breakpoints.386 = breakpoints;
  if (breakpoints.386 == 0B) goto <D.32203>; else goto <D.32204>;
  <D.32203>:
  return;
  <D.32204>:
  domain = mono_domain_get ();
  mono_loader_lock ();
  i = 0;
  goto <D.26017>;
  <D.26016>:
  {
    struct MonoBreakpoint * bp;
    gboolean found;

    breakpoints.386 = breakpoints;
    D.32205 = breakpoints.386->pdata;
    D.32206 = (long unsigned int) i;
    D.32207 = D.32206 * 8;
    D.32208 = D.32205 + D.32207;
    bp = *D.32208;
    found = 0;
    D.32209 = bp_matches_method (bp, method);
    if (D.32209 == 0) goto <D.32210>; else goto <D.32211>;
    <D.32210>:
    // predicted unlikely by continue predictor.
    goto <D.26009>;
    <D.32211>:
    j = 0;
    goto <D.26012>;
    <D.26011>:
    {
      struct BreakpointInstance * inst;

      D.32212 = bp->children;
      D.32213 = D.32212->pdata;
      D.32214 = (long unsigned int) j;
      D.32215 = D.32214 * 8;
      D.32216 = D.32213 + D.32215;
      inst = *D.32216;
      D.32217 = inst->ji;
      if (D.32217 == ji) goto <D.32218>; else goto <D.32219>;
      <D.32218>:
      found = 1;
      <D.32219>:
    }
    j = j + 1;
    <D.26012>:
    D.32212 = bp->children;
    D.32220 = D.32212->len;
    j.387 = (unsigned int) j;
    if (D.32220 > j.387) goto <D.26011>; else goto <D.26013>;
    <D.26013>:
    if (found == 0) goto <D.32222>; else goto <D.32223>;
    <D.32222>:
    jmethod = jinfo_get_method (ji);
    {
      int ret;

      D.32224 = &domain->lock.mutex;
      ret = pthread_mutex_lock (D.32224);
      if (ret != 0) goto <D.32225>; else goto <D.32226>;
      <D.32225>:
      monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
      <D.32226>:
      D.32227 = ret != 0;
      D.32228 = (long int) D.32227;
      D.32229 = __builtin_expect (D.32228, 0);
      if (D.32229 != 0) goto <D.32230>; else goto <D.32231>;
      <D.32230>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 4271, "ret == 0");
      <D.32231>:
    }
    D.32232 = domain->runtime_info;
    D.32233 = MEM[(struct MonoJitDomainInfo *)D.32232].seq_points;
    seq_points = monoeg_g_hash_table_lookup (D.32233, jmethod);
    if (seq_points == 0B) goto <D.32234>; else goto <D.32235>;
    <D.32234>:
    D.32236 = BIT_FIELD_REF <*jmethod, 64, 256>;
    D.32237 = D.32236 & 2251799813685248;
    if (D.32237 != 0) goto <D.32238>; else goto <D.32239>;
    <D.32238>:
    D.32232 = domain->runtime_info;
    D.32233 = MEM[(struct MonoJitDomainInfo *)D.32232].seq_points;
    D.32240 = mono_method_get_declaring_generic_method (jmethod);
    seq_points = monoeg_g_hash_table_lookup (D.32233, D.32240);
    <D.32239>:
    <D.32235>:
    {
      int ret;

      D.32224 = &domain->lock.mutex;
      ret = pthread_mutex_unlock (D.32224);
      if (ret != 0) goto <D.32241>; else goto <D.32242>;
      <D.32241>:
      monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
      <D.32242>:
      D.32243 = ret != 0;
      D.32244 = (long int) D.32243;
      D.32245 = __builtin_expect (D.32244, 0);
      if (D.32245 != 0) goto <D.32246>; else goto <D.32247>;
      <D.32246>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 4275, "ret == 0");
      <D.32247>:
    }
    if (seq_points == 0B) goto <D.32248>; else goto <D.32249>;
    <D.32248>:
    // predicted unlikely by continue predictor.
    goto <D.26009>;
    <D.32249>:
    D.32250 = seq_points == 0B;
    D.32251 = (long int) D.32250;
    D.32252 = __builtin_expect (D.32251, 0);
    if (D.32252 != 0) goto <D.32253>; else goto <D.32254>;
    <D.32253>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 4279, "seq_points");
    <D.32254>:
    insert_breakpoint (seq_points, domain, ji, bp, 0B);
    <D.32223>:
  }
  <D.26009>:
  i = i + 1;
  <D.26017>:
  breakpoints.386 = breakpoints;
  D.32255 = breakpoints.386->len;
  i.388 = (unsigned int) i;
  if (D.32255 > i.388) goto <D.26016>; else goto <D.26018>;
  <D.26018>:
  mono_loader_unlock ();
}


assembly_unload (struct MonoProfiler * prof, struct MonoAssembly * assembly)
{
  process_profiler_event (9, assembly);
  clear_event_requests_for_assembly (assembly);
  clear_types_for_assembly (assembly);
}


clear_event_requests_for_assembly (struct MonoAssembly * assembly)
{
  struct GPtrArray * event_requests.389;
  void * * D.32259;
  long unsigned int D.32260;
  long unsigned int D.32261;
  void * * D.32262;
  int D.32263;
  int D.32266;
  int D.32267;
  unsigned int D.32268;
  unsigned int i.390;
  int i;
  gboolean found;

  mono_loader_lock ();
  found = 1;
  goto <D.26575>;
  <D.26574>:
  found = 0;
  i = 0;
  goto <D.26573>;
  <D.26572>:
  {
    struct EventRequest * req;

    event_requests.389 = event_requests;
    D.32259 = event_requests.389->pdata;
    D.32260 = (long unsigned int) i;
    D.32261 = D.32260 * 8;
    D.32262 = D.32259 + D.32261;
    req = *D.32262;
    D.32263 = event_req_matches_assembly (req, assembly);
    if (D.32263 != 0) goto <D.32264>; else goto <D.32265>;
    <D.32264>:
    D.32266 = req->id;
    D.32267 = req->event_kind;
    clear_event_request (D.32266, D.32267);
    found = 1;
    goto <D.26571>;
    <D.32265>:
  }
  i = i + 1;
  <D.26573>:
  event_requests.389 = event_requests;
  D.32268 = event_requests.389->len;
  i.390 = (unsigned int) i;
  if (D.32268 > i.390) goto <D.26572>; else goto <D.26571>;
  <D.26571>:
  <D.26575>:
  if (found != 0) goto <D.26574>; else goto <D.26576>;
  <D.26576>:
  mono_loader_unlock ();
}


event_req_matches_assembly (struct EventRequest * req, struct MonoAssembly * assembly)
{
  int D.32270;
  gboolean D.32273;
  void * D.32274;
  <unnamed type> D.32275;
  struct MonoClass * D.32278;
  struct MonoImage * D.32281;
  struct MonoAssembly * D.32282;
  struct MonoAssembly * * D.32287;
  long unsigned int D.32290;
  long unsigned int D.32291;
  struct MonoAssembly * * D.32292;
  struct MonoAssembly * D.32293;
  int D.32296;

  D.32270 = req->event_kind;
  if (D.32270 == 10) goto <D.32271>; else goto <D.32272>;
  <D.32271>:
  D.32274 = req->info;
  D.32273 = breakpoint_matches_assembly (D.32274, assembly);
  return D.32273;
  <D.32272>:
  {
    int i;
    int j;

    i = 0;
    goto <D.26563>;
    <D.26562>:
    {
      struct Modifier * m;

      m = &req->modifiers[i];
      D.32275 = m->kind;
      if (D.32275 == 8) goto <D.32276>; else goto <D.32277>;
      <D.32276>:
      D.32278 = m->data.exc_class;
      if (D.32278 != 0B) goto <D.32279>; else goto <D.32280>;
      <D.32279>:
      D.32278 = m->data.exc_class;
      D.32281 = D.32278->image;
      D.32282 = D.32281->assembly;
      if (D.32282 == assembly) goto <D.32283>; else goto <D.32284>;
      <D.32283>:
      D.32273 = 1;
      return D.32273;
      <D.32284>:
      <D.32280>:
      <D.32277>:
      D.32275 = m->kind;
      if (D.32275 == 11) goto <D.32285>; else goto <D.32286>;
      <D.32285>:
      D.32287 = m->data.assemblies;
      if (D.32287 != 0B) goto <D.32288>; else goto <D.32289>;
      <D.32288>:
      j = 0;
      goto <D.26560>;
      <D.26559>:
      D.32287 = m->data.assemblies;
      D.32290 = (long unsigned int) j;
      D.32291 = D.32290 * 8;
      D.32292 = D.32287 + D.32291;
      D.32293 = *D.32292;
      if (D.32293 == assembly) goto <D.32294>; else goto <D.32295>;
      <D.32294>:
      D.32273 = 1;
      return D.32273;
      <D.32295>:
      j = j + 1;
      <D.26560>:
      D.32287 = m->data.assemblies;
      D.32290 = (long unsigned int) j;
      D.32291 = D.32290 * 8;
      D.32292 = D.32287 + D.32291;
      D.32293 = *D.32292;
      if (D.32293 != 0B) goto <D.26559>; else goto <D.26561>;
      <D.26561>:
      <D.32289>:
      <D.32286>:
    }
    i = i + 1;
    <D.26563>:
    D.32296 = req->nmodifiers;
    if (D.32296 > i) goto <D.26562>; else goto <D.26564>;
    <D.26564>:
  }
  D.32273 = 0;
  return D.32273;
}


breakpoint_matches_assembly (struct MonoBreakpoint * bp, struct MonoAssembly * assembly)
{
  gboolean D.32298;
  int iftmp.391;
  struct MonoMethod * D.32302;
  struct MonoClass * D.32304;
  struct MonoImage * D.32305;
  struct MonoAssembly * D.32306;

  D.32302 = bp->method;
  if (D.32302 != 0B) goto <D.32303>; else goto <D.32300>;
  <D.32303>:
  D.32302 = bp->method;
  D.32304 = D.32302->klass;
  D.32305 = D.32304->image;
  D.32306 = D.32305->assembly;
  if (D.32306 == assembly) goto <D.32307>; else goto <D.32300>;
  <D.32307>:
  iftmp.391 = 1;
  goto <D.32301>;
  <D.32300>:
  iftmp.391 = 0;
  <D.32301>:
  D.32298 = iftmp.391;
  return D.32298;
}


clear_types_for_assembly (struct MonoAssembly * assembly)
{
  struct GHashTable * D.32309;
  struct MonoDomain * domain;
  struct AgentDomainInfo * info;

  domain = mono_domain_get ();
  info = 0B;
  mono_loader_lock ();
  info = get_agent_domain_info (domain);
  D.32309 = info->loaded_classes;
  monoeg_g_hash_table_foreach_remove (D.32309, type_comes_from_assembly, assembly);
  mono_loader_unlock ();
}


type_comes_from_assembly (void * klass, void * also_klass, void * assembly)
{
  gboolean D.32310;
  struct MonoImage * D.32311;
  struct MonoImage * D.32312;
  _Bool D.32313;

  D.32311 = mono_class_get_image (klass);
  D.32312 = mono_assembly_get_image (assembly);
  D.32313 = D.32311 == D.32312;
  D.32310 = (gboolean) D.32313;
  return D.32310;
}


assembly_load (struct MonoProfiler * prof, struct MonoAssembly * assembly, int result)
{
  struct GPtrArray * pending_assembly_loads.392;

  mono_loader_lock ();
  pending_assembly_loads.392 = pending_assembly_loads;
  monoeg_g_ptr_array_add (pending_assembly_loads.392, assembly);
  mono_loader_unlock ();
}


thread_end (struct MonoProfiler * prof, uintptr_t tid)
{
  struct MonoGHashTable * tid_to_thread.393;
  const void * tid.394;
  struct MonoGHashTable * tid_to_thread_obj.395;
  struct MonoGHashTable * thread_to_tls.396;
  struct MonoInternalThread * * D.32324;
  int log_level.397;
  _Bool D.32328;
  long int D.32329;
  long int D.32330;
  struct FILE * log_file.398;
  void * tid.399;
  struct MonoInternalThread * thread;
  struct DebuggerTlsData * tls;

  tls = 0B;
  mono_loader_lock ();
  tid_to_thread.393 = tid_to_thread;
  tid.394 = (const void *) tid;
  thread = mono_g_hash_table_lookup (tid_to_thread.393, tid.394);
  if (thread != 0B) goto <D.32318>; else goto <D.32319>;
  <D.32318>:
  tid_to_thread_obj.395 = tid_to_thread_obj;
  tid.394 = (const void *) tid;
  mono_g_hash_table_remove (tid_to_thread_obj.395, tid.394);
  thread_to_tls.396 = thread_to_tls;
  tls = mono_g_hash_table_lookup (thread_to_tls.396, thread);
  if (tls != 0B) goto <D.32322>; else goto <D.32323>;
  <D.32322>:
  tls->terminated = 1;
  D.32324 = &tls->thread;
  mono_gc_deregister_root (D.32324);
  tls->thread = 0B;
  <D.32323>:
  <D.32319>:
  mono_loader_unlock ();
  if (thread != 0B) goto <D.32325>; else goto <D.32326>;
  <D.32325>:
  log_level.397 = log_level;
  D.32328 = log_level.397 > 0;
  D.32329 = (long int) D.32328;
  D.32330 = __builtin_expect (D.32329, 0);
  if (D.32330 != 0) goto <D.32331>; else goto <D.32332>;
  <D.32331>:
  log_file.398 = log_file;
  tid.399 = (void *) tid;
  fprintf (log_file.398, "[%p] Thread terminated, obj=%p, tls=%p.\n", tid.399, thread, tls);
  log_file.398 = log_file;
  fflush (log_file.398);
  <D.32332>:
  process_profiler_event (3, thread);
  <D.32326>:
}


thread_startup (struct MonoProfiler * prof, uintptr_t tid)
{
  long unsigned int debugger_thread_id.400;
  long unsigned int D.32338;
  _Bool D.32339;
  long int D.32340;
  long int D.32341;
  struct MonoGHashTable * tid_to_thread.401;
  const void * tid.402;
  int log_level.403;
  _Bool D.32351;
  long int D.32352;
  long int D.32353;
  struct FILE * log_file.404;
  void * tid.405;
  struct MonoGHashTable * thread_to_tls.406;
  struct MonoGHashTable * tid_to_thread_obj.407;
  unsigned int debugger_tls_id.408;
  _Bool D.32363;
  long int D.32364;
  long int D.32365;
  struct MonoInternalThread * * D.32370;
  void * D.32371;
  struct MonoThread * D.32374;
  struct MonoInternalThread * thread;
  struct MonoInternalThread * old_thread;
  struct DebuggerTlsData * tls;

  thread = mono_thread_internal_current ();
  debugger_thread_id.400 = debugger_thread_id;
  if (tid == debugger_thread_id.400) goto <D.32336>; else goto <D.32337>;
  <D.32336>:
  return;
  <D.32337>:
  D.32338 = thread->tid;
  D.32339 = D.32338 != tid;
  D.32340 = (long int) D.32339;
  D.32341 = __builtin_expect (D.32340, 0);
  if (D.32341 != 0) goto <D.32342>; else goto <D.32343>;
  <D.32342>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 3789, "thread->tid == tid");
  <D.32343>:
  mono_loader_lock ();
  tid_to_thread.401 = tid_to_thread;
  tid.402 = (const void *) tid;
  old_thread = mono_g_hash_table_lookup (tid_to_thread.401, tid.402);
  mono_loader_unlock ();
  if (old_thread != 0B) goto <D.32346>; else goto <D.32347>;
  <D.32346>:
  if (thread == old_thread) goto <D.32348>; else goto <D.32349>;
  <D.32348>:
  log_level.403 = log_level;
  D.32351 = log_level.403 > 0;
  D.32352 = (long int) D.32351;
  D.32353 = __builtin_expect (D.32352, 0);
  if (D.32353 != 0) goto <D.32354>; else goto <D.32355>;
  <D.32354>:
  log_file.404 = log_file;
  tid.405 = (void *) tid;
  tid.405 = (void *) tid;
  fprintf (log_file.404, "[%p] thread_start () called multiple times for %p, ignored.\n", tid.405, tid.405);
  log_file.404 = log_file;
  fflush (log_file.404);
  <D.32355>:
  return;
  <D.32349>:
  log_level.403 = log_level;
  D.32351 = log_level.403 > 0;
  D.32352 = (long int) D.32351;
  D.32353 = __builtin_expect (D.32352, 0);
  if (D.32353 != 0) goto <D.32358>; else goto <D.32359>;
  <D.32358>:
  log_file.404 = log_file;
  tid.405 = (void *) tid;
  tid.405 = (void *) tid;
  fprintf (log_file.404, "[%p] Removing stale data for tid %p.\n", tid.405, tid.405);
  log_file.404 = log_file;
  fflush (log_file.404);
  <D.32359>:
  mono_loader_lock ();
  thread_to_tls.406 = thread_to_tls;
  mono_g_hash_table_remove (thread_to_tls.406, old_thread);
  tid_to_thread.401 = tid_to_thread;
  tid.402 = (const void *) tid;
  mono_g_hash_table_remove (tid_to_thread.401, tid.402);
  tid_to_thread_obj.407 = tid_to_thread_obj;
  tid.402 = (const void *) tid;
  mono_g_hash_table_remove (tid_to_thread_obj.407, tid.402);
  mono_loader_unlock ();
  <D.32347>:
  debugger_tls_id.408 = debugger_tls_id;
  tls = pthread_getspecific (debugger_tls_id.408);
  D.32363 = tls != 0B;
  D.32364 = (long int) D.32363;
  D.32365 = __builtin_expect (D.32364, 0);
  if (D.32365 != 0) goto <D.32366>; else goto <D.32367>;
  <D.32366>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 3817, "!tls");
  <D.32367>:
  tls = monoeg_malloc0 (3384);
  if (0 != 0) goto <D.32368>; else goto <D.32369>;
  <D.32368>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 3820, "sizeof (tls->thread) == sizeof (MonoObject*)");
  <D.32369>:
  D.32370 = &tls->thread;
  D.32371 = mono_gc_make_root_descr_all_refs (1);
  mono_gc_register_root (D.32370, 8, D.32371);
  tls->thread = thread;
  debugger_tls_id.408 = debugger_tls_id;
  mono_native_tls_set_value (debugger_tls_id.408, tls);
  log_level.403 = log_level;
  D.32351 = log_level.403 > 0;
  D.32352 = (long int) D.32351;
  D.32353 = __builtin_expect (D.32352, 0);
  if (D.32353 != 0) goto <D.32372>; else goto <D.32373>;
  <D.32372>:
  log_file.404 = log_file;
  tid.405 = (void *) tid;
  fprintf (log_file.404, "[%p] Thread started, obj=%p, tls=%p.\n", tid.405, thread, tls);
  log_file.404 = log_file;
  fflush (log_file.404);
  <D.32373>:
  mono_loader_lock ();
  thread_to_tls.406 = thread_to_tls;
  mono_g_hash_table_insert (thread_to_tls.406, thread, tls);
  tid_to_thread.401 = tid_to_thread;
  tid.405 = (void *) tid;
  mono_g_hash_table_insert (tid_to_thread.401, tid.405, thread);
  tid_to_thread_obj.407 = tid_to_thread_obj;
  tid.405 = (void *) tid;
  D.32374 = mono_thread_current ();
  mono_g_hash_table_insert (tid_to_thread_obj.407, tid.405, D.32374);
  mono_loader_unlock ();
  process_profiler_event (2, thread);
  suspend_current ();
}


mono_native_tls_set_value (pthread_key_t key, void * value)
{
  int D.32376;
  int D.32377;
  _Bool D.32378;

  D.32377 = pthread_setspecific (key, value);
  D.32378 = D.32377 == 0;
  D.32376 = (int) D.32378;
  return D.32376;
}


appdomain_unload (struct MonoProfiler * prof, struct MonoDomain * domain)
{
  struct MonoGHashTable * thread_to_tls.409;

  clear_breakpoints_for_domain (domain);
  mono_loader_lock ();
  thread_to_tls.409 = thread_to_tls;
  mono_g_hash_table_foreach (thread_to_tls.409, invalidate_each_thread, 0B);
  mono_loader_unlock ();
  process_profiler_event (5, domain);
}


invalidate_each_thread (void * key, void * value, void * user_data)
{
  invalidate_frames (value);
}


clear_breakpoints_for_domain (struct MonoDomain * domain)
{
  struct GPtrArray * breakpoints.410;
  void * * D.32384;
  long unsigned int D.32385;
  long unsigned int D.32386;
  void * * D.32387;
  struct GPtrArray * D.32388;
  void * * D.32389;
  long unsigned int D.32390;
  long unsigned int D.32391;
  void * * D.32392;
  struct MonoDomain * D.32393;
  unsigned int j.411;
  unsigned int D.32398;
  unsigned int D.32399;
  unsigned int i.412;
  int i;
  int j;

  breakpoints.410 = breakpoints;
  if (breakpoints.410 == 0B) goto <D.32382>; else goto <D.32383>;
  <D.32382>:
  return;
  <D.32383>:
  mono_loader_lock ();
  i = 0;
  goto <D.26080>;
  <D.26079>:
  {
    struct MonoBreakpoint * bp;

    breakpoints.410 = breakpoints;
    D.32384 = breakpoints.410->pdata;
    D.32385 = (long unsigned int) i;
    D.32386 = D.32385 * 8;
    D.32387 = D.32384 + D.32386;
    bp = *D.32387;
    j = 0;
    goto <D.26077>;
    <D.26076>:
    {
      struct BreakpointInstance * inst;

      D.32388 = bp->children;
      D.32389 = D.32388->pdata;
      D.32390 = (long unsigned int) j;
      D.32391 = D.32390 * 8;
      D.32392 = D.32389 + D.32391;
      inst = *D.32392;
      D.32393 = inst->domain;
      if (D.32393 == domain) goto <D.32394>; else goto <D.32395>;
      <D.32394>:
      remove_breakpoint (inst);
      monoeg_g_free (inst);
      D.32388 = bp->children;
      j.411 = (unsigned int) j;
      monoeg_g_ptr_array_remove_index_fast (D.32388, j.411);
      goto <D.32397>;
      <D.32395>:
      j = j + 1;
      <D.32397>:
    }
    <D.26077>:
    D.32388 = bp->children;
    D.32398 = D.32388->len;
    j.411 = (unsigned int) j;
    if (D.32398 > j.411) goto <D.26076>; else goto <D.26078>;
    <D.26078>:
  }
  i = i + 1;
  <D.26080>:
  breakpoints.410 = breakpoints;
  D.32399 = breakpoints.410->len;
  i.412 = (unsigned int) i;
  if (D.32399 > i.412) goto <D.26079>; else goto <D.26081>;
  <D.26081>:
  mono_loader_unlock ();
}


appdomain_load (struct MonoProfiler * prof, struct MonoDomain * domain, int result)
{
  struct GHashTable * domains.413;

  mono_loader_lock ();
  domains.413 = domains;
  monoeg_g_hash_table_insert_replace (domains.413, domain, domain, 0);
  mono_loader_unlock ();
  process_profiler_event (4, domain);
}


runtime_initialized (struct MonoProfiler * prof)
{
  struct MonoThread * D.32403;
  int D.32404;

  D.32403 = mono_thread_current ();
  process_profiler_event (0, D.32403);
  D.32404 = agent_config.defer;
  if (D.32404 != 0) goto <D.32405>; else goto <D.32406>;
  <D.32405>:
  start_debugger_thread ();
  <D.32406>:
}


runtime_shutdown (struct MonoProfiler * prof)
{
  struct MonoThread * D.32407;

  D.32407 = mono_thread_current ();
  process_profiler_event (1, D.32407);
  mono_debugger_agent_cleanup ();
}


mono_debugger_agent_cleanup ()
{
  int inited.414;

  inited.414 = inited;
  if (inited.414 == 0) goto <D.32409>; else goto <D.32410>;
  <D.32409>:
  return;
  <D.32410>:
  stop_debugger_thread ();
  breakpoints_cleanup ();
  objrefs_cleanup ();
  ids_cleanup ();
  pthread_mutex_destroy (&debugger_thread_exited_mutex);
}


stop_debugger_thread ()
{
  int inited.415;
  long unsigned int D.32415;
  long unsigned int debugger_thread_id.416;
  int debugger_thread_exited.417;

  inited.415 = inited;
  if (inited.415 == 0) goto <D.32413>; else goto <D.32414>;
  <D.32413>:
  return;
  <D.32414>:
  transport_close1 ();
  D.32415 = GetCurrentThreadId ();
  debugger_thread_id.416 = debugger_thread_id;
  if (D.32415 != debugger_thread_id.416) goto <D.32417>; else goto <D.32418>;
  <D.32417>:
  <D.25151>:
  pthread_mutex_lock (&debugger_thread_exited_mutex);
  debugger_thread_exited.417 = debugger_thread_exited;
  if (debugger_thread_exited.417 == 0) goto <D.32420>; else goto <D.32421>;
  <D.32420>:
  pthread_cond_wait (&debugger_thread_exited_cond, &debugger_thread_exited_mutex);
  <D.32421>:
  pthread_mutex_unlock (&debugger_thread_exited_mutex);
  debugger_thread_exited.417 = debugger_thread_exited;
  if (debugger_thread_exited.417 == 0) goto <D.25151>; else goto <D.25152>;
  <D.25152>:
  <D.32418>:
  transport_close2 ();
}


transport_close1 ()
{
  struct DebuggerTransport * transport.418;
  void (*<T8f1>) (void) D.32424;

  transport.418 = transport;
  D.32424 = transport.418->close1;
  D.32424 ();
}


breakpoints_cleanup ()
{
  struct GPtrArray * event_requests.419;
  void * * D.32426;
  long unsigned int D.32427;
  long unsigned int D.32428;
  void * * D.32429;
  int D.32430;
  void * D.32433;
  unsigned int i.420;
  unsigned int D.32436;
  struct GPtrArray * breakpoints.421;
  void * * D.32438;
  void * * D.32439;
  void * D.32440;
  unsigned int D.32441;
  struct GHashTable * bp_locs.422;
  int i;

  mono_loader_lock ();
  i = 0;
  goto <D.26064>;
  <D.26063>:
  {
    struct EventRequest * req;

    event_requests.419 = event_requests;
    D.32426 = event_requests.419->pdata;
    D.32427 = (long unsigned int) i;
    D.32428 = D.32427 * 8;
    D.32429 = D.32426 + D.32428;
    req = *D.32429;
    D.32430 = req->event_kind;
    if (D.32430 == 10) goto <D.32431>; else goto <D.32432>;
    <D.32431>:
    D.32433 = req->info;
    clear_breakpoint (D.32433);
    event_requests.419 = event_requests;
    i.420 = (unsigned int) i;
    monoeg_g_ptr_array_remove_index_fast (event_requests.419, i.420);
    monoeg_g_free (req);
    goto <D.32435>;
    <D.32432>:
    i = i + 1;
    <D.32435>:
  }
  <D.26064>:
  event_requests.419 = event_requests;
  D.32436 = event_requests.419->len;
  i.420 = (unsigned int) i;
  if (D.32436 > i.420) goto <D.26063>; else goto <D.26065>;
  <D.26065>:
  i = 0;
  goto <D.26067>;
  <D.26066>:
  breakpoints.421 = breakpoints;
  D.32438 = breakpoints.421->pdata;
  D.32427 = (long unsigned int) i;
  D.32428 = D.32427 * 8;
  D.32439 = D.32438 + D.32428;
  D.32440 = *D.32439;
  monoeg_g_free (D.32440);
  i = i + 1;
  <D.26067>:
  breakpoints.421 = breakpoints;
  D.32441 = breakpoints.421->len;
  i.420 = (unsigned int) i;
  if (D.32441 > i.420) goto <D.26066>; else goto <D.26068>;
  <D.26068>:
  breakpoints.421 = breakpoints;
  monoeg_g_ptr_array_free (breakpoints.421, 1);
  bp_locs.422 = bp_locs;
  monoeg_g_hash_table_destroy (bp_locs.422);
  breakpoints = 0B;
  bp_locs = 0B;
  mono_loader_unlock ();
}


objrefs_cleanup ()
{
  struct GHashTable * objrefs.423;

  objrefs.423 = objrefs;
  monoeg_g_hash_table_destroy (objrefs.423);
  objrefs = 0B;
}


ids_cleanup ()
{
  struct GPtrArray * D.32444;
  void * * D.32447;
  long unsigned int D.32448;
  long unsigned int D.32449;
  void * * D.32450;
  void * D.32451;
  unsigned int D.32452;
  unsigned int j.424;
  int i;
  int j;

  i = 0;
  goto <D.25355>;
  <D.25354>:
  D.32444 = ids[i];
  if (D.32444 != 0B) goto <D.32445>; else goto <D.32446>;
  <D.32445>:
  j = 0;
  goto <D.25352>;
  <D.25351>:
  D.32444 = ids[i];
  D.32447 = D.32444->pdata;
  D.32448 = (long unsigned int) j;
  D.32449 = D.32448 * 8;
  D.32450 = D.32447 + D.32449;
  D.32451 = *D.32450;
  monoeg_g_free (D.32451);
  j = j + 1;
  <D.25352>:
  D.32444 = ids[i];
  D.32452 = D.32444->len;
  j.424 = (unsigned int) j;
  if (D.32452 > j.424) goto <D.25351>; else goto <D.25353>;
  <D.25353>:
  D.32444 = ids[i];
  monoeg_g_ptr_array_free (D.32444, 1);
  <D.32446>:
  ids[i] = 0B;
  i = i + 1;
  <D.25355>:
  if (i <= 6) goto <D.25354>; else goto <D.25356>;
  <D.25356>:
}


transport_init ()
{
  char * D.32454;
  const char * D.32455;
  int D.32456;
  int ntransports.425;
  struct _IO_FILE * stderr.426;
  const char * iftmp.427;
  struct DebuggerTransport * D.32466;
  int i;

  register_socket_transport ();
  i = 0;
  goto <D.25114>;
  <D.25113>:
  D.32454 = agent_config.transport;
  D.32455 = transports[i].name;
  D.32456 = strcmp (D.32454, D.32455);
  if (D.32456 == 0) goto <D.25112>; else goto <D.32457>;
  <D.32457>:
  i = i + 1;
  <D.25114>:
  ntransports.425 = ntransports;
  if (i < ntransports.425) goto <D.25113>; else goto <D.25112>;
  <D.25112>:
  ntransports.425 = ntransports;
  if (i == ntransports.425) goto <D.32459>; else goto <D.32460>;
  <D.32459>:
  stderr.426 = stderr;
  fprintf (stderr.426, "debugger-agent: The supported values for the \'transport\' option are: ");
  i = 0;
  goto <D.25116>;
  <D.25115>:
  stderr.426 = stderr;
  if (i > 0) goto <D.32463>; else goto <D.32464>;
  <D.32463>:
  iftmp.427 = ", ";
  goto <D.32465>;
  <D.32464>:
  iftmp.427 = "";
  <D.32465>:
  D.32455 = transports[i].name;
  fprintf (stderr.426, "%s\'%s\'", iftmp.427, D.32455);
  i = i + 1;
  <D.25116>:
  ntransports.425 = ntransports;
  if (i < ntransports.425) goto <D.25115>; else goto <D.25117>;
  <D.25117>:
  stderr.426 = stderr;
  fprintf (stderr.426, "\n");
  exit (1);
  <D.32460>:
  D.32466 = &transports[i];
  transport = D.32466;
}


register_socket_transport ()
{
  struct DebuggerTransport trans;

  try
    {
      trans.name = "dt_socket";
      trans.connect = socket_transport_connect;
      trans.close1 = socket_transport_close1;
      trans.close2 = socket_transport_close2;
      trans.send = socket_transport_send;
      trans.recv = socket_transport_recv;
      register_transport (&trans);
    }
  finally
    {
      trans = {CLOBBER};
    }
}


socket_transport_recv (void * buf, int len)
{
  sizetype D.32467;
  void * D.32468;
  int D.32469;
  long unsigned int D.32470;
  long int D.32471;
  int D.32474;
  int * D.32480;
  int D.32481;
  unsigned int D.32485;
  int last_keepalive.428;
  int D.32487;
  int D.32495;
  int res;
  int total;
  int fd;
  int flags;
  static gint32 last_keepalive;
  gint32 msecs;
  void again = <<< error >>>;

  total = 0;
  fd = conn_fd;
  flags = 0;
  <D.25038>:
  again:
  D.32467 = (sizetype) total;
  D.32468 = buf + D.32467;
  D.32469 = len - total;
  D.32470 = (long unsigned int) D.32469;
  D.32471 = recv (fd, D.32468, D.32470, flags);
  res = (int) D.32471;
  if (res > 0) goto <D.32472>; else goto <D.32473>;
  <D.32472>:
  total = total + res;
  <D.32473>:
  D.32474 = agent_config.keepalive;
  if (D.32474 != 0) goto <D.32475>; else goto <D.32476>;
  <D.32475>:
  {
    gboolean need_keepalive;

    need_keepalive = 0;
    if (res == -1) goto <D.32479>; else goto <D.32477>;
    <D.32479>:
    D.32480 = __errno_location ();
    D.32481 = *D.32480;
    if (D.32481 == 11) goto <D.32482>; else goto <D.32477>;
    <D.32482>:
    need_keepalive = 1;
    goto <D.32478>;
    <D.32477>:
    if (res == -1) goto <D.32483>; else goto <D.32484>;
    <D.32483>:
    D.32485 = mono_msec_ticks ();
    msecs = (gint32) D.32485;
    last_keepalive.428 = last_keepalive;
    D.32487 = msecs - last_keepalive.428;
    D.32474 = agent_config.keepalive;
    if (D.32487 >= D.32474) goto <D.32488>; else goto <D.32489>;
    <D.32488>:
    need_keepalive = 1;
    last_keepalive = msecs;
    <D.32489>:
    <D.32484>:
    <D.32478>:
    if (need_keepalive != 0) goto <D.32490>; else goto <D.32491>;
    <D.32490>:
    process_profiler_event (14, 0B);
    goto again;
    <D.32491>:
  }
  <D.32476>:
  if (res > 0) goto <D.32493>; else goto <D.32492>;
  <D.32493>:
  if (total < len) goto <D.25038>; else goto <D.32492>;
  <D.32492>:
  if (res == -1) goto <D.32494>; else goto <D.25039>;
  <D.32494>:
  D.32480 = __errno_location ();
  D.32481 = *D.32480;
  if (D.32481 == 4) goto <D.25038>; else goto <D.25039>;
  <D.25039>:
  D.32495 = total;
  return D.32495;
}


__attribute__((__artificial__, __gnu_inline__, __always_inline__))
recv (int __fd, void * __buf, size_t __n, int __flags)
{
  long unsigned int D.32497;
  int D.32500;
  ssize_t D.32503;
  long unsigned int D.32504;
  long unsigned int D.32505;
  long unsigned int D.32508;

  D.32497 = __builtin_object_size (__buf, 0);
  if (D.32497 != 18446744073709551615) goto <D.32498>; else goto <D.32499>;
  <D.32498>:
  D.32500 = __builtin_constant_p (__n);
  if (D.32500 == 0) goto <D.32501>; else goto <D.32502>;
  <D.32501>:
  D.32504 = __builtin_object_size (__buf, 0);
  D.32503 = __recv_chk (__fd, __buf, __n, D.32504, __flags);
  return D.32503;
  <D.32502>:
  D.32505 = __builtin_object_size (__buf, 0);
  if (D.32505 < __n) goto <D.32506>; else goto <D.32507>;
  <D.32506>:
  D.32508 = __builtin_object_size (__buf, 0);
  D.32503 = __recv_chk_warn (__fd, __buf, __n, D.32508, __flags);
  return D.32503;
  <D.32507>:
  <D.32499>:
  D.32503 = __recv_alias (__fd, __buf, __n, __flags);
  return D.32503;
}


socket_transport_send (void * data, int len)
{
  int conn_fd.429;
  long unsigned int D.32511;
  long int D.32512;
  int * D.32514;
  int D.32515;
  gboolean D.32518;
  int res;

  <D.25053>:
  conn_fd.429 = conn_fd;
  D.32511 = (long unsigned int) len;
  D.32512 = send (conn_fd.429, data, D.32511, 0);
  res = (int) D.32512;
  if (res == -1) goto <D.32513>; else goto <D.25054>;
  <D.32513>:
  D.32514 = __errno_location ();
  D.32515 = *D.32514;
  if (D.32515 == 4) goto <D.25053>; else goto <D.25054>;
  <D.25054>:
  if (res != len) goto <D.32516>; else goto <D.32517>;
  <D.32516>:
  D.32518 = 0;
  return D.32518;
  <D.32517>:
  D.32518 = 1;
  return D.32518;
}


socket_transport_close2 ()
{
  int conn_fd.430;

  conn_fd.430 = conn_fd;
  shutdown (conn_fd.430, 2);
}


socket_transport_close1 ()
{
  int conn_fd.431;
  int listen_fd.432;

  conn_fd.431 = conn_fd;
  shutdown (conn_fd.431, 0);
  listen_fd.432 = listen_fd;
  shutdown (listen_fd.432, 2);
  listen_fd.432 = listen_fd;
  close (listen_fd.432);
}


socket_transport_connect (const char * address)
{
  char * D.32523;
  _Bool D.32526;
  long int D.32527;
  long int D.32528;
  char * host.433;
  int port.434;
  struct _IO_FILE * stderr.435;
  const char * D.32539;
  int D.32540;
  _Bool D.32545;
  long int D.32546;
  long int D.32547;
  int * D.32552;
  int D.32553;
  char * D.32554;
  union 
{
  struct sockaddr * restrict __sockaddr__;
  struct sockaddr_at * restrict __sockaddr_at__;
  struct sockaddr_ax25 * restrict __sockaddr_ax25__;
  struct sockaddr_dl * restrict __sockaddr_dl__;
  struct sockaddr_eon * restrict __sockaddr_eon__;
  struct sockaddr_in * restrict __sockaddr_in__;
  struct sockaddr_in6 * restrict __sockaddr_in6__;
  struct sockaddr_inarp * restrict __sockaddr_inarp__;
  struct sockaddr_ipx * restrict __sockaddr_ipx__;
  struct sockaddr_iso * restrict __sockaddr_iso__;
  struct sockaddr_ns * restrict __sockaddr_ns__;
  struct sockaddr_un * restrict __sockaddr_un__;
  struct sockaddr_x25 * restrict __sockaddr_x25__;
} D.32555;
  short unsigned int D.32558;
  short unsigned int D.32559;
  int port.436;
  int D.32562;
  int D.32563;
  int D.32564;
  int D.32567;
  union 
{
  const struct sockaddr * restrict __sockaddr__;
  const struct sockaddr_at * restrict __sockaddr_at__;
  const struct sockaddr_ax25 * restrict __sockaddr_ax25__;
  const struct sockaddr_dl * restrict __sockaddr_dl__;
  const struct sockaddr_eon * restrict __sockaddr_eon__;
  const struct sockaddr_in * restrict __sockaddr_in__;
  const struct sockaddr_in6 * restrict __sockaddr_in6__;
  const struct sockaddr_inarp * restrict __sockaddr_inarp__;
  const struct sockaddr_ipx * restrict __sockaddr_ipx__;
  const struct sockaddr_iso * restrict __sockaddr_iso__;
  const struct sockaddr_ns * restrict __sockaddr_ns__;
  const struct sockaddr_un * restrict __sockaddr_un__;
  const struct sockaddr_x25 * restrict __sockaddr_x25__;
} D.32570;
  struct sockaddr * D.32571;
  unsigned int D.32572;
  struct addrinfo * result.437;
  int D.32578;
  int log_level.438;
  _Bool D.32582;
  long int D.32583;
  long int D.32584;
  struct FILE * log_file.439;
  int D.32588;
  int D.32591;
  long int D.32592;
  long int D.25082;
  long int iftmp.440;
  int D.32594;
  long int iftmp.441;
  unsigned long __d.442;
  long int D.32603;
  long int D.32604;
  int D.32605;
  long unsigned int D.32606;
  long int D.32607;
  long int D.32608;
  int D.32609;
  int D.32612;
  int conn_fd.443;
  union 
{
  const struct sockaddr * restrict __sockaddr__;
  const struct sockaddr_at * restrict __sockaddr_at__;
  const struct sockaddr_ax25 * restrict __sockaddr_ax25__;
  const struct sockaddr_dl * restrict __sockaddr_dl__;
  const struct sockaddr_eon * restrict __sockaddr_eon__;
  const struct sockaddr_in * restrict __sockaddr_in__;
  const struct sockaddr_in6 * restrict __sockaddr_in6__;
  const struct sockaddr_inarp * restrict __sockaddr_inarp__;
  const struct sockaddr_ipx * restrict __sockaddr_ipx__;
  const struct sockaddr_iso * restrict __sockaddr_iso__;
  const struct sockaddr_ns * restrict __sockaddr_ns__;
  const struct sockaddr_un * restrict __sockaddr_un__;
  const struct sockaddr_x25 * restrict __sockaddr_x25__;
} D.32621;
  int D.32622;
  int D.32626;
  struct addrinfo hints;
  struct addrinfo * result;
  struct addrinfo * rp;
  int sfd;
  int s;
  int res;
  char port_string[128];
  char * host;
  int port;

  try
    {
      sfd = -1;
      D.32523 = agent_config.address;
      if (D.32523 != 0B) goto <D.32524>; else goto <D.32525>;
      <D.32524>:
      D.32523 = agent_config.address;
      res = parse_address (D.32523, &host, &port);
      D.32526 = res != 0;
      D.32527 = (long int) D.32526;
      D.32528 = __builtin_expect (D.32527, 0);
      if (D.32528 != 0) goto <D.32529>; else goto <D.32530>;
      <D.32529>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 1177, "res == 0");
      <D.32530>:
      goto <D.32531>;
      <D.32525>:
      host = 0B;
      port = 0;
      <D.32531>:
      conn_fd = -1;
      listen_fd = -1;
      host.433 = host;
      if (host.433 != 0B) goto <D.32533>; else goto <D.32534>;
      <D.32533>:
      port.434 = port;
      sprintf (&port_string, "%d", port.434);
      mono_network_init ();
      memset (&hints, 0, 48);
      hints.ai_family = 0;
      hints.ai_socktype = 1;
      hints.ai_flags = 0;
      hints.ai_protocol = 0;
      host.433 = host;
      s = getaddrinfo (host.433, &port_string, &hints, &result);
      if (s != 0) goto <D.32536>; else goto <D.32537>;
      <D.32536>:
      stderr.435 = stderr;
      host.433 = host;
      port.434 = port;
      D.32539 = gai_strerror (s);
      fprintf (stderr.435, "debugger-agent: Unable to resolve %s:%d: %s\n", host.433, port.434, D.32539);
      exit (1);
      <D.32537>:
      <D.32534>:
      D.32540 = agent_config.server;
      if (D.32540 != 0) goto <D.32541>; else goto <D.32542>;
      <D.32541>:
      host.433 = host;
      if (host.433 == 0B) goto <D.32543>; else goto <D.32544>;
      <D.32543>:
      {
        struct sockaddr_in addr;
        socklen_t addrlen;

        try
          {
            sfd = socket (2, 1, 0);
            D.32545 = sfd == 0;
            D.32546 = (long int) D.32545;
            D.32547 = __builtin_expect (D.32546, 0);
            if (D.32547 != 0) goto <D.32548>; else goto <D.32549>;
            <D.32548>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 1222, "sfd");
            <D.32549>:
            res = listen (sfd, 16);
            if (res == -1) goto <D.32550>; else goto <D.32551>;
            <D.32550>:
            stderr.435 = stderr;
            D.32552 = __errno_location ();
            D.32553 = *D.32552;
            D.32554 = strerror (D.32553);
            fprintf (stderr.435, "debugger-agent: Unable to setup listening socket: %s\n", D.32554);
            exit (1);
            <D.32551>:
            listen_fd = sfd;
            addrlen = 16;
            memset (&addr, 0, 16);
            D.32555.__sockaddr__ = &addr;
            res = getsockname (sfd, D.32555, &addrlen);
            D.32526 = res != 0;
            D.32527 = (long int) D.32526;
            D.32528 = __builtin_expect (D.32527, 0);
            if (D.32528 != 0) goto <D.32556>; else goto <D.32557>;
            <D.32556>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 1235, "res == 0");
            <D.32557>:
            host = "127.0.0.1";
            D.32558 = addr.sin_port;
            D.32559 = __uint16_identity (D.32558);
            port.436 = (int) D.32559;
            port = port.436;
            host.433 = host;
            port.434 = port;
            printf ("%s:%d\n", host.433, port.434);
          }
        finally
          {
            addr = {CLOBBER};
            addrlen = {CLOBBER};
          }
      }
      goto <D.32561>;
      <D.32544>:
      rp = result;
      goto <D.25073>;
      <D.25072>:
      {
        int n;

        try
          {
            n = 1;
            D.32562 = rp->ai_family;
            D.32563 = rp->ai_socktype;
            D.32564 = rp->ai_protocol;
            sfd = socket (D.32562, D.32563, D.32564);
            if (sfd == -1) goto <D.32565>; else goto <D.32566>;
            <D.32565>:
            // predicted unlikely by continue predictor.
            goto <D.25070>;
            <D.32566>:
            D.32567 = setsockopt (sfd, 1, 2, &n, 4);
            if (D.32567 == -1) goto <D.32568>; else goto <D.32569>;
            <D.32568>:
            // predicted unlikely by continue predictor.
            goto <D.25070>;
            <D.32569>:
            D.32571 = rp->ai_addr;
            D.32570.__sockaddr__ = D.32571;
            D.32572 = rp->ai_addrlen;
            res = bind (sfd, D.32570, D.32572);
            if (res == -1) goto <D.32573>; else goto <D.32574>;
            <D.32573>:
            // predicted unlikely by continue predictor.
            goto <D.25070>;
            <D.32574>:
            res = listen (sfd, 16);
            if (res == -1) goto <D.32575>; else goto <D.32576>;
            <D.32575>:
            // predicted unlikely by continue predictor.
            goto <D.25070>;
            <D.32576>:
            listen_fd = sfd;
            goto <D.25071>;
          }
        finally
          {
            n = {CLOBBER};
          }
      }
      <D.25070>:
      rp = rp->ai_next;
      <D.25073>:
      if (rp != 0B) goto <D.25072>; else goto <D.25071>;
      <D.25071>:
      result.437 = result;
      freeaddrinfo (result.437);
      <D.32561>:
      D.32578 = agent_config.defer;
      if (D.32578 != 0) goto <D.32579>; else goto <D.32580>;
      <D.32579>:
      return;
      <D.32580>:
      log_level.438 = log_level;
      D.32582 = log_level.438 > 0;
      D.32583 = (long int) D.32582;
      D.32584 = __builtin_expect (D.32583, 0);
      if (D.32584 != 0) goto <D.32585>; else goto <D.32586>;
      <D.32585>:
      log_file.439 = log_file;
      host.433 = host;
      port.434 = port;
      D.32588 = agent_config.timeout;
      fprintf (log_file.439, "Listening on %s:%d (timeout=%d ms)...\n", host.433, port.434, D.32588);
      log_file.439 = log_file;
      fflush (log_file.439);
      <D.32586>:
      D.32588 = agent_config.timeout;
      if (D.32588 != 0) goto <D.32589>; else goto <D.32590>;
      <D.32589>:
      {
        struct fd_set readfds;
        struct timeval tv;

        try
          {
            tv.tv_sec = 0;
            D.32588 = agent_config.timeout;
            D.32591 = D.32588 * 1000;
            D.32592 = (long int) D.32591;
            tv.tv_usec = D.32592;
            {
              unsigned int __i;
              struct fd_set * __arr;

              __arr = &readfds;
              __i = 0;
              goto <D.25079>;
              <D.25078>:
              __arr->fds_bits[__i] = 0;
              __i = __i + 1;
              <D.25079>:
              if (__i <= 15) goto <D.25078>; else goto <D.25080>;
              <D.25080>:
            }
            {
              long int __d;

              __d = (long int) sfd;
              D.32594 = __builtin_constant_p (__d);
              if (D.32594 != 0) goto <D.32595>; else goto <D.32596>;
              <D.32595>:
              __d.442 = (unsigned long) __d;
              if (__d.442 <= 1023) goto <D.32599>; else goto <D.32600>;
              <D.32599>:
              iftmp.441 = __d / 64;
              goto <D.32601>;
              <D.32600>:
              iftmp.441 = __fdelt_warn (__d);
              <D.32601>:
              iftmp.440 = iftmp.441;
              goto <D.32602>;
              <D.32596>:
              iftmp.440 = __fdelt_chk (__d);
              <D.32602>:
              D.25082 = iftmp.440;
            }
            D.32603 = D.25082;
            D.32604 = readfds.fds_bits[D.32603];
            D.32605 = sfd % 64;
            D.32606 = 1 << D.32605;
            D.32607 = (long int) D.32606;
            D.32608 = D.32604 | D.32607;
            readfds.fds_bits[D.32603] = D.32608;
            D.32609 = sfd + 1;
            res = select (D.32609, &readfds, 0B, 0B, &tv);
            if (res == 0) goto <D.32610>; else goto <D.32611>;
            <D.32610>:
            stderr.435 = stderr;
            fprintf (stderr.435, "debugger-agent: Timed out waiting to connect.\n");
            exit (1);
            <D.32611>:
          }
        finally
          {
            readfds = {CLOBBER};
            tv = {CLOBBER};
          }
      }
      <D.32590>:
      D.32612 = socket_transport_accept (sfd);
      conn_fd = D.32612;
      conn_fd.443 = conn_fd;
      if (conn_fd.443 == -1) goto <D.32614>; else goto <D.32615>;
      <D.32614>:
      exit (1);
      <D.32615>:
      log_level.438 = log_level;
      D.32582 = log_level.438 > 0;
      D.32583 = (long int) D.32582;
      D.32584 = __builtin_expect (D.32583, 0);
      if (D.32584 != 0) goto <D.32616>; else goto <D.32617>;
      <D.32616>:
      log_file.439 = log_file;
      conn_fd.443 = conn_fd;
      fprintf (log_file.439, "Accepted connection from client, socket fd=%d.\n", conn_fd.443);
      log_file.439 = log_file;
      fflush (log_file.439);
      <D.32617>:
      goto <D.32618>;
      <D.32542>:
      rp = result;
      goto <D.25086>;
      <D.25085>:
      D.32562 = rp->ai_family;
      D.32563 = rp->ai_socktype;
      D.32564 = rp->ai_protocol;
      sfd = socket (D.32562, D.32563, D.32564);
      if (sfd == -1) goto <D.32619>; else goto <D.32620>;
      <D.32619>:
      // predicted unlikely by continue predictor.
      goto <D.25083>;
      <D.32620>:
      D.32571 = rp->ai_addr;
      D.32621.__sockaddr__ = D.32571;
      D.32572 = rp->ai_addrlen;
      D.32622 = connect (sfd, D.32621, D.32572);
      if (D.32622 != -1) goto <D.25084>; else goto <D.32623>;
      <D.32623>:
      close (sfd);
      <D.25083>:
      rp = rp->ai_next;
      <D.25086>:
      if (rp != 0B) goto <D.25085>; else goto <D.25084>;
      <D.25084>:
      if (rp == 0B) goto <D.32624>; else goto <D.32625>;
      <D.32624>:
      stderr.435 = stderr;
      host.433 = host;
      port.434 = port;
      fprintf (stderr.435, "debugger-agent: Unable to connect to %s:%d\n", host.433, port.434);
      exit (1);
      <D.32625>:
      conn_fd = sfd;
      result.437 = result;
      freeaddrinfo (result.437);
      <D.32618>:
      D.32626 = transport_handshake ();
      if (D.32626 == 0) goto <D.32627>; else goto <D.32628>;
      <D.32627>:
      exit (1);
      <D.32628>:
    }
  finally
    {
      hints = {CLOBBER};
      result = {CLOBBER};
      port_string = {CLOBBER};
      host = {CLOBBER};
      port = {CLOBBER};
    }
}


__uint16_identity (__uint16_t __x)
{
  __uint16_t D.32634;

  D.32634 = __x;
  return D.32634;
}


register_transport (struct DebuggerTransport * trans)
{
  int ntransports.444;
  _Bool D.32637;
  long int D.32638;
  long int D.32639;
  struct DebuggerTransport * D.32642;
  int D.32643;

  ntransports.444 = ntransports;
  D.32637 = ntransports.444 > 15;
  D.32638 = (long int) D.32637;
  D.32639 = __builtin_expect (D.32638, 0);
  if (D.32639 != 0) goto <D.32640>; else goto <D.32641>;
  <D.32640>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 1419, "ntransports < MAX_TRANSPORTS");
  <D.32641>:
  ntransports.444 = ntransports;
  D.32642 = &transports[ntransports.444];
  memcpy (D.32642, trans, 48);
  ntransports.444 = ntransports;
  D.32643 = ntransports.444 + 1;
  ntransports = D.32643;
}


mono_native_tls_alloc (pthread_key_t * key, void * destructor)
{
  int D.32644;
  void (*<Tc6>) (void *) destructor.445;
  int D.32646;
  _Bool D.32647;

  destructor.445 = (void (*<Tc6>) (void *)) destructor;
  D.32646 = pthread_key_create (key, destructor.445);
  D.32647 = D.32646 == 0;
  D.32644 = (int) D.32647;
  return D.32644;
}


ids_init ()
{
  struct GPtrArray * D.32649;
  int i;

  i = 0;
  goto <D.25344>;
  <D.25343>:
  D.32649 = monoeg_g_ptr_array_new ();
  ids[i] = D.32649;
  i = i + 1;
  <D.25344>:
  if (i <= 6) goto <D.25343>; else goto <D.25345>;
  <D.25345>:
}


objrefs_init ()
{
  struct GHashTable * D.32650;

  D.32650 = monoeg_g_hash_table_new_full (0B, 0B, 0B, free_objref);
  objrefs = D.32650;
}


free_objref (void * value)
{
  unsigned int D.32651;
  struct ObjRef * o;

  o = value;
  D.32651 = o->handle;
  mono_gchandle_free (D.32651);
  monoeg_g_free (o);
}


breakpoints_init ()
{
  struct GPtrArray * D.32652;
  struct GHashTable * D.32653;

  D.32652 = monoeg_g_ptr_array_new ();
  breakpoints = D.32652;
  D.32653 = monoeg_g_hash_table_new (0B, 0B);
  bp_locs = D.32653;
}


suspend_init ()
{
  pthread_mutex_init (&suspend_mutex, 0B);
  pthread_cond_init (&suspend_cond, 0B);
  sem_init (&suspend_sem, 0, 0);
}


finish_agent_init (gboolean on_startup)
{
  int D.32654;
  char * D.32657;
  char * D.32660;
  char * D.32661;
  struct _IO_FILE * stderr.446;
  int res;

  D.32654 = InterlockedCompareExchange (&inited, 1, 0);
  if (D.32654 == 1) goto <D.32655>; else goto <D.32656>;
  <D.32655>:
  return;
  <D.32656>:
  D.32657 = agent_config.launch;
  if (D.32657 != 0B) goto <D.32658>; else goto <D.32659>;
  <D.32658>:
  {
    char * argv[16];

    try
      {
        D.32657 = agent_config.launch;
        argv[0] = D.32657;
        D.32660 = agent_config.transport;
        argv[1] = D.32660;
        D.32661 = agent_config.address;
        argv[2] = D.32661;
        argv[3] = 0B;
        res = monoeg_g_spawn_async_with_pipes (0B, &argv, 0B, 0, 0B, 0B, 0B, 0B, 0B, 0B, 0B);
        if (res == 0) goto <D.32662>; else goto <D.32663>;
        <D.32662>:
        stderr.446 = stderr;
        D.32657 = agent_config.launch;
        fprintf (stderr.446, "Failed to execute \'%s\'.\n", D.32657);
        exit (1);
        <D.32663>:
      }
    finally
      {
        argv = {CLOBBER};
      }
  }
  <D.32659>:
  D.32661 = agent_config.address;
  transport_connect (D.32661);
  if (on_startup == 0) goto <D.32665>; else goto <D.32666>;
  <D.32665>:
  vm_start_event_sent = 1;
  start_debugger_thread ();
  <D.32666>:
}


InterlockedCompareExchange (volatile gint32 * dest, gint32 exch, gint32 comp)
{
  gint32 D.32668;
  unsigned int comp.447;
  unsigned int exch.448;
  unsigned int D.32671;

  comp.447 = (unsigned int) comp;
  exch.448 = (unsigned int) exch;
  D.32671 = __sync_val_compare_and_swap_4 (dest, comp.447, exch.448);
  D.32668 = (gint32) D.32671;
  return D.32668;
}


transport_connect (const char * address)
{
  struct DebuggerTransport * transport.449;
  void (*<T40a8>) (const char *) D.32674;

  transport.449 = transport;
  D.32674 = transport.449->connect;
  D.32674 (address);
}


mono_debugger_agent_register_transport (struct DebuggerTransport * trans)
{
  register_transport (trans);
}


__attribute__((visibility ("hidden")))
mono_debugger_agent_transport_handshake ()
{
  gboolean D.32675;

  D.32675 = transport_handshake ();
  return D.32675;
}


__attribute__((visibility ("hidden")))
mono_debugger_agent_free_domain_info (struct MonoDomain * domain)
{
  void * D.32677;
  struct GHashTable * D.32680;
  struct GHashTable * D.32683;
  struct GHashTable * D.32684;
  struct GPtrArray * file_names.450;
  void * * D.32686;
  long unsigned int D.32687;
  long unsigned int D.32688;
  void * * D.32689;
  void * D.32690;
  unsigned int D.32691;
  unsigned int i.451;
  int D.32693;
  struct GHashTable * D.32694;
  char * basename.452;
  struct GSList * l.453;
  int D.32697;
  struct GHashTable * D.32698;
  int D.32699;
  struct GPtrArray * D.32700;
  void * * D.32703;
  long unsigned int D.32704;
  long unsigned int D.32705;
  void * * D.32706;
  struct MonoDomain * D.32707;
  unsigned int D.32710;
  unsigned int j.454;
  struct GHashTable * domains.455;
  struct AgentDomainInfo * info;
  int i;
  int j;
  struct GHashTableIter iter;
  struct GPtrArray * file_names;
  char * basename;
  struct GSList * l;

  try
    {
      D.32677 = domain->runtime_info;
      info = MEM[(struct MonoJitDomainInfo *)D.32677].agent_info;
      if (info != 0B) goto <D.32678>; else goto <D.32679>;
      <D.32678>:
      i = 0;
      goto <D.25368>;
      <D.25367>:
      D.32680 = info->val_to_id[i];
      if (D.32680 != 0B) goto <D.32681>; else goto <D.32682>;
      <D.32681>:
      D.32680 = info->val_to_id[i];
      monoeg_g_hash_table_destroy (D.32680);
      <D.32682>:
      i = i + 1;
      <D.25368>:
      if (i <= 6) goto <D.25367>; else goto <D.25369>;
      <D.25369>:
      D.32683 = info->loaded_classes;
      monoeg_g_hash_table_destroy (D.32683);
      D.32684 = info->source_files;
      monoeg_g_hash_table_iter_init (&iter, D.32684);
      goto <D.25374>;
      <D.25373>:
      i = 0;
      goto <D.25371>;
      <D.25370>:
      file_names.450 = file_names;
      D.32686 = file_names.450->pdata;
      D.32687 = (long unsigned int) i;
      D.32688 = D.32687 * 8;
      D.32689 = D.32686 + D.32688;
      D.32690 = *D.32689;
      monoeg_g_free (D.32690);
      i = i + 1;
      <D.25371>:
      file_names.450 = file_names;
      D.32691 = file_names.450->len;
      i.451 = (unsigned int) i;
      if (D.32691 > i.451) goto <D.25370>; else goto <D.25372>;
      <D.25372>:
      file_names.450 = file_names;
      monoeg_g_ptr_array_free (file_names.450, 1);
      <D.25374>:
      D.32693 = monoeg_g_hash_table_iter_next (&iter, 0B, &file_names);
      if (D.32693 != 0) goto <D.25373>; else goto <D.25375>;
      <D.25375>:
      D.32694 = info->source_file_to_class;
      monoeg_g_hash_table_iter_init (&iter, D.32694);
      goto <D.25377>;
      <D.25376>:
      basename.452 = basename;
      monoeg_g_free (basename.452);
      l.453 = l;
      monoeg_g_slist_free (l.453);
      <D.25377>:
      D.32697 = monoeg_g_hash_table_iter_next (&iter, &basename, &l);
      if (D.32697 != 0) goto <D.25376>; else goto <D.25378>;
      <D.25378>:
      D.32698 = info->source_file_to_class_ignorecase;
      monoeg_g_hash_table_iter_init (&iter, D.32698);
      goto <D.25380>;
      <D.25379>:
      basename.452 = basename;
      monoeg_g_free (basename.452);
      l.453 = l;
      monoeg_g_slist_free (l.453);
      <D.25380>:
      D.32699 = monoeg_g_hash_table_iter_next (&iter, &basename, &l);
      if (D.32699 != 0) goto <D.25379>; else goto <D.25381>;
      <D.25381>:
      monoeg_g_free (info);
      <D.32679>:
      D.32677 = domain->runtime_info;
      MEM[(struct MonoJitDomainInfo *)D.32677].agent_info = 0B;
      i = 0;
      goto <D.25387>;
      <D.25386>:
      D.32700 = ids[i];
      if (D.32700 != 0B) goto <D.32701>; else goto <D.32702>;
      <D.32701>:
      j = 0;
      goto <D.25384>;
      <D.25383>:
      {
        struct Id * id;

        D.32700 = ids[i];
        D.32703 = D.32700->pdata;
        D.32704 = (long unsigned int) j;
        D.32705 = D.32704 * 8;
        D.32706 = D.32703 + D.32705;
        id = *D.32706;
        D.32707 = id->domain;
        if (D.32707 == domain) goto <D.32708>; else goto <D.32709>;
        <D.32708>:
        id->domain = 0B;
        <D.32709>:
      }
      j = j + 1;
      <D.25384>:
      D.32700 = ids[i];
      D.32710 = D.32700->len;
      j.454 = (unsigned int) j;
      if (D.32710 > j.454) goto <D.25383>; else goto <D.25385>;
      <D.25385>:
      <D.32702>:
      i = i + 1;
      <D.25387>:
      if (i <= 6) goto <D.25386>; else goto <D.25388>;
      <D.25388>:
      mono_loader_lock ();
      domains.455 = domains;
      monoeg_g_hash_table_remove (domains.455, domain);
      mono_loader_unlock ();
    }
  finally
    {
      iter = {CLOBBER};
      file_names = {CLOBBER};
      basename = {CLOBBER};
      l = {CLOBBER};
    }
}


__attribute__((visibility ("hidden")))
mono_debugger_agent_thread_interrupt (void * sigctx, struct MonoJitInfo * ji)
{
  int inited.456;
  gboolean D.32716;
  unsigned int debugger_tls_id.457;
  int log_level.458;
  _Bool D.32721;
  long int D.32722;
  long int D.32723;
  struct FILE * log_file.459;
  long unsigned int D.32727;
  void * D.32728;
  struct DebuggerTlsData * tls;

  inited.456 = inited;
  if (inited.456 == 0) goto <D.32714>; else goto <D.32715>;
  <D.32714>:
  D.32716 = 0;
  return D.32716;
  <D.32715>:
  debugger_tls_id.457 = debugger_tls_id;
  tls = pthread_getspecific (debugger_tls_id.457);
  if (tls == 0B) goto <D.32718>; else goto <D.32719>;
  <D.32718>:
  log_level.458 = log_level;
  D.32721 = log_level.458 > 0;
  D.32722 = (long int) D.32721;
  D.32723 = __builtin_expect (D.32722, 0);
  if (D.32723 != 0) goto <D.32724>; else goto <D.32725>;
  <D.32724>:
  log_file.459 = log_file;
  D.32727 = GetCurrentThreadId ();
  D.32728 = (void *) D.32727;
  fprintf (log_file.459, "[%p] Received interrupt with no TLS, continuing.\n", D.32728);
  log_file.459 = log_file;
  fflush (log_file.459);
  <D.32725>:
  D.32716 = 0;
  return D.32716;
  <D.32719>:
  D.32716 = thread_interrupt (tls, 0B, sigctx, ji);
  return D.32716;
}


__attribute__((visibility ("hidden")))
mono_debugger_agent_breakpoint_hit (void * sigctx)
{
  resume_from_signal_handler (sigctx, process_breakpoint);
}


process_breakpoint ()
{
  process_signal_event (process_breakpoint_inner);
}


process_breakpoint_inner (struct DebuggerTlsData * tls)
{
  long unsigned int D.32730;
  struct MonoDomain * D.32731;
  _Bool D.32732;
  long int D.32733;
  long int D.32734;
  long int ip.460;
  void * D.32738;
  long int D.32739;
  long int D.32740;
  long unsigned int D.32743;
  long unsigned int D.32744;
  int D.32746;
  struct MonoDomain * D.32747;
  int native_offset.461;
  _Bool D.32751;
  long int D.32752;
  long int D.32753;
  int log_level.462;
  _Bool D.32757;
  long int D.32758;
  long int D.32759;
  struct FILE * log_file.463;
  long unsigned int D.32763;
  void * D.32764;
  const char * D.32765;
  int iftmp.464;
  struct GPtrArray * breakpoints.465;
  void * * D.32771;
  long unsigned int D.32772;
  long unsigned int D.32773;
  void * * D.32774;
  struct MonoMethod * D.32775;
  struct GPtrArray * D.32778;
  void * * D.32779;
  long unsigned int D.32780;
  long unsigned int D.32781;
  void * * D.32782;
  struct MonoJitInfo * D.32783;
  struct SeqPoint * D.32786;
  struct EventRequest * D.32789;
  int D.32790;
  unsigned int D.32794;
  unsigned int j.466;
  unsigned int D.32796;
  unsigned int i.467;
  unsigned int D.32798;
  unsigned int D.32801;
  int D.32804;
  void * * D.32810;
  void * * D.32811;
  struct MonoInternalThread * D.32812;
  struct MonoInternalThread * D.32813;
  struct MonoSeqPointInfo * info.468;
  unsigned int D.32819;
  int suspend_policy.469;
  struct MonoJitInfo * ji;
  guint8 * ip;
  int i;
  int j;
  int suspend_policy;
  guint32 native_offset;
  struct MonoBreakpoint * bp;
  struct BreakpointInstance * inst;
  struct GPtrArray * bp_reqs;
  struct GPtrArray * ss_reqs_orig;
  struct GPtrArray * ss_reqs;
  struct GSList * bp_events;
  struct GSList * ss_events;
  struct GSList * enter_leave_events;
  EventKind kind;
  struct MonoContext * ctx;
  struct MonoMethod * method;
  struct MonoSeqPointInfo * info;
  struct SeqPoint * sp;

  try
    {
      bp_events = 0B;
      ss_events = 0B;
      enter_leave_events = 0B;
      kind = 10;
      ctx = &tls->restore_ctx;
      D.32730 = ctx->uc_mcontext.psw.addr;
      ip = (guint8 *) D.32730;
      D.32731 = mono_domain_get ();
      ji = mini_jit_info_table_find (D.32731, ip, 0B);
      D.32732 = ji == 0B;
      D.32733 = (long int) D.32732;
      D.32734 = __builtin_expect (D.32733, 0);
      if (D.32734 != 0) goto <D.32735>; else goto <D.32736>;
      <D.32735>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 4554, "ji");
      <D.32736>:
      method = jinfo_get_method (ji);
      ip.460 = (long int) ip;
      D.32738 = ji->code_start;
      D.32739 = (long int) D.32738;
      D.32740 = ip.460 - D.32739;
      native_offset = (guint32) D.32740;
      mono_arch_skip_breakpoint (ctx, ji);
      D.32743 = BIT_FIELD_REF <*method, 64, 256>;
      D.32744 = D.32743 & 4467570830351532032;
      if (D.32744 != 0) goto <D.32741>; else goto <D.32745>;
      <D.32745>:
      D.32746 = tls->disable_breakpoints;
      if (D.32746 != 0) goto <D.32741>; else goto <D.32742>;
      <D.32741>:
      return;
      <D.32742>:
      bp_reqs = monoeg_g_ptr_array_new ();
      ss_reqs = monoeg_g_ptr_array_new ();
      ss_reqs_orig = monoeg_g_ptr_array_new ();
      mono_loader_lock ();
      D.32747 = mono_domain_get ();
      native_offset.461 = (int) native_offset;
      sp = find_prev_seq_point_for_native_offset (D.32747, method, native_offset.461, &info);
      if (sp == 0B) goto <D.32749>; else goto <D.32750>;
      <D.32749>:
      no_seq_points_found (method);
      <D.32750>:
      D.32751 = sp == 0B;
      D.32752 = (long int) D.32751;
      D.32753 = __builtin_expect (D.32752, 0);
      if (D.32753 != 0) goto <D.32754>; else goto <D.32755>;
      <D.32754>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 4581, "sp");
      <D.32755>:
      log_level.462 = log_level;
      D.32757 = log_level.462 > 0;
      D.32758 = (long int) D.32757;
      D.32759 = __builtin_expect (D.32758, 0);
      if (D.32759 != 0) goto <D.32760>; else goto <D.32761>;
      <D.32760>:
      log_file.463 = log_file;
      D.32763 = GetCurrentThreadId ();
      D.32764 = (void *) D.32763;
      D.32765 = method->name;
      if (sp != 0B) goto <D.32767>; else goto <D.32768>;
      <D.32767>:
      iftmp.464 = sp->il_offset;
      goto <D.32769>;
      <D.32768>:
      iftmp.464 = -1;
      <D.32769>:
      fprintf (log_file.463, "[%p] Breakpoint hit, method=%s, ip=%p, offset=0x%x, sp il offset=0x%x.\n", D.32764, D.32765, ip, native_offset, iftmp.464);
      log_file.463 = log_file;
      fflush (log_file.463);
      <D.32761>:
      bp = 0B;
      i = 0;
      goto <D.26124>;
      <D.26123>:
      breakpoints.465 = breakpoints;
      D.32771 = breakpoints.465->pdata;
      D.32772 = (long unsigned int) i;
      D.32773 = D.32772 * 8;
      D.32774 = D.32771 + D.32773;
      bp = *D.32774;
      D.32775 = bp->method;
      if (D.32775 == 0B) goto <D.32776>; else goto <D.32777>;
      <D.32776>:
      // predicted unlikely by continue predictor.
      goto <D.26119>;
      <D.32777>:
      j = 0;
      goto <D.26121>;
      <D.26120>:
      D.32778 = bp->children;
      D.32779 = D.32778->pdata;
      D.32780 = (long unsigned int) j;
      D.32781 = D.32780 * 8;
      D.32782 = D.32779 + D.32781;
      inst = *D.32782;
      D.32783 = inst->ji;
      if (D.32783 == ji) goto <D.32784>; else goto <D.32785>;
      <D.32784>:
      D.32786 = inst->sp;
      if (D.32786 == sp) goto <D.32787>; else goto <D.32788>;
      <D.32787>:
      D.32789 = bp->req;
      D.32790 = D.32789->event_kind;
      if (D.32790 == 11) goto <D.32791>; else goto <D.32792>;
      <D.32791>:
      D.32789 = bp->req;
      monoeg_g_ptr_array_add (ss_reqs_orig, D.32789);
      goto <D.32793>;
      <D.32792>:
      D.32789 = bp->req;
      monoeg_g_ptr_array_add (bp_reqs, D.32789);
      <D.32793>:
      <D.32788>:
      <D.32785>:
      j = j + 1;
      <D.26121>:
      D.32778 = bp->children;
      D.32794 = D.32778->len;
      j.466 = (unsigned int) j;
      if (D.32794 > j.466) goto <D.26120>; else goto <D.26122>;
      <D.26122>:
      <D.26119>:
      i = i + 1;
      <D.26124>:
      breakpoints.465 = breakpoints;
      D.32796 = breakpoints.465->len;
      i.467 = (unsigned int) i;
      if (D.32796 > i.467) goto <D.26123>; else goto <D.26125>;
      <D.26125>:
      D.32798 = bp_reqs->len;
      if (D.32798 == 0) goto <D.32799>; else goto <D.32800>;
      <D.32799>:
      D.32801 = ss_reqs_orig->len;
      if (D.32801 == 0) goto <D.32802>; else goto <D.32803>;
      <D.32802>:
      D.32804 = sp->il_offset;
      if (D.32804 == -1) goto <D.32805>; else goto <D.32806>;
      <D.32805>:
      kind = 6;
      goto <D.32807>;
      <D.32806>:
      D.32804 = sp->il_offset;
      if (D.32804 == 16777215) goto <D.32808>; else goto <D.32809>;
      <D.32808>:
      kind = 7;
      <D.32809>:
      <D.32807>:
      <D.32803>:
      <D.32800>:
      i = 0;
      goto <D.26131>;
      <D.26130>:
      {
        struct EventRequest * req;
        struct SingleStepReq * ss_req;
        gboolean hit;

        D.32810 = ss_reqs_orig->pdata;
        D.32772 = (long unsigned int) i;
        D.32773 = D.32772 * 8;
        D.32811 = D.32810 + D.32773;
        req = *D.32811;
        ss_req = req->info;
        D.32812 = mono_thread_internal_current ();
        D.32813 = ss_req->thread;
        if (D.32812 != D.32813) goto <D.32814>; else goto <D.32815>;
        <D.32814>:
        // predicted unlikely by continue predictor.
        goto <D.26129>;
        <D.32815>:
        hit = ss_update (ss_req, ji, sp, tls, ctx);
        if (hit != 0) goto <D.32816>; else goto <D.32817>;
        <D.32816>:
        monoeg_g_ptr_array_add (ss_reqs, req);
        <D.32817>:
        info.468 = info;
        ss_start (ss_req, method, sp, info.468, ctx, tls, 0);
      }
      <D.26129>:
      i = i + 1;
      <D.26131>:
      D.32801 = ss_reqs_orig->len;
      i.467 = (unsigned int) i;
      if (D.32801 > i.467) goto <D.26130>; else goto <D.26132>;
      <D.26132>:
      D.32819 = ss_reqs->len;
      if (D.32819 != 0) goto <D.32820>; else goto <D.32821>;
      <D.32820>:
      ss_events = create_event_list (11, ss_reqs, ji, 0B, &suspend_policy);
      <D.32821>:
      D.32798 = bp_reqs->len;
      if (D.32798 != 0) goto <D.32822>; else goto <D.32823>;
      <D.32822>:
      bp_events = create_event_list (10, bp_reqs, ji, 0B, &suspend_policy);
      <D.32823>:
      if (kind != 10) goto <D.32824>; else goto <D.32825>;
      <D.32824>:
      enter_leave_events = create_event_list (kind, 0B, ji, 0B, &suspend_policy);
      <D.32825>:
      mono_loader_unlock ();
      monoeg_g_ptr_array_free (bp_reqs, 1);
      monoeg_g_ptr_array_free (ss_reqs, 1);
      if (ss_events != 0B) goto <D.32826>; else goto <D.32827>;
      <D.32826>:
      suspend_policy.469 = suspend_policy;
      process_event (11, method, 0, ctx, ss_events, suspend_policy.469);
      <D.32827>:
      if (bp_events != 0B) goto <D.32829>; else goto <D.32830>;
      <D.32829>:
      suspend_policy.469 = suspend_policy;
      process_event (kind, method, 0, ctx, bp_events, suspend_policy.469);
      <D.32830>:
      if (enter_leave_events != 0B) goto <D.32831>; else goto <D.32832>;
      <D.32831>:
      suspend_policy.469 = suspend_policy;
      process_event (kind, method, 0, ctx, enter_leave_events, suspend_policy.469);
      <D.32832>:
    }
  finally
    {
      suspend_policy = {CLOBBER};
      info = {CLOBBER};
    }
}


ss_update (struct SingleStepReq * req, struct MonoJitInfo * ji, struct SeqPoint * sp, struct DebuggerTlsData * tls, struct MonoContext * ctx)
{
  <unnamed type> D.32836;
  int D.32839;
  int D.32840;
  int log_level.470;
  _Bool D.32844;
  long int D.32845;
  long int D.32846;
  struct FILE * log_file.471;
  long unsigned int D.32850;
  void * D.32851;
  int D.32852;
  gboolean D.32853;
  int D.32858;
  struct MonoThreadUnwindState * D.32861;
  struct MonoInternalThread * D.32862;
  int D.32863;
  int D.32866;
  long unsigned int D.32873;
  void * D.32874;
  <unnamed type> D.32875;
  unsigned int D.32880;
  struct SingleStepReq * ss_req.472;
  struct MonoMethod * D.32885;
  unsigned int D.32887;
  int D.32888;
  unsigned int D.32889;
  long unsigned int D.32894;
  void * D.32895;
  long unsigned int D.32899;
  void * D.32900;
  int D.32903;
  struct MonoDebugMethodInfo * minfo;
  struct MonoDebugSourceLocation * loc;
  gboolean hit;
  struct MonoMethod * method;

  loc = 0B;
  hit = 1;
  D.32836 = req->depth;
  if (D.32836 == 1) goto <D.32837>; else goto <D.32838>;
  <D.32837>:
  D.32839 = sp->flags;
  D.32840 = D.32839 & 1;
  if (D.32840 != 0) goto <D.32841>; else goto <D.32842>;
  <D.32841>:
  log_level.470 = log_level;
  D.32844 = log_level.470 > 0;
  D.32845 = (long int) D.32844;
  D.32846 = __builtin_expect (D.32845, 0);
  if (D.32846 != 0) goto <D.32847>; else goto <D.32848>;
  <D.32847>:
  log_file.471 = log_file;
  D.32850 = GetCurrentThreadId ();
  D.32851 = (void *) D.32850;
  D.32852 = sp->il_offset;
  fprintf (log_file.471, "[%p] Seq point at nonempty stack %x while stepping over, continuing single stepping.\n", D.32851, D.32852);
  log_file.471 = log_file;
  fflush (log_file.471);
  <D.32848>:
  D.32853 = 0;
  return D.32853;
  <D.32842>:
  <D.32838>:
  D.32836 = req->depth;
  if (D.32836 == 1) goto <D.32854>; else goto <D.32855>;
  <D.32854>:
  if (hit != 0) goto <D.32856>; else goto <D.32857>;
  <D.32856>:
  D.32858 = tls->context.valid;
  if (D.32858 == 0) goto <D.32859>; else goto <D.32860>;
  <D.32859>:
  D.32861 = &tls->context;
  mono_thread_state_init_from_monoctx (D.32861, ctx);
  <D.32860>:
  D.32862 = tls->thread;
  compute_frame_info (D.32862, tls);
  D.32863 = req->nframes;
  if (D.32863 != 0) goto <D.32864>; else goto <D.32865>;
  <D.32864>:
  D.32866 = tls->frame_count;
  if (D.32866 != 0) goto <D.32867>; else goto <D.32868>;
  <D.32867>:
  D.32866 = tls->frame_count;
  D.32863 = req->nframes;
  if (D.32866 > D.32863) goto <D.32869>; else goto <D.32870>;
  <D.32869>:
  log_level.470 = log_level;
  D.32844 = log_level.470 > 0;
  D.32845 = (long int) D.32844;
  D.32846 = __builtin_expect (D.32845, 0);
  if (D.32846 != 0) goto <D.32871>; else goto <D.32872>;
  <D.32871>:
  log_file.471 = log_file;
  D.32873 = GetCurrentThreadId ();
  D.32874 = (void *) D.32873;
  fprintf (log_file.471, "[%p] Breakpoint at lower frame while stepping over, continuing single stepping.\n", D.32874);
  log_file.471 = log_file;
  fflush (log_file.471);
  <D.32872>:
  D.32853 = 0;
  return D.32853;
  <D.32870>:
  <D.32868>:
  <D.32865>:
  <D.32857>:
  <D.32855>:
  D.32875 = req->size;
  if (D.32875 != 1) goto <D.32876>; else goto <D.32877>;
  <D.32876>:
  D.32853 = 1;
  return D.32853;
  <D.32877>:
  method = jinfo_get_method (ji);
  minfo = mono_debug_lookup_method (method);
  if (minfo != 0B) goto <D.32878>; else goto <D.32879>;
  <D.32878>:
  D.32852 = sp->il_offset;
  D.32880 = (unsigned int) D.32852;
  loc = mono_debug_symfile_lookup_location (minfo, D.32880);
  <D.32879>:
  if (loc == 0B) goto <D.32881>; else goto <D.32883>;
  <D.32883>:
  ss_req.472 = ss_req;
  D.32885 = ss_req.472->last_method;
  if (D.32885 == method) goto <D.32886>; else goto <D.32882>;
  <D.32886>:
  D.32887 = loc->row;
  ss_req.472 = ss_req;
  D.32888 = ss_req.472->last_line;
  D.32889 = (unsigned int) D.32888;
  if (D.32887 == D.32889) goto <D.32881>; else goto <D.32882>;
  <D.32881>:
  if (loc == 0B) goto <D.32890>; else goto <D.32891>;
  <D.32890>:
  log_level.470 = log_level;
  D.32844 = log_level.470 > 0;
  D.32845 = (long int) D.32844;
  D.32846 = __builtin_expect (D.32845, 0);
  if (D.32846 != 0) goto <D.32892>; else goto <D.32893>;
  <D.32892>:
  log_file.471 = log_file;
  D.32894 = GetCurrentThreadId ();
  D.32895 = (void *) D.32894;
  D.32852 = sp->il_offset;
  fprintf (log_file.471, "[%p] No line number info for il offset %x, continuing single stepping.\n", D.32895, D.32852);
  log_file.471 = log_file;
  fflush (log_file.471);
  <D.32893>:
  goto <D.32896>;
  <D.32891>:
  log_level.470 = log_level;
  D.32844 = log_level.470 > 0;
  D.32845 = (long int) D.32844;
  D.32846 = __builtin_expect (D.32845, 0);
  if (D.32846 != 0) goto <D.32897>; else goto <D.32898>;
  <D.32897>:
  log_file.471 = log_file;
  D.32899 = GetCurrentThreadId ();
  D.32900 = (void *) D.32899;
  D.32887 = loc->row;
  fprintf (log_file.471, "[%p] Same source line (%d), continuing single stepping.\n", D.32900, D.32887);
  log_file.471 = log_file;
  fflush (log_file.471);
  <D.32898>:
  <D.32896>:
  hit = 0;
  <D.32882>:
  if (loc != 0B) goto <D.32901>; else goto <D.32902>;
  <D.32901>:
  ss_req.472 = ss_req;
  ss_req.472->last_method = method;
  ss_req.472 = ss_req;
  D.32887 = loc->row;
  D.32903 = (int) D.32887;
  ss_req.472->last_line = D.32903;
  mono_debug_free_source_location (loc);
  <D.32902>:
  D.32853 = hit;
  return D.32853;
}


process_signal_event (void (*<T4478>) (struct DebuggerTlsData *) func)
{
  unsigned int debugger_tls_id.473;
  struct MonoContext * D.32906;
  struct MonoContext * D.32907;
  struct DebuggerTlsData * tls;
  struct MonoContext orig_restore_ctx;
  struct MonoContext ctx;

  try
    {
      debugger_tls_id.473 = debugger_tls_id;
      tls = pthread_getspecific (debugger_tls_id.473);
      D.32906 = &tls->restore_ctx;
      memcpy (&orig_restore_ctx, D.32906, 512);
      D.32906 = &tls->restore_ctx;
      D.32907 = &tls->handler_ctx;
      memcpy (D.32906, D.32907, 512);
      func (tls);
      D.32906 = &tls->restore_ctx;
      memcpy (&ctx, D.32906, 512);
      D.32906 = &tls->restore_ctx;
      memcpy (D.32906, &orig_restore_ctx, 512);
      mono_restore_context (&ctx);
      monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "debugger-agent.c", 4670);
    }
  finally
    {
      orig_restore_ctx = {CLOBBER};
      ctx = {CLOBBER};
    }
}


resume_from_signal_handler (void * sigctx, void * func)
{
  unsigned int debugger_tls_id.474;
  struct _IO_FILE * stderr.475;
  long unsigned int D.32912;
  void * D.32913;
  _Bool D.32914;
  long int D.32915;
  long int D.32916;
  struct MonoContext * D.32919;
  long unsigned int func.476;
  struct DebuggerTlsData * tls;
  struct MonoContext ctx;

  try
    {
      debugger_tls_id.474 = debugger_tls_id;
      tls = pthread_getspecific (debugger_tls_id.474);
      if (tls == 0B) goto <D.32909>; else goto <D.32910>;
      <D.32909>:
      stderr.475 = stderr;
      D.32912 = GetCurrentThreadId ();
      D.32913 = (void *) D.32912;
      fprintf (stderr.475, "Thread %p is not attached to the JIT.\n", D.32913);
      <D.32910>:
      D.32914 = tls == 0B;
      D.32915 = (long int) D.32914;
      D.32916 = __builtin_expect (D.32915, 0);
      if (D.32916 != 0) goto <D.32917>; else goto <D.32918>;
      <D.32917>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 4690, "tls");
      <D.32918>:
      mono_arch_sigctx_to_monoctx (sigctx, &ctx);
      D.32919 = &tls->handler_ctx;
      memcpy (D.32919, &ctx, 512);
      func.476 = (long unsigned int) func;
      ctx.uc_mcontext.gregs[14] = func.476;
      func.476 = (long unsigned int) func;
      ctx.uc_mcontext.psw.addr = func.476;
      mono_arch_monoctx_to_sigctx (&ctx, sigctx);
    }
  finally
    {
      ctx = {CLOBBER};
    }
}


__attribute__((visibility ("hidden")))
mono_debugger_agent_user_break ()
{
  int D.32921;
  long unsigned int D.32924;
  void * D.32925;
  _Bool D.32926;
  long int D.32927;
  long int D.32928;
  int suspend_policy.477;

  D.32921 = agent_config.enabled;
  if (D.32921 != 0) goto <D.32922>; else goto <D.32923>;
  <D.32922>:
  {
    struct MonoContext ctx;
    int suspend_policy;
    struct GSList * events;

    try
      {
        ctx.uc_mcontext.gregs[14] = 0;
        ctx.uc_mcontext.psw.addr = 0;
        mono_walk_stack_with_ctx (user_break_cb, 0B, 0, &ctx);
        D.32924 = ctx.uc_mcontext.psw.addr;
        D.32925 = (void *) D.32924;
        D.32926 = D.32925 == 0B;
        D.32927 = (long int) D.32926;
        D.32928 = __builtin_expect (D.32927, 0);
        if (D.32928 != 0) goto <D.32929>; else goto <D.32930>;
        <D.32929>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 4747, "MONO_CONTEXT_GET_IP (&ctx) != NULL");
        <D.32930>:
        mono_loader_lock ();
        events = create_event_list (15, 0B, 0B, 0B, &suspend_policy);
        mono_loader_unlock ();
        suspend_policy.477 = suspend_policy;
        process_event (15, 0B, 0, &ctx, events, suspend_policy.477);
      }
    finally
      {
        ctx = {CLOBBER};
        suspend_policy = {CLOBBER};
      }
  }
  goto <D.32932>;
  <D.32923>:
  raise (5);
  <D.32932>:
}


user_break_cb (struct StackFrameInfo * frame, struct MonoContext * ctx, void * data)
{
  int D.32933;
  gboolean D.32936;

  D.32933 = frame->managed;
  if (D.32933 != 0) goto <D.32934>; else goto <D.32935>;
  <D.32934>:
  MEM[(struct MonoContext *)data] = *ctx;
  D.32936 = 1;
  return D.32936;
  <D.32935>:
  D.32936 = 0;
  return D.32936;
}


__attribute__((visibility ("hidden")))
mono_debugger_agent_single_step_event (void * sigctx)
{
  long unsigned int D.32938;
  long unsigned int debugger_thread_id.478;

  D.32938 = GetCurrentThreadId ();
  debugger_thread_id.478 = debugger_thread_id;
  if (D.32938 == debugger_thread_id.478) goto <D.32940>; else goto <D.32941>;
  <D.32940>:
  {
    struct MonoContext ctx;

    try
      {
        mono_arch_sigctx_to_monoctx (sigctx, &ctx);
        mono_arch_skip_single_step (&ctx);
        mono_arch_monoctx_to_sigctx (&ctx, sigctx);
        return;
      }
    finally
      {
        ctx = {CLOBBER};
      }
  }
  <D.32941>:
  resume_from_signal_handler (sigctx, process_single_step);
}


process_single_step ()
{
  process_signal_event (process_single_step_inner);
}


process_single_step_inner (struct DebuggerTlsData * tls)
{
  long unsigned int D.32944;
  int suspend_count.479;
  struct SingleStepReq * ss_req.480;
  struct MonoInternalThread * D.32951;
  struct MonoInternalThread * D.32952;
  int log_level.481;
  struct MonoDomain * D.32958;
  _Bool D.32959;
  long int D.32960;
  long int D.32961;
  struct FILE * log_file.482;
  long unsigned int D.32965;
  void * D.32966;
  <unnamed type> D.32967;
  const char * D.32968;
  struct MonoMethod * D.32969;
  char * D.32970;
  void * D.32971;
  long unsigned int D.32972;
  void * D.32973;
  void * D.32974;
  struct MonoDomain * D.32975;
  _Bool D.32976;
  long int D.32977;
  long int D.32978;
  _Bool D.32981;
  long int D.32982;
  long int D.32983;
  long unsigned int D.32986;
  long unsigned int D.32987;
  struct MonoClass * D.32994;
  struct MonoClass * D.32995;
  const char * D.32998;
  int D.32999;
  char * D.33001;
  struct MonoDomain * domain.483;
  long int ip.484;
  void * D.33004;
  long int D.33005;
  long int D.33006;
  int D.33007;
  int D.33010;
  struct MonoSeqPointInfo * info.485;
  <unnamed type> D.33014;
  unsigned int D.33015;
  short unsigned int D.33018;
  int D.33019;
  int D.33020;
  int D.33023;
  struct EventRequest * D.33026;
  struct MonoMethod * D.33027;
  int suspend_policy.486;
  struct MonoJitInfo * ji;
  guint8 * ip;
  struct GPtrArray * reqs;
  int il_offset;
  int suspend_policy;
  struct MonoDomain * domain;
  struct GSList * events;
  struct MonoContext * ctx;
  struct MonoMethod * method;
  struct SeqPoint * sp;
  struct MonoSeqPointInfo * info;

  try
    {
      ctx = &tls->restore_ctx;
      D.32944 = ctx->uc_mcontext.psw.addr;
      ip = (guint8 *) D.32944;
      mono_arch_skip_single_step (ctx);
      suspend_count.479 = suspend_count;
      if (suspend_count.479 > 0) goto <D.32946>; else goto <D.32947>;
      <D.32946>:
      process_suspend (tls, ctx);
      return;
      <D.32947>:
      ss_req.480 = ss_req;
      if (ss_req.480 == 0B) goto <D.32949>; else goto <D.32950>;
      <D.32949>:
      return;
      <D.32950>:
      D.32951 = mono_thread_internal_current ();
      ss_req.480 = ss_req;
      D.32952 = ss_req.480->thread;
      if (D.32951 != D.32952) goto <D.32953>; else goto <D.32954>;
      <D.32953>:
      return;
      <D.32954>:
      log_level.481 = log_level;
      if (log_level.481 > 0) goto <D.32956>; else goto <D.32957>;
      <D.32956>:
      D.32958 = mono_domain_get ();
      ji = mini_jit_info_table_find (D.32958, ip, &domain);
      log_level.481 = log_level;
      D.32959 = log_level.481 > 0;
      D.32960 = (long int) D.32959;
      D.32961 = __builtin_expect (D.32960, 0);
      if (D.32961 != 0) goto <D.32962>; else goto <D.32963>;
      <D.32962>:
      log_file.482 = log_file;
      D.32965 = GetCurrentThreadId ();
      D.32966 = (void *) D.32965;
      ss_req.480 = ss_req;
      D.32967 = ss_req.480->depth;
      D.32968 = ss_depth_to_string (D.32967);
      D.32969 = jinfo_get_method (ji);
      D.32970 = mono_method_full_name (D.32969, 1);
      D.32944 = ctx->uc_mcontext.psw.addr;
      D.32971 = (void *) D.32944;
      D.32972 = ctx->uc_mcontext.gregs[15];
      D.32973 = (void *) D.32972;
      ss_req.480 = ss_req;
      D.32974 = ss_req.480->last_sp;
      fprintf (log_file.482, "[%p] Single step event (depth=%s) at %s (%p), sp %p, last sp %p\n", D.32966, D.32968, D.32970, D.32971, D.32973, D.32974);
      log_file.482 = log_file;
      fflush (log_file.482);
      <D.32963>:
      <D.32957>:
      D.32975 = mono_domain_get ();
      ji = mini_jit_info_table_find (D.32975, ip, &domain);
      D.32976 = ji == 0B;
      D.32977 = (long int) D.32976;
      D.32978 = __builtin_expect (D.32977, 0);
      if (D.32978 != 0) goto <D.32979>; else goto <D.32980>;
      <D.32979>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 4813, "ji");
      <D.32980>:
      method = jinfo_get_method (ji);
      D.32981 = method == 0B;
      D.32982 = (long int) D.32981;
      D.32983 = __builtin_expect (D.32982, 0);
      if (D.32983 != 0) goto <D.32984>; else goto <D.32985>;
      <D.32984>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 4815, "method");
      <D.32985>:
      D.32986 = BIT_FIELD_REF <*method, 64, 256>;
      D.32987 = D.32986 & 4467570830351532032;
      if (D.32987 != 0) goto <D.32988>; else goto <D.32989>;
      <D.32988>:
      D.32986 = BIT_FIELD_REF <*method, 64, 256>;
      D.32987 = D.32986 & 4467570830351532032;
      if (D.32987 != 2449958197289549824) goto <D.32990>; else goto <D.32991>;
      <D.32990>:
      return;
      <D.32991>:
      <D.32989>:
      D.32994 = method->klass;
      D.32995 = mono_defaults.string_class;
      if (D.32994 == D.32995) goto <D.32996>; else goto <D.32997>;
      <D.32996>:
      D.32998 = method->name;
      D.32999 = strcmp (D.32998, "memset");
      if (D.32999 == 0) goto <D.32992>; else goto <D.33000>;
      <D.33000>:
      D.32998 = method->name;
      D.33001 = strstr (D.32998, "memcpy");
      if (D.33001 != 0B) goto <D.32992>; else goto <D.32993>;
      <D.32992>:
      return;
      <D.32993>:
      <D.32997>:
      domain.483 = domain;
      ip.484 = (long int) ip;
      D.33004 = ji->code_start;
      D.33005 = (long int) D.33004;
      D.33006 = ip.484 - D.33005;
      D.33007 = (int) D.33006;
      sp = find_next_seq_point_for_native_offset (domain.483, method, D.33007, &info);
      if (sp == 0B) goto <D.33008>; else goto <D.33009>;
      <D.33008>:
      return;
      <D.33009>:
      il_offset = sp->il_offset;
      ss_req.480 = ss_req;
      D.33010 = ss_update (ss_req.480, ji, sp, tls, ctx);
      if (D.33010 == 0) goto <D.33011>; else goto <D.33012>;
      <D.33011>:
      return;
      <D.33012>:
      ss_req.480 = ss_req;
      info.485 = info;
      ss_start (ss_req.480, method, sp, info.485, ctx, tls, 0);
      ss_req.480 = ss_req;
      D.33014 = ss_req.480->filter;
      D.33015 = D.33014 & 1;
      if (D.33015 != 0) goto <D.33016>; else goto <D.33017>;
      <D.33016>:
      D.33018 = method->flags;
      D.33019 = (int) D.33018;
      D.33020 = D.33019 & 2048;
      if (D.33020 != 0) goto <D.33021>; else goto <D.33022>;
      <D.33021>:
      D.32998 = method->name;
      D.33023 = strcmp (D.32998, ".cctor");
      if (D.33023 == 0) goto <D.33024>; else goto <D.33025>;
      <D.33024>:
      return;
      <D.33025>:
      <D.33022>:
      <D.33017>:
      reqs = monoeg_g_ptr_array_new ();
      mono_loader_lock ();
      ss_req.480 = ss_req;
      D.33026 = ss_req.480->req;
      monoeg_g_ptr_array_add (reqs, D.33026);
      events = create_event_list (11, reqs, ji, 0B, &suspend_policy);
      monoeg_g_ptr_array_free (reqs, 1);
      mono_loader_unlock ();
      D.33027 = jinfo_get_method (ji);
      suspend_policy.486 = suspend_policy;
      process_event (11, D.33027, il_offset, ctx, events, suspend_policy.486);
    }
  finally
    {
      suspend_policy = {CLOBBER};
      domain = {CLOBBER};
      info = {CLOBBER};
    }
}


process_suspend (struct DebuggerTlsData * tls, struct MonoContext * ctx)
{
  long unsigned int D.33032;
  int D.33033;
  long unsigned int D.33036;
  long unsigned int debugger_thread_id.487;
  unsigned int D.33040;
  int suspend_count.488;
  unsigned int suspend_count.489;
  int log_level.490;
  _Bool D.33046;
  long int D.33047;
  long int D.33048;
  struct FILE * log_file.491;
  long unsigned int D.33052;
  void * D.33053;
  long unsigned int D.33058;
  void * D.33059;
  struct MonoDomain * D.33060;
  struct MonoClass * D.33063;
  struct MonoClass * D.33064;
  const char * D.33067;
  int D.33068;
  char * D.33070;
  guint8 * ip;
  struct MonoJitInfo * ji;
  struct MonoMethod * method;

  D.33032 = ctx->uc_mcontext.psw.addr;
  ip = (guint8 *) D.33032;
  D.33033 = mono_loader_lock_is_owned_by_self ();
  if (D.33033 != 0) goto <D.33034>; else goto <D.33035>;
  <D.33034>:
  return;
  <D.33035>:
  D.33036 = GetCurrentThreadId ();
  debugger_thread_id.487 = debugger_thread_id;
  if (D.33036 == debugger_thread_id.487) goto <D.33038>; else goto <D.33039>;
  <D.33038>:
  return;
  <D.33039>:
  D.33040 = tls->resume_count;
  suspend_count.488 = suspend_count;
  suspend_count.489 = (unsigned int) suspend_count.488;
  if (D.33040 != suspend_count.489) goto <D.33043>; else goto <D.33044>;
  <D.33043>:
  tls->suspending = 1;
  <D.33044>:
  log_level.490 = log_level;
  D.33046 = log_level.490 > 0;
  D.33047 = (long int) D.33046;
  D.33048 = __builtin_expect (D.33047, 0);
  if (D.33048 != 0) goto <D.33049>; else goto <D.33050>;
  <D.33049>:
  log_file.491 = log_file;
  D.33052 = GetCurrentThreadId ();
  D.33053 = (void *) D.33052;
  fprintf (log_file.491, "[%p] Received single step event for suspending.\n", D.33053);
  log_file.491 = log_file;
  fflush (log_file.491);
  <D.33050>:
  D.33040 = tls->resume_count;
  suspend_count.488 = suspend_count;
  suspend_count.489 = (unsigned int) suspend_count.488;
  if (D.33040 == suspend_count.489) goto <D.33054>; else goto <D.33055>;
  <D.33054>:
  log_level.490 = log_level;
  D.33046 = log_level.490 > 0;
  D.33047 = (long int) D.33046;
  D.33048 = __builtin_expect (D.33047, 0);
  if (D.33048 != 0) goto <D.33056>; else goto <D.33057>;
  <D.33056>:
  log_file.491 = log_file;
  D.33058 = GetCurrentThreadId ();
  D.33059 = (void *) D.33058;
  fprintf (log_file.491, "[%p] Ignored during single threaded invoke.\n", D.33059);
  log_file.491 = log_file;
  fflush (log_file.491);
  <D.33057>:
  return;
  <D.33055>:
  D.33060 = mono_domain_get ();
  ji = mini_jit_info_table_find (D.33060, ip, 0B);
  method = jinfo_get_method (ji);
  D.33063 = method->klass;
  D.33064 = mono_defaults.string_class;
  if (D.33063 == D.33064) goto <D.33065>; else goto <D.33066>;
  <D.33065>:
  D.33067 = method->name;
  D.33068 = strcmp (D.33067, "memset");
  if (D.33068 == 0) goto <D.33061>; else goto <D.33069>;
  <D.33069>:
  D.33067 = method->name;
  D.33070 = strstr (D.33067, "memcpy");
  if (D.33070 != 0B) goto <D.33061>; else goto <D.33062>;
  <D.33061>:
  return;
  <D.33062>:
  <D.33066>:
  save_thread_context (ctx);
  suspend_current ();
}


__attribute__((visibility ("hidden")))
debugger_agent_single_step_from_context (struct MonoContext * ctx)
{
  unsigned int debugger_tls_id.492;
  _Bool D.33073;
  long int D.33074;
  long int D.33075;
  struct MonoContext * D.33078;
  struct DebuggerTlsData * tls;
  struct MonoContext orig_restore_ctx;

  try
    {
      debugger_tls_id.492 = debugger_tls_id;
      tls = pthread_getspecific (debugger_tls_id.492);
      D.33073 = tls == 0B;
      D.33074 = (long int) D.33073;
      D.33075 = __builtin_expect (D.33074, 0);
      if (D.33075 != 0) goto <D.33076>; else goto <D.33077>;
      <D.33076>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 4909, "tls");
      <D.33077>:
      D.33078 = &tls->restore_ctx;
      memcpy (&orig_restore_ctx, D.33078, 512);
      D.33078 = &tls->restore_ctx;
      memcpy (D.33078, ctx, 512);
      process_single_step_inner (tls);
      D.33078 = &tls->restore_ctx;
      memcpy (ctx, D.33078, 512);
      D.33078 = &tls->restore_ctx;
      memcpy (D.33078, &orig_restore_ctx, 512);
    }
  finally
    {
      orig_restore_ctx = {CLOBBER};
    }
}


__attribute__((visibility ("hidden")))
debugger_agent_breakpoint_from_context (struct MonoContext * ctx)
{
  unsigned int debugger_tls_id.493;
  _Bool D.33080;
  long int D.33081;
  long int D.33082;
  struct MonoContext * D.33085;
  struct DebuggerTlsData * tls;
  struct MonoContext orig_restore_ctx;

  try
    {
      debugger_tls_id.493 = debugger_tls_id;
      tls = pthread_getspecific (debugger_tls_id.493);
      D.33080 = tls == 0B;
      D.33081 = (long int) D.33080;
      D.33082 = __builtin_expect (D.33081, 0);
      if (D.33082 != 0) goto <D.33083>; else goto <D.33084>;
      <D.33083>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 4928, "tls");
      <D.33084>:
      D.33085 = &tls->restore_ctx;
      memcpy (&orig_restore_ctx, D.33085, 512);
      D.33085 = &tls->restore_ctx;
      memcpy (D.33085, ctx, 512);
      process_breakpoint_inner (tls);
      D.33085 = &tls->restore_ctx;
      memcpy (ctx, D.33085, 512);
      D.33085 = &tls->restore_ctx;
      memcpy (D.33085, &orig_restore_ctx, 512);
    }
  finally
    {
      orig_restore_ctx = {CLOBBER};
    }
}


__attribute__((visibility ("hidden")))
mono_debugger_agent_debug_log (int level, struct MonoString * category, struct MonoString * message)
{
  int D.33086;
  char * iftmp.494;
  char * iftmp.495;
  int suspend_policy.496;
  char * D.33098;
  char * D.33099;
  int suspend_policy;
  struct GSList * events;
  struct EventInfo ei;

  try
    {
      D.33086 = agent_config.enabled;
      if (D.33086 == 0) goto <D.33087>; else goto <D.33088>;
      <D.33087>:
      return;
      <D.33088>:
      mono_loader_lock ();
      events = create_event_list (16, 0B, 0B, 0B, &suspend_policy);
      mono_loader_unlock ();
      ei.level = level;
      if (category != 0B) goto <D.33090>; else goto <D.33091>;
      <D.33090>:
      iftmp.494 = mono_string_to_utf8 (category);
      goto <D.33092>;
      <D.33091>:
      iftmp.494 = 0B;
      <D.33092>:
      ei.category = iftmp.494;
      if (message != 0B) goto <D.33094>; else goto <D.33095>;
      <D.33094>:
      iftmp.495 = mono_string_to_utf8 (message);
      goto <D.33096>;
      <D.33095>:
      iftmp.495 = 0B;
      <D.33096>:
      ei.message = iftmp.495;
      suspend_policy.496 = suspend_policy;
      process_event (16, &ei, 0, 0B, events, suspend_policy.496);
      D.33098 = ei.category;
      monoeg_g_free (D.33098);
      D.33099 = ei.message;
      monoeg_g_free (D.33099);
    }
  finally
    {
      suspend_policy = {CLOBBER};
      ei = {CLOBBER};
    }
}


__attribute__((visibility ("hidden")))
mono_debugger_agent_debug_log_is_enabled ()
{
  gboolean D.33103;

  D.33103 = agent_config.enabled;
  return D.33103;
}


__attribute__((visibility ("hidden")))
mono_debugger_agent_handle_exception (struct MonoException * exc, struct MonoContext * throw_ctx, struct MonoContext * catch_ctx)
{
  struct MonoGHashTable * thread_to_tls.497;
  int D.33110;
  int D.33115;
  int D.33120;
  int inited.498;
  struct GSList * D.33127;
  struct MonoVTable * D.33132;
  struct MonoClass * D.33133;
  struct MonoType * D.33134;
  unsigned char D.33137;
  int D.33139;
  struct MonoDomain * D.33144;
  long unsigned int D.33145;
  char * D.33146;
  struct MonoDomain * D.33149;
  long unsigned int D.33150;
  char * D.33151;
  _Bool D.33153;
  int D.33154;
  struct GPtrArray * event_requests.499;
  void * * D.33156;
  long unsigned int D.33157;
  long unsigned int D.33158;
  void * * D.33159;
  int D.33160;
  <unnamed type> D.33163;
  long unsigned int D.33170;
  long unsigned int D.33171;
  struct MonoAssembly * * D.33172;
  struct MonoAssembly * D.33173;
  struct MonoMethod * D.33174;
  struct MonoClass * D.33175;
  struct MonoImage * D.33176;
  struct MonoAssembly * D.33177;
  int D.33182;
  unsigned int D.33183;
  unsigned int i.500;
  int D.33187;
  struct MonoThreadUnwindState * D.33192;
  struct MonoDomain * D.33193;
  int suspend_policy.501;
  int i;
  int j;
  int suspend_policy;
  struct GSList * events;
  struct MonoJitInfo * ji;
  struct MonoJitInfo * catch_ji;
  struct EventInfo ei;
  struct DebuggerTlsData * tls;

  try
    {
      tls = 0B;
      thread_to_tls.497 = thread_to_tls;
      if (thread_to_tls.497 != 0B) goto <D.33106>; else goto <D.33107>;
      <D.33106>:
      {
        struct MonoInternalThread * thread;

        thread = mono_thread_internal_current ();
        mono_loader_lock ();
        thread_to_tls.497 = thread_to_tls;
        tls = mono_g_hash_table_lookup (thread_to_tls.497, thread);
        mono_loader_unlock ();
        if (tls != 0B) goto <D.33108>; else goto <D.33109>;
        <D.33108>:
        D.33110 = tls->abort_requested;
        if (D.33110 != 0) goto <D.33111>; else goto <D.33112>;
        <D.33111>:
        return;
        <D.33112>:
        <D.33109>:
        if (tls != 0B) goto <D.33113>; else goto <D.33114>;
        <D.33113>:
        D.33115 = tls->disable_breakpoints;
        if (D.33115 != 0) goto <D.33116>; else goto <D.33117>;
        <D.33116>:
        return;
        <D.33117>:
        <D.33114>:
      }
      <D.33107>:
      memset (&ei, 0, 552);
      if (catch_ctx == 0B) goto <D.33118>; else goto <D.33119>;
      <D.33118>:
      D.33120 = agent_config.onuncaught;
      if (D.33120 != 0) goto <D.33121>; else goto <D.33122>;
      <D.33121>:
      inited.498 = inited;
      if (inited.498 == 0) goto <D.33124>; else goto <D.33125>;
      <D.33124>:
      finish_agent_init (0);
      events = monoeg_g_slist_append (0B, 16777215B);
      ei.exc = exc;
      process_event (13, &ei, 0, throw_ctx, events, 2);
      return;
      <D.33125>:
      <D.33122>:
      goto <D.33126>;
      <D.33119>:
      D.33127 = agent_config.onthrow;
      if (D.33127 != 0B) goto <D.33128>; else goto <D.33129>;
      <D.33128>:
      inited.498 = inited;
      if (inited.498 == 0) goto <D.33130>; else goto <D.33131>;
      <D.33130>:
      {
        struct GSList * l;
        gboolean found;

        found = 0;
        l = agent_config.onthrow;
        goto <D.26304>;
        <D.26303>:
        {
          char * ex_type;
          char * f;

          ex_type = l->data;
          D.33132 = exc->object.vtable;
          D.33133 = D.33132->klass;
          D.33134 = &D.33133->byval_arg;
          f = mono_type_full_name (D.33134);
          D.33137 = MEM[(const unsigned char * {ref-all})ex_type];
          if (D.33137 == 0) goto <D.33135>; else goto <D.33138>;
          <D.33138>:
          D.33139 = strcmp (ex_type, f);
          if (D.33139 == 0) goto <D.33135>; else goto <D.33136>;
          <D.33135>:
          found = 1;
          <D.33136>:
          monoeg_g_free (f);
        }
        l = l->next;
        <D.26304>:
        if (l != 0B) goto <D.26303>; else goto <D.26305>;
        <D.26305>:
        if (found != 0) goto <D.33140>; else goto <D.33141>;
        <D.33140>:
        finish_agent_init (0);
        events = monoeg_g_slist_append (0B, 16777215B);
        ei.exc = exc;
        process_event (13, &ei, 0, throw_ctx, events, 2);
        return;
        <D.33141>:
      }
      <D.33131>:
      <D.33129>:
      <D.33126>:
      inited.498 = inited;
      if (inited.498 == 0) goto <D.33142>; else goto <D.33143>;
      <D.33142>:
      return;
      <D.33143>:
      D.33144 = mono_domain_get ();
      D.33145 = throw_ctx->uc_mcontext.psw.addr;
      D.33146 = (char *) D.33145;
      ji = mini_jit_info_table_find (D.33144, D.33146, 0B);
      if (catch_ctx != 0B) goto <D.33147>; else goto <D.33148>;
      <D.33147>:
      D.33149 = mono_domain_get ();
      D.33150 = catch_ctx->uc_mcontext.psw.addr;
      D.33151 = (char *) D.33150;
      catch_ji = mini_jit_info_table_find (D.33149, D.33151, 0B);
      goto <D.33152>;
      <D.33148>:
      catch_ji = 0B;
      <D.33152>:
      ei.exc = exc;
      D.33153 = catch_ctx != 0B;
      D.33154 = (int) D.33153;
      ei.caught = D.33154;
      mono_loader_lock ();
      i = 0;
      goto <D.26319>;
      <D.26318>:
      {
        struct EventRequest * req;

        event_requests.499 = event_requests;
        D.33156 = event_requests.499->pdata;
        D.33157 = (long unsigned int) i;
        D.33158 = D.33157 * 8;
        D.33159 = D.33156 + D.33158;
        req = *D.33159;
        D.33160 = req->event_kind;
        if (D.33160 != 13) goto <D.33161>; else goto <D.33162>;
        <D.33161>:
        // predicted unlikely by continue predictor.
        goto <D.26307>;
        <D.33162>:
        j = 0;
        goto <D.26316>;
        <D.26315>:
        {
          struct Modifier * mod;

          mod = &req->modifiers[j];
          D.33163 = mod->kind;
          if (D.33163 == 11) goto <D.33164>; else goto <D.33165>;
          <D.33164>:
          if (catch_ji != 0B) goto <D.33166>; else goto <D.33167>;
          <D.33166>:
          {
            int k;
            gboolean found;
            struct MonoAssembly * * assemblies;

            found = 0;
            assemblies = mod->data.assemblies;
            if (assemblies != 0B) goto <D.33168>; else goto <D.33169>;
            <D.33168>:
            k = 0;
            goto <D.26313>;
            <D.26312>:
            D.33170 = (long unsigned int) k;
            D.33171 = D.33170 * 8;
            D.33172 = assemblies + D.33171;
            D.33173 = *D.33172;
            D.33174 = jinfo_get_method (catch_ji);
            D.33175 = D.33174->klass;
            D.33176 = D.33175->image;
            D.33177 = D.33176->assembly;
            if (D.33173 == D.33177) goto <D.33178>; else goto <D.33179>;
            <D.33178>:
            found = 1;
            <D.33179>:
            k = k + 1;
            <D.26313>:
            D.33170 = (long unsigned int) k;
            D.33171 = D.33170 * 8;
            D.33172 = assemblies + D.33171;
            D.33173 = *D.33172;
            if (D.33173 != 0B) goto <D.26312>; else goto <D.26314>;
            <D.26314>:
            <D.33169>:
            if (found == 0) goto <D.33180>; else goto <D.33181>;
            <D.33180>:
            ei.caught = 0;
            <D.33181>:
          }
          <D.33167>:
          <D.33165>:
        }
        j = j + 1;
        <D.26316>:
        D.33182 = req->nmodifiers;
        if (D.33182 > j) goto <D.26315>; else goto <D.26317>;
        <D.26317>:
      }
      <D.26307>:
      i = i + 1;
      <D.26319>:
      event_requests.499 = event_requests;
      D.33183 = event_requests.499->len;
      i.500 = (unsigned int) i;
      if (D.33183 > i.500) goto <D.26318>; else goto <D.26320>;
      <D.26320>:
      events = create_event_list (13, 0B, ji, &ei, &suspend_policy);
      mono_loader_unlock ();
      if (tls != 0B) goto <D.33185>; else goto <D.33186>;
      <D.33185>:
      D.33187 = ei.caught;
      if (D.33187 != 0) goto <D.33188>; else goto <D.33189>;
      <D.33188>:
      if (catch_ctx != 0B) goto <D.33190>; else goto <D.33191>;
      <D.33190>:
      D.33192 = &tls->catch_state;
      memset (D.33192, 0, 544);
      tls->catch_state.ctx = *catch_ctx;
      D.33193 = mono_domain_get ();
      tls->catch_state.unwind_data[0] = D.33193;
      tls->catch_state.valid = 1;
      <D.33191>:
      <D.33189>:
      <D.33186>:
      suspend_policy.501 = suspend_policy;
      process_event (13, &ei, 0, throw_ctx, events, suspend_policy.501);
      if (tls != 0B) goto <D.33195>; else goto <D.33196>;
      <D.33195>:
      tls->catch_state.valid = 0;
      <D.33196>:
    }
  finally
    {
      suspend_policy = {CLOBBER};
      ei = {CLOBBER};
    }
}


__attribute__((visibility ("hidden")))
mono_debugger_agent_begin_exception_filter (struct MonoException * exc, struct MonoContext * ctx, struct MonoContext * orig_ctx)
{
  int inited.502;
  unsigned int debugger_tls_id.503;
  struct MonoThreadUnwindState * D.33206;
  int D.33207;
  _Bool D.33208;
  long int D.33209;
  long int D.33210;
  struct DebuggerTlsData * tls;

  inited.502 = inited;
  if (inited.502 == 0) goto <D.33201>; else goto <D.33202>;
  <D.33201>:
  return;
  <D.33202>:
  debugger_tls_id.503 = debugger_tls_id;
  tls = pthread_getspecific (debugger_tls_id.503);
  if (tls == 0B) goto <D.33204>; else goto <D.33205>;
  <D.33204>:
  return;
  <D.33205>:
  D.33206 = &tls->filter_state;
  D.33207 = mono_thread_state_init_from_monoctx (D.33206, orig_ctx);
  D.33208 = D.33207 == 0;
  D.33209 = (long int) D.33208;
  D.33210 = __builtin_expect (D.33209, 0);
  if (D.33210 != 0) goto <D.33211>; else goto <D.33212>;
  <D.33211>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 5475, "mono_thread_state_init_from_monoctx (&tls->filter_state, orig_ctx)");
  <D.33212>:
}


__attribute__((visibility ("hidden")))
mono_debugger_agent_end_exception_filter (struct MonoException * exc, struct MonoContext * ctx, struct MonoContext * orig_ctx)
{
  int inited.504;
  unsigned int debugger_tls_id.505;
  struct DebuggerTlsData * tls;

  inited.504 = inited;
  if (inited.504 == 0) goto <D.33215>; else goto <D.33216>;
  <D.33215>:
  return;
  <D.33216>:
  debugger_tls_id.505 = debugger_tls_id;
  tls = pthread_getspecific (debugger_tls_id.505);
  if (tls == 0B) goto <D.33218>; else goto <D.33219>;
  <D.33218>:
  return;
  <D.33219>:
  tls->filter_state.valid = 0;
}