mono_debugger_agent_parse_options (char * options)
{
  int D.27450;
  const gchar * D.27453;
  gchar * D.27454;
  int D.27456;
  const gchar * D.27459;
  gchar * D.27460;
  int D.27462;
  const char * D.27465;
  int D.27466;
  int D.27468;
  gchar * D.27471;
  int D.27473;
  char * D.27476;
  int D.27477;
  int D.27479;
  char * D.27482;
  int D.27483;
  int D.27485;
  char * D.27488;
  int D.27489;
  int D.27491;
  gchar * D.27494;
  struct GSList * D.27495;
  struct GSList * D.27496;
  int D.27498;
  gchar * D.27501;
  struct GSList * D.27502;
  int D.27504;
  int D.27507;
  const char * D.27510;
  int D.27511;
  int D.27513;
  const gchar * D.27516;
  gchar * D.27517;
  int D.27519;
  const char * D.27522;
  int D.27523;
  _Bool D.27524;
  int D.27525;
  int D.27527;
  int D.27530;
  int D.27532;
  int D.27535;
  char * D.27538;
  int D.27539;
  int D.27542;
  char * D.27545;
  unsigned int D.27548;
  unsigned int D.27549;
  unsigned int D.27550;
  gchar * D.27551;
  char * D.27552;
  struct _IO_FILE * stderr.0;
  int D.24822;
  int iftmp.1;
  int D.24821;
  const char[10] * D.27563;
  unsigned char D.27564;
  int D.27565;
  unsigned char D.27566;
  int D.27567;
  _Bool D.27568;
  _Bool D.27569;
  _Bool D.27570;
  const unsigned char * D.27573;
  unsigned char D.27574;
  int D.27575;
  const unsigned char * D.27576;
  unsigned char D.27577;
  int D.27578;
  _Bool D.27579;
  _Bool D.27580;
  const unsigned char * D.27583;
  unsigned char D.27584;
  int D.27585;
  const unsigned char * D.27586;
  unsigned char D.27587;
  int D.27588;
  _Bool D.27589;
  _Bool D.27590;
  const unsigned char * D.27593;
  unsigned char D.27594;
  int D.27595;
  const unsigned char * D.27596;
  unsigned char D.27597;
  int D.27598;
  int D.27604;
  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.27448>; else goto <D.27449>;
      <D.27448>:
      options = monoeg_g_strdup_printf ("%s,%s", options, extra);
      <D.27449>:
      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.24812>;
      <D.24811>:
      {
        char * arg;

        arg = *ptr;
        D.27450 = strncmp (arg, "transport=", 10);
        if (D.27450 == 0) goto <D.27451>; else goto <D.27452>;
        <D.27451>:
        D.27453 = arg + 10;
        D.27454 = monoeg_strdup (D.27453);
        agent_config.transport = D.27454;
        goto <D.27455>;
        <D.27452>:
        D.27456 = strncmp (arg, "address=", 8);
        if (D.27456 == 0) goto <D.27457>; else goto <D.27458>;
        <D.27457>:
        D.27459 = arg + 8;
        D.27460 = monoeg_strdup (D.27459);
        agent_config.address = D.27460;
        goto <D.27461>;
        <D.27458>:
        D.27462 = strncmp (arg, "loglevel=", 9);
        if (D.27462 == 0) goto <D.27463>; else goto <D.27464>;
        <D.27463>:
        D.27465 = arg + 9;
        D.27466 = atoi (D.27465);
        agent_config.log_level = D.27466;
        goto <D.27467>;
        <D.27464>:
        D.27468 = strncmp (arg, "logfile=", 8);
        if (D.27468 == 0) goto <D.27469>; else goto <D.27470>;
        <D.27469>:
        D.27459 = arg + 8;
        D.27471 = monoeg_strdup (D.27459);
        agent_config.log_file = D.27471;
        goto <D.27472>;
        <D.27470>:
        D.27473 = strncmp (arg, "suspend=", 8);
        if (D.27473 == 0) goto <D.27474>; else goto <D.27475>;
        <D.27474>:
        D.27476 = arg + 8;
        D.27477 = parse_flag ("suspend", D.27476);
        agent_config.suspend = D.27477;
        goto <D.27478>;
        <D.27475>:
        D.27479 = strncmp (arg, "server=", 7);
        if (D.27479 == 0) goto <D.27480>; else goto <D.27481>;
        <D.27480>:
        D.27482 = arg + 7;
        D.27483 = parse_flag ("server", D.27482);
        agent_config.server = D.27483;
        goto <D.27484>;
        <D.27481>:
        D.27485 = strncmp (arg, "onuncaught=", 11);
        if (D.27485 == 0) goto <D.27486>; else goto <D.27487>;
        <D.27486>:
        D.27488 = arg + 11;
        D.27489 = parse_flag ("onuncaught", D.27488);
        agent_config.onuncaught = D.27489;
        goto <D.27490>;
        <D.27487>:
        D.27491 = strncmp (arg, "onthrow=", 8);
        if (D.27491 == 0) goto <D.27492>; else goto <D.27493>;
        <D.27492>:
        D.27459 = arg + 8;
        D.27494 = monoeg_strdup (D.27459);
        D.27495 = agent_config.onthrow;
        D.27496 = monoeg_g_slist_append (D.27495, D.27494);
        agent_config.onthrow = D.27496;
        goto <D.27497>;
        <D.27493>:
        D.27498 = strncmp (arg, "onthrow", 7);
        if (D.27498 == 0) goto <D.27499>; else goto <D.27500>;
        <D.27499>:
        D.27501 = monoeg_strdup ("");
        D.27495 = agent_config.onthrow;
        D.27502 = monoeg_g_slist_append (D.27495, D.27501);
        agent_config.onthrow = D.27502;
        goto <D.27503>;
        <D.27500>:
        D.27504 = strncmp (arg, "help", 4);
        if (D.27504 == 0) goto <D.27505>; else goto <D.27506>;
        <D.27505>:
        print_usage ();
        exit (0);
        <D.27506>:
        D.27507 = strncmp (arg, "timeout=", 8);
        if (D.27507 == 0) goto <D.27508>; else goto <D.27509>;
        <D.27508>:
        D.27510 = arg + 8;
        D.27511 = atoi (D.27510);
        agent_config.timeout = D.27511;
        goto <D.27512>;
        <D.27509>:
        D.27513 = strncmp (arg, "launch=", 7);
        if (D.27513 == 0) goto <D.27514>; else goto <D.27515>;
        <D.27514>:
        D.27516 = arg + 7;
        D.27517 = monoeg_strdup (D.27516);
        agent_config.launch = D.27517;
        goto <D.27518>;
        <D.27515>:
        D.27519 = strncmp (arg, "embedding=", 10);
        if (D.27519 == 0) goto <D.27520>; else goto <D.27521>;
        <D.27520>:
        D.27522 = arg + 10;
        D.27523 = atoi (D.27522);
        D.27524 = D.27523 == 1;
        D.27525 = (int) D.27524;
        agent_config.embedding = D.27525;
        goto <D.27526>;
        <D.27521>:
        D.27527 = strncmp (arg, "keepalive=", 10);
        if (D.27527 == 0) goto <D.27528>; else goto <D.27529>;
        <D.27528>:
        D.27522 = arg + 10;
        D.27530 = atoi (D.27522);
        agent_config.keepalive = D.27530;
        goto <D.27531>;
        <D.27529>:
        D.27532 = strncmp (arg, "setpgid=", 8);
        if (D.27532 == 0) goto <D.27533>; else goto <D.27534>;
        <D.27533>:
        D.27476 = arg + 8;
        D.27535 = parse_flag ("setpgid", D.27476);
        agent_config.setpgid = D.27535;
        goto <D.27536>;
        <D.27534>:
        print_usage ();
        exit (1);
        <D.27536>:
        <D.27531>:
        <D.27526>:
        <D.27518>:
        <D.27512>:
        <D.27503>:
        <D.27497>:
        <D.27490>:
        <D.27484>:
        <D.27478>:
        <D.27472>:
        <D.27467>:
        <D.27461>:
        <D.27455>:
      }
      ptr = ptr + 4;
      <D.24812>:
      if (ptr != 0B) goto <D.27537>; else goto <D.24813>;
      <D.27537>:
      D.27538 = *ptr;
      if (D.27538 != 0B) goto <D.24811>; else goto <D.24813>;
      <D.24813>:
      D.27539 = agent_config.server;
      if (D.27539 != 0) goto <D.27540>; else goto <D.27541>;
      <D.27540>:
      D.27542 = agent_config.suspend;
      if (D.27542 == 0) goto <D.27543>; else goto <D.27544>;
      <D.27543>:
      agent_config.defer = 1;
      D.27545 = agent_config.address;
      if (D.27545 == 0B) goto <D.27546>; else goto <D.27547>;
      <D.27546>:
      D.27548 = GetCurrentProcessId ();
      D.27549 = D.27548 % 1000;
      D.27550 = D.27549 + 56000;
      D.27551 = monoeg_g_strdup_printf ("0.0.0.0:%u", D.27550);
      agent_config.address = D.27551;
      <D.27547>:
      <D.27544>:
      <D.27541>:
      D.27552 = agent_config.transport;
      if (D.27552 == 0B) goto <D.27553>; else goto <D.27554>;
      <D.27553>:
      stderr.0 = stderr;
      fprintf (stderr.0, "debugger-agent: The \'transport\' option is mandatory.\n");
      exit (1);
      <D.27554>:
      D.27545 = agent_config.address;
      if (D.27545 == 0B) goto <D.27556>; else goto <D.27557>;
      <D.27556>:
      D.27539 = agent_config.server;
      if (D.27539 == 0) goto <D.27558>; else goto <D.27559>;
      <D.27558>:
      stderr.0 = stderr;
      fprintf (stderr.0, "debugger-agent: The \'address\' option is mandatory.\n");
      exit (1);
      <D.27559>:
      <D.27557>:
      {
        size_t __s1_len;
        size_t __s2_len;

        __s2_len = 9;
        if (__s2_len <= 3) goto <D.27561>; else goto <D.27562>;
        <D.27561>:
        {
          const unsigned char * __s2;
          int __result;

          __s2 = agent_config.transport;
          D.27563 = "dt_socket";
          D.27564 = MEM[(const unsigned char *)D.27563];
          D.27565 = (int) D.27564;
          D.27566 = *__s2;
          D.27567 = (int) D.27566;
          __result = D.27565 - D.27567;
          {
            D.27568 = __s2_len != 0;
            D.27569 = __result == 0;
            D.27570 = D.27568 & D.27569;
            if (D.27570 != 0) goto <D.27571>; else goto <D.27572>;
            <D.27571>:
            D.27573 = &MEM[(void *)"dt_socket" + 1B];
            D.27574 = *D.27573;
            D.27575 = (int) D.27574;
            D.27576 = __s2 + 1;
            D.27577 = *D.27576;
            D.27578 = (int) D.27577;
            __result = D.27575 - D.27578;
            D.27579 = __s2_len > 1;
            D.27569 = __result == 0;
            D.27580 = D.27579 & D.27569;
            if (D.27580 != 0) goto <D.27581>; else goto <D.27582>;
            <D.27581>:
            D.27583 = &MEM[(void *)"dt_socket" + 2B];
            D.27584 = *D.27583;
            D.27585 = (int) D.27584;
            D.27586 = __s2 + 2;
            D.27587 = *D.27586;
            D.27588 = (int) D.27587;
            __result = D.27585 - D.27588;
            D.27589 = __s2_len > 2;
            D.27569 = __result == 0;
            D.27590 = D.27589 & D.27569;
            if (D.27590 != 0) goto <D.27591>; else goto <D.27592>;
            <D.27591>:
            D.27593 = &MEM[(void *)"dt_socket" + 3B];
            D.27594 = *D.27593;
            D.27595 = (int) D.27594;
            D.27596 = __s2 + 3;
            D.27597 = *D.27596;
            D.27598 = (int) D.27597;
            __result = D.27595 - D.27598;
            <D.27592>:
            <D.27582>:
            <D.27572>:
          }
          D.24821 = __result;
        }
        iftmp.1 = -D.24821;
        goto <D.27599>;
        <D.27562>:
        D.27552 = agent_config.transport;
        iftmp.1 = __builtin_strcmp (D.27552, "dt_socket");
        <D.27599>:
        D.24822 = iftmp.1;
      }
      if (D.24822 == 0) goto <D.27600>; else goto <D.27601>;
      <D.27600>:
      D.27545 = agent_config.address;
      if (D.27545 != 0B) goto <D.27602>; else goto <D.27603>;
      <D.27602>:
      D.27545 = agent_config.address;
      D.27604 = parse_address (D.27545, &host, &port);
      if (D.27604 != 0) goto <D.27605>; else goto <D.27606>;
      <D.27605>:
      stderr.0 = stderr;
      fprintf (stderr.0, "debugger-agent: The format of the \'address\' options is \'<host>:<port>\'\n");
      exit (1);
      <D.27606>:
      <D.27603>:
      <D.27601>:
    }
  finally
    {
      host = {CLOBBER};
      port = {CLOBBER};
    }
}


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

  if (str != 0B) goto <D.27607>; else goto <D.27608>;
  <D.27607>:
  D.27609 = __strdup (str);
  return D.27609;
  <D.27608>:
  D.27609 = 0B;
  return D.27609;
}


atoi (const char * __nptr)
{
  int D.27611;

  D.27611 = strtol (__nptr, 0B, 10);
  return D.27611;
}


parse_flag (const char * option, char * flag)
{
  int D.24657;
  int iftmp.2;
  int D.24656;
  const char[2] * D.27616;
  unsigned char D.27617;
  int D.27618;
  unsigned char D.27619;
  int D.27620;
  _Bool D.27621;
  _Bool D.27622;
  _Bool D.27623;
  const unsigned char * D.27626;
  unsigned char D.27627;
  int D.27628;
  const unsigned char * D.27629;
  unsigned char D.27630;
  int D.27631;
  _Bool D.27632;
  _Bool D.27633;
  const unsigned char * D.27636;
  unsigned char D.27637;
  int D.27638;
  const unsigned char * D.27639;
  unsigned char D.27640;
  int D.27641;
  _Bool D.27642;
  _Bool D.27643;
  const unsigned char * D.27646;
  unsigned char D.27647;
  int D.27648;
  const unsigned char * D.27649;
  unsigned char D.27650;
  int D.27651;
  gboolean D.27655;
  int D.24666;
  int iftmp.3;
  int D.24665;
  const char[2] * D.27659;
  unsigned char D.27660;
  int D.27661;
  unsigned char D.27662;
  int D.27663;
  _Bool D.27664;
  _Bool D.27665;
  _Bool D.27666;
  const unsigned char * D.27669;
  unsigned char D.27670;
  int D.27671;
  const unsigned char * D.27672;
  unsigned char D.27673;
  int D.27674;
  _Bool D.27675;
  _Bool D.27676;
  const unsigned char * D.27679;
  unsigned char D.27680;
  int D.27681;
  const unsigned char * D.27682;
  unsigned char D.27683;
  int D.27684;
  _Bool D.27685;
  _Bool D.27686;
  const unsigned char * D.27689;
  unsigned char D.27690;
  int D.27691;
  const unsigned char * D.27692;
  unsigned char D.27693;
  int D.27694;
  struct _IO_FILE * stderr.4;

  {
    size_t __s1_len;
    size_t __s2_len;

    __s2_len = 1;
    if (__s2_len <= 3) goto <D.27614>; else goto <D.27615>;
    <D.27614>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = flag;
      D.27616 = "y";
      D.27617 = MEM[(const unsigned char *)D.27616];
      D.27618 = (int) D.27617;
      D.27619 = *__s2;
      D.27620 = (int) D.27619;
      __result = D.27618 - D.27620;
      {
        D.27621 = __s2_len != 0;
        D.27622 = __result == 0;
        D.27623 = D.27621 & D.27622;
        if (D.27623 != 0) goto <D.27624>; else goto <D.27625>;
        <D.27624>:
        D.27626 = &MEM[(void *)"y" + 1B];
        D.27627 = *D.27626;
        D.27628 = (int) D.27627;
        D.27629 = __s2 + 1;
        D.27630 = *D.27629;
        D.27631 = (int) D.27630;
        __result = D.27628 - D.27631;
        D.27632 = __s2_len > 1;
        D.27622 = __result == 0;
        D.27633 = D.27632 & D.27622;
        if (D.27633 != 0) goto <D.27634>; else goto <D.27635>;
        <D.27634>:
        D.27636 = &MEM[(void *)"y" + 2B];
        D.27637 = *D.27636;
        D.27638 = (int) D.27637;
        D.27639 = __s2 + 2;
        D.27640 = *D.27639;
        D.27641 = (int) D.27640;
        __result = D.27638 - D.27641;
        D.27642 = __s2_len > 2;
        D.27622 = __result == 0;
        D.27643 = D.27642 & D.27622;
        if (D.27643 != 0) goto <D.27644>; else goto <D.27645>;
        <D.27644>:
        D.27646 = &MEM[(void *)"y" + 3B];
        D.27647 = *D.27646;
        D.27648 = (int) D.27647;
        D.27649 = __s2 + 3;
        D.27650 = *D.27649;
        D.27651 = (int) D.27650;
        __result = D.27648 - D.27651;
        <D.27645>:
        <D.27635>:
        <D.27625>:
      }
      D.24656 = __result;
    }
    iftmp.2 = -D.24656;
    goto <D.27652>;
    <D.27615>:
    iftmp.2 = __builtin_strcmp (flag, "y");
    <D.27652>:
    D.24657 = iftmp.2;
  }
  if (D.24657 == 0) goto <D.27653>; else goto <D.27654>;
  <D.27653>:
  D.27655 = 1;
  return D.27655;
  <D.27654>:
  {
    size_t __s1_len;
    size_t __s2_len;

    __s2_len = 1;
    if (__s2_len <= 3) goto <D.27657>; else goto <D.27658>;
    <D.27657>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = flag;
      D.27659 = "n";
      D.27660 = MEM[(const unsigned char *)D.27659];
      D.27661 = (int) D.27660;
      D.27662 = *__s2;
      D.27663 = (int) D.27662;
      __result = D.27661 - D.27663;
      {
        D.27664 = __s2_len != 0;
        D.27665 = __result == 0;
        D.27666 = D.27664 & D.27665;
        if (D.27666 != 0) goto <D.27667>; else goto <D.27668>;
        <D.27667>:
        D.27669 = &MEM[(void *)"n" + 1B];
        D.27670 = *D.27669;
        D.27671 = (int) D.27670;
        D.27672 = __s2 + 1;
        D.27673 = *D.27672;
        D.27674 = (int) D.27673;
        __result = D.27671 - D.27674;
        D.27675 = __s2_len > 1;
        D.27665 = __result == 0;
        D.27676 = D.27675 & D.27665;
        if (D.27676 != 0) goto <D.27677>; else goto <D.27678>;
        <D.27677>:
        D.27679 = &MEM[(void *)"n" + 2B];
        D.27680 = *D.27679;
        D.27681 = (int) D.27680;
        D.27682 = __s2 + 2;
        D.27683 = *D.27682;
        D.27684 = (int) D.27683;
        __result = D.27681 - D.27684;
        D.27685 = __s2_len > 2;
        D.27665 = __result == 0;
        D.27686 = D.27685 & D.27665;
        if (D.27686 != 0) goto <D.27687>; else goto <D.27688>;
        <D.27687>:
        D.27689 = &MEM[(void *)"n" + 3B];
        D.27690 = *D.27689;
        D.27691 = (int) D.27690;
        D.27692 = __s2 + 3;
        D.27693 = *D.27692;
        D.27694 = (int) D.27693;
        __result = D.27691 - D.27694;
        <D.27688>:
        <D.27678>:
        <D.27668>:
      }
      D.24665 = __result;
    }
    iftmp.3 = -D.24665;
    goto <D.27695>;
    <D.27658>:
    iftmp.3 = __builtin_strcmp (flag, "n");
    <D.27695>:
    D.24666 = iftmp.3;
  }
  if (D.24666 == 0) goto <D.27696>; else goto <D.27697>;
  <D.27696>:
  D.27655 = 0;
  return D.27655;
  <D.27697>:
  stderr.4 = stderr;
  fprintf (stderr.4, "debugger-agent: The valid values for the \'%s\' option are \'y\' and \'n\'.\n", option);
  exit (1);
  D.27655 = 0;
  return D.27655;
}


print_usage ()
{
  struct _IO_FILE * stderr.5;

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


parse_address (char * address, char * * host, int * port)
{
  _Bool D.27701;
  _Bool D.27702;
  _Bool D.27703;
  int D.27706;
  int pos.6;
  int address.7;
  int D.27709;
  int D.27710;
  unsigned int D.27711;
  void * D.27712;
  unsigned int D.27713;
  char * D.27714;
  sizetype D.27715;
  char * D.27716;
  const char * D.27717;
  int D.27718;
  char * pos;

  pos = __builtin_strchr (address, 58);
  D.27701 = pos == 0B;
  D.27702 = pos == address;
  D.27703 = D.27701 | D.27702;
  if (D.27703 != 0) goto <D.27704>; else goto <D.27705>;
  <D.27704>:
  D.27706 = 1;
  return D.27706;
  <D.27705>:
  pos.6 = (int) pos;
  address.7 = (int) address;
  D.27709 = pos.6 - address.7;
  D.27710 = D.27709 + 1;
  D.27711 = (unsigned int) D.27710;
  D.27712 = monoeg_malloc (D.27711);
  *host = D.27712;
  pos.6 = (int) pos;
  address.7 = (int) address;
  D.27709 = pos.6 - address.7;
  D.27713 = (unsigned int) D.27709;
  D.27714 = *host;
  strncpy (D.27714, address, D.27713);
  D.27714 = *host;
  pos.6 = (int) pos;
  address.7 = (int) address;
  D.27709 = pos.6 - address.7;
  D.27715 = (sizetype) D.27709;
  D.27716 = D.27714 + D.27715;
  *D.27716 = 0;
  D.27717 = pos + 1;
  D.27718 = atoi (D.27717);
  *port = D.27718;
  D.27706 = 0;
  return D.27706;
}


strncpy (char * restrict __dest, const char * restrict __src, size_t __len)
{
  char * D.27720;
  unsigned int D.27721;

  D.27721 = __builtin_object_size (__dest, 1);
  D.27720 = __builtin___strncpy_chk (__dest, __src, __len, D.27721);
  return D.27720;
}


fprintf (struct FILE * restrict __stream, const char * restrict __fmt)
{
  int D.27723;

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


mono_debugger_agent_init ()
{
  int D.27725;
  struct GPtrArray * event_requests.8;
  struct MonoGHashTable * thread_to_tls.9;
  int D.27730;
  struct MonoGHashTable * tid_to_thread.10;
  int D.27734;
  struct MonoGHashTable * tid_to_thread_obj.11;
  int D.27738;
  struct GPtrArray * pending_assembly_loads.12;
  struct GHashTable * domains.13;
  int log_level.14;
  int embedding.15;
  char * D.27745;
  struct FILE * log_file.16;
  struct FILE * log_file.17;
  int * D.27752;
  int D.27753;
  char * D.27754;
  struct _IO_FILE * stderr.18;
  struct _IO_FILE * stdout.19;
  struct MonoDebugOptions * D.27758;
  struct MonoDebugOptions * D.27759;
  struct MonoDebugOptions * D.27760;
  int D.27761;
  int D.27764;
  struct GSList * D.27767;

  D.27725 = agent_config.enabled;
  if (D.27725 == 0) goto <D.27726>; else goto <D.27727>;
  <D.27726>:
  return;
  <D.27727>:
  transport_init ();
  mono_loader_lock_track_ownership (1);
  event_requests.8 = monoeg_g_ptr_array_new ();
  event_requests = event_requests.8;
  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);
  thread_to_tls.9 = mono_g_hash_table_new_type (0B, 0B, 1);
  thread_to_tls = thread_to_tls.9;
  D.27730 = mono_gc_is_moving ();
  if (D.27730 == 0) goto <D.27731>; else goto <D.27732>;
  <D.27731>:
  mono_gc_register_root (&thread_to_tls, 4, 0B);
  <D.27732>:
  tid_to_thread.10 = mono_g_hash_table_new_type (0B, 0B, 2);
  tid_to_thread = tid_to_thread.10;
  D.27734 = mono_gc_is_moving ();
  if (D.27734 == 0) goto <D.27735>; else goto <D.27736>;
  <D.27735>:
  mono_gc_register_root (&tid_to_thread, 4, 0B);
  <D.27736>:
  tid_to_thread_obj.11 = mono_g_hash_table_new_type (0B, 0B, 2);
  tid_to_thread_obj = tid_to_thread_obj.11;
  D.27738 = mono_gc_is_moving ();
  if (D.27738 == 0) goto <D.27739>; else goto <D.27740>;
  <D.27739>:
  mono_gc_register_root (&tid_to_thread_obj, 4, 0B);
  <D.27740>:
  pending_assembly_loads.12 = monoeg_g_ptr_array_new ();
  pending_assembly_loads = pending_assembly_loads.12;
  domains.13 = monoeg_g_hash_table_new (mono_aligned_addr_hash, 0B);
  domains = domains.13;
  log_level.14 = agent_config.log_level;
  log_level = log_level.14;
  embedding.15 = agent_config.embedding;
  embedding = embedding.15;
  disconnected = 1;
  D.27745 = agent_config.log_file;
  if (D.27745 != 0B) goto <D.27746>; else goto <D.27747>;
  <D.27746>:
  D.27745 = agent_config.log_file;
  log_file.16 = fopen (D.27745, "w+");
  log_file = log_file.16;
  log_file.17 = log_file;
  if (log_file.17 == 0B) goto <D.27750>; else goto <D.27751>;
  <D.27750>:
  D.27752 = __errno_location ();
  D.27753 = *D.27752;
  D.27754 = strerror (D.27753);
  D.27745 = agent_config.log_file;
  stderr.18 = stderr;
  fprintf (stderr.18, "Unable to create log file \'%s\': %s.\n", D.27745, D.27754);
  exit (1);
  <D.27751>:
  goto <D.27756>;
  <D.27747>:
  stdout.19 = stdout;
  log_file = stdout.19;
  <D.27756>:
  ids_init ();
  objrefs_init ();
  breakpoints_init ();
  suspend_init ();
  D.27758 = mini_get_debug_options ();
  D.27758->gen_seq_points = 1;
  D.27759 = mini_get_debug_options ();
  D.27759->mdb_optimizations = 1;
  D.27760 = mini_get_debug_options ();
  D.27760->load_aot_jit_info_eagerly = 1;
  D.27761 = agent_config.setpgid;
  if (D.27761 != 0) goto <D.27762>; else goto <D.27763>;
  <D.27762>:
  setpgid (0, 0);
  <D.27763>:
  D.27764 = agent_config.onuncaught;
  if (D.27764 == 0) goto <D.27765>; else goto <D.27766>;
  <D.27765>:
  D.27767 = agent_config.onthrow;
  if (D.27767 == 0B) goto <D.27768>; else goto <D.27769>;
  <D.27768>:
  finish_agent_init (1);
  <D.27769>:
  <D.27766>:
}


end_runtime_invoke (struct MonoProfiler * prof, struct MonoMethod * method)
{
  int embedding.20;
  struct SingleStepReq * ss_req.21;
  void * ss_invoke_addr.22;
  struct MonoInternalThread * D.27779;
  struct MonoInternalThread * D.27780;
  struct GPtrArray * event_requests.23;
  void * * D.27782;
  unsigned int i.24;
  unsigned int D.27784;
  void * * D.27785;
  int D.27786;
  void * D.27789;
  unsigned int i.25;
  unsigned int D.27791;
  int i;
  void * stackptr;

  stackptr = __builtin_frame_address (1);
  embedding.20 = embedding;
  if (embedding.20 == 0) goto <D.27771>; else goto <D.27774>;
  <D.27774>:
  ss_req.21 = ss_req;
  if (ss_req.21 == 0B) goto <D.27771>; else goto <D.27776>;
  <D.27776>:
  ss_invoke_addr.22 = ss_invoke_addr;
  if (stackptr != ss_invoke_addr.22) goto <D.27771>; else goto <D.27778>;
  <D.27778>:
  ss_req.21 = ss_req;
  D.27779 = ss_req.21->thread;
  D.27780 = mono_thread_internal_current ();
  if (D.27779 != D.27780) goto <D.27771>; else goto <D.27772>;
  <D.27771>:
  return;
  <D.27772>:
  mono_loader_lock ();
  ss_invoke_addr = 0B;
  i = 0;
  goto <D.25751>;
  <D.25750>:
  {
    struct EventRequest * req;

    event_requests.23 = event_requests;
    D.27782 = event_requests.23->pdata;
    i.24 = (unsigned int) i;
    D.27784 = i.24 * 4;
    D.27785 = D.27782 + D.27784;
    req = *D.27785;
    D.27786 = req->event_kind;
    if (D.27786 == 11) goto <D.27787>; else goto <D.27788>;
    <D.27787>:
    D.27789 = req->info;
    ss_destroy (D.27789);
    i.25 = (unsigned int) i;
    event_requests.23 = event_requests;
    monoeg_g_ptr_array_remove_index_fast (event_requests.23, i.25);
    monoeg_g_free (req);
    goto <D.25749>;
    <D.27788>:
  }
  i = i + 1;
  <D.25751>:
  i.25 = (unsigned int) i;
  event_requests.23 = event_requests;
  D.27791 = event_requests.23->len;
  if (i.25 < D.27791) goto <D.25750>; else goto <D.25749>;
  <D.25749>:
  mono_loader_unlock ();
}


ss_destroy (struct SingleStepReq * req)
{
  struct SingleStepReq * ss_req.26;
  _Bool D.27794;
  long int D.27795;
  long int D.27796;

  ss_req.26 = ss_req;
  D.27794 = ss_req.26 != req;
  D.27795 = (long int) D.27794;
  D.27796 = __builtin_expect (D.27795, 0);
  if (D.27796 != 0) goto <D.27797>; else goto <D.27798>;
  <D.27797>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 5255, "ss_req == req");
  <D.27798>:
  ss_req.26 = ss_req;
  ss_stop (ss_req.26);
  ss_req.26 = ss_req;
  monoeg_g_free (ss_req.26);
  ss_req = 0B;
}


ss_stop (struct SingleStepReq * ss_req)
{
  struct GSList * D.27799;
  void * D.27802;
  int D.27803;

  D.27799 = ss_req->bps;
  if (D.27799 != 0B) goto <D.27800>; else goto <D.27801>;
  <D.27800>:
  {
    struct GSList * l;

    l = ss_req->bps;
    goto <D.26068>;
    <D.26067>:
    D.27802 = l->data;
    clear_breakpoint (D.27802);
    l = l->next;
    <D.26068>:
    if (l != 0B) goto <D.26067>; else goto <D.26069>;
    <D.26069>:
    D.27799 = ss_req->bps;
    monoeg_g_slist_free (D.27799);
    ss_req->bps = 0B;
  }
  <D.27801>:
  D.27803 = ss_req->global;
  if (D.27803 != 0) goto <D.27804>; else goto <D.27805>;
  <D.27804>:
  stop_single_stepping ();
  ss_req->global = 0;
  <D.27805>:
}


clear_breakpoint (struct MonoBreakpoint * bp)
{
  struct GPtrArray * D.27806;
  void * * D.27807;
  unsigned int i.27;
  unsigned int D.27809;
  void * * D.27810;
  unsigned int i.28;
  unsigned int D.27812;
  struct GPtrArray * breakpoints.29;
  int i;

  i = 0;
  goto <D.25891>;
  <D.25890>:
  {
    struct BreakpointInstance * inst;

    D.27806 = bp->children;
    D.27807 = D.27806->pdata;
    i.27 = (unsigned int) i;
    D.27809 = i.27 * 4;
    D.27810 = D.27807 + D.27809;
    inst = *D.27810;
    remove_breakpoint (inst);
    monoeg_g_free (inst);
  }
  i = i + 1;
  <D.25891>:
  i.28 = (unsigned int) i;
  D.27806 = bp->children;
  D.27812 = D.27806->len;
  if (i.28 < D.27812) goto <D.25890>; else goto <D.25892>;
  <D.25892>:
  mono_loader_lock ();
  breakpoints.29 = breakpoints;
  monoeg_g_ptr_array_remove (breakpoints.29, bp);
  mono_loader_unlock ();
  D.27806 = bp->children;
  monoeg_g_ptr_array_free (D.27806, 1);
  monoeg_g_free (bp);
}


remove_breakpoint (struct BreakpointInstance * inst)
{
  struct GHashTable * bp_locs.30;
  void * D.27815;
  int D.27816;
  void * D.27817;
  _Bool D.27818;
  long int D.27819;
  long int D.27820;
  long int D.27825;
  int count;
  struct MonoJitInfo * ji;
  guint8 * ip;

  ji = inst->ji;
  ip = inst->ip;
  mono_loader_lock ();
  bp_locs.30 = bp_locs;
  D.27815 = monoeg_g_hash_table_lookup (bp_locs.30, ip);
  count = (int) D.27815;
  D.27816 = count + -1;
  D.27817 = (void *) D.27816;
  bp_locs.30 = bp_locs;
  monoeg_g_hash_table_insert_replace (bp_locs.30, ip, D.27817, 0);
  mono_loader_unlock ();
  D.27818 = count <= 0;
  D.27819 = (long int) D.27818;
  D.27820 = __builtin_expect (D.27819, 0);
  if (D.27820 != 0) goto <D.27821>; else goto <D.27822>;
  <D.27821>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 4193, "count > 0");
  <D.27822>:
  if (count == 1) goto <D.27823>; else goto <D.27824>;
  <D.27823>:
  D.27825 = inst->native_offset;
  if (D.27825 != -1) goto <D.27826>; else goto <D.27827>;
  <D.27826>:
  mono_arch_clear_breakpoint (ji, ip);
  <D.27827>:
  <D.27824>:
}


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

  val = InterlockedDecrement (&ss_count);
  if (val == 0) goto <D.27828>; else goto <D.27829>;
  <D.27828>:
  mono_arch_stop_single_stepping ();
  <D.27829>:
  ss_req.31 = ss_req;
  if (ss_req.31 != 0B) goto <D.27831>; else goto <D.27832>;
  <D.27831>:
  ss_invoke_addr = 0B;
  <D.27832>:
}


InterlockedDecrement (volatile gint32 * val)
{
  gint32 D.27833;
  unsigned int D.27834;

  D.27834 = __sync_sub_and_fetch_4 (val, 1);
  D.27833 = (gint32) D.27834;
  return D.27833;
}


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

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


jit_end (struct MonoProfiler * prof, struct MonoMethod * method, struct MonoJitInfo * jinfo, int result)
{
  struct GPtrArray * pending_assembly_loads.33;
  unsigned int D.27840;
  void * * D.27843;
  struct MonoClass * D.27845;

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

    assembly = 0B;
    mono_loader_lock ();
    pending_assembly_loads.33 = pending_assembly_loads;
    D.27840 = pending_assembly_loads.33->len;
    if (D.27840 != 0) goto <D.27841>; else goto <D.27842>;
    <D.27841>:
    pending_assembly_loads.33 = pending_assembly_loads;
    D.27843 = pending_assembly_loads.33->pdata;
    assembly = *D.27843;
    pending_assembly_loads.33 = pending_assembly_loads;
    monoeg_g_ptr_array_remove_index (pending_assembly_loads.33, 0);
    <D.27842>:
    mono_loader_unlock ();
    if (assembly != 0B) goto <D.27844>; else goto <D.25774>;
    <D.27844>:
    process_profiler_event (8, assembly);
  }
  goto <D.25775>;
  <D.25774>:
  D.27845 = method->klass;
  send_type_load (D.27845);
  if (result == 0) goto <D.27846>; else goto <D.27847>;
  <D.27846>:
  add_pending_breakpoints (method, jinfo);
  <D.27847>:
}


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

  try
    {
      ei_arg = 0B;
      if (event == 12) goto <D.27848>; else goto <D.27849>;
      <D.27848>:
      ei.klass = arg;
      ei_arg = &ei;
      <D.27849>:
      mono_loader_lock ();
      events = create_event_list (event, 0B, 0B, ei_arg, &suspend_policy);
      mono_loader_unlock ();
      suspend_policy.34 = suspend_policy;
      process_event (event, arg, 0, 0B, events, suspend_policy.34);
    }
  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.27855;
  void * * D.27856;
  unsigned int i.35;
  unsigned int D.27858;
  void * * D.27859;
  int D.27860;
  unsigned int D.27861;
  <unnamed type> D.27864;
  int D.27867;
  int D.27872;
  struct MonoInternalThread * D.27878;
  struct MonoInternalThread * D.27879;
  struct MonoClass * D.27887;
  int D.27890;
  struct MonoObject * D.27893;
  struct MonoVTable * D.27894;
  struct MonoClass * D.27895;
  int D.27896;
  int D.27905;
  int D.27908;
  int D.27913;
  unsigned int k.36;
  unsigned int D.27923;
  struct MonoAssembly * * D.27924;
  struct MonoAssembly * D.27925;
  struct MonoMethod * D.27926;
  struct MonoClass * D.27927;
  struct MonoImage * D.27928;
  struct MonoAssembly * D.27929;
  struct MonoClass * D.27938;
  struct GPtrArray * source_file_list.37;
  void * * D.27943;
  unsigned int i.38;
  unsigned int D.27945;
  void * * D.27946;
  char * D.27947;
  struct GHashTable * D.27948;
  void * D.27949;
  void * D.27953;
  unsigned int i.39;
  unsigned int D.27957;
  struct MonoType * D.27965;
  struct GHashTable * D.27966;
  void * D.27967;
  <unnamed type> D.27972;
  unsigned int D.27973;
  struct MonoMethod * D.27978;
  short unsigned int D.27979;
  int D.27980;
  int D.27981;
  int D.25608;
  int iftmp.40;
  int D.25607;
  struct MonoMethod * D.27987;
  const char[7] * D.27988;
  unsigned char D.27989;
  int D.27990;
  unsigned char D.27991;
  int D.27992;
  _Bool D.27993;
  _Bool D.27994;
  _Bool D.27995;
  const unsigned char * D.27998;
  unsigned char D.27999;
  int D.28000;
  const unsigned char * D.28001;
  unsigned char D.28002;
  int D.28003;
  _Bool D.28004;
  _Bool D.28005;
  const unsigned char * D.28008;
  unsigned char D.28009;
  int D.28010;
  const unsigned char * D.28011;
  unsigned char D.28012;
  int D.28013;
  _Bool D.28014;
  _Bool D.28015;
  const unsigned char * D.28018;
  unsigned char D.28019;
  int D.28020;
  const unsigned char * D.28021;
  unsigned char D.28022;
  int D.28023;
  struct MonoMethod * D.28025;
  const char * D.28026;
  unsigned int D.28029;
  struct MonoClass * klass.41;
  struct MonoImage * D.28037;
  struct MonoClass * klass.42;
  _Bool D.28039;
  long int D.28040;
  long int D.28041;
  unsigned char D.28044;
  unsigned char D.28045;
  struct MonoMethod * D.28048;
  int D.28051;
  unsigned char D.28054;
  unsigned int D.28057;
  struct MonoClass * klass.43;
  struct MonoClass * klass.44;
  _Bool D.28066;
  long int D.28067;
  long int D.28068;
  unsigned char D.28071;
  unsigned char D.28072;
  struct MonoMethod * D.28075;
  int D.28078;
  struct MonoMethod * D.28081;
  struct MonoClass * D.28082;
  int D.28085;
  unsigned char D.28088;
  int D.28091;
  int D.28094;
  int D.28095;
  int D.28096;
  int D.28097;
  void * D.28098;
  unsigned int i.45;
  unsigned int D.28100;
  int i;
  int j;
  struct GSList * events;

  events = 0B;
  *suspend_policy = 0;
  if (reqs == 0B) goto <D.27851>; else goto <D.27852>;
  <D.27851>:
  reqs = event_requests;
  <D.27852>:
  if (reqs == 0B) goto <D.27853>; else goto <D.27854>;
  <D.27853>:
  D.27855 = 0B;
  return D.27855;
  <D.27854>:
  i = 0;
  goto <D.25617>;
  <D.25616>:
  {
    struct EventRequest * req;

    D.27856 = reqs->pdata;
    i.35 = (unsigned int) i;
    D.27858 = i.35 * 4;
    D.27859 = D.27856 + D.27858;
    req = *D.27859;
    D.27860 = req->event_kind;
    D.27861 = (unsigned int) D.27860;
    if (D.27861 == event) goto <D.27862>; else goto <D.27863>;
    <D.27862>:
    {
      gboolean filtered;

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

        mod = &req->modifiers[j];
        D.27864 = mod->kind;
        if (D.27864 == 1) goto <D.27865>; else goto <D.27866>;
        <D.27865>:
        filtered = 1;
        D.27867 = mod->data.count;
        if (D.27867 > 0) goto <D.27868>; else goto <D.27869>;
        <D.27868>:
        D.27867 = mod->data.count;
        if (D.27867 > 0) goto <D.27870>; else goto <D.27871>;
        <D.27870>:
        D.27867 = mod->data.count;
        D.27872 = D.27867 + -1;
        mod->data.count = D.27872;
        D.27867 = mod->data.count;
        if (D.27867 == 0) goto <D.27873>; else goto <D.27874>;
        <D.27873>:
        filtered = 0;
        <D.27874>:
        <D.27871>:
        <D.27869>:
        goto <D.27875>;
        <D.27866>:
        D.27864 = mod->kind;
        if (D.27864 == 3) goto <D.27876>; else goto <D.27877>;
        <D.27876>:
        D.27878 = mod->data.thread;
        D.27879 = mono_thread_internal_current ();
        if (D.27878 != D.27879) goto <D.27880>; else goto <D.27881>;
        <D.27880>:
        filtered = 1;
        <D.27881>:
        goto <D.27882>;
        <D.27877>:
        D.27864 = mod->kind;
        if (D.27864 == 8) goto <D.27885>; else goto <D.27883>;
        <D.27885>:
        if (ei != 0B) goto <D.27886>; else goto <D.27883>;
        <D.27886>:
        D.27887 = mod->data.exc_class;
        if (D.27887 != 0B) goto <D.27888>; else goto <D.27889>;
        <D.27888>:
        D.27890 = mod->subclasses;
        if (D.27890 != 0) goto <D.27891>; else goto <D.27892>;
        <D.27891>:
        D.27893 = ei->exc;
        D.27894 = D.27893->vtable;
        D.27895 = D.27894->klass;
        D.27887 = mod->data.exc_class;
        D.27896 = mono_class_is_assignable_from (D.27887, D.27895);
        if (D.27896 == 0) goto <D.27897>; else goto <D.27898>;
        <D.27897>:
        filtered = 1;
        <D.27898>:
        <D.27892>:
        <D.27889>:
        D.27887 = mod->data.exc_class;
        if (D.27887 != 0B) goto <D.27899>; else goto <D.27900>;
        <D.27899>:
        D.27890 = mod->subclasses;
        if (D.27890 == 0) goto <D.27901>; else goto <D.27902>;
        <D.27901>:
        D.27887 = mod->data.exc_class;
        D.27893 = ei->exc;
        D.27894 = D.27893->vtable;
        D.27895 = D.27894->klass;
        if (D.27887 != D.27895) goto <D.27903>; else goto <D.27904>;
        <D.27903>:
        filtered = 1;
        <D.27904>:
        <D.27902>:
        <D.27900>:
        D.27905 = ei->caught;
        if (D.27905 != 0) goto <D.27906>; else goto <D.27907>;
        <D.27906>:
        D.27908 = mod->caught;
        if (D.27908 == 0) goto <D.27909>; else goto <D.27910>;
        <D.27909>:
        filtered = 1;
        <D.27910>:
        <D.27907>:
        D.27905 = ei->caught;
        if (D.27905 == 0) goto <D.27911>; else goto <D.27912>;
        <D.27911>:
        D.27913 = mod->uncaught;
        if (D.27913 == 0) goto <D.27914>; else goto <D.27915>;
        <D.27914>:
        filtered = 1;
        <D.27915>:
        <D.27912>:
        goto <D.27884>;
        <D.27883>:
        D.27864 = mod->kind;
        if (D.27864 == 11) goto <D.27918>; else goto <D.27916>;
        <D.27918>:
        if (ji != 0B) goto <D.27919>; else goto <D.27916>;
        <D.27919>:
        {
          int k;
          gboolean found;
          struct MonoAssembly * * assemblies;

          found = 0;
          assemblies = mod->data.assemblies;
          if (assemblies != 0B) goto <D.27920>; else goto <D.27921>;
          <D.27920>:
          k = 0;
          goto <D.25580>;
          <D.25579>:
          k.36 = (unsigned int) k;
          D.27923 = k.36 * 4;
          D.27924 = assemblies + D.27923;
          D.27925 = *D.27924;
          D.27926 = jinfo_get_method (ji);
          D.27927 = D.27926->klass;
          D.27928 = D.27927->image;
          D.27929 = D.27928->assembly;
          if (D.27925 == D.27929) goto <D.27930>; else goto <D.27931>;
          <D.27930>:
          found = 1;
          <D.27931>:
          k = k + 1;
          <D.25580>:
          k.36 = (unsigned int) k;
          D.27923 = k.36 * 4;
          D.27924 = assemblies + D.27923;
          D.27925 = *D.27924;
          if (D.27925 != 0B) goto <D.25579>; else goto <D.25581>;
          <D.25581>:
          <D.27921>:
          if (found == 0) goto <D.27932>; else goto <D.27933>;
          <D.27932>:
          filtered = 1;
          <D.27933>:
        }
        goto <D.27917>;
        <D.27916>:
        D.27864 = mod->kind;
        if (D.27864 == 12) goto <D.27936>; else goto <D.27934>;
        <D.27936>:
        if (ei != 0B) goto <D.27937>; else goto <D.27934>;
        <D.27937>:
        D.27938 = ei->klass;
        if (D.27938 != 0B) goto <D.27939>; else goto <D.27934>;
        <D.27939>:
        {
          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.25597>;
              <D.25596>:
              {
                struct MonoDebugMethodInfo * minfo;

                minfo = mono_debug_lookup_method (method);
                if (minfo != 0B) goto <D.27940>; else goto <D.27941>;
                <D.27940>:
                mono_debug_symfile_get_line_numbers_full (minfo, &source_file, &source_file_list, 0B, 0B, 0B, 0B, 0B);
                i = 0;
                goto <D.25594>;
                <D.25593>:
                source_file_list.37 = source_file_list;
                D.27943 = source_file_list.37->pdata;
                i.38 = (unsigned int) i;
                D.27945 = i.38 * 4;
                D.27946 = D.27943 + D.27945;
                sinfo = *D.27946;
                D.27947 = sinfo->source_file;
                s = strdup_tolower (D.27947);
                D.27948 = mod->data.source_files;
                D.27949 = monoeg_g_hash_table_lookup (D.27948, s);
                if (D.27949 != 0B) goto <D.27950>; else goto <D.27951>;
                <D.27950>:
                found = 1;
                goto <D.27952>;
                <D.27951>:
                {
                  char * s2;
                  char * s3;

                  D.27947 = sinfo->source_file;
                  s2 = monoeg_g_path_get_basename (D.27947);
                  s3 = strdup_tolower (s2);
                  D.27948 = mod->data.source_files;
                  D.27953 = monoeg_g_hash_table_lookup (D.27948, s3);
                  if (D.27953 != 0B) goto <D.27954>; else goto <D.27955>;
                  <D.27954>:
                  found = 1;
                  <D.27955>:
                  monoeg_g_free (s2);
                  monoeg_g_free (s3);
                }
                <D.27952>:
                monoeg_g_free (s);
                i = i + 1;
                <D.25594>:
                i.39 = (unsigned int) i;
                source_file_list.37 = source_file_list;
                D.27957 = source_file_list.37->len;
                if (i.39 < D.27957) goto <D.25593>; else goto <D.25595>;
                <D.25595>:
                source_file_list.37 = source_file_list;
                monoeg_g_ptr_array_free (source_file_list.37, 1);
                <D.27941>:
              }
              <D.25597>:
              D.27938 = ei->klass;
              method = mono_class_get_methods (D.27938, &iter);
              if (method != 0B) goto <D.25596>; else goto <D.25598>;
              <D.25598>:
              if (found == 0) goto <D.27958>; else goto <D.27959>;
              <D.27958>:
              filtered = 1;
              <D.27959>:
            }
          finally
            {
              iter = {CLOBBER};
              source_file = {CLOBBER};
              source_file_list = {CLOBBER};
            }
        }
        goto <D.27935>;
        <D.27934>:
        D.27864 = mod->kind;
        if (D.27864 == 13) goto <D.27962>; else goto <D.27960>;
        <D.27962>:
        if (ei != 0B) goto <D.27963>; else goto <D.27960>;
        <D.27963>:
        D.27938 = ei->klass;
        if (D.27938 != 0B) goto <D.27964>; else goto <D.27960>;
        <D.27964>:
        {
          char * s;

          D.27938 = ei->klass;
          D.27965 = &D.27938->byval_arg;
          s = mono_type_full_name (D.27965);
          D.27966 = mod->data.type_names;
          D.27967 = monoeg_g_hash_table_lookup (D.27966, s);
          if (D.27967 == 0B) goto <D.27968>; else goto <D.27969>;
          <D.27968>:
          filtered = 1;
          <D.27969>:
          monoeg_g_free (s);
        }
        goto <D.27961>;
        <D.27960>:
        D.27864 = mod->kind;
        if (D.27864 == 10) goto <D.27970>; else goto <D.27971>;
        <D.27970>:
        D.27972 = mod->data.filter;
        D.27973 = D.27972 & 1;
        if (D.27973 != 0) goto <D.27974>; else goto <D.27975>;
        <D.27974>:
        if (ji != 0B) goto <D.27976>; else goto <D.27977>;
        <D.27976>:
        D.27978 = jinfo_get_method (ji);
        D.27979 = D.27978->flags;
        D.27980 = (int) D.27979;
        D.27981 = D.27980 & 2048;
        if (D.27981 != 0) goto <D.27982>; else goto <D.27983>;
        <D.27982>:
        {
          size_t __s1_len;
          size_t __s2_len;

          __s2_len = 6;
          if (__s2_len <= 3) goto <D.27985>; else goto <D.27986>;
          <D.27985>:
          {
            const unsigned char * __s2;
            int __result;

            D.27987 = jinfo_get_method (ji);
            __s2 = D.27987->name;
            D.27988 = ".cctor";
            D.27989 = MEM[(const unsigned char *)D.27988];
            D.27990 = (int) D.27989;
            D.27991 = *__s2;
            D.27992 = (int) D.27991;
            __result = D.27990 - D.27992;
            {
              D.27993 = __s2_len != 0;
              D.27994 = __result == 0;
              D.27995 = D.27993 & D.27994;
              if (D.27995 != 0) goto <D.27996>; else goto <D.27997>;
              <D.27996>:
              D.27998 = &MEM[(void *)".cctor" + 1B];
              D.27999 = *D.27998;
              D.28000 = (int) D.27999;
              D.28001 = __s2 + 1;
              D.28002 = *D.28001;
              D.28003 = (int) D.28002;
              __result = D.28000 - D.28003;
              D.28004 = __s2_len > 1;
              D.27994 = __result == 0;
              D.28005 = D.28004 & D.27994;
              if (D.28005 != 0) goto <D.28006>; else goto <D.28007>;
              <D.28006>:
              D.28008 = &MEM[(void *)".cctor" + 2B];
              D.28009 = *D.28008;
              D.28010 = (int) D.28009;
              D.28011 = __s2 + 2;
              D.28012 = *D.28011;
              D.28013 = (int) D.28012;
              __result = D.28010 - D.28013;
              D.28014 = __s2_len > 2;
              D.27994 = __result == 0;
              D.28015 = D.28014 & D.27994;
              if (D.28015 != 0) goto <D.28016>; else goto <D.28017>;
              <D.28016>:
              D.28018 = &MEM[(void *)".cctor" + 3B];
              D.28019 = *D.28018;
              D.28020 = (int) D.28019;
              D.28021 = __s2 + 3;
              D.28022 = *D.28021;
              D.28023 = (int) D.28022;
              __result = D.28020 - D.28023;
              <D.28017>:
              <D.28007>:
              <D.27997>:
            }
            D.25607 = __result;
          }
          iftmp.40 = -D.25607;
          goto <D.28024>;
          <D.27986>:
          D.28025 = jinfo_get_method (ji);
          D.28026 = D.28025->name;
          iftmp.40 = __builtin_strcmp (D.28026, ".cctor");
          <D.28024>:
          D.25608 = iftmp.40;
        }
        if (D.25608 == 0) goto <D.28027>; else goto <D.28028>;
        <D.28027>:
        filtered = 1;
        <D.28028>:
        <D.27983>:
        <D.27977>:
        <D.27975>:
        D.27972 = mod->data.filter;
        D.28029 = D.27972 & 2;
        if (D.28029 != 0) goto <D.28030>; else goto <D.28031>;
        <D.28030>:
        if (ji != 0B) goto <D.28032>; else goto <D.28033>;
        <D.28032>:
        {
          struct MonoCustomAttrInfo * ainfo;
          static struct MonoClass * klass;

          klass.41 = klass;
          if (klass.41 == 0B) goto <D.28035>; else goto <D.28036>;
          <D.28035>:
          D.28037 = mono_defaults.corlib;
          klass.42 = mono_class_from_name (D.28037, "System.Diagnostics", "DebuggerHiddenAttribute");
          klass = klass.42;
          klass.41 = klass;
          D.28039 = klass.41 == 0B;
          D.28040 = (long int) D.28039;
          D.28041 = __builtin_expect (D.28040, 0);
          if (D.28041 != 0) goto <D.28042>; else goto <D.28043>;
          <D.28042>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 3454, "klass");
          <D.28043>:
          <D.28036>:
          D.28044 = BIT_FIELD_REF <*ji, 8, 176>;
          D.28045 = D.28044 & 64;
          if (D.28045 == 0) goto <D.28046>; else goto <D.28047>;
          <D.28046>:
          D.28048 = jinfo_get_method (ji);
          ainfo = mono_custom_attrs_from_method (D.28048);
          if (ainfo != 0B) goto <D.28049>; else goto <D.28050>;
          <D.28049>:
          klass.41 = klass;
          D.28051 = mono_custom_attrs_has_attr (ainfo, klass.41);
          if (D.28051 != 0) goto <D.28052>; else goto <D.28053>;
          <D.28052>:
          ji->dbg_hidden = -1;
          <D.28053>:
          mono_custom_attrs_free (ainfo);
          <D.28050>:
          ji->dbg_hidden_inited = -1;
          <D.28047>:
          D.28044 = BIT_FIELD_REF <*ji, 8, 176>;
          D.28054 = D.28044 & 128;
          if (D.28054 != 0) goto <D.28055>; else goto <D.28056>;
          <D.28055>:
          filtered = 1;
          <D.28056>:
        }
        <D.28033>:
        <D.28031>:
        D.27972 = mod->data.filter;
        D.28057 = D.27972 & 4;
        if (D.28057 != 0) goto <D.28058>; else goto <D.28059>;
        <D.28058>:
        if (ji != 0B) goto <D.28060>; else goto <D.28061>;
        <D.28060>:
        {
          struct MonoCustomAttrInfo * ainfo;
          static struct MonoClass * klass;

          klass.43 = klass;
          if (klass.43 == 0B) goto <D.28063>; else goto <D.28064>;
          <D.28063>:
          D.28037 = mono_defaults.corlib;
          klass.44 = mono_class_from_name (D.28037, "System.Diagnostics", "DebuggerStepThroughAttribute");
          klass = klass.44;
          klass.43 = klass;
          D.28066 = klass.43 == 0B;
          D.28067 = (long int) D.28066;
          D.28068 = __builtin_expect (D.28067, 0);
          if (D.28068 != 0) goto <D.28069>; else goto <D.28070>;
          <D.28069>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 3474, "klass");
          <D.28070>:
          <D.28064>:
          D.28071 = BIT_FIELD_REF <*ji, 8, 184>;
          D.28072 = D.28071 & 2;
          if (D.28072 == 0) goto <D.28073>; else goto <D.28074>;
          <D.28073>:
          D.28075 = jinfo_get_method (ji);
          ainfo = mono_custom_attrs_from_method (D.28075);
          if (ainfo != 0B) goto <D.28076>; else goto <D.28077>;
          <D.28076>:
          klass.43 = klass;
          D.28078 = mono_custom_attrs_has_attr (ainfo, klass.43);
          if (D.28078 != 0) goto <D.28079>; else goto <D.28080>;
          <D.28079>:
          ji->dbg_step_through = -1;
          <D.28080>:
          mono_custom_attrs_free (ainfo);
          <D.28077>:
          D.28081 = jinfo_get_method (ji);
          D.28082 = D.28081->klass;
          ainfo = mono_custom_attrs_from_class (D.28082);
          if (ainfo != 0B) goto <D.28083>; else goto <D.28084>;
          <D.28083>:
          klass.43 = klass;
          D.28085 = mono_custom_attrs_has_attr (ainfo, klass.43);
          if (D.28085 != 0) goto <D.28086>; else goto <D.28087>;
          <D.28086>:
          ji->dbg_step_through = -1;
          <D.28087>:
          mono_custom_attrs_free (ainfo);
          <D.28084>:
          ji->dbg_step_through_inited = -1;
          <D.28074>:
          D.28071 = BIT_FIELD_REF <*ji, 8, 184>;
          D.28088 = D.28071 & 4;
          if (D.28088 != 0) goto <D.28089>; else goto <D.28090>;
          <D.28089>:
          filtered = 1;
          <D.28090>:
        }
        <D.28061>:
        <D.28059>:
        <D.27971>:
        <D.27961>:
        <D.27935>:
        <D.27917>:
        <D.27884>:
        <D.27882>:
        <D.27875>:
      }
      j = j + 1;
      <D.25614>:
      D.28091 = req->nmodifiers;
      if (D.28091 > j) goto <D.25613>; else goto <D.25615>;
      <D.25615>:
      if (filtered == 0) goto <D.28092>; else goto <D.28093>;
      <D.28092>:
      D.28094 = req->suspend_policy;
      D.28095 = *suspend_policy;
      D.28096 = MAX_EXPR <D.28094, D.28095>;
      *suspend_policy = D.28096;
      D.28097 = req->id;
      D.28098 = (void *) D.28097;
      events = monoeg_g_slist_append (events, D.28098);
      <D.28093>:
    }
    <D.27863>:
  }
  i = i + 1;
  <D.25617>:
  i.45 = (unsigned int) i;
  D.28100 = reqs->len;
  if (i.45 < D.28100) goto <D.25616>; else goto <D.25618>;
  <D.25618>:
  if (event == 0) goto <D.28101>; else goto <D.28102>;
  <D.28101>:
  events = monoeg_g_slist_append (events, 0B);
  <D.28102>:
  if (event == 1) goto <D.28103>; else goto <D.28104>;
  <D.28103>:
  events = monoeg_g_slist_append (events, 0B);
  <D.28104>:
  D.27855 = events;
  return D.27855;
}


strdup_tolower (char * s)
{
  int D.25559;
  char D.28108;
  int D.28109;
  int D.28110;
  const int iftmp.46;
  unsigned int __c.47;
  unsigned int D.28115;
  const __int32_t * * D.28118;
  const __int32_t * D.28119;
  unsigned int __c.48;
  unsigned int D.28121;
  const __int32_t * D.28122;
  unsigned int D.28126;
  unsigned int D.28127;
  const __int32_t * D.28128;
  char D.28129;
  char * D.28130;
  char * s2;
  char * p;

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

    {
      if (0 != 0) goto <D.28106>; else goto <D.28107>;
      <D.28106>:
      D.28108 = *p;
      D.28109 = (int) D.28108;
      D.28110 = __builtin_constant_p (D.28109);
      if (D.28110 != 0) goto <D.28111>; else goto <D.28112>;
      <D.28111>:
      {
        int __c;

        D.28108 = *p;
        __c = (int) D.28108;
        __c.47 = (unsigned int) __c;
        D.28115 = __c.47 + 128;
        if (D.28115 <= 383) goto <D.28116>; else goto <D.28117>;
        <D.28116>:
        D.28118 = __ctype_tolower_loc ();
        D.28119 = *D.28118;
        __c.48 = (unsigned int) __c;
        D.28121 = __c.48 * 4;
        D.28122 = D.28119 + D.28121;
        iftmp.46 = *D.28122;
        goto <D.28123>;
        <D.28117>:
        iftmp.46 = __c;
        <D.28123>:
        __res = iftmp.46;
      }
      goto <D.28124>;
      <D.28112>:
      D.28108 = *p;
      D.28109 = (int) D.28108;
      __res = tolower (D.28109);
      <D.28124>:
      goto <D.28125>;
      <D.28107>:
      D.28118 = __ctype_tolower_loc ();
      D.28119 = *D.28118;
      D.28108 = *p;
      D.28126 = (unsigned int) D.28108;
      D.28127 = D.28126 * 4;
      D.28128 = D.28119 + D.28127;
      __res = *D.28128;
      <D.28125>:
    }
    D.25559 = __res;
  }
  D.28129 = (char) D.25559;
  *p = D.28129;
  p = p + 1;
  <D.25561>:
  D.28108 = *p;
  if (D.28108 != 0) goto <D.25560>; else goto <D.25562>;
  <D.25562>:
  D.28130 = s2;
  return D.28130;
}


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

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


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.28138;
  long int D.28139;
  long int D.28140;
  const char * D.28143;
  struct FILE * log_file.51;
  int vm_start_event_sent.52;
  const char * D.28152;
  int vm_death_event_sent.53;
  const char * D.28158;
  int D.28159;
  const char * D.28166;
  int disconnected.54;
  const char * D.28172;
  int D.28178;
  unsigned int D.28181;
  unsigned int debugger_thread_id.55;
  unsigned int D.28187;
  unsigned int D.28192;
  unsigned char D.28193;
  int D.28194;
  unsigned int nevents.56;
  unsigned char D.28196;
  int D.28197;
  void * D.28198;
  unsigned int D.28199;
  int ecount.57;
  int ecount.58;
  _Bool D.28204;
  _Bool D.28205;
  _Bool D.28206;
  long long unsigned int D.28209;
  struct MonoDomain * D.28210;
  int protocol_version_set.59;
  int major_version.60;
  int minor_version.61;
  int D.28220;
  unsigned int D.28221;
  struct MonoObject * D.28222;
  int D.28223;
  unsigned int D.28224;
  const char * iftmp.62;
  char * D.28226;
  const char * iftmp.63;
  char * D.28231;
  int iftmp.64;
  int D.28238;
  int D.28246;
  const char * D.28257;
  _Bool D.28260;
  long int D.28261;
  long int D.28262;
  const char * D.28265;
  unsigned int D.28266;
  void * D.28267;
  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.28135>; else goto <D.28136>;
      <D.28135>:
      log_level.50 = log_level;
      D.28138 = log_level.50 > 1;
      D.28139 = (long int) D.28138;
      D.28140 = __builtin_expect (D.28139, 0);
      if (D.28140 != 0) goto <D.28141>; else goto <D.28142>;
      <D.28141>:
      D.28143 = event_to_string (event);
      log_file.51 = log_file;
      fprintf (log_file.51, "Debugger agent not initialized yet: dropping %s\n", D.28143);
      log_file.51 = log_file;
      fflush (log_file.51);
      <D.28142>:
      return;
      <D.28136>:
      vm_start_event_sent.52 = vm_start_event_sent;
      if (vm_start_event_sent.52 == 0) goto <D.28146>; else goto <D.28147>;
      <D.28146>:
      if (event != 0) goto <D.28148>; else goto <D.28149>;
      <D.28148>:
      log_level.50 = log_level;
      D.28138 = log_level.50 > 1;
      D.28139 = (long int) D.28138;
      D.28140 = __builtin_expect (D.28139, 0);
      if (D.28140 != 0) goto <D.28150>; else goto <D.28151>;
      <D.28150>:
      D.28152 = event_to_string (event);
      log_file.51 = log_file;
      fprintf (log_file.51, "VM start event not sent yet: dropping %s\n", D.28152);
      log_file.51 = log_file;
      fflush (log_file.51);
      <D.28151>:
      return;
      <D.28149>:
      <D.28147>:
      vm_death_event_sent.53 = vm_death_event_sent;
      if (vm_death_event_sent.53 != 0) goto <D.28154>; else goto <D.28155>;
      <D.28154>:
      log_level.50 = log_level;
      D.28138 = log_level.50 > 1;
      D.28139 = (long int) D.28138;
      D.28140 = __builtin_expect (D.28139, 0);
      if (D.28140 != 0) goto <D.28156>; else goto <D.28157>;
      <D.28156>:
      D.28158 = event_to_string (event);
      log_file.51 = log_file;
      fprintf (log_file.51, "VM death event has been sent: dropping %s\n", D.28158);
      log_file.51 = log_file;
      fflush (log_file.51);
      <D.28157>:
      return;
      <D.28155>:
      D.28159 = mono_runtime_is_shutting_down ();
      if (D.28159 != 0) goto <D.28160>; else goto <D.28161>;
      <D.28160>:
      if (event != 1) goto <D.28162>; else goto <D.28163>;
      <D.28162>:
      log_level.50 = log_level;
      D.28138 = log_level.50 > 1;
      D.28139 = (long int) D.28138;
      D.28140 = __builtin_expect (D.28139, 0);
      if (D.28140 != 0) goto <D.28164>; else goto <D.28165>;
      <D.28164>:
      D.28166 = event_to_string (event);
      log_file.51 = log_file;
      fprintf (log_file.51, "Mono runtime is shutting down: dropping %s\n", D.28166);
      log_file.51 = log_file;
      fflush (log_file.51);
      <D.28165>:
      return;
      <D.28163>:
      <D.28161>:
      disconnected.54 = disconnected;
      if (disconnected.54 != 0) goto <D.28168>; else goto <D.28169>;
      <D.28168>:
      log_level.50 = log_level;
      D.28138 = log_level.50 > 1;
      D.28139 = (long int) D.28138;
      D.28140 = __builtin_expect (D.28139, 0);
      if (D.28140 != 0) goto <D.28170>; else goto <D.28171>;
      <D.28170>:
      D.28172 = event_to_string (event);
      log_file.51 = log_file;
      fprintf (log_file.51, "Debugger client is not connected: dropping %s\n", D.28172);
      log_file.51 = log_file;
      fflush (log_file.51);
      <D.28171>:
      return;
      <D.28169>:
      if (event == 14) goto <D.28173>; else goto <D.28174>;
      <D.28173>:
      suspend_policy = 0;
      goto <D.28175>;
      <D.28174>:
      if (events == 0B) goto <D.28176>; else goto <D.28177>;
      <D.28176>:
      return;
      <D.28177>:
      D.28178 = agent_config.defer;
      if (D.28178 != 0) goto <D.28179>; else goto <D.28180>;
      <D.28179>:
      D.28181 = GetCurrentThreadId ();
      debugger_thread_id.55 = debugger_thread_id;
      if (D.28181 == debugger_thread_id.55) goto <D.28183>; else goto <D.28184>;
      <D.28183>:
      suspend_policy = 0;
      thread = mono_thread_get_main ();
      goto <D.28185>;
      <D.28184>:
      thread = mono_thread_current ();
      <D.28185>:
      goto <D.28186>;
      <D.28180>:
      D.28187 = GetCurrentThreadId ();
      debugger_thread_id.55 = debugger_thread_id;
      if (D.28187 == debugger_thread_id.55) goto <D.28188>; else goto <D.28189>;
      <D.28188>:
      if (event != 1) goto <D.28190>; else goto <D.28191>;
      <D.28190>:
      return;
      <D.28191>:
      <D.28189>:
      <D.28186>:
      <D.28175>:
      D.28192 = monoeg_g_slist_length (events);
      nevents = (int) D.28192;
      buffer_init (&buf, 128);
      D.28193 = (unsigned char) suspend_policy;
      D.28194 = (int) D.28193;
      buffer_add_byte (&buf, D.28194);
      nevents.56 = (unsigned int) nevents;
      buffer_add_int (&buf, nevents.56);
      l = events;
      goto <D.25678>;
      <D.25677>:
      D.28196 = (unsigned char) event;
      D.28197 = (int) D.28196;
      buffer_add_byte (&buf, D.28197);
      D.28198 = l->data;
      D.28199 = (unsigned int) D.28198;
      buffer_add_int (&buf, D.28199);
      ecount.57 = ecount;
      ecount.58 = ecount.57 + 1;
      ecount = ecount.58;
      if (thread == 0B) goto <D.28202>; else goto <D.28203>;
      <D.28202>:
      thread = mono_thread_current ();
      <D.28203>:
      D.28204 = event == 0;
      D.28205 = arg != 0B;
      D.28206 = D.28204 & D.28205;
      if (D.28206 != 0) goto <D.28207>; else goto <D.28208>;
      <D.28207>:
      thread = arg;
      <D.28208>:
      buffer_add_objid (&buf, thread);
      switch (event) <default: <D.25676>, case 0: <D.25668>, case 1: <D.25669>, case 2: <D.25656>, case 3: <D.25657>, case 4: <D.25659>, case 5: <D.25660>, case 6: <D.25661>, case 7: <D.25662>, case 8: <D.25663>, case 9: <D.25664>, case 10: <D.25666>, case 11: <D.25667>, case 12: <D.25665>, case 13: <D.25670>, case 14: <D.25675>, case 15: <D.25672>, case 16: <D.25673>>
      <D.25656>:
      <D.25657>:
      goto <D.25658>;
      <D.25659>:
      <D.25660>:
      buffer_add_domainid (&buf, arg);
      goto <D.25658>;
      <D.25661>:
      <D.25662>:
      buffer_add_methodid (&buf, domain, arg);
      goto <D.25658>;
      <D.25663>:
      <D.25664>:
      buffer_add_assemblyid (&buf, domain, arg);
      goto <D.25658>;
      <D.25665>:
      buffer_add_typeid (&buf, domain, arg);
      goto <D.25658>;
      <D.25666>:
      <D.25667>:
      buffer_add_methodid (&buf, domain, arg);
      D.28209 = (long long unsigned int) il_offset;
      buffer_add_long (&buf, D.28209);
      goto <D.25658>;
      <D.25668>:
      D.28210 = mono_get_root_domain ();
      buffer_add_domainid (&buf, D.28210);
      goto <D.25658>;
      <D.25669>:
      protocol_version_set.59 = protocol_version_set;
      if (protocol_version_set.59 != 0) goto <D.28214>; else goto <D.28215>;
      <D.28214>:
      major_version.60 = major_version;
      if (major_version.60 > 2) goto <D.28211>; else goto <D.28217>;
      <D.28217>:
      major_version.60 = major_version;
      if (major_version.60 == 2) goto <D.28218>; else goto <D.28212>;
      <D.28218>:
      minor_version.61 = minor_version;
      if (minor_version.61 > 26) goto <D.28211>; else goto <D.28212>;
      <D.28211>:
      D.28220 = mono_environment_exitcode_get ();
      D.28221 = (unsigned int) D.28220;
      buffer_add_int (&buf, D.28221);
      <D.28212>:
      <D.28215>:
      goto <D.25658>;
      <D.25670>:
      {
        struct EventInfo * ei;

        ei = arg;
        D.28222 = ei->exc;
        buffer_add_objid (&buf, D.28222);
        keepalive_obj = ei->exc;
        goto <D.25658>;
      }
      <D.25672>:
      goto <D.25658>;
      <D.25673>:
      {
        struct EventInfo * ei;

        ei = arg;
        D.28223 = ei->level;
        D.28224 = (unsigned int) D.28223;
        buffer_add_int (&buf, D.28224);
        D.28226 = ei->category;
        if (D.28226 != 0B) goto <D.28227>; else goto <D.28228>;
        <D.28227>:
        iftmp.62 = ei->category;
        goto <D.28229>;
        <D.28228>:
        iftmp.62 = "";
        <D.28229>:
        buffer_add_string (&buf, iftmp.62);
        D.28231 = ei->message;
        if (D.28231 != 0B) goto <D.28232>; else goto <D.28233>;
        <D.28232>:
        iftmp.63 = ei->message;
        goto <D.28234>;
        <D.28233>:
        iftmp.63 = "";
        <D.28234>:
        buffer_add_string (&buf, iftmp.63);
        goto <D.25658>;
      }
      <D.25675>:
      suspend_policy = 0;
      goto <D.25658>;
      <D.25676>:
      monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "debugger-agent.c", 3680);
      <D.25658>:
      l = l->next;
      <D.25678>:
      if (l != 0B) goto <D.25677>; else goto <D.25679>;
      <D.25679>:
      if (event == 0) goto <D.28235>; else goto <D.28236>;
      <D.28235>:
      D.28238 = agent_config.suspend;
      if (D.28238 != 0) goto <D.28239>; else goto <D.28240>;
      <D.28239>:
      iftmp.64 = 2;
      goto <D.28241>;
      <D.28240>:
      iftmp.64 = 0;
      <D.28241>:
      suspend_policy = iftmp.64;
      D.28178 = agent_config.defer;
      if (D.28178 == 0) goto <D.28242>; else goto <D.28243>;
      <D.28242>:
      start_debugger_thread ();
      <D.28243>:
      <D.28236>:
      if (event == 1) goto <D.28244>; else goto <D.28245>;
      <D.28244>:
      vm_death_event_sent = 1;
      suspend_policy = 0;
      <D.28245>:
      D.28246 = mono_runtime_is_shutting_down ();
      if (D.28246 != 0) goto <D.28247>; else goto <D.28248>;
      <D.28247>:
      suspend_policy = 0;
      <D.28248>:
      if (suspend_policy != 0) goto <D.28249>; else goto <D.28250>;
      <D.28249>:
      save_thread_context (ctx);
      suspend_vm ();
      if (keepalive_obj != 0B) goto <D.28251>; else goto <D.28252>;
      <D.28251>:
      get_objref (keepalive_obj);
      <D.28252>:
      <D.28250>:
      send_success = send_packet (64, 100, &buf);
      buffer_free (&buf);
      monoeg_g_slist_free (events);
      events = 0B;
      if (send_success == 0) goto <D.28253>; else goto <D.28254>;
      <D.28253>:
      log_level.50 = log_level;
      D.28138 = log_level.50 > 1;
      D.28139 = (long int) D.28138;
      D.28140 = __builtin_expect (D.28139, 0);
      if (D.28140 != 0) goto <D.28255>; else goto <D.28256>;
      <D.28255>:
      D.28257 = event_to_string (event);
      log_file.51 = log_file;
      fprintf (log_file.51, "Sending command %s failed.\n", D.28257);
      log_file.51 = log_file;
      fflush (log_file.51);
      <D.28256>:
      return;
      <D.28254>:
      if (event == 0) goto <D.28258>; else goto <D.28259>;
      <D.28258>:
      vm_start_event_sent = 1;
      <D.28259>:
      log_level.50 = log_level;
      D.28260 = log_level.50 > 0;
      D.28261 = (long int) D.28260;
      D.28262 = __builtin_expect (D.28261, 0);
      if (D.28262 != 0) goto <D.28263>; else goto <D.28264>;
      <D.28263>:
      ecount.57 = ecount;
      D.28265 = event_to_string (event);
      D.28266 = GetCurrentThreadId ();
      D.28267 = (void *) D.28266;
      log_file.51 = log_file;
      fprintf (log_file.51, "[%p] Sent %d events %s(%d), suspend=%d.\n", D.28267, nevents, D.28265, ecount.57, suspend_policy);
      log_file.51 = log_file;
      fflush (log_file.51);
      <D.28264>:
      switch (suspend_policy) <default: <D.25684>, case 0: <D.25680>, case 1: <D.25683>, case 2: <D.25682>>
      <D.25680>:
      goto <D.25681>;
      <D.25682>:
      suspend_current ();
      goto <D.25681>;
      <D.25683>:
      monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "debugger-agent.c", 3737);
      <D.25684>:
      monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "debugger-agent.c", 3740);
      <D.25681>:
    }
  finally
    {
      buf = {CLOBBER};
    }
}


buffer_init (struct Buffer * buf, int size)
{
  unsigned int size.65;
  void * D.28274;
  guint8 * D.28275;
  sizetype size.66;
  guint8 * D.28277;

  size.65 = (unsigned int) size;
  D.28274 = monoeg_malloc (size.65);
  buf->buf = D.28274;
  D.28275 = buf->buf;
  buf->p = D.28275;
  D.28275 = buf->buf;
  size.66 = (sizetype) size;
  D.28277 = D.28275 + size.66;
  buf->end = D.28277;
}


buffer_add_byte (struct Buffer * buf, guint8 val)
{
  guint8 * D.28278;
  guint8 * D.28279;

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


buffer_make_room (struct Buffer * buf, int size)
{
  guint8 * D.28280;
  int D.28281;
  guint8 * D.28282;
  int D.28283;
  int D.28284;
  guint8 * D.28287;
  int D.28288;
  int D.28289;
  int D.28290;
  unsigned int new_size.67;
  sizetype size.68;
  guint8 * D.28293;
  sizetype new_size.69;
  guint8 * D.28295;

  D.28280 = buf->end;
  D.28281 = (int) D.28280;
  D.28282 = buf->p;
  D.28283 = (int) D.28282;
  D.28284 = D.28281 - D.28283;
  if (D.28284 < size) goto <D.28285>; else goto <D.28286>;
  <D.28285>:
  {
    int new_size;
    guint8 * p;

    D.28280 = buf->end;
    D.28281 = (int) D.28280;
    D.28287 = buf->buf;
    D.28288 = (int) D.28287;
    D.28289 = D.28281 - D.28288;
    D.28290 = D.28289 + size;
    new_size = D.28290 + 32;
    new_size.67 = (unsigned int) new_size;
    D.28287 = buf->buf;
    p = monoeg_realloc (D.28287, new_size.67);
    D.28282 = buf->p;
    D.28283 = (int) D.28282;
    D.28287 = buf->buf;
    D.28288 = (int) D.28287;
    size = D.28283 - D.28288;
    buf->buf = p;
    size.68 = (sizetype) size;
    D.28293 = p + size.68;
    buf->p = D.28293;
    D.28287 = buf->buf;
    new_size.69 = (sizetype) new_size;
    D.28295 = D.28287 + new_size.69;
    buf->end = D.28295;
  }
  <D.28286>:
}


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.28296;

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


get_id (struct MonoDomain * domain, IdType type, void * val)
{
  int D.28299;
  union mono_mutex_t * D.28300;
  _Bool D.28303;
  long int D.28304;
  long int D.28305;
  struct GHashTable * D.28308;
  struct GHashTable * D.28311;
  _Bool D.28316;
  long int D.28317;
  long int D.28318;
  struct GPtrArray * D.28321;
  unsigned int D.28322;
  unsigned int D.28323;
  int D.28324;
  _Bool D.28327;
  long int D.28328;
  long int D.28329;
  struct Id * id;
  struct AgentDomainInfo * info;

  if (val == 0B) goto <D.28297>; else goto <D.28298>;
  <D.28297>:
  D.28299 = 0;
  return D.28299;
  <D.28298>:
  mono_loader_lock ();
  {
    int ret;

    D.28300 = &domain->lock.mutex;
    ret = pthread_mutex_lock (D.28300);
    if (ret != 0) goto <D.28301>; else goto <D.28302>;
    <D.28301>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.28302>:
    D.28303 = ret != 0;
    D.28304 = (long int) D.28303;
    D.28305 = __builtin_expect (D.28304, 0);
    if (D.28305 != 0) goto <D.28306>; else goto <D.28307>;
    <D.28306>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 2149, "ret == 0");
    <D.28307>:
  }
  info = get_agent_domain_info (domain);
  D.28308 = info->val_to_id[type];
  if (D.28308 == 0B) goto <D.28309>; else goto <D.28310>;
  <D.28309>:
  D.28311 = monoeg_g_hash_table_new (mono_aligned_addr_hash, 0B);
  info->val_to_id[type] = D.28311;
  <D.28310>:
  D.28308 = info->val_to_id[type];
  id = monoeg_g_hash_table_lookup (D.28308, val);
  if (id != 0B) goto <D.28312>; else goto <D.28313>;
  <D.28312>:
  {
    int ret;

    D.28300 = &domain->lock.mutex;
    ret = pthread_mutex_unlock (D.28300);
    if (ret != 0) goto <D.28314>; else goto <D.28315>;
    <D.28314>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.28315>:
    D.28316 = ret != 0;
    D.28317 = (long int) D.28316;
    D.28318 = __builtin_expect (D.28317, 0);
    if (D.28318 != 0) goto <D.28319>; else goto <D.28320>;
    <D.28319>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 2158, "ret == 0");
    <D.28320>:
  }
  mono_loader_unlock ();
  D.28299 = id->id;
  return D.28299;
  <D.28313>:
  id = monoeg_malloc0 (12);
  D.28321 = ids[type];
  D.28322 = D.28321->len;
  D.28323 = D.28322 + 1;
  D.28324 = (int) D.28323;
  id->id = D.28324;
  id->domain = domain;
  id->data.val = val;
  D.28308 = info->val_to_id[type];
  monoeg_g_hash_table_insert_replace (D.28308, val, id, 0);
  {
    int ret;

    D.28300 = &domain->lock.mutex;
    ret = pthread_mutex_unlock (D.28300);
    if (ret != 0) goto <D.28325>; else goto <D.28326>;
    <D.28325>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.28326>:
    D.28327 = ret != 0;
    D.28328 = (long int) D.28327;
    D.28329 = __builtin_expect (D.28328, 0);
    if (D.28329 != 0) goto <D.28330>; else goto <D.28331>;
    <D.28330>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 2171, "ret == 0");
    <D.28331>:
  }
  D.28321 = ids[type];
  monoeg_g_ptr_array_add (D.28321, id);
  mono_loader_unlock ();
  D.28299 = id->id;
  return D.28299;
}


get_agent_domain_info (struct MonoDomain * domain)
{
  union mono_mutex_t * D.28333;
  _Bool D.28336;
  long int D.28337;
  long int D.28338;
  void * D.28341;
  void * D.28344;
  struct GHashTable * D.28345;
  struct GHashTable * D.28346;
  struct GHashTable * D.28347;
  struct GHashTable * D.28348;
  _Bool D.28351;
  long int D.28352;
  long int D.28353;
  struct AgentDomainInfo * D.28356;
  struct AgentDomainInfo * info;

  info = 0B;
  {
    int ret;

    D.28333 = &domain->lock.mutex;
    ret = pthread_mutex_lock (D.28333);
    if (ret != 0) goto <D.28334>; else goto <D.28335>;
    <D.28334>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.28335>:
    D.28336 = ret != 0;
    D.28337 = (long int) D.28336;
    D.28338 = __builtin_expect (D.28337, 0);
    if (D.28338 != 0) goto <D.28339>; else goto <D.28340>;
    <D.28339>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 2122, "ret == 0");
    <D.28340>:
  }
  D.28341 = domain->runtime_info;
  info = MEM[(struct MonoJitDomainInfo *)D.28341].agent_info;
  if (info == 0B) goto <D.28342>; else goto <D.28343>;
  <D.28342>:
  D.28341 = domain->runtime_info;
  D.28344 = monoeg_malloc0 (44);
  MEM[(struct MonoJitDomainInfo *)D.28341].agent_info = D.28344;
  info = MEM[(struct MonoJitDomainInfo *)D.28341].agent_info;
  D.28345 = monoeg_g_hash_table_new (mono_aligned_addr_hash, 0B);
  info->loaded_classes = D.28345;
  D.28346 = monoeg_g_hash_table_new (mono_aligned_addr_hash, 0B);
  info->source_files = D.28346;
  D.28347 = monoeg_g_hash_table_new (monoeg_g_str_hash, monoeg_g_str_equal);
  info->source_file_to_class = D.28347;
  D.28348 = monoeg_g_hash_table_new (monoeg_g_str_hash, monoeg_g_str_equal);
  info->source_file_to_class_ignorecase = D.28348;
  <D.28343>:
  {
    int ret;

    D.28333 = &domain->lock.mutex;
    ret = pthread_mutex_unlock (D.28333);
    if (ret != 0) goto <D.28349>; else goto <D.28350>;
    <D.28349>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.28350>:
    D.28351 = ret != 0;
    D.28352 = (long int) D.28351;
    D.28353 = __builtin_expect (D.28352, 0);
    if (D.28353 != 0) goto <D.28354>; else goto <D.28355>;
    <D.28354>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 2133, "ret == 0");
    <D.28355>:
  }
  D.28356 = info;
  return D.28356;
}


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

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


buffer_add_typeid (struct Buffer * buf, struct MonoDomain * domain, struct MonoClass * klass)
{
  int log_level.71;
  _Bool D.28360;
  long int D.28361;
  long int D.28362;
  struct MonoType * D.28367;
  unsigned int D.28368;
  unsigned int debugger_thread_id.72;
  struct FILE * log_file.73;
  unsigned int D.28378;
  void * D.28379;

  buffer_add_ptr_id (buf, domain, 2, klass);
  log_level.71 = log_level;
  D.28360 = log_level.71 > 1;
  D.28361 = (long int) D.28360;
  D.28362 = __builtin_expect (D.28361, 0);
  if (D.28362 != 0) goto <D.28363>; else goto <D.28364>;
  <D.28363>:
  if (klass != 0B) goto <D.28365>; else goto <D.28366>;
  <D.28365>:
  {
    char * s;

    D.28367 = &klass->byval_arg;
    s = mono_type_full_name (D.28367);
    D.28368 = GetCurrentThreadId ();
    debugger_thread_id.72 = debugger_thread_id;
    if (D.28368 == debugger_thread_id.72) goto <D.28370>; else goto <D.28371>;
    <D.28370>:
    log_level.71 = log_level;
    D.28360 = log_level.71 > 1;
    D.28361 = (long int) D.28360;
    D.28362 = __builtin_expect (D.28361, 0);
    if (D.28362 != 0) goto <D.28372>; else goto <D.28373>;
    <D.28372>:
    log_file.73 = log_file;
    fprintf (log_file.73, "[dbg]   send class [%s]\n", s);
    log_file.73 = log_file;
    fflush (log_file.73);
    <D.28373>:
    goto <D.28375>;
    <D.28371>:
    log_level.71 = log_level;
    D.28360 = log_level.71 > 1;
    D.28361 = (long int) D.28360;
    D.28362 = __builtin_expect (D.28361, 0);
    if (D.28362 != 0) goto <D.28376>; else goto <D.28377>;
    <D.28376>:
    D.28378 = GetCurrentThreadId ();
    D.28379 = (void *) D.28378;
    log_file.73 = log_file;
    fprintf (log_file.73, "[%p]   send class [%s]\n", D.28379, s);
    log_file.73 = log_file;
    fflush (log_file.73);
    <D.28377>:
    <D.28375>:
    monoeg_g_free (s);
  }
  <D.28366>:
  <D.28364>:
}


buffer_add_methodid (struct Buffer * buf, struct MonoDomain * domain, struct MonoMethod * method)
{
  int log_level.74;
  _Bool D.28381;
  long int D.28382;
  long int D.28383;
  struct FILE * log_file.75;

  buffer_add_ptr_id (buf, domain, 3, method);
  log_level.74 = log_level;
  D.28381 = log_level.74 > 1;
  D.28382 = (long int) D.28381;
  D.28383 = __builtin_expect (D.28382, 0);
  if (D.28383 != 0) goto <D.28384>; else goto <D.28385>;
  <D.28384>:
  if (method != 0B) goto <D.28386>; else goto <D.28387>;
  <D.28386>:
  {
    char * s;

    s = mono_method_full_name (method, 1);
    log_level.74 = log_level;
    D.28381 = log_level.74 > 1;
    D.28382 = (long int) D.28381;
    D.28383 = __builtin_expect (D.28382, 0);
    if (D.28383 != 0) goto <D.28388>; else goto <D.28389>;
    <D.28388>:
    log_file.75 = log_file;
    fprintf (log_file.75, "[dbg]   send method [%s]\n", s);
    log_file.75 = log_file;
    fflush (log_file.75);
    <D.28389>:
    monoeg_g_free (s);
  }
  <D.28387>:
  <D.28385>:
}


buffer_add_long (struct Buffer * buf, guint64 l)
{
  long long unsigned int D.28391;
  unsigned int D.28392;
  unsigned int D.28393;

  D.28391 = l >> 32;
  D.28392 = (unsigned int) D.28391;
  buffer_add_int (buf, D.28392);
  D.28393 = (unsigned int) l;
  buffer_add_int (buf, D.28393);
}


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.28394;

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


get_objid (struct MonoObject * obj)
{
  int D.28395;
  struct ObjRef * D.28396;

  D.28396 = get_objref (obj);
  D.28395 = D.28396->id;
  return D.28395;
}


buffer_add_int (struct Buffer * buf, guint32 val)
{
  guint8 * D.28398;
  unsigned int D.28399;
  unsigned char D.28400;
  guint8 * D.28401;
  unsigned int D.28402;
  unsigned char D.28403;
  guint8 * D.28404;
  unsigned int D.28405;
  unsigned char D.28406;
  guint8 * D.28407;
  unsigned char D.28408;
  guint8 * D.28409;

  buffer_make_room (buf, 4);
  D.28398 = buf->p;
  D.28399 = val >> 24;
  D.28400 = (unsigned char) D.28399;
  *D.28398 = D.28400;
  D.28398 = buf->p;
  D.28401 = D.28398 + 1;
  D.28402 = val >> 16;
  D.28403 = (unsigned char) D.28402;
  *D.28401 = D.28403;
  D.28398 = buf->p;
  D.28404 = D.28398 + 2;
  D.28405 = val >> 8;
  D.28406 = (unsigned char) D.28405;
  *D.28404 = D.28406;
  D.28398 = buf->p;
  D.28407 = D.28398 + 3;
  D.28408 = (unsigned char) val;
  *D.28407 = D.28408;
  D.28398 = buf->p;
  D.28409 = D.28398 + 4;
  buf->p = D.28409;
}


buffer_add_string (struct Buffer * buf, const char * str)
{
  unsigned int D.28413;
  unsigned int len.76;
  int len;

  if (str == 0B) goto <D.28410>; else goto <D.28411>;
  <D.28410>:
  buffer_add_int (buf, 0);
  goto <D.28412>;
  <D.28411>:
  D.28413 = strlen (str);
  len = (int) D.28413;
  len.76 = (unsigned int) len;
  buffer_add_int (buf, len.76);
  buffer_add_data (buf, str, len);
  <D.28412>:
}


buffer_add_data (struct Buffer * buf, guint8 * data, int len)
{
  unsigned int len.77;
  guint8 * D.28416;
  sizetype len.78;
  guint8 * D.28418;

  buffer_make_room (buf, len);
  len.77 = (unsigned int) len;
  D.28416 = buf->p;
  memcpy (D.28416, data, len.77);
  D.28416 = buf->p;
  len.78 = (sizetype) len;
  D.28418 = D.28416 + len.78;
  buf->p = D.28418;
}


memcpy (void * restrict __dest, const void * restrict __src, size_t __len)
{
  void * D.28419;
  unsigned int D.28420;

  D.28420 = __builtin_object_size (__dest, 0);
  D.28419 = __builtin___memcpy_chk (__dest, __src, __len, D.28420);
  return D.28419;
}


start_debugger_thread ()
{
  void * debugger_thread_handle.79;
  void * debugger_thread_handle.80;
  _Bool D.28424;
  long int D.28425;
  long int D.28426;

  debugger_thread_handle.79 = mono_threads_create_thread (debugger_thread, 0B, 0, 0, 0B);
  debugger_thread_handle = debugger_thread_handle.79;
  debugger_thread_handle.80 = debugger_thread_handle;
  D.28424 = debugger_thread_handle.80 == 0B;
  D.28425 = (long int) D.28424;
  D.28426 = __builtin_expect (D.28425, 0);
  if (D.28426 != 0) goto <D.28427>; else goto <D.28428>;
  <D.28427>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 1580, "debugger_thread_handle");
  <D.28428>:
}


debugger_thread (void * arg)
{
  int log_level.81;
  _Bool D.28430;
  long int D.28431;
  long int D.28432;
  unsigned int D.28435;
  void * D.28436;
  struct FILE * log_file.82;
  unsigned int debugger_thread_id.83;
  struct MonoDomain * D.28439;
  struct MonoInternalThread * D.28440;
  unsigned int D.28441;
  unsigned int D.28442;
  int D.28443;
  int D.28446;
  struct MonoThread * D.28452;
  guint8 * p.84;
  _Bool D.28458;
  long int D.28459;
  long int D.28460;
  <unnamed type> command_set.85;
  const char * D.28470;
  int D.28471;
  unsigned int D.28472;
  sizetype len.86;
  sizetype D.28480;
  _Bool D.28481;
  _Bool D.28482;
  _Bool D.28483;
  int err.87;
  unsigned int command.88;
  unsigned int D.28492;
  _Bool D.28496;
  _Bool D.28497;
  _Bool D.28498;
  int vm_death_event_sent.89;
  int D.28506;
  _Bool D.28509;
  long int D.28510;
  long int D.28511;
  guint32 D.28514;
  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.81 = log_level;
      D.28430 = log_level.81 > 0;
      D.28431 = (long int) D.28430;
      D.28432 = __builtin_expect (D.28431, 0);
      if (D.28432 != 0) goto <D.28433>; else goto <D.28434>;
      <D.28433>:
      D.28435 = GetCurrentThreadId ();
      D.28436 = (void *) D.28435;
      log_file.82 = log_file;
      fprintf (log_file.82, "[dbg] Agent thread started, pid=%p\n", D.28436);
      log_file.82 = log_file;
      fflush (log_file.82);
      <D.28434>:
      debugger_thread_id.83 = GetCurrentThreadId ();
      debugger_thread_id = debugger_thread_id.83;
      D.28439 = mono_get_root_domain ();
      mono_jit_thread_attach (D.28439);
      D.28440 = mono_thread_internal_current ();
      D.28441 = D.28440->flags;
      D.28442 = D.28441 | 1;
      D.28440->flags = D.28442;
      mono_set_is_debugger_attached (1);
      D.28443 = agent_config.defer;
      if (D.28443 != 0) goto <D.28444>; else goto <D.28445>;
      <D.28444>:
      D.28446 = wait_for_attach ();
      if (D.28446 == 0) goto <D.28447>; else goto <D.28448>;
      <D.28447>:
      log_level.81 = log_level;
      D.28430 = log_level.81 > 0;
      D.28431 = (long int) D.28430;
      D.28432 = __builtin_expect (D.28431, 0);
      if (D.28432 != 0) goto <D.28449>; else goto <D.28450>;
      <D.28449>:
      log_file.82 = log_file;
      fprintf (log_file.82, "[dbg] Can\'t attach, aborting debugger thread.\n");
      log_file.82 = log_file;
      fflush (log_file.82);
      <D.28450>:
      attach_failed = 1;
      goto <D.28451>;
      <D.28448>:
      D.28452 = mono_thread_get_main ();
      process_profiler_event (0, D.28452);
      <D.28451>:
      <D.28445>:
      goto <D.27446>;
      <D.27445>:
      res = transport_recv (&header, 11);
      if (res != 11) goto <D.28453>; else goto <D.28454>;
      <D.28453>:
      log_level.81 = log_level;
      D.28430 = log_level.81 > 0;
      D.28431 = (long int) D.28430;
      D.28432 = __builtin_expect (D.28431, 0);
      if (D.28432 != 0) goto <D.28455>; else goto <D.28456>;
      <D.28455>:
      log_file.82 = log_file;
      fprintf (log_file.82, "[dbg] transport_recv () returned %d, expected %d.\n", res, 11);
      log_file.82 = log_file;
      fflush (log_file.82);
      <D.28456>:
      goto <D.27428>;
      <D.28454>:
      p = &header;
      end = &MEM[(void *)&header + 11B];
      p.84 = p;
      len = decode_int (p.84, &p, end);
      p.84 = p;
      id = decode_int (p.84, &p, end);
      p.84 = p;
      flags = decode_byte (p.84, &p, end);
      p.84 = p;
      command_set = decode_byte (p.84, &p, end);
      p.84 = p;
      command = decode_byte (p.84, &p, end);
      D.28458 = flags != 0;
      D.28459 = (long int) D.28458;
      D.28460 = __builtin_expect (D.28459, 0);
      if (D.28460 != 0) goto <D.28461>; else goto <D.28462>;
      <D.28461>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 9156, "flags == 0");
      <D.28462>:
      log_level.81 = log_level;
      if (log_level.81 != 0) goto <D.28463>; else goto <D.28464>;
      <D.28463>:
      {
        const char * cmd_str;
        char cmd_num[256];

        try
          {
            command_set.85 = (<unnamed type>) command_set;
            cmd_str = cmd_to_string (command_set.85, command);
            if (cmd_str == 0B) goto <D.28466>; else goto <D.28467>;
            <D.28466>:
            sprintf (&cmd_num, "%d", command);
            cmd_str = &cmd_num;
            <D.28467>:
            log_level.81 = log_level;
            D.28430 = log_level.81 > 0;
            D.28431 = (long int) D.28430;
            D.28432 = __builtin_expect (D.28431, 0);
            if (D.28432 != 0) goto <D.28468>; else goto <D.28469>;
            <D.28468>:
            command_set.85 = (<unnamed type>) command_set;
            D.28470 = command_set_to_string (command_set.85);
            log_file.82 = log_file;
            fprintf (log_file.82, "[dbg] Command %s(%s) [%d].\n", D.28470, cmd_str, id);
            log_file.82 = log_file;
            fflush (log_file.82);
            <D.28469>:
          }
        finally
          {
            cmd_num = {CLOBBER};
          }
      }
      <D.28464>:
      D.28471 = len + -11;
      D.28472 = (unsigned int) D.28471;
      data = monoeg_malloc (D.28472);
      if (len > 11) goto <D.28473>; else goto <D.28474>;
      <D.28473>:
      D.28471 = len + -11;
      res = transport_recv (data, D.28471);
      D.28471 = len + -11;
      if (D.28471 != res) goto <D.28475>; else goto <D.28476>;
      <D.28475>:
      log_level.81 = log_level;
      D.28430 = log_level.81 > 0;
      D.28431 = (long int) D.28430;
      D.28432 = __builtin_expect (D.28431, 0);
      if (D.28432 != 0) goto <D.28477>; else goto <D.28478>;
      <D.28477>:
      D.28471 = len + -11;
      log_file.82 = log_file;
      fprintf (log_file.82, "[dbg] transport_recv () returned %d, expected %d.\n", res, D.28471);
      log_file.82 = log_file;
      fflush (log_file.82);
      <D.28478>:
      goto <D.27428>;
      <D.28476>:
      <D.28474>:
      p = data;
      len.86 = (sizetype) len;
      D.28480 = len.86 + 4294967285;
      end = data + D.28480;
      buffer_init (&buf, 128);
      err = 0;
      no_reply = 0;
      switch (command_set) <default: <D.27444>, case 1: <D.27431>, case 9: <D.27443>, case 10: <D.27442>, case 11: <D.27439>, case 13: <D.27441>, case 15: <D.27433>, case 16: <D.27440>, case 20: <D.27434>, case 21: <D.27435>, case 22: <D.27438>, case 23: <D.27437>, case 24: <D.27436>>
      <D.27431>:
      p.84 = p;
      err = vm_commands (command, id, p.84, end, &buf);
      D.28481 = err == 0;
      D.28482 = command == 7;
      D.28483 = D.28481 & D.28482;
      if (D.28483 != 0) goto <D.28484>; else goto <D.28485>;
      <D.28484>:
      no_reply = 1;
      <D.28485>:
      goto <D.27432>;
      <D.27433>:
      p.84 = p;
      err = event_commands (command, p.84, end, &buf);
      goto <D.27432>;
      <D.27434>:
      p.84 = p;
      err = domain_commands (command, p.84, end, &buf);
      goto <D.27432>;
      <D.27435>:
      p.84 = p;
      err = assembly_commands (command, p.84, end, &buf);
      goto <D.27432>;
      <D.27436>:
      p.84 = p;
      err = module_commands (command, p.84, end, &buf);
      goto <D.27432>;
      <D.27437>:
      p.84 = p;
      err = type_commands (command, p.84, end, &buf);
      goto <D.27432>;
      <D.27438>:
      p.84 = p;
      err = method_commands (command, p.84, end, &buf);
      goto <D.27432>;
      <D.27439>:
      p.84 = p;
      err = thread_commands (command, p.84, end, &buf);
      goto <D.27432>;
      <D.27440>:
      p.84 = p;
      err = frame_commands (command, p.84, end, &buf);
      goto <D.27432>;
      <D.27441>:
      p.84 = p;
      err = array_commands (command, p.84, end, &buf);
      goto <D.27432>;
      <D.27442>:
      p.84 = p;
      err = string_commands (command, p.84, end, &buf);
      goto <D.27432>;
      <D.27443>:
      p.84 = p;
      err = object_commands (command, p.84, end, &buf);
      goto <D.27432>;
      <D.27444>:
      err = 100;
      <D.27432>:
      if (no_reply == 0) goto <D.28486>; else goto <D.28487>;
      <D.28486>:
      err.87 = (int) err;
      send_reply_packet (id, err.87, &buf);
      <D.28487>:
      monoeg_g_free (data);
      buffer_free (&buf);
      if (command_set == 1) goto <D.28489>; else goto <D.28490>;
      <D.28489>:
      command.88 = (unsigned int) command;
      D.28492 = command.88 + 4294967291;
      if (D.28492 <= 1) goto <D.27428>; else goto <D.28493>;
      <D.28493>:
      <D.28490>:
      <D.27446>:
      if (attach_failed == 0) goto <D.27445>; else goto <D.27428>;
      <D.27428>:
      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.81 = log_level;
      D.28430 = log_level.81 > 0;
      D.28431 = (long int) D.28430;
      D.28432 = __builtin_expect (D.28431, 0);
      if (D.28432 != 0) goto <D.28494>; else goto <D.28495>;
      <D.28494>:
      log_file.82 = log_file;
      fprintf (log_file.82, "[dbg] Debugger thread exited.\n");
      log_file.82 = log_file;
      fflush (log_file.82);
      <D.28495>:
      D.28496 = attach_failed == 0;
      D.28497 = command_set == 1;
      D.28498 = D.28496 & D.28497;
      if (D.28498 != 0) goto <D.28499>; else goto <D.28500>;
      <D.28499>:
      if (command == 6) goto <D.28501>; else goto <D.28502>;
      <D.28501>:
      vm_death_event_sent.89 = vm_death_event_sent;
      if (vm_death_event_sent.89 == 0) goto <D.28504>; else goto <D.28505>;
      <D.28504>:
      D.28506 = mono_runtime_is_shutting_down ();
      if (D.28506 == 0) goto <D.28507>; else goto <D.28508>;
      <D.28507>:
      log_level.81 = log_level;
      D.28509 = log_level.81 > 1;
      D.28510 = (long int) D.28509;
      D.28511 = __builtin_expect (D.28510, 0);
      if (D.28511 != 0) goto <D.28512>; else goto <D.28513>;
      <D.28512>:
      log_file.82 = log_file;
      fprintf (log_file.82, "[dbg] Detached - restarting clean debugger thread.\n");
      log_file.82 = log_file;
      fflush (log_file.82);
      <D.28513>:
      start_debugger_thread ();
      <D.28508>:
      <D.28505>:
      <D.28502>:
      <D.28500>:
      D.28514 = 0;
      return D.28514;
    }
  finally
    {
      header = {CLOBBER};
      p = {CLOBBER};
      buf = {CLOBBER};
    }
}


wait_for_attach ()
{
  int listen_fd.90;
  int log_level.91;
  _Bool D.28521;
  long int D.28522;
  long int D.28523;
  struct FILE * log_file.92;
  gboolean D.28527;
  int conn_fd.93;
  int conn_fd.94;
  int D.28536;
  _Bool D.28537;
  int disconnected.95;
  int disconnected.96;

  listen_fd.90 = listen_fd;
  if (listen_fd.90 == -1) goto <D.28518>; else goto <D.28519>;
  <D.28518>:
  log_level.91 = log_level;
  D.28521 = log_level.91 > 0;
  D.28522 = (long int) D.28521;
  D.28523 = __builtin_expect (D.28522, 0);
  if (D.28523 != 0) goto <D.28524>; else goto <D.28525>;
  <D.28524>:
  log_file.92 = log_file;
  fprintf (log_file.92, "[dbg] Invalid listening socket\n");
  log_file.92 = log_file;
  fflush (log_file.92);
  <D.28525>:
  D.28527 = 0;
  return D.28527;
  <D.28519>:
  listen_fd.90 = listen_fd;
  conn_fd.93 = socket_transport_accept (listen_fd.90);
  conn_fd = conn_fd.93;
  log_level.91 = log_level;
  D.28521 = log_level.91 > 0;
  D.28522 = (long int) D.28521;
  D.28523 = __builtin_expect (D.28522, 0);
  if (D.28523 != 0) goto <D.28529>; else goto <D.28530>;
  <D.28529>:
  conn_fd.94 = conn_fd;
  log_file.92 = log_file;
  fprintf (log_file.92, "Accepted connection on %d\n", conn_fd.94);
  log_file.92 = log_file;
  fflush (log_file.92);
  <D.28530>:
  conn_fd.94 = conn_fd;
  if (conn_fd.94 == -1) goto <D.28532>; else goto <D.28533>;
  <D.28532>:
  log_level.91 = log_level;
  D.28521 = log_level.91 > 0;
  D.28522 = (long int) D.28521;
  D.28523 = __builtin_expect (D.28522, 0);
  if (D.28523 != 0) goto <D.28534>; else goto <D.28535>;
  <D.28534>:
  log_file.92 = log_file;
  fprintf (log_file.92, "[dbg] Bad client connection\n");
  log_file.92 = log_file;
  fflush (log_file.92);
  <D.28535>:
  D.28527 = 0;
  return D.28527;
  <D.28533>:
  D.28536 = transport_handshake ();
  D.28537 = D.28536 == 0;
  disconnected.95 = (int) D.28537;
  disconnected = disconnected.95;
  disconnected.96 = disconnected;
  if (disconnected.96 != 0) goto <D.28540>; else goto <D.28541>;
  <D.28540>:
  log_level.91 = log_level;
  D.28521 = log_level.91 > 0;
  D.28522 = (long int) D.28521;
  D.28523 = __builtin_expect (D.28522, 0);
  if (D.28523 != 0) goto <D.28542>; else goto <D.28543>;
  <D.28542>:
  log_file.92 = log_file;
  fprintf (log_file.92, "Transport handshake failed!\n");
  log_file.92 = log_file;
  fflush (log_file.92);
  <D.28543>:
  D.28527 = 0;
  return D.28527;
  <D.28541>:
  D.28527 = 1;
  return D.28527;
}


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.28545;
  int conn_fd.97;
  int conn_fd.98;
  struct _IO_FILE * stderr.99;
  int log_level.100;
  _Bool D.28553;
  long int D.28554;
  long int D.28555;
  struct FILE * log_file.101;
  int D.28559;

  D.28545.__sockaddr__ = 0B;
  conn_fd.97 = accept (socket_fd, D.28545, 0B);
  conn_fd = conn_fd.97;
  conn_fd.98 = conn_fd;
  if (conn_fd.98 == -1) goto <D.28548>; else goto <D.28549>;
  <D.28548>:
  stderr.99 = stderr;
  fprintf (stderr.99, "debugger-agent: Unable to listen on %d\n", socket_fd);
  goto <D.28551>;
  <D.28549>:
  log_level.100 = log_level;
  D.28553 = log_level.100 > 0;
  D.28554 = (long int) D.28553;
  D.28555 = __builtin_expect (D.28554, 0);
  if (D.28555 != 0) goto <D.28556>; else goto <D.28557>;
  <D.28556>:
  conn_fd.98 = conn_fd;
  log_file.101 = log_file;
  fprintf (log_file.101, "Accepted connection from client, connection fd=%d.\n", conn_fd.98);
  log_file.101 = log_file;
  fflush (log_file.101);
  <D.28557>:
  <D.28551>:
  D.28559 = conn_fd;
  return D.28559;
}


transport_handshake ()
{
  unsigned int D.28561;
  int D.28562;
  int * D.28564;
  int D.28565;
  _Bool D.28566;
  long int D.28567;
  long int D.28568;
  unsigned int D.28571;
  int D.28572;
  unsigned int res.102;
  unsigned int D.28576;
  char[128] * handshake_msg.103;
  char D.28579;
  _Bool D.28580;
  unsigned int D.28581;
  int D.28582;
  struct _IO_FILE * stderr.104;
  gboolean D.28584;
  int conn_fd.105;
  _Bool D.28588;
  long int D.28589;
  long int D.28590;
  char handshake_msg[128];
  guint8 buf[128];
  int res;

  try
    {
      disconnected = 1;
      sprintf (&handshake_msg, "DWP-Handshake");
      <D.24961>:
      D.28561 = strlen (&handshake_msg);
      D.28562 = (int) D.28561;
      res = transport_send (&handshake_msg, D.28562);
      if (res == -1) goto <D.28563>; else goto <D.24962>;
      <D.28563>:
      D.28564 = __errno_location ();
      D.28565 = *D.28564;
      if (D.28565 == 4) goto <D.24961>; else goto <D.24962>;
      <D.24962>:
      D.28566 = res == -1;
      D.28567 = (long int) D.28566;
      D.28568 = __builtin_expect (D.28567, 0);
      if (D.28568 != 0) goto <D.28569>; else goto <D.28570>;
      <D.28569>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 1498, "res != -1");
      <D.28570>:
      D.28571 = strlen (&handshake_msg);
      D.28572 = (int) D.28571;
      res = transport_recv (&buf, D.28572);
      res.102 = (unsigned int) res;
      D.28576 = strlen (&handshake_msg);
      if (res.102 != D.28576) goto <D.28573>; else goto <D.28577>;
      <D.28577>:
      handshake_msg.103 = &handshake_msg;
      D.28579 = MEM[(const char *)handshake_msg.103];
      D.28580 = D.28579 != 0;
      D.28581 = (unsigned int) D.28580;
      D.28582 = memcmp (&buf, &handshake_msg, D.28581);
      if (D.28582 != 0) goto <D.28573>; else goto <D.28574>;
      <D.28573>:
      stderr.104 = stderr;
      fprintf (stderr.104, "debugger-agent: DWP handshake failed.\n");
      D.28584 = 0;
      return D.28584;
      <D.28574>:
      major_version = 2;
      minor_version = 27;
      protocol_version_set = 0;
      conn_fd.105 = conn_fd;
      if (conn_fd.105 != 0) goto <D.28586>; else goto <D.28587>;
      <D.28586>:
      {
        int flag;
        int result;

        try
          {
            flag = 1;
            conn_fd.105 = conn_fd;
            result = setsockopt (conn_fd.105, 6, 1, &flag, 4);
            D.28588 = result < 0;
            D.28589 = (long int) D.28588;
            D.28590 = __builtin_expect (D.28589, 0);
            if (D.28590 != 0) goto <D.28591>; else goto <D.28592>;
            <D.28591>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 1528, "result >= 0");
            <D.28592>:
          }
        finally
          {
            flag = {CLOBBER};
          }
      }
      <D.28587>:
      set_keepalive ();
      disconnected = 0;
      D.28584 = 1;
      return D.28584;
    }
  finally
    {
      handshake_msg = {CLOBBER};
      buf = {CLOBBER};
    }
}


transport_send (void * buf, int len)
{
  int D.28595;
  struct DebuggerTransport * transport.106;
  gboolean (*<T3eb1>) (void *, int) D.28597;

  transport.106 = transport;
  D.28597 = transport.106->send;
  D.28595 = D.28597 (buf, len);
  return D.28595;
}


set_keepalive ()
{
  int D.28601;
  int conn_fd.107;
  int D.28604;
  int D.28605;
  int D.28606;
  _Bool D.28607;
  long int D.28608;
  long int D.28609;
  struct timeval tv;
  int result;

  try
    {
      D.28601 = agent_config.keepalive;
      if (D.28601 == 0) goto <D.28599>; else goto <D.28602>;
      <D.28602>:
      conn_fd.107 = conn_fd;
      if (conn_fd.107 == 0) goto <D.28599>; else goto <D.28600>;
      <D.28599>:
      return;
      <D.28600>:
      D.28601 = agent_config.keepalive;
      D.28604 = D.28601 / 1000;
      tv.tv_sec = D.28604;
      D.28601 = agent_config.keepalive;
      D.28605 = D.28601 % 1000;
      D.28606 = D.28605 * 1000;
      tv.tv_usec = D.28606;
      conn_fd.107 = conn_fd;
      result = setsockopt (conn_fd.107, 1, 20, &tv, 8);
      D.28607 = result < 0;
      D.28608 = (long int) D.28607;
      D.28609 = __builtin_expect (D.28608, 0);
      if (D.28609 != 0) goto <D.28610>; else goto <D.28611>;
      <D.28610>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 1126, "result >= 0");
      <D.28611>:
    }
  finally
    {
      tv = {CLOBBER};
    }
}


decode_int (guint8 * buf, guint8 * * endbuf, guint8 * limit)
{
  guint8 * D.28615;
  guint8 * D.28616;
  _Bool D.28617;
  long int D.28618;
  long int D.28619;
  int D.28622;
  unsigned char D.28623;
  int D.28624;
  int D.28625;
  guint8 * D.28626;
  unsigned char D.28627;
  int D.28628;
  int D.28629;
  int D.28630;
  guint8 * D.28631;
  unsigned char D.28632;
  int D.28633;
  int D.28634;
  int D.28635;
  guint8 * D.28636;
  unsigned char D.28637;
  int D.28638;

  D.28615 = buf + 4;
  *endbuf = D.28615;
  D.28616 = *endbuf;
  D.28617 = D.28616 > limit;
  D.28618 = (long int) D.28617;
  D.28619 = __builtin_expect (D.28618, 0);
  if (D.28619 != 0) goto <D.28620>; else goto <D.28621>;
  <D.28620>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 1599, "*endbuf <= limit");
  <D.28621>:
  D.28623 = *buf;
  D.28624 = (int) D.28623;
  D.28625 = D.28624 << 24;
  D.28626 = buf + 1;
  D.28627 = *D.28626;
  D.28628 = (int) D.28627;
  D.28629 = D.28628 << 16;
  D.28630 = D.28625 | D.28629;
  D.28631 = buf + 2;
  D.28632 = *D.28631;
  D.28633 = (int) D.28632;
  D.28634 = D.28633 << 8;
  D.28635 = D.28630 | D.28634;
  D.28636 = buf + 3;
  D.28637 = *D.28636;
  D.28638 = (int) D.28637;
  D.28622 = D.28635 | D.28638;
  return D.28622;
}


decode_byte (guint8 * buf, guint8 * * endbuf, guint8 * limit)
{
  guint8 * D.28640;
  guint8 * D.28641;
  _Bool D.28642;
  long int D.28643;
  long int D.28644;
  int D.28647;
  unsigned char D.28648;

  D.28640 = buf + 1;
  *endbuf = D.28640;
  D.28641 = *endbuf;
  D.28642 = D.28641 > limit;
  D.28643 = (long int) D.28642;
  D.28644 = __builtin_expect (D.28643, 0);
  if (D.28644 != 0) goto <D.28645>; else goto <D.28646>;
  <D.28645>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 1591, "*endbuf <= limit");
  <D.28646>:
  D.28648 = *buf;
  D.28647 = (int) D.28648;
  return D.28647;
}


cmd_to_string (CommandSet set, int command)
{
  const char * D.28650;
  _Bool D.28651;
  _Bool D.28652;
  _Bool D.28653;
  sizetype command.108;
  sizetype D.28657;
  sizetype D.28658;
  const char * * D.28659;
  const char * * cmds;
  int cmds_len;

  cmds_len = 0;
  switch (set) <default: <D.27407>, case 1: <D.27393>, case 9: <D.27395>, case 10: <D.27396>, case 11: <D.27397>, case 13: <D.27398>, case 15: <D.27399>, case 16: <D.27400>, case 20: <D.27401>, case 21: <D.27402>, case 22: <D.27403>, case 23: <D.27404>, case 24: <D.27405>, case 64: <D.27406>>
  <D.27393>:
  cmds = &vm_cmds_str;
  cmds_len = 12;
  goto <D.27394>;
  <D.27395>:
  cmds = &object_cmds_str;
  cmds_len = 7;
  goto <D.27394>;
  <D.27396>:
  cmds = &string_cmds_str;
  cmds_len = 3;
  goto <D.27394>;
  <D.27397>:
  cmds = &thread_cmds_str;
  cmds_len = 6;
  goto <D.27394>;
  <D.27398>:
  cmds = &array_cmds_str;
  cmds_len = 3;
  goto <D.27394>;
  <D.27399>:
  cmds = &event_cmds_str;
  cmds_len = 3;
  goto <D.27394>;
  <D.27400>:
  cmds = &stack_frame_cmds_str;
  cmds_len = 3;
  goto <D.27394>;
  <D.27401>:
  cmds = &appdomain_cmds_str;
  cmds_len = 7;
  goto <D.27394>;
  <D.27402>:
  cmds = &assembly_cmds_str;
  cmds_len = 6;
  goto <D.27394>;
  <D.27403>:
  cmds = &method_cmds_str;
  cmds_len = 10;
  goto <D.27394>;
  <D.27404>:
  cmds = &type_cmds_str;
  cmds_len = 18;
  goto <D.27394>;
  <D.27405>:
  cmds = &module_cmds_str;
  cmds_len = 1;
  goto <D.27394>;
  <D.27406>:
  cmds = &event_cmds_str;
  cmds_len = 3;
  goto <D.27394>;
  <D.27407>:
  D.28650 = 0B;
  return D.28650;
  <D.27394>:
  D.28651 = command > 0;
  D.28652 = command <= cmds_len;
  D.28653 = D.28651 & D.28652;
  if (D.28653 != 0) goto <D.28654>; else goto <D.28655>;
  <D.28654>:
  command.108 = (sizetype) command;
  D.28657 = command.108 + 1073741823;
  D.28658 = D.28657 * 4;
  D.28659 = cmds + D.28658;
  D.28650 = *D.28659;
  return D.28650;
  <D.28655>:
  D.28650 = 0B;
  return D.28650;
}


sprintf (char * restrict __s, const char * restrict __fmt)
{
  int D.28661;
  unsigned int D.28662;

  D.28662 = __builtin_object_size (__s, 1);
  D.28661 = __builtin___sprintf_chk (__s, 1, D.28662, __fmt, __builtin_va_arg_pack ());
  return D.28661;
}


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

  switch (command_set) <default: <D.27374>, case 1: <D.27361>, case 9: <D.27362>, case 10: <D.27363>, case 11: <D.27364>, case 13: <D.27365>, case 15: <D.27366>, case 16: <D.27367>, case 20: <D.27368>, case 21: <D.27369>, case 22: <D.27370>, case 23: <D.27371>, case 24: <D.27372>, case 64: <D.27373>>
  <D.27361>:
  D.28664 = "VM";
  return D.28664;
  <D.27362>:
  D.28664 = "OBJECT_REF";
  return D.28664;
  <D.27363>:
  D.28664 = "STRING_REF";
  return D.28664;
  <D.27364>:
  D.28664 = "THREAD";
  return D.28664;
  <D.27365>:
  D.28664 = "ARRAY_REF";
  return D.28664;
  <D.27366>:
  D.28664 = "EVENT_REQUEST";
  return D.28664;
  <D.27367>:
  D.28664 = "STACK_FRAME";
  return D.28664;
  <D.27368>:
  D.28664 = "APPDOMAIN";
  return D.28664;
  <D.27369>:
  D.28664 = "ASSEMBLY";
  return D.28664;
  <D.27370>:
  D.28664 = "METHOD";
  return D.28664;
  <D.27371>:
  D.28664 = "TYPE";
  return D.28664;
  <D.27372>:
  D.28664 = "MODULE";
  return D.28664;
  <D.27373>:
  D.28664 = "EVENT";
  return D.28664;
  <D.27374>:
  D.28664 = "";
  return D.28664;
}


transport_recv (void * buf, int len)
{
  int D.28666;
  struct DebuggerTransport * transport.109;
  int (*<T3eb2>) (void *, int) D.28668;

  transport.109 = transport;
  D.28668 = transport.109->recv;
  D.28666 = D.28668 (buf, len);
  return D.28666;
}


vm_commands (int command, int id, guint8 * p, guint8 * end, struct Buffer * buf)
{
  guint8 * p.110;
  int major_version.111;
  int minor_version.112;
  int log_level.113;
  _Bool D.28674;
  long int D.28675;
  long int D.28676;
  int minor_version.114;
  int major_version.115;
  struct FILE * log_file.116;
  struct MonoGHashTable * tid_to_thread_obj.117;
  unsigned int D.28683;
  int suspend_count.118;
  ErrorCode D.28687;
  struct GPtrArray * event_requests.119;
  void * * D.28689;
  int D.28690;
  int D.28691;
  unsigned int D.28692;
  int D.28693;
  int D.28694;
  struct MonoImage * D.28695;
  struct MonoGHashTable * tid_to_thread.120;
  _Bool D.28699;
  _Bool D.28700;
  _Bool D.28701;
  struct MonoGHashTable * thread_to_tls.121;
  void * D.28705;
  void * D.28706;
  void * D.28707;
  struct InvokeData * D.28708;
  int D.28710;
  <unnamed type> D.28718;
  int D.28726;
  struct MonoThread * thread.122;
  struct _MonoInternalThread * D.28730;
  _Bool D.28731;
  long int D.28732;
  long int D.28733;
  int D.28736;
  struct InvokeData * D.28739;
  void * D.28742;
  int end.123;
  int p.124;
  int D.28745;
  unsigned int D.28746;
  void * D.28747;
  unsigned int D.28748;
  guint8 * D.28749;
  sizetype D.28750;
  guint8 * D.28751;
  unsigned int suspend_count.125;
  int D.28753;
  <unnamed type> D.28757;
  struct MonoThread * thread.126;
  struct _MonoInternalThread * D.28761;
  _Bool D.28762;
  long int D.28763;
  long int D.28764;
  int D.28767;
  struct InvokeData * D.28772;
  int D.28774;
  struct GHashTable * domains.127;
  struct MonoDomain * domain.128;
  void * D.28777;
  struct GHashTable * D.28778;
  struct MonoClass * klass.129;
  struct GHashTable * D.28780;
  void * D.28781;
  void * * D.28784;
  unsigned int i.130;
  unsigned int D.28786;
  void * * D.28787;
  struct GHashTable * D.28788;
  gchar * D.28791;
  struct GHashTable * D.28793;
  gchar * D.28796;
  unsigned int i.131;
  unsigned int D.28799;
  int D.28800;
  void * klass.132;
  int D.28805;
  unsigned int D.28806;
  void * * D.28807;
  void * * D.28808;
  void * D.28809;
  void * * D.28810;
  void * * D.28811;
  void * D.28812;
  int D.28813;
  struct MonoDomain * domain.133;
  union mono_mutex_t * D.28817;
  _Bool D.28820;
  long int D.28821;
  long int D.28822;
  struct MonoImage * D.28825;
  struct MonoClass * D.28830;
  _Bool D.28833;
  long int D.28834;
  long int D.28835;
  int D.28838;
  unsigned int D.28839;
  void * * D.28840;
  unsigned int i.134;
  unsigned int D.28842;
  void * * D.28843;
  void * D.28844;
  void * * D.28845;
  void * * D.28846;
  void * D.28847;
  unsigned int i.135;

  switch (command) <default: <D.26713>, case 1: <D.26601>, case 2: <D.26606>, case 3: <D.26607>, case 4: <D.26608>, case 5: <D.26617>, case 6: <D.26609>, case 7: <D.26634>, case 8: <D.26605>, case 9: <D.26647>, case 10: <D.26653>, case 11: <D.26655>, case 12: <D.26689>, case 13: <D.26635>>
  <D.26601>:
  {
    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.26604>;
  }
  <D.26605>:
  p.110 = p;
  major_version.111 = decode_int (p.110, &p, end);
  major_version = major_version.111;
  p.110 = p;
  minor_version.112 = decode_int (p.110, &p, end);
  minor_version = minor_version.112;
  protocol_version_set = 1;
  log_level.113 = log_level;
  D.28674 = log_level.113 > 0;
  D.28675 = (long int) D.28674;
  D.28676 = __builtin_expect (D.28675, 0);
  if (D.28676 != 0) goto <D.28677>; else goto <D.28678>;
  <D.28677>:
  minor_version.114 = minor_version;
  major_version.115 = major_version;
  log_file.116 = log_file;
  fprintf (log_file.116, "[dbg] Protocol version %d.%d, client protocol version %d.%d.\n", 2, 27, major_version.115, minor_version.114);
  log_file.116 = log_file;
  fflush (log_file.116);
  <D.28678>:
  goto <D.26604>;
  <D.26606>:
  mono_loader_lock ();
  tid_to_thread_obj.117 = tid_to_thread_obj;
  D.28683 = mono_g_hash_table_size (tid_to_thread_obj.117);
  buffer_add_int (buf, D.28683);
  tid_to_thread_obj.117 = tid_to_thread_obj;
  mono_g_hash_table_foreach (tid_to_thread_obj.117, add_thread, buf);
  mono_loader_unlock ();
  goto <D.26604>;
  <D.26607>:
  suspend_vm ();
  wait_for_suspend ();
  goto <D.26604>;
  <D.26608>:
  suspend_count.118 = suspend_count;
  if (suspend_count.118 == 0) goto <D.28685>; else goto <D.28686>;
  <D.28685>:
  D.28687 = 101;
  return D.28687;
  <D.28686>:
  resume_vm ();
  clear_suspended_objs ();
  goto <D.26604>;
  <D.26609>:
  mono_loader_lock ();
  goto <D.26612>;
  <D.26611>:
  {
    struct EventRequest * req;

    event_requests.119 = event_requests;
    D.28689 = event_requests.119->pdata;
    req = *D.28689;
    D.28690 = req->event_kind;
    D.28691 = req->id;
    clear_event_request (D.28691, D.28690);
  }
  <D.26612>:
  event_requests.119 = event_requests;
  D.28692 = event_requests.119->len;
  if (D.28692 != 0) goto <D.26611>; else goto <D.26613>;
  <D.26613>:
  mono_loader_unlock ();
  goto <D.26615>;
  <D.26614>:
  resume_vm ();
  <D.26615>:
  suspend_count.118 = suspend_count;
  if (suspend_count.118 > 0) goto <D.26614>; else goto <D.26616>;
  <D.26616>:
  disconnected = 1;
  vm_start_event_sent = 0;
  goto <D.26604>;
  <D.26617>:
  {
    struct MonoInternalThread * thread;
    struct DebuggerTlsData * tls;
    struct MonoClass * env_class;
    struct MonoMethod * exit_method;
    void * * args;
    int exit_code;

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

      event_requests.119 = event_requests;
      D.28689 = event_requests.119->pdata;
      req = *D.28689;
      D.28693 = req->event_kind;
      D.28694 = req->id;
      clear_event_request (D.28694, D.28693);
    }
    <D.26626>:
    event_requests.119 = event_requests;
    D.28692 = event_requests.119->len;
    if (D.28692 != 0) goto <D.26625>; else goto <D.26627>;
    <D.26627>:
    mono_loader_unlock ();
    suspend_vm ();
    wait_for_suspend ();
    D.28695 = mono_defaults.corlib;
    env_class = mono_class_from_name (D.28695, "System", "Environment");
    if (env_class != 0B) goto <D.28696>; else goto <D.28697>;
    <D.28696>:
    exit_method = mono_class_get_method_from_name (env_class, "Exit", 1);
    <D.28697>:
    mono_loader_lock ();
    tid_to_thread.120 = tid_to_thread;
    thread = mono_g_hash_table_find (tid_to_thread.120, is_really_suspended, 0B);
    mono_loader_unlock ();
    D.28699 = thread != 0B;
    D.28700 = exit_method != 0B;
    D.28701 = D.28699 & D.28700;
    if (D.28701 != 0) goto <D.28702>; else goto <D.28703>;
    <D.28702>:
    mono_loader_lock ();
    thread_to_tls.121 = thread_to_tls;
    tls = mono_g_hash_table_lookup (thread_to_tls.121, thread);
    mono_loader_unlock ();
    args = monoeg_malloc0 (4);
    D.28705 = monoeg_malloc (4);
    *args = D.28705;
    D.28706 = *args;
    MEM[(int *)D.28706] = exit_code;
    D.28707 = monoeg_malloc0 (76);
    tls->pending_invoke = D.28707;
    D.28708 = tls->pending_invoke;
    D.28708->method = exit_method;
    D.28708 = tls->pending_invoke;
    D.28708->args = args;
    D.28708 = tls->pending_invoke;
    D.28708->nmethods = 1;
    goto <D.26629>;
    <D.26628>:
    resume_vm ();
    <D.26629>:
    suspend_count.118 = suspend_count;
    if (suspend_count.118 > 0) goto <D.26628>; else goto <D.26630>;
    <D.26630>:
    goto <D.28709>;
    <D.28703>:
    goto <D.26632>;
    <D.26631>:
    resume_vm ();
    <D.26632>:
    suspend_count.118 = suspend_count;
    if (suspend_count.118 > 0) goto <D.26631>; else goto <D.26633>;
    <D.26633>:
    D.28710 = mono_runtime_try_shutdown ();
    if (D.28710 == 0) goto <D.26604>; else goto <D.28711>;
    <D.28711>:
    mono_environment_exitcode_set (exit_code);
    log_level.113 = log_level;
    D.28674 = log_level.113 > 0;
    D.28675 = (long int) D.28674;
    D.28676 = __builtin_expect (D.28675, 0);
    if (D.28676 != 0) goto <D.28712>; else goto <D.28713>;
    <D.28712>:
    log_file.116 = log_file;
    fprintf (log_file.116, "Suspending all threads...\n");
    log_file.116 = log_file;
    fflush (log_file.116);
    <D.28713>:
    mono_thread_suspend_all_other_threads ();
    log_level.113 = log_level;
    D.28674 = log_level.113 > 0;
    D.28675 = (long int) D.28674;
    D.28676 = __builtin_expect (D.28675, 0);
    if (D.28676 != 0) goto <D.28714>; else goto <D.28715>;
    <D.28714>:
    log_file.116 = log_file;
    fprintf (log_file.116, "Shutting down the runtime...\n");
    log_file.116 = log_file;
    fflush (log_file.116);
    <D.28715>:
    mono_runtime_quit ();
    transport_close2 ();
    log_level.113 = log_level;
    D.28674 = log_level.113 > 0;
    D.28675 = (long int) D.28674;
    D.28676 = __builtin_expect (D.28675, 0);
    if (D.28676 != 0) goto <D.28716>; else goto <D.28717>;
    <D.28716>:
    log_file.116 = log_file;
    fprintf (log_file.116, "Exiting...\n");
    log_file.116 = log_file;
    fflush (log_file.116);
    <D.28717>:
    exit (exit_code);
    <D.28709>:
    goto <D.26604>;
  }
  <D.26634>:
  <D.26635>:
  {
    int objid;
    struct MonoThread * thread;
    struct DebuggerTlsData * tls;
    int i;
    int count;
    int err;
    int flags;
    int nmethods;

    try
      {
        p.110 = p;
        objid = decode_objid (p.110, &p, end);
        D.28718 = get_object (objid, &thread);
        err = (int) D.28718;
        if (err != 0) goto <D.28719>; else goto <D.28720>;
        <D.28719>:
        D.28687 = (ErrorCode) err;
        return D.28687;
        <D.28720>:
        p.110 = p;
        flags = decode_int (p.110, &p, end);
        if (command == 13) goto <D.28721>; else goto <D.28722>;
        <D.28721>:
        p.110 = p;
        nmethods = decode_int (p.110, &p, end);
        goto <D.28723>;
        <D.28722>:
        nmethods = 1;
        <D.28723>:
        suspend_count.118 = suspend_count;
        if (suspend_count.118 != 0) goto <D.28724>; else goto <D.28725>;
        <D.28724>:
        wait_for_suspend ();
        <D.28725>:
        D.28726 = is_suspended ();
        if (D.28726 == 0) goto <D.28727>; else goto <D.28728>;
        <D.28727>:
        D.28687 = 101;
        return D.28687;
        <D.28728>:
        mono_loader_lock ();
        thread.122 = thread;
        D.28730 = thread.122->internal_thread;
        thread_to_tls.121 = thread_to_tls;
        tls = mono_g_hash_table_lookup (thread_to_tls.121, D.28730);
        mono_loader_unlock ();
        D.28731 = tls == 0B;
        D.28732 = (long int) D.28731;
        D.28733 = __builtin_expect (D.28732, 0);
        if (D.28733 != 0) goto <D.28734>; else goto <D.28735>;
        <D.28734>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 6722, "tls");
        <D.28735>:
        D.28736 = tls->really_suspended;
        if (D.28736 == 0) goto <D.28737>; else goto <D.28738>;
        <D.28737>:
        D.28687 = 101;
        return D.28687;
        <D.28738>:
        D.28739 = tls->pending_invoke;
        if (D.28739 != 0B) goto <D.28740>; else goto <D.28741>;
        <D.28740>:
        D.28687 = 101;
        return D.28687;
        <D.28741>:
        D.28742 = monoeg_malloc0 (76);
        tls->pending_invoke = D.28742;
        D.28739 = tls->pending_invoke;
        D.28739->id = id;
        D.28739 = tls->pending_invoke;
        D.28739->flags = flags;
        D.28739 = tls->pending_invoke;
        end.123 = (int) end;
        p.110 = p;
        p.124 = (int) p.110;
        D.28745 = end.123 - p.124;
        D.28746 = (unsigned int) D.28745;
        D.28747 = monoeg_malloc (D.28746);
        D.28739->p = D.28747;
        end.123 = (int) end;
        p.110 = p;
        p.124 = (int) p.110;
        D.28745 = end.123 - p.124;
        D.28748 = (unsigned int) D.28745;
        p.110 = p;
        D.28739 = tls->pending_invoke;
        D.28749 = D.28739->p;
        memcpy (D.28749, p.110, D.28748);
        D.28739 = tls->pending_invoke;
        D.28739 = tls->pending_invoke;
        D.28749 = D.28739->p;
        end.123 = (int) end;
        p.110 = p;
        p.124 = (int) p.110;
        D.28745 = end.123 - p.124;
        D.28750 = (sizetype) D.28745;
        D.28751 = D.28749 + D.28750;
        D.28739->endp = D.28751;
        D.28739 = tls->pending_invoke;
        suspend_count.118 = suspend_count;
        suspend_count.125 = (unsigned int) suspend_count.118;
        D.28739->suspend_count = suspend_count.125;
        D.28739 = tls->pending_invoke;
        D.28739->nmethods = nmethods;
        D.28753 = flags & 2;
        if (D.28753 != 0) goto <D.28754>; else goto <D.28755>;
        <D.28754>:
        thread.122 = thread;
        D.28730 = thread.122->internal_thread;
        resume_thread (D.28730);
        goto <D.28756>;
        <D.28755>:
        count = suspend_count;
        i = 0;
        goto <D.26645>;
        <D.26644>:
        resume_vm ();
        i = i + 1;
        <D.26645>:
        if (i < count) goto <D.26644>; else goto <D.26646>;
        <D.26646>:
        <D.28756>:
        goto <D.26604>;
      }
    finally
      {
        thread = {CLOBBER};
      }
  }
  <D.26647>:
  {
    int objid;
    struct MonoThread * thread;
    struct DebuggerTlsData * tls;
    int invoke_id;
    int err;

    try
      {
        p.110 = p;
        objid = decode_objid (p.110, &p, end);
        D.28757 = get_object (objid, &thread);
        err = (int) D.28757;
        if (err != 0) goto <D.28758>; else goto <D.28759>;
        <D.28758>:
        D.28687 = (ErrorCode) err;
        return D.28687;
        <D.28759>:
        p.110 = p;
        invoke_id = decode_int (p.110, &p, end);
        mono_loader_lock ();
        thread.126 = thread;
        D.28761 = thread.126->internal_thread;
        thread_to_tls.121 = thread_to_tls;
        tls = mono_g_hash_table_lookup (thread_to_tls.121, D.28761);
        D.28762 = tls == 0B;
        D.28763 = (long int) D.28762;
        D.28764 = __builtin_expect (D.28763, 0);
        if (D.28764 != 0) goto <D.28765>; else goto <D.28766>;
        <D.28765>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 6767, "tls");
        <D.28766>:
        D.28767 = tls->abort_requested;
        if (D.28767 != 0) goto <D.28768>; else goto <D.28769>;
        <D.28768>:
        mono_loader_unlock ();
        goto <D.26604>;
        <D.28769>:
        D.28772 = tls->invoke;
        if (D.28772 == 0B) goto <D.28770>; else goto <D.28773>;
        <D.28773>:
        D.28772 = tls->invoke;
        D.28774 = D.28772->id;
        if (D.28774 != invoke_id) goto <D.28770>; else goto <D.28771>;
        <D.28770>:
        mono_loader_unlock ();
        D.28687 = 104;
        return D.28687;
        <D.28771>:
        tls->abort_requested = 1;
        thread.126 = thread;
        D.28761 = thread.126->internal_thread;
        ves_icall_System_Threading_Thread_Abort (D.28761, 0B);
        mono_loader_unlock ();
        goto <D.26604>;
      }
    finally
      {
        thread = {CLOBBER};
      }
  }
  <D.26653>:
  {
    int timeout;

    p.110 = p;
    timeout = decode_int (p.110, &p, end);
    agent_config.keepalive = timeout;
    set_keepalive ();
    goto <D.26604>;
  }
  <D.26655>:
  {
    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.110 = p;
        fname = decode_string (p.110, &p, end);
        p.110 = p;
        ignore_case = decode_byte (p.110, &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.127 = domains;
        monoeg_g_hash_table_iter_init (&iter, domains.127);
        goto <D.26684>;
        <D.26683>:
        {
          struct AgentDomainInfo * info;

          domain.128 = domain;
          D.28777 = domain.128->runtime_info;
          info = MEM[(struct MonoJitDomainInfo *)D.28777].agent_info;
          D.28778 = info->loaded_classes;
          monoeg_g_hash_table_iter_init (&kiter, D.28778);
          goto <D.26677>;
          <D.26676>:
          klass.129 = klass;
          D.28780 = info->source_files;
          D.28781 = monoeg_g_hash_table_lookup (D.28780, klass.129);
          if (D.28781 == 0B) goto <D.28782>; else goto <D.28783>;
          <D.28782>:
          klass.129 = klass;
          files = get_source_files_for_type (klass.129);
          klass.129 = klass;
          D.28780 = info->source_files;
          monoeg_g_hash_table_insert_replace (D.28780, klass.129, files, 0);
          i = 0;
          goto <D.26674>;
          <D.26673>:
          {
            char * s;
            char * s2;
            char * s3;

            D.28784 = files->pdata;
            i.130 = (unsigned int) i;
            D.28786 = i.130 * 4;
            D.28787 = D.28784 + D.28786;
            s = *D.28787;
            s2 = monoeg_g_path_get_basename (s);
            D.28788 = info->source_file_to_class;
            class_list = monoeg_g_hash_table_lookup (D.28788, s2);
            if (class_list == 0B) goto <D.28789>; else goto <D.28790>;
            <D.28789>:
            klass.129 = klass;
            class_list = monoeg_g_slist_prepend (class_list, klass.129);
            D.28791 = monoeg_strdup (s2);
            D.28788 = info->source_file_to_class;
            monoeg_g_hash_table_insert_replace (D.28788, D.28791, class_list, 0);
            goto <D.28792>;
            <D.28790>:
            klass.129 = klass;
            class_list = monoeg_g_slist_prepend (class_list, klass.129);
            D.28788 = info->source_file_to_class;
            monoeg_g_hash_table_insert_replace (D.28788, s2, class_list, 0);
            <D.28792>:
            s3 = strdup_tolower (s2);
            D.28793 = info->source_file_to_class_ignorecase;
            class_list = monoeg_g_hash_table_lookup (D.28793, s3);
            if (class_list == 0B) goto <D.28794>; else goto <D.28795>;
            <D.28794>:
            klass.129 = klass;
            class_list = monoeg_g_slist_prepend (class_list, klass.129);
            D.28796 = monoeg_strdup (s3);
            D.28793 = info->source_file_to_class_ignorecase;
            monoeg_g_hash_table_insert_replace (D.28793, D.28796, class_list, 0);
            goto <D.28797>;
            <D.28795>:
            klass.129 = klass;
            class_list = monoeg_g_slist_prepend (class_list, klass.129);
            D.28793 = info->source_file_to_class_ignorecase;
            monoeg_g_hash_table_insert_replace (D.28793, s3, class_list, 0);
            <D.28797>:
            monoeg_g_free (s2);
            monoeg_g_free (s3);
          }
          i = i + 1;
          <D.26674>:
          i.131 = (unsigned int) i;
          D.28799 = files->len;
          if (i.131 < D.28799) goto <D.26673>; else goto <D.26675>;
          <D.26675>:
          <D.28783>:
          <D.26677>:
          D.28800 = monoeg_g_hash_table_iter_next (&kiter, 0B, &klass);
          if (D.28800 != 0) goto <D.26676>; else goto <D.26678>;
          <D.26678>:
          if (ignore_case != 0) goto <D.28801>; else goto <D.28802>;
          <D.28801>:
          {
            char * s;

            s = strdup_tolower (basename);
            D.28793 = info->source_file_to_class_ignorecase;
            class_list = monoeg_g_hash_table_lookup (D.28793, s);
            monoeg_g_free (s);
          }
          goto <D.28803>;
          <D.28802>:
          D.28788 = info->source_file_to_class;
          class_list = monoeg_g_hash_table_lookup (D.28788, basename);
          <D.28803>:
          l = class_list;
          goto <D.26681>;
          <D.26680>:
          klass.132 = l->data;
          klass = klass.132;
          klass.129 = klass;
          monoeg_g_ptr_array_add (res_classes, klass.129);
          domain.128 = domain;
          monoeg_g_ptr_array_add (res_domains, domain.128);
          l = l->next;
          <D.26681>:
          if (l != 0B) goto <D.26680>; else goto <D.26682>;
          <D.26682>:
        }
        <D.26684>:
        D.28805 = monoeg_g_hash_table_iter_next (&iter, 0B, &domain);
        if (D.28805 != 0) goto <D.26683>; else goto <D.26685>;
        <D.26685>:
        mono_loader_unlock ();
        monoeg_g_free (fname);
        monoeg_g_free (basename);
        D.28806 = res_classes->len;
        buffer_add_int (buf, D.28806);
        i = 0;
        goto <D.26687>;
        <D.26686>:
        D.28807 = res_classes->pdata;
        i.130 = (unsigned int) i;
        D.28786 = i.130 * 4;
        D.28808 = D.28807 + D.28786;
        D.28809 = *D.28808;
        D.28810 = res_domains->pdata;
        i.130 = (unsigned int) i;
        D.28786 = i.130 * 4;
        D.28811 = D.28810 + D.28786;
        D.28812 = *D.28811;
        buffer_add_typeid (buf, D.28812, D.28809);
        i = i + 1;
        <D.26687>:
        i.131 = (unsigned int) i;
        D.28806 = res_classes->len;
        if (i.131 < D.28806) goto <D.26686>; else goto <D.26688>;
        <D.26688>:
        monoeg_g_ptr_array_free (res_classes, 1);
        monoeg_g_ptr_array_free (res_domains, 1);
        goto <D.26604>;
      }
    finally
      {
        iter = {CLOBBER};
        kiter = {CLOBBER};
        domain = {CLOBBER};
        klass = {CLOBBER};
      }
  }
  <D.26689>:
  {
    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.110 = p;
        name = decode_string (p.110, &p, end);
        p.110 = p;
        ignore_case = decode_byte (p.110, &p, end);
        D.28813 = mono_reflection_parse_type (name, &info);
        if (D.28813 == 0) goto <D.28814>; else goto <D.28815>;
        <D.28814>:
        monoeg_g_free (name);
        mono_reflection_free_type_info (&info);
        D.28687 = 102;
        return D.28687;
        <D.28815>:
        res_classes = monoeg_g_ptr_array_new ();
        res_domains = monoeg_g_ptr_array_new ();
        mono_loader_lock ();
        domains.127 = domains;
        monoeg_g_hash_table_iter_init (&iter, domains.127);
        goto <D.26708>;
        <D.26707>:
        {
          struct MonoAssembly * ass;
          gboolean type_resolve;
          struct MonoType * t;
          struct GSList * tmp;

          try
            {
              {
                int ret;

                domain.133 = domain;
                D.28817 = &domain.133->assemblies_lock.mutex;
                ret = pthread_mutex_lock (D.28817);
                if (ret != 0) goto <D.28818>; else goto <D.28819>;
                <D.28818>:
                monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
                <D.28819>:
                D.28820 = ret != 0;
                D.28821 = (long int) D.28820;
                D.28822 = __builtin_expect (D.28821, 0);
                if (D.28822 != 0) goto <D.28823>; else goto <D.28824>;
                <D.28823>:
                monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 6927, "ret == 0");
                <D.28824>:
              }
              domain.133 = domain;
              tmp = domain.133->domain_assemblies;
              goto <D.26704>;
              <D.26703>:
              ass = tmp->data;
              D.28825 = ass->image;
              if (D.28825 != 0B) goto <D.28826>; else goto <D.28827>;
              <D.28826>:
              type_resolve = 1;
              D.28825 = ass->image;
              t = mono_reflection_get_type (D.28825, &info, ignore_case, &type_resolve);
              if (t != 0B) goto <D.28828>; else goto <D.28829>;
              <D.28828>:
              D.28830 = mono_type_get_class (t);
              monoeg_g_ptr_array_add (res_classes, D.28830);
              domain.133 = domain;
              monoeg_g_ptr_array_add (res_domains, domain.133);
              <D.28829>:
              <D.28827>:
              tmp = tmp->next;
              <D.26704>:
              if (tmp != 0B) goto <D.26703>; else goto <D.26705>;
              <D.26705>:
              {
                int ret;

                domain.133 = domain;
                D.28817 = &domain.133->assemblies_lock.mutex;
                ret = pthread_mutex_unlock (D.28817);
                if (ret != 0) goto <D.28831>; else goto <D.28832>;
                <D.28831>:
                monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
                <D.28832>:
                D.28833 = ret != 0;
                D.28834 = (long int) D.28833;
                D.28835 = __builtin_expect (D.28834, 0);
                if (D.28835 != 0) goto <D.28836>; else goto <D.28837>;
                <D.28836>:
                monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 6940, "ret == 0");
                <D.28837>:
              }
            }
          finally
            {
              type_resolve = {CLOBBER};
            }
        }
        <D.26708>:
        D.28838 = monoeg_g_hash_table_iter_next (&iter, 0B, &domain);
        if (D.28838 != 0) goto <D.26707>; else goto <D.26709>;
        <D.26709>:
        mono_loader_unlock ();
        monoeg_g_free (name);
        mono_reflection_free_type_info (&info);
        D.28839 = res_classes->len;
        buffer_add_int (buf, D.28839);
        i = 0;
        goto <D.26711>;
        <D.26710>:
        D.28840 = res_classes->pdata;
        i.134 = (unsigned int) i;
        D.28842 = i.134 * 4;
        D.28843 = D.28840 + D.28842;
        D.28844 = *D.28843;
        D.28845 = res_domains->pdata;
        i.134 = (unsigned int) i;
        D.28842 = i.134 * 4;
        D.28846 = D.28845 + D.28842;
        D.28847 = *D.28846;
        buffer_add_typeid (buf, D.28847, D.28844);
        i = i + 1;
        <D.26711>:
        i.135 = (unsigned int) i;
        D.28839 = res_classes->len;
        if (i.135 < D.28839) goto <D.26710>; else goto <D.26712>;
        <D.26712>:
        monoeg_g_ptr_array_free (res_classes, 1);
        monoeg_g_ptr_array_free (res_domains, 1);
        goto <D.26604>;
      }
    finally
      {
        iter = {CLOBBER};
        domain = {CLOBBER};
        info = {CLOBBER};
      }
  }
  <D.26713>:
  D.28687 = 100;
  return D.28687;
  <D.26604>:
  D.28687 = 0;
  return D.28687;
}


is_really_suspended (void * key, void * value, void * user_data)
{
  struct MonoGHashTable * thread_to_tls.136;
  _Bool D.28858;
  long int D.28859;
  long int D.28860;
  gboolean D.28863;
  struct MonoThread * thread;
  struct DebuggerTlsData * tls;
  gboolean res;

  thread = value;
  mono_loader_lock ();
  thread_to_tls.136 = thread_to_tls;
  tls = mono_g_hash_table_lookup (thread_to_tls.136, thread);
  D.28858 = tls == 0B;
  D.28859 = (long int) D.28858;
  D.28860 = __builtin_expect (D.28859, 0);
  if (D.28860 != 0) goto <D.28861>; else goto <D.28862>;
  <D.28861>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 6512, "tls");
  <D.28862>:
  res = tls->really_suspended;
  mono_loader_unlock ();
  D.28863 = res;
  return D.28863;
}


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.137;

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


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

  D.28866 = 1;
  return D.28866;
}


clear_event_request (int req_id, int etype)
{
  struct GPtrArray * event_requests.138;
  void * * D.28869;
  unsigned int i.139;
  unsigned int D.28871;
  void * * D.28872;
  int D.28873;
  int D.28876;
  void * D.28881;
  unsigned int i.140;
  unsigned int D.28889;
  int i;

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

    event_requests.138 = event_requests;
    D.28869 = event_requests.138->pdata;
    i.139 = (unsigned int) i;
    D.28871 = i.139 * 4;
    D.28872 = D.28869 + D.28871;
    req = *D.28872;
    D.28873 = req->id;
    if (D.28873 == req_id) goto <D.28874>; else goto <D.28875>;
    <D.28874>:
    D.28876 = req->event_kind;
    if (D.28876 == etype) goto <D.28877>; else goto <D.28878>;
    <D.28877>:
    D.28876 = req->event_kind;
    if (D.28876 == 10) goto <D.28879>; else goto <D.28880>;
    <D.28879>:
    D.28881 = req->info;
    clear_breakpoint (D.28881);
    <D.28880>:
    D.28876 = req->event_kind;
    if (D.28876 == 11) goto <D.28882>; else goto <D.28883>;
    <D.28882>:
    D.28881 = req->info;
    ss_destroy (D.28881);
    <D.28883>:
    D.28876 = req->event_kind;
    if (D.28876 == 6) goto <D.28884>; else goto <D.28885>;
    <D.28884>:
    D.28881 = req->info;
    clear_breakpoint (D.28881);
    <D.28885>:
    D.28876 = req->event_kind;
    if (D.28876 == 7) goto <D.28886>; else goto <D.28887>;
    <D.28886>:
    D.28881 = req->info;
    clear_breakpoint (D.28881);
    <D.28887>:
    i.140 = (unsigned int) i;
    event_requests.138 = event_requests;
    monoeg_g_ptr_array_remove_index_fast (event_requests.138, i.140);
    monoeg_g_free (req);
    goto <D.26447>;
    <D.28878>:
    <D.28875>:
  }
  i = i + 1;
  <D.26449>:
  i.140 = (unsigned int) i;
  event_requests.138 = event_requests;
  D.28889 = event_requests.138->len;
  if (i.140 < D.28889) goto <D.26448>; else goto <D.26447>;
  <D.26447>:
  mono_loader_unlock ();
}


transport_close2 ()
{
  struct DebuggerTransport * transport.141;
  void (*<T7b9>) (void) D.28891;

  transport.141 = transport;
  D.28891 = transport.141->close2;
  D.28891 ();
}


wait_for_suspend ()
{
  struct MonoGHashTable * thread_to_tls.142;
  unsigned int D.28893;
  int log_level.143;
  _Bool D.28896;
  long int D.28897;
  long int D.28898;
  struct FILE * log_file.144;
  _Bool D.28902;
  long int D.28903;
  long int D.28904;
  int nthreads;
  int nwait;
  int err;
  gboolean waited;

  waited = 0;
  mono_loader_lock ();
  thread_to_tls.142 = thread_to_tls;
  D.28893 = mono_g_hash_table_size (thread_to_tls.142);
  nthreads = (int) D.28893;
  mono_loader_unlock ();
  <D.25446>:
  nwait = count_threads_to_wait_for ();
  if (nwait != 0) goto <D.28894>; else goto <D.25445>;
  <D.28894>:
  log_level.143 = log_level;
  D.28896 = log_level.143 > 0;
  D.28897 = (long int) D.28896;
  D.28898 = __builtin_expect (D.28897, 0);
  if (D.28898 != 0) goto <D.28899>; else goto <D.28900>;
  <D.28899>:
  log_file.144 = log_file;
  fprintf (log_file.144, "Waiting for %d(%d) threads to suspend...\n", nwait, nthreads);
  log_file.144 = log_file;
  fflush (log_file.144);
  <D.28900>:
  err = mono_sem_wait (&suspend_sem, 0);
  D.28902 = err != 0;
  D.28903 = (long int) D.28902;
  D.28904 = __builtin_expect (D.28903, 0);
  if (D.28904 != 0) goto <D.28905>; else goto <D.28906>;
  <D.28905>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 2962, "err == 0");
  <D.28906>:
  waited = 1;
  goto <D.25446>;
  <D.25445>:
  if (waited != 0) goto <D.28907>; else goto <D.28908>;
  <D.28907>:
  log_level.143 = log_level;
  D.28896 = log_level.143 > 0;
  D.28897 = (long int) D.28896;
  D.28898 = __builtin_expect (D.28897, 0);
  if (D.28898 != 0) goto <D.28909>; else goto <D.28910>;
  <D.28909>:
  log_file.144 = log_file;
  fprintf (log_file.144, "%d threads suspended.\n", nthreads);
  log_file.144 = log_file;
  fflush (log_file.144);
  <D.28910>:
  <D.28908>:
}


count_threads_to_wait_for ()
{
  struct MonoGHashTable * thread_to_tls.145;
  int D.28912;
  int count;

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


count_thread (void * key, void * value, void * user_data)
{
  int D.28915;
  int D.28918;
  int D.28921;
  int D.28922;
  struct DebuggerTlsData * tls;

  tls = value;
  D.28915 = tls->suspended;
  if (D.28915 == 0) goto <D.28916>; else goto <D.28917>;
  <D.28916>:
  D.28918 = tls->terminated;
  if (D.28918 == 0) goto <D.28919>; else goto <D.28920>;
  <D.28919>:
  D.28921 = MEM[(int *)user_data];
  D.28922 = D.28921 + 1;
  MEM[(int *)user_data] = D.28922;
  <D.28920>:
  <D.28917>:
}


is_suspended ()
{
  gboolean D.28923;
  int D.28924;
  _Bool D.28925;

  D.28924 = count_threads_to_wait_for ();
  D.28925 = D.28924 == 0;
  D.28923 = (gboolean) D.28925;
  return D.28923;
}


resume_thread (struct MonoInternalThread * thread)
{
  unsigned int D.28927;
  unsigned int debugger_thread_id.146;
  _Bool D.28929;
  long int D.28930;
  long int D.28931;
  struct MonoGHashTable * thread_to_tls.147;
  _Bool D.28935;
  long int D.28936;
  long int D.28937;
  int suspend_count.148;
  _Bool D.28941;
  long int D.28942;
  long int D.28943;
  int log_level.149;
  _Bool D.28947;
  long int D.28948;
  long int D.28949;
  long long unsigned int D.28952;
  int D.28953;
  void * D.28954;
  struct FILE * log_file.150;
  unsigned int D.28956;
  unsigned int suspend_count.151;
  unsigned int D.28958;
  _Bool D.28959;
  long int D.28960;
  long int D.28961;
  int err;
  struct DebuggerTlsData * tls;

  D.28927 = GetCurrentThreadId ();
  debugger_thread_id.146 = debugger_thread_id;
  D.28929 = D.28927 != debugger_thread_id.146;
  D.28930 = (long int) D.28929;
  D.28931 = __builtin_expect (D.28930, 0);
  if (D.28931 != 0) goto <D.28932>; else goto <D.28933>;
  <D.28932>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 2796, "debugger_thread_id == GetCurrentThreadId ()");
  <D.28933>:
  mono_loader_lock ();
  thread_to_tls.147 = thread_to_tls;
  tls = mono_g_hash_table_lookup (thread_to_tls.147, thread);
  D.28935 = tls == 0B;
  D.28936 = (long int) D.28935;
  D.28937 = __builtin_expect (D.28936, 0);
  if (D.28937 != 0) goto <D.28938>; else goto <D.28939>;
  <D.28938>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 2801, "tls");
  <D.28939>:
  pthread_mutex_lock (&suspend_mutex);
  suspend_count.148 = suspend_count;
  D.28941 = suspend_count.148 <= 0;
  D.28942 = (long int) D.28941;
  D.28943 = __builtin_expect (D.28942, 0);
  if (D.28943 != 0) goto <D.28944>; else goto <D.28945>;
  <D.28944>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 2805, "suspend_count > 0");
  <D.28945>:
  log_level.149 = log_level;
  D.28947 = log_level.149 > 0;
  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>:
  D.28952 = thread->tid;
  D.28953 = (int) D.28952;
  D.28954 = (void *) D.28953;
  log_file.150 = log_file;
  fprintf (log_file.150, "[%p] Resuming thread...\n", D.28954);
  log_file.150 = log_file;
  fflush (log_file.150);
  <D.28951>:
  D.28956 = tls->resume_count;
  suspend_count.148 = suspend_count;
  suspend_count.151 = (unsigned int) suspend_count.148;
  D.28958 = D.28956 + suspend_count.151;
  tls->resume_count = D.28958;
  err = pthread_cond_broadcast (&suspend_cond);
  D.28959 = err != 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", 2816, "err == 0");
  <D.28963>:
  pthread_mutex_unlock (&suspend_mutex);
  mono_loader_unlock ();
}


resume_vm ()
{
  unsigned int D.28964;
  unsigned int debugger_thread_id.152;
  _Bool D.28966;
  long int D.28967;
  long int D.28968;
  int suspend_count.153;
  _Bool D.28972;
  long int D.28973;
  long int D.28974;
  int suspend_count.154;
  int log_level.155;
  _Bool D.28979;
  long int D.28980;
  long int D.28981;
  unsigned int D.28984;
  void * D.28985;
  struct FILE * log_file.156;
  struct MonoGHashTable * thread_to_tls.157;
  _Bool D.28990;
  long int D.28991;
  long int D.28992;
  int err;

  D.28964 = GetCurrentThreadId ();
  debugger_thread_id.152 = debugger_thread_id;
  D.28966 = D.28964 != debugger_thread_id.152;
  D.28967 = (long int) D.28966;
  D.28968 = __builtin_expect (D.28967, 0);
  if (D.28968 != 0) goto <D.28969>; else goto <D.28970>;
  <D.28969>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 2755, "debugger_thread_id == GetCurrentThreadId ()");
  <D.28970>:
  mono_loader_lock ();
  pthread_mutex_lock (&suspend_mutex);
  suspend_count.153 = suspend_count;
  D.28972 = suspend_count.153 <= 0;
  D.28973 = (long int) D.28972;
  D.28974 = __builtin_expect (D.28973, 0);
  if (D.28974 != 0) goto <D.28975>; else goto <D.28976>;
  <D.28975>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 2761, "suspend_count > 0");
  <D.28976>:
  suspend_count.153 = suspend_count;
  suspend_count.154 = suspend_count.153 + -1;
  suspend_count = suspend_count.154;
  log_level.155 = log_level;
  D.28979 = log_level.155 > 0;
  D.28980 = (long int) D.28979;
  D.28981 = __builtin_expect (D.28980, 0);
  if (D.28981 != 0) goto <D.28982>; else goto <D.28983>;
  <D.28982>:
  suspend_count.153 = suspend_count;
  D.28984 = GetCurrentThreadId ();
  D.28985 = (void *) D.28984;
  log_file.156 = log_file;
  fprintf (log_file.156, "[%p] Resuming vm, suspend count=%d...\n", D.28985, suspend_count.153);
  log_file.156 = log_file;
  fflush (log_file.156);
  <D.28983>:
  suspend_count.153 = suspend_count;
  if (suspend_count.153 == 0) goto <D.28987>; else goto <D.28988>;
  <D.28987>:
  stop_single_stepping ();
  thread_to_tls.157 = thread_to_tls;
  mono_g_hash_table_foreach (thread_to_tls.157, reset_native_thread_suspend_state, 0B);
  <D.28988>:
  err = pthread_cond_broadcast (&suspend_cond);
  D.28990 = err != 0;
  D.28991 = (long int) D.28990;
  D.28992 = __builtin_expect (D.28991, 0);
  if (D.28992 != 0) goto <D.28993>; else goto <D.28994>;
  <D.28993>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 2774, "err == 0");
  <D.28994>:
  pthread_mutex_unlock (&suspend_mutex);
  suspend_count.153 = suspend_count;
  if (suspend_count.153 == 0) goto <D.28995>; else goto <D.28996>;
  <D.28995>:
  mono_thread_pool_resume ();
  <D.28996>:
  mono_loader_unlock ();
}


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

  tls = value;
  D.28997 = tls->really_suspended;
  if (D.28997 == 0) goto <D.28998>; else goto <D.28999>;
  <D.28998>:
  D.29000 = tls->suspended;
  if (D.29000 != 0) goto <D.29001>; else goto <D.29002>;
  <D.29001>:
  tls->suspended = 0;
  tls->context.valid = 0;
  tls->async_state.valid = 0;
  invalidate_frames (tls);
  <D.29002>:
  <D.28999>:
}


invalidate_frames (struct DebuggerTlsData * tls)
{
  unsigned int debugger_tls_id.158;
  _Bool D.29006;
  long int D.29007;
  long int D.29008;
  struct StackFrame * * D.29011;
  unsigned int i.159;
  unsigned int D.29013;
  struct StackFrame * * D.29014;
  struct StackFrame * D.29015;
  struct MonoDebugMethodJitInfo * D.29016;
  int D.29019;
  int i;

  if (tls == 0B) goto <D.29003>; else goto <D.29004>;
  <D.29003>:
  debugger_tls_id.158 = debugger_tls_id;
  tls = pthread_getspecific (debugger_tls_id.158);
  <D.29004>:
  D.29006 = tls == 0B;
  D.29007 = (long int) D.29006;
  D.29008 = __builtin_expect (D.29007, 0);
  if (D.29008 != 0) goto <D.29009>; else goto <D.29010>;
  <D.29009>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 2831, "tls");
  <D.29010>:
  i = 0;
  goto <D.25418>;
  <D.25417>:
  D.29011 = tls->frames;
  i.159 = (unsigned int) i;
  D.29013 = i.159 * 4;
  D.29014 = D.29011 + D.29013;
  D.29015 = *D.29014;
  D.29016 = D.29015->jit;
  if (D.29016 != 0B) goto <D.29017>; else goto <D.29018>;
  <D.29017>:
  D.29011 = tls->frames;
  i.159 = (unsigned int) i;
  D.29013 = i.159 * 4;
  D.29014 = D.29011 + D.29013;
  D.29015 = *D.29014;
  D.29016 = D.29015->jit;
  mono_debug_free_method_jit_info (D.29016);
  <D.29018>:
  D.29011 = tls->frames;
  i.159 = (unsigned int) i;
  D.29013 = i.159 * 4;
  D.29014 = D.29011 + D.29013;
  D.29015 = *D.29014;
  monoeg_g_free (D.29015);
  i = i + 1;
  <D.25418>:
  D.29019 = tls->frame_count;
  if (D.29019 > i) goto <D.25417>; else goto <D.25419>;
  <D.25419>:
  D.29011 = tls->frames;
  monoeg_g_free (D.29011);
  tls->frame_count = 0;
  tls->frames = 0B;
}


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

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


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

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


get_object (int objid, struct MonoObject * * obj)
{
  <unnamed type> D.29024;
  ErrorCode D.29027;
  struct MonoObject * D.29028;
  int err;

  D.29024 = get_object_allow_null (objid, obj);
  err = (int) D.29024;
  if (err != 0) goto <D.29025>; else goto <D.29026>;
  <D.29025>:
  D.29027 = (ErrorCode) err;
  return D.29027;
  <D.29026>:
  D.29028 = *obj;
  if (D.29028 == 0B) goto <D.29029>; else goto <D.29030>;
  <D.29029>:
  D.29027 = 20;
  return D.29027;
  <D.29030>:
  D.29027 = 0;
  return D.29027;
}


get_object_allow_null (int objid, struct MonoObject * * obj)
{
  ErrorCode D.29034;
  struct GHashTable * objrefs.160;
  const void * objid.161;
  unsigned int D.29041;
  struct MonoObject * D.29042;
  struct MonoObject * D.29043;
  struct ObjRef * ref;

  if (objid == 0) goto <D.29032>; else goto <D.29033>;
  <D.29032>:
  *obj = 0B;
  D.29034 = 0;
  return D.29034;
  <D.29033>:
  objrefs.160 = objrefs;
  if (objrefs.160 == 0B) goto <D.29036>; else goto <D.29037>;
  <D.29036>:
  D.29034 = 20;
  return D.29034;
  <D.29037>:
  mono_loader_lock ();
  objid.161 = (const void *) objid;
  objrefs.160 = objrefs;
  ref = monoeg_g_hash_table_lookup (objrefs.160, objid.161);
  if (ref != 0B) goto <D.29039>; else goto <D.29040>;
  <D.29039>:
  D.29041 = ref->handle;
  D.29042 = mono_gchandle_get_target (D.29041);
  *obj = D.29042;
  mono_loader_unlock ();
  D.29043 = *obj;
  if (D.29043 == 0B) goto <D.29044>; else goto <D.29045>;
  <D.29044>:
  D.29034 = 20;
  return D.29034;
  <D.29045>:
  D.29034 = 0;
  return D.29034;
  <D.29040>:
  mono_loader_unlock ();
  D.29034 = 20;
  return D.29034;
}


get_source_files_for_type (struct MonoClass * klass)
{
  struct GPtrArray * source_file_list.162;
  void * * D.29050;
  unsigned int j.163;
  unsigned int D.29052;
  void * * D.29053;
  int D.26584;
  char * D.29054;
  void * * D.29055;
  unsigned int i.164;
  unsigned int D.29057;
  void * * D.29058;
  void * D.29059;
  unsigned int i.165;
  unsigned int D.29062;
  gchar * D.29065;
  unsigned int j.166;
  unsigned int D.29067;
  struct GPtrArray * D.29068;
  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.26592>;
      <D.26591>:
      {
        struct MonoDebugMethodInfo * minfo;
        struct GPtrArray * source_file_list;

        try
          {
            minfo = mono_debug_lookup_method (method);
            if (minfo != 0B) goto <D.29047>; else goto <D.29048>;
            <D.29047>:
            mono_debug_symfile_get_line_numbers_full (minfo, 0B, &source_file_list, 0B, 0B, 0B, 0B, 0B);
            j = 0;
            goto <D.26589>;
            <D.26588>:
            source_file_list.162 = source_file_list;
            D.29050 = source_file_list.162->pdata;
            j.163 = (unsigned int) j;
            D.29052 = j.163 * 4;
            D.29053 = D.29050 + D.29052;
            sinfo = *D.29053;
            i = 0;
            goto <D.26587>;
            <D.26586>:
            {
              size_t __s1_len;
              size_t __s2_len;

              D.29054 = sinfo->source_file;
              D.29055 = files->pdata;
              i.164 = (unsigned int) i;
              D.29057 = i.164 * 4;
              D.29058 = D.29055 + D.29057;
              D.29059 = *D.29058;
              D.26584 = __builtin_strcmp (D.29059, D.29054);
            }
            if (D.26584 == 0) goto <D.26585>; else goto <D.29060>;
            <D.29060>:
            i = i + 1;
            <D.26587>:
            i.165 = (unsigned int) i;
            D.29062 = files->len;
            if (i.165 < D.29062) goto <D.26586>; else goto <D.26585>;
            <D.26585>:
            i.165 = (unsigned int) i;
            D.29062 = files->len;
            if (i.165 == D.29062) goto <D.29063>; else goto <D.29064>;
            <D.29063>:
            D.29054 = sinfo->source_file;
            D.29065 = monoeg_strdup (D.29054);
            monoeg_g_ptr_array_add (files, D.29065);
            <D.29064>:
            j = j + 1;
            <D.26589>:
            j.166 = (unsigned int) j;
            source_file_list.162 = source_file_list;
            D.29067 = source_file_list.162->len;
            if (j.166 < D.29067) goto <D.26588>; else goto <D.26590>;
            <D.26590>:
            source_file_list.162 = source_file_list;
            monoeg_g_ptr_array_free (source_file_list.162, 1);
            <D.29048>:
          }
        finally
          {
            source_file_list = {CLOBBER};
          }
      }
      <D.26592>:
      method = mono_class_get_methods (klass, &iter);
      if (method != 0B) goto <D.26591>; else goto <D.26593>;
      <D.26593>:
      D.29068 = files;
      return D.29068;
    }
  finally
    {
      iter = {CLOBBER};
    }
}


decode_string (guint8 * buf, guint8 * * endbuf, guint8 * limit)
{
  guint8 * buf.167;
  char * D.29074;
  int D.29075;
  unsigned int D.29076;
  _Bool D.29077;
  long int D.29078;
  long int D.29079;
  unsigned int len.168;
  sizetype len.169;
  char * D.29084;
  guint8 * buf.170;
  int len;
  char * s;

  buf.167 = buf;
  len = decode_int (buf.167, &buf, limit);
  if (len < 0) goto <D.29072>; else goto <D.29073>;
  <D.29072>:
  buf.167 = buf;
  *endbuf = buf.167;
  D.29074 = 0B;
  return D.29074;
  <D.29073>:
  D.29075 = len + 1;
  D.29076 = (unsigned int) D.29075;
  s = monoeg_malloc (D.29076);
  D.29077 = s == 0B;
  D.29078 = (long int) D.29077;
  D.29079 = __builtin_expect (D.29078, 0);
  if (D.29079 != 0) goto <D.29080>; else goto <D.29081>;
  <D.29080>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 1633, "s");
  <D.29081>:
  len.168 = (unsigned int) len;
  buf.167 = buf;
  memcpy (s, buf.167, len.168);
  len.169 = (sizetype) len;
  D.29084 = s + len.169;
  *D.29084 = 0;
  buf.167 = buf;
  len.169 = (sizetype) len;
  buf.170 = buf.167 + len.169;
  buf = buf.170;
  buf.167 = buf;
  *endbuf = buf.167;
  D.29074 = s;
  return D.29074;
}


event_commands (int command, guint8 * p, guint8 * end, struct Buffer * buf)
{
  guint8 * p.171;
  unsigned int nmodifiers.172;
  unsigned int D.29089;
  unsigned int D.29090;
  int D.29091;
  <unnamed type> mod.173;
  int D.29095;
  int err.174;
  ErrorCode D.29102;
  long long int D.29103;
  int protocol_version_set.175;
  int major_version.176;
  int minor_version.177;
  <unnamed type> filter.178;
  <unnamed type> D.29122;
  unsigned int D.29123;
  unsigned int D.29126;
  struct MonoInternalThread * * D.29130;
  <unnamed type> D.29131;
  int err.179;
  int D.29140;
  int D.29141;
  int D.29148;
  int log_level.180;
  _Bool D.29150;
  long int D.29151;
  long int D.29152;
  const char * iftmp.181;
  int D.29156;
  const char * iftmp.182;
  int D.29161;
  const char * iftmp.183;
  int D.29166;
  const char * iftmp.184;
  struct FILE * log_file.185;
  struct MonoClass * D.29177;
  int D.29178;
  unsigned int n.186;
  unsigned int D.29185;
  void * D.29186;
  struct MonoAssembly * * D.29187;
  unsigned int j.187;
  unsigned int D.29189;
  struct MonoAssembly * * D.29190;
  struct MonoAssembly * D.29191;
  struct GHashTable * D.29197;
  struct GHashTable * D.29200;
  struct GHashTable * D.29204;
  struct GHashTable * D.29207;
  int D.29209;
  _Bool D.29212;
  long int D.29213;
  long int D.29214;
  struct MonoBreakpoint * D.29217;
  int D.29218;
  const char * D.29223;
  _Bool D.29227;
  long int D.29228;
  long int D.29229;
  <unnamed type> D.29232;
  int err.188;
  <unnamed type> depth.189;
  <unnamed type> size.190;
  struct MonoThread * step_thread.191;
  struct _MonoInternalThread * D.29239;
  <unnamed type> D.29240;
  int err.192;
  struct MonoBreakpoint * D.29247;
  struct MonoBreakpoint * D.29251;
  int D.29259;
  struct GPtrArray * event_requests.193;
  int D.29263;
  struct GHashTable * domains.194;
  struct MonoGHashTable * tid_to_thread.195;
  int D.29268;
  unsigned int D.29269;
  void * * D.29270;
  unsigned int i.196;
  unsigned int D.29272;
  void * * D.29273;
  int D.29274;
  void * D.29277;
  unsigned int i.197;
  unsigned int D.29280;
  int err;
  struct MonoError error;

  try
    {
      switch (command) <default: <D.26777>, case 1: <D.26722>, case 2: <D.26768>, case 3: <D.26771>>
      <D.26722>:
      {
        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.171 = p;
            event_kind = decode_byte (p.171, &p, end);
            p.171 = p;
            suspend_policy = decode_byte (p.171, &p, end);
            p.171 = p;
            nmodifiers = decode_byte (p.171, &p, end);
            nmodifiers.172 = (unsigned int) nmodifiers;
            D.29089 = nmodifiers.172 + 1;
            D.29090 = D.29089 * 20;
            req = monoeg_malloc0 (D.29090);
            D.29091 = InterlockedIncrement (&event_request_id);
            req->id = D.29091;
            req->event_kind = event_kind;
            req->suspend_policy = suspend_policy;
            req->nmodifiers = nmodifiers;
            method = 0B;
            i = 0;
            goto <D.26759>;
            <D.26758>:
            p.171 = p;
            mod = decode_byte (p.171, &p, end);
            mod.173 = (<unnamed type>) mod;
            req->modifiers[i].kind = mod.173;
            if (mod == 1) goto <D.29093>; else goto <D.29094>;
            <D.29093>:
            p.171 = p;
            D.29095 = decode_int (p.171, &p, end);
            req->modifiers[i].data.count = D.29095;
            goto <D.29096>;
            <D.29094>:
            if (mod == 7) goto <D.29097>; else goto <D.29098>;
            <D.29097>:
            p.171 = p;
            method = decode_methodid (p.171, &p, end, &domain, &err);
            err.174 = err;
            if (err.174 != 0) goto <D.29100>; else goto <D.29101>;
            <D.29100>:
            err.174 = err;
            D.29102 = (ErrorCode) err.174;
            return D.29102;
            <D.29101>:
            p.171 = p;
            D.29103 = decode_long (p.171, &p, end);
            location = (long int) D.29103;
            goto <D.29104>;
            <D.29098>:
            if (mod == 10) goto <D.29105>; else goto <D.29106>;
            <D.29105>:
            p.171 = p;
            step_thread_id = decode_id (p.171, &p, end);
            p.171 = p;
            size = decode_int (p.171, &p, end);
            p.171 = p;
            depth = decode_int (p.171, &p, end);
            protocol_version_set.175 = protocol_version_set;
            if (protocol_version_set.175 != 0) goto <D.29110>; else goto <D.29111>;
            <D.29110>:
            major_version.176 = major_version;
            if (major_version.176 > 2) goto <D.29107>; else goto <D.29113>;
            <D.29113>:
            major_version.176 = major_version;
            if (major_version.176 == 2) goto <D.29114>; else goto <D.29108>;
            <D.29114>:
            minor_version.177 = minor_version;
            if (minor_version.177 > 15) goto <D.29107>; else goto <D.29108>;
            <D.29107>:
            p.171 = p;
            filter = decode_int (p.171, &p, end);
            <D.29108>:
            <D.29111>:
            filter.178 = (<unnamed type>) filter;
            req->modifiers[i].data.filter = filter.178;
            protocol_version_set.175 = protocol_version_set;
            if (protocol_version_set.175 == 0) goto <D.29117>; else goto <D.29119>;
            <D.29119>:
            major_version.176 = major_version;
            if (major_version.176 <= 2) goto <D.29120>; else goto <D.29118>;
            <D.29120>:
            major_version.176 = major_version;
            if (major_version.176 != 2) goto <D.29117>; else goto <D.29121>;
            <D.29121>:
            minor_version.177 = minor_version;
            if (minor_version.177 <= 25) goto <D.29117>; else goto <D.29118>;
            <D.29117>:
            D.29122 = req->modifiers[i].data.filter;
            D.29123 = D.29122 & 2;
            if (D.29123 != 0) goto <D.29124>; else goto <D.29125>;
            <D.29124>:
            D.29122 = req->modifiers[i].data.filter;
            D.29126 = D.29122 | 4;
            req->modifiers[i].data.filter = D.29126;
            <D.29125>:
            <D.29118>:
            goto <D.29127>;
            <D.29106>:
            if (mod == 3) goto <D.29128>; else goto <D.29129>;
            <D.29128>:
            {
              int id;

              p.171 = p;
              id = decode_id (p.171, &p, end);
              D.29130 = &req->modifiers[i].data.thread;
              D.29131 = get_object (id, D.29130);
              err.179 = (int) D.29131;
              err = err.179;
              err.174 = err;
              if (err.174 != 0) goto <D.29133>; else goto <D.29134>;
              <D.29133>:
              monoeg_g_free (req);
              err.174 = err;
              D.29102 = (ErrorCode) err.174;
              return D.29102;
              <D.29134>:
            }
            goto <D.29135>;
            <D.29129>:
            if (mod == 8) goto <D.29136>; else goto <D.29137>;
            <D.29136>:
            {
              struct MonoClass * exc_class;

              p.171 = p;
              exc_class = decode_typeid (p.171, &p, end, &domain, &err);
              err.174 = err;
              if (err.174 != 0) goto <D.29138>; else goto <D.29139>;
              <D.29138>:
              err.174 = err;
              D.29102 = (ErrorCode) err.174;
              return D.29102;
              <D.29139>:
              p.171 = p;
              D.29140 = decode_byte (p.171, &p, end);
              req->modifiers[i].caught = D.29140;
              p.171 = p;
              D.29141 = decode_byte (p.171, &p, end);
              req->modifiers[i].uncaught = D.29141;
              protocol_version_set.175 = protocol_version_set;
              if (protocol_version_set.175 != 0) goto <D.29145>; else goto <D.29142>;
              <D.29145>:
              major_version.176 = major_version;
              if (major_version.176 > 2) goto <D.29143>; else goto <D.29146>;
              <D.29146>:
              major_version.176 = major_version;
              if (major_version.176 == 2) goto <D.29147>; else goto <D.29142>;
              <D.29147>:
              minor_version.177 = minor_version;
              if (minor_version.177 > 24) goto <D.29143>; else goto <D.29142>;
              <D.29143>:
              p.171 = p;
              D.29148 = decode_byte (p.171, &p, end);
              req->modifiers[i].subclasses = D.29148;
              goto <D.29144>;
              <D.29142>:
              req->modifiers[i].subclasses = 1;
              <D.29144>:
              log_level.180 = log_level;
              D.29150 = log_level.180 > 0;
              D.29151 = (long int) D.29150;
              D.29152 = __builtin_expect (D.29151, 0);
              if (D.29152 != 0) goto <D.29153>; else goto <D.29154>;
              <D.29153>:
              D.29156 = req->modifiers[i].subclasses;
              if (D.29156 != 0) goto <D.29157>; else goto <D.29158>;
              <D.29157>:
              iftmp.181 = ", include-subclasses";
              goto <D.29159>;
              <D.29158>:
              iftmp.181 = "";
              <D.29159>:
              D.29161 = req->modifiers[i].uncaught;
              if (D.29161 != 0) goto <D.29162>; else goto <D.29163>;
              <D.29162>:
              iftmp.182 = ", uncaught";
              goto <D.29164>;
              <D.29163>:
              iftmp.182 = "";
              <D.29164>:
              D.29166 = req->modifiers[i].caught;
              if (D.29166 != 0) goto <D.29167>; else goto <D.29168>;
              <D.29167>:
              iftmp.183 = ", caught";
              goto <D.29169>;
              <D.29168>:
              iftmp.183 = "";
              <D.29169>:
              if (exc_class != 0B) goto <D.29171>; else goto <D.29172>;
              <D.29171>:
              iftmp.184 = exc_class->name;
              goto <D.29173>;
              <D.29172>:
              iftmp.184 = "all";
              <D.29173>:
              log_file.185 = log_file;
              fprintf (log_file.185, "[dbg] \tEXCEPTION_ONLY filter (%s%s%s%s).\n", iftmp.184, iftmp.183, iftmp.182, iftmp.181);
              log_file.185 = log_file;
              fflush (log_file.185);
              <D.29154>:
              if (exc_class != 0B) goto <D.29175>; else goto <D.29176>;
              <D.29175>:
              req->modifiers[i].data.exc_class = exc_class;
              D.29177 = mono_defaults.exception_class;
              D.29178 = mono_class_is_assignable_from (D.29177, exc_class);
              if (D.29178 == 0) goto <D.29179>; else goto <D.29180>;
              <D.29179>:
              monoeg_g_free (req);
              D.29102 = 102;
              return D.29102;
              <D.29180>:
              <D.29176>:
            }
            goto <D.29181>;
            <D.29137>:
            if (mod == 11) goto <D.29182>; else goto <D.29183>;
            <D.29182>:
            {
              int n;
              int j;

              p.171 = p;
              n = decode_int (p.171, &p, end);
              n.186 = (unsigned int) n;
              D.29185 = n.186 * 4;
              D.29186 = monoeg_malloc0 (D.29185);
              req->modifiers[i].data.assemblies = D.29186;
              j = 0;
              goto <D.26743>;
              <D.26742>:
              D.29187 = req->modifiers[i].data.assemblies;
              j.187 = (unsigned int) j;
              D.29189 = j.187 * 4;
              D.29190 = D.29187 + D.29189;
              p.171 = p;
              D.29191 = decode_assemblyid (p.171, &p, end, &domain, &err);
              *D.29190 = D.29191;
              err.174 = err;
              if (err.174 != 0) goto <D.29192>; else goto <D.29193>;
              <D.29192>:
              D.29187 = req->modifiers[i].data.assemblies;
              monoeg_g_free (D.29187);
              err.174 = err;
              D.29102 = (ErrorCode) err.174;
              return D.29102;
              <D.29193>:
              j = j + 1;
              <D.26743>:
              if (j < n) goto <D.26742>; else goto <D.26744>;
              <D.26744>:
            }
            goto <D.29194>;
            <D.29183>:
            if (mod == 12) goto <D.29195>; else goto <D.29196>;
            <D.29195>:
            {
              int n;
              int j;

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

                p.171 = p;
                s = decode_string (p.171, &p, end);
                if (s != 0B) goto <D.29198>; else goto <D.29199>;
                <D.29198>:
                s2 = strdup_tolower (s);
                D.29200 = modifier->data.source_files;
                monoeg_g_hash_table_insert_replace (D.29200, s2, s2, 0);
                monoeg_g_free (s);
                <D.29199>:
              }
              j = j + 1;
              <D.26750>:
              if (j < n) goto <D.26749>; else goto <D.26751>;
              <D.26751>:
            }
            goto <D.29201>;
            <D.29196>:
            if (mod == 13) goto <D.29202>; else goto <D.29203>;
            <D.29202>:
            {
              int n;
              int j;

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

                p.171 = p;
                s = decode_string (p.171, &p, end);
                if (s != 0B) goto <D.29205>; else goto <D.29206>;
                <D.29205>:
                D.29207 = modifier->data.type_names;
                monoeg_g_hash_table_insert_replace (D.29207, s, s, 0);
                <D.29206>:
              }
              j = j + 1;
              <D.26756>:
              if (j < n) goto <D.26755>; else goto <D.26757>;
              <D.26757>:
            }
            goto <D.29208>;
            <D.29203>:
            monoeg_g_free (req);
            D.29102 = 100;
            return D.29102;
            <D.29208>:
            <D.29201>:
            <D.29194>:
            <D.29181>:
            <D.29135>:
            <D.29127>:
            <D.29104>:
            <D.29096>:
            i = i + 1;
            <D.26759>:
            if (i < nmodifiers) goto <D.26758>; else goto <D.26760>;
            <D.26760>:
            D.29209 = req->event_kind;
            if (D.29209 == 10) goto <D.29210>; else goto <D.29211>;
            <D.29210>:
            D.29212 = method == 0B;
            D.29213 = (long int) D.29212;
            D.29214 = __builtin_expect (D.29213, 0);
            if (D.29214 != 0) goto <D.29215>; else goto <D.29216>;
            <D.29215>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 7086, "method");
            <D.29216>:
            D.29217 = set_breakpoint (method, location, req, &error);
            req->info = D.29217;
            D.29218 = mono_error_ok (&error);
            if (D.29218 == 0) goto <D.29219>; else goto <D.29220>;
            <D.29219>:
            monoeg_g_free (req);
            log_level.180 = log_level;
            D.29150 = log_level.180 > 0;
            D.29151 = (long int) D.29150;
            D.29152 = __builtin_expect (D.29151, 0);
            if (D.29152 != 0) goto <D.29221>; else goto <D.29222>;
            <D.29221>:
            D.29223 = mono_error_get_message (&error);
            log_file.185 = log_file;
            fprintf (log_file.185, "[dbg] Failed to set breakpoint: %s\n", D.29223);
            log_file.185 = log_file;
            fflush (log_file.185);
            <D.29222>:
            mono_error_cleanup (&error);
            D.29102 = 106;
            return D.29102;
            <D.29220>:
            goto <D.29224>;
            <D.29211>:
            D.29209 = req->event_kind;
            if (D.29209 == 11) goto <D.29225>; else goto <D.29226>;
            <D.29225>:
            D.29227 = step_thread_id == 0;
            D.29228 = (long int) D.29227;
            D.29229 = __builtin_expect (D.29228, 0);
            if (D.29229 != 0) goto <D.29230>; else goto <D.29231>;
            <D.29230>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 7096, "step_thread_id");
            <D.29231>:
            D.29232 = get_object (step_thread_id, &step_thread);
            err.188 = (int) D.29232;
            err = err.188;
            err.174 = err;
            if (err.174 != 0) goto <D.29234>; else goto <D.29235>;
            <D.29234>:
            monoeg_g_free (req);
            err.174 = err;
            D.29102 = (ErrorCode) err.174;
            return D.29102;
            <D.29235>:
            depth.189 = (<unnamed type>) depth;
            size.190 = (<unnamed type>) size;
            step_thread.191 = step_thread;
            D.29239 = step_thread.191->internal_thread;
            D.29240 = ss_create (D.29239, size.190, depth.189, req);
            err.192 = (int) D.29240;
            err = err.192;
            err.174 = err;
            if (err.174 != 0) goto <D.29242>; else goto <D.29243>;
            <D.29242>:
            monoeg_g_free (req);
            err.174 = err;
            D.29102 = (ErrorCode) err.174;
            return D.29102;
            <D.29243>:
            goto <D.29244>;
            <D.29226>:
            D.29209 = req->event_kind;
            if (D.29209 == 6) goto <D.29245>; else goto <D.29246>;
            <D.29245>:
            D.29247 = set_breakpoint (0B, -1, req, 0B);
            req->info = D.29247;
            goto <D.29248>;
            <D.29246>:
            D.29209 = req->event_kind;
            if (D.29209 == 7) goto <D.29249>; else goto <D.29250>;
            <D.29249>:
            D.29251 = set_breakpoint (0B, 16777215, req, 0B);
            req->info = D.29251;
            goto <D.29252>;
            <D.29250>:
            D.29209 = req->event_kind;
            if (D.29209 == 13) goto <D.29253>; else goto <D.29254>;
            <D.29253>:
            goto <D.29255>;
            <D.29254>:
            D.29209 = req->event_kind;
            if (D.29209 == 12) goto <D.29256>; else goto <D.29257>;
            <D.29256>:
            goto <D.29258>;
            <D.29257>:
            D.29259 = req->nmodifiers;
            if (D.29259 != 0) goto <D.29260>; else goto <D.29261>;
            <D.29260>:
            monoeg_g_free (req);
            D.29102 = 100;
            return D.29102;
            <D.29261>:
            <D.29258>:
            <D.29255>:
            <D.29252>:
            <D.29248>:
            <D.29244>:
            <D.29224>:
            mono_loader_lock ();
            event_requests.193 = event_requests;
            monoeg_g_ptr_array_add (event_requests.193, req);
            D.29263 = agent_config.defer;
            if (D.29263 != 0) goto <D.29264>; else goto <D.29265>;
            <D.29264>:
            D.29209 = req->event_kind;
            switch (D.29209) <default: <D.26766>, case 2: <D.26764>, case 4: <D.26761>, case 8: <D.26763>, case 12: <D.26765>>
            <D.26761>:
            domains.194 = domains;
            monoeg_g_hash_table_foreach (domains.194, emit_appdomain_load, 0B);
            goto <D.26762>;
            <D.26763>:
            mono_assembly_foreach (emit_assembly_load, 0B);
            goto <D.26762>;
            <D.26764>:
            tid_to_thread.195 = tid_to_thread;
            mono_g_hash_table_foreach (tid_to_thread.195, emit_thread_start, 0B);
            goto <D.26762>;
            <D.26765>:
            mono_domain_foreach (send_types_for_domain, 0B);
            goto <D.26762>;
            <D.26766>:
            goto <D.26762>;
            <D.26762>:
            <D.29265>:
            mono_loader_unlock ();
            D.29268 = req->id;
            D.29269 = (unsigned int) D.29268;
            buffer_add_int (buf, D.29269);
            goto <D.26767>;
          }
        finally
          {
            step_thread = {CLOBBER};
            domain = {CLOBBER};
          }
      }
      <D.26768>:
      {
        int etype;
        int req_id;

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

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

          event_requests.193 = event_requests;
          D.29270 = event_requests.193->pdata;
          i.196 = (unsigned int) i;
          D.29272 = i.196 * 4;
          D.29273 = D.29270 + D.29272;
          req = *D.29273;
          D.29274 = req->event_kind;
          if (D.29274 == 10) goto <D.29275>; else goto <D.29276>;
          <D.29275>:
          D.29277 = req->info;
          clear_breakpoint (D.29277);
          i.197 = (unsigned int) i;
          event_requests.193 = event_requests;
          monoeg_g_ptr_array_remove_index_fast (event_requests.193, i.197);
          monoeg_g_free (req);
          goto <D.29279>;
          <D.29276>:
          i = i + 1;
          <D.29279>:
        }
        <D.26775>:
        i.197 = (unsigned int) i;
        event_requests.193 = event_requests;
        D.29280 = event_requests.193->len;
        if (i.197 < D.29280) goto <D.26774>; else goto <D.26776>;
        <D.26776>:
        mono_loader_unlock ();
        goto <D.26767>;
      }
      <D.26777>:
      D.29102 = 100;
      return D.29102;
      <D.26767>:
      D.29102 = 0;
      return D.29102;
    }
  finally
    {
      err = {CLOBBER};
      error = {CLOBBER};
    }
}


send_types_for_domain (struct MonoDomain * domain, void * user_data)
{
  union mono_mutex_t * D.29286;
  _Bool D.29289;
  long int D.29290;
  long int D.29291;
  _Bool D.29294;
  long int D.29295;
  long int D.29296;
  struct GHashTable * D.29299;
  _Bool D.29302;
  long int D.29303;
  long int D.29304;
  struct AgentDomainInfo * info;

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

    D.29286 = &domain->lock.mutex;
    ret = pthread_mutex_lock (D.29286);
    if (ret != 0) goto <D.29287>; else goto <D.29288>;
    <D.29287>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.29288>:
    D.29289 = ret != 0;
    D.29290 = (long int) D.29289;
    D.29291 = __builtin_expect (D.29290, 0);
    if (D.29291 != 0) goto <D.29292>; else goto <D.29293>;
    <D.29292>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 4009, "ret == 0");
    <D.29293>:
  }
  info = get_agent_domain_info (domain);
  D.29294 = info == 0B;
  D.29295 = (long int) D.29294;
  D.29296 = __builtin_expect (D.29295, 0);
  if (D.29296 != 0) goto <D.29297>; else goto <D.29298>;
  <D.29297>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 4011, "info");
  <D.29298>:
  D.29299 = info->loaded_classes;
  monoeg_g_hash_table_foreach (D.29299, emit_type_load, 0B);
  {
    int ret;

    D.29286 = &domain->lock.mutex;
    ret = pthread_mutex_unlock (D.29286);
    if (ret != 0) goto <D.29300>; else goto <D.29301>;
    <D.29300>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.29301>:
    D.29302 = ret != 0;
    D.29303 = (long int) D.29302;
    D.29304 = __builtin_expect (D.29303, 0);
    if (D.29304 != 0) goto <D.29305>; else goto <D.29306>;
    <D.29305>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 4013, "ret == 0");
    <D.29306>:
  }
  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)
{
  unsigned int key.198;
  unsigned int debugger_thread_id.199;

  key.198 = (unsigned int) key;
  debugger_thread_id.199 = debugger_thread_id;
  if (key.198 != debugger_thread_id.199) goto <D.29309>; else goto <D.29310>;
  <D.29309>:
  process_profiler_event (2, value);
  <D.29310>:
}


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.29311;
  struct GHashTable * D.29312;

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


InterlockedIncrement (volatile gint32 * val)
{
  gint32 D.29313;
  unsigned int D.29314;

  D.29314 = __sync_add_and_fetch_4 (val, 1);
  D.29313 = (gint32) D.29314;
  return D.29313;
}


decode_methodid (guint8 * buf, guint8 * * endbuf, guint8 * limit, struct MonoDomain * * domain, int * err)
{
  int log_level.200;
  _Bool D.29317;
  long int D.29318;
  long int D.29319;
  struct FILE * log_file.201;
  struct MonoMethod * D.29327;
  struct MonoMethod * m;

  m = decode_ptr_id (buf, endbuf, limit, 3, domain, err);
  log_level.200 = log_level;
  D.29317 = log_level.200 > 1;
  D.29318 = (long int) D.29317;
  D.29319 = __builtin_expect (D.29318, 0);
  if (D.29319 != 0) goto <D.29320>; else goto <D.29321>;
  <D.29320>:
  if (m != 0B) goto <D.29322>; else goto <D.29323>;
  <D.29322>:
  {
    char * s;

    s = mono_method_full_name (m, 1);
    log_level.200 = log_level;
    D.29317 = log_level.200 > 1;
    D.29318 = (long int) D.29317;
    D.29319 = __builtin_expect (D.29318, 0);
    if (D.29319 != 0) goto <D.29324>; else goto <D.29325>;
    <D.29324>:
    log_file.201 = log_file;
    fprintf (log_file.201, "[dbg]   recv method [%s]\n", s);
    log_file.201 = log_file;
    fflush (log_file.201);
    <D.29325>:
    monoeg_g_free (s);
  }
  <D.29323>:
  <D.29321>:
  D.29327 = m;
  return D.29327;
}


decode_ptr_id (guint8 * buf, guint8 * * endbuf, guint8 * limit, IdType type, struct MonoDomain * * domain, int * err)
{
  void * D.29333;
  int iftmp.202;
  unsigned int id.203;
  struct GPtrArray * D.29340;
  unsigned int D.29341;
  _Bool D.29342;
  long int D.29343;
  long int D.29344;
  void * * D.29347;
  sizetype id.204;
  sizetype D.29349;
  sizetype D.29350;
  void * * D.29351;
  struct MonoDomain * D.29352;
  struct Id * res;
  int id;

  id = decode_id (buf, endbuf, limit);
  *err = 0;
  if (domain != 0B) goto <D.29329>; else goto <D.29330>;
  <D.29329>:
  *domain = 0B;
  <D.29330>:
  if (id == 0) goto <D.29331>; else goto <D.29332>;
  <D.29331>:
  D.29333 = 0B;
  return D.29333;
  <D.29332>:
  mono_loader_lock ();
  if (id <= 0) goto <D.29335>; else goto <D.29338>;
  <D.29338>:
  id.203 = (unsigned int) id;
  D.29340 = ids[type];
  D.29341 = D.29340->len;
  if (id.203 > D.29341) goto <D.29335>; else goto <D.29336>;
  <D.29335>:
  iftmp.202 = 1;
  goto <D.29337>;
  <D.29336>:
  iftmp.202 = 0;
  <D.29337>:
  D.29342 = iftmp.202 != 0;
  D.29343 = (long int) D.29342;
  D.29344 = __builtin_expect (D.29343, 0);
  if (D.29344 != 0) goto <D.29345>; else goto <D.29346>;
  <D.29345>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 2196, "id > 0 && id <= ids [type]->len");
  <D.29346>:
  D.29340 = ids[type];
  D.29347 = D.29340->pdata;
  id.204 = (sizetype) id;
  D.29349 = id.204 + 1073741823;
  D.29350 = D.29349 * 4;
  D.29351 = D.29347 + D.29350;
  res = *D.29351;
  mono_loader_unlock ();
  D.29352 = res->domain;
  if (D.29352 == 0B) goto <D.29353>; else goto <D.29354>;
  <D.29353>:
  *err = 103;
  D.29333 = 0B;
  return D.29333;
  <D.29354>:
  if (domain != 0B) goto <D.29355>; else goto <D.29356>;
  <D.29355>:
  D.29352 = res->domain;
  *domain = D.29352;
  <D.29356>:
  D.29333 = res->data.val;
  return D.29333;
}


decode_long (guint8 * buf, guint8 * * endbuf, guint8 * limit)
{
  guint8 * buf.205;
  int D.29359;
  int D.29360;
  gint64 D.29361;
  long long unsigned int D.29362;
  long long unsigned int D.29363;
  long long unsigned int D.29364;
  long long unsigned int D.29365;
  guint32 high;
  guint32 low;

  buf.205 = buf;
  D.29359 = decode_int (buf.205, &buf, limit);
  high = (guint32) D.29359;
  buf.205 = buf;
  D.29360 = decode_int (buf.205, &buf, limit);
  low = (guint32) D.29360;
  buf.205 = buf;
  *endbuf = buf.205;
  D.29362 = (long long unsigned int) high;
  D.29363 = D.29362 << 32;
  D.29364 = (long long unsigned int) low;
  D.29365 = D.29363 | D.29364;
  D.29361 = (gint64) D.29365;
  return D.29361;
}


decode_typeid (guint8 * buf, guint8 * * endbuf, guint8 * limit, struct MonoDomain * * domain, int * err)
{
  int log_level.206;
  _Bool D.29368;
  long int D.29369;
  long int D.29370;
  struct MonoType * D.29375;
  struct FILE * log_file.207;
  struct MonoClass * D.29379;
  struct MonoClass * klass;

  klass = decode_ptr_id (buf, endbuf, limit, 2, domain, err);
  log_level.206 = log_level;
  D.29368 = log_level.206 > 1;
  D.29369 = (long int) D.29368;
  D.29370 = __builtin_expect (D.29369, 0);
  if (D.29370 != 0) goto <D.29371>; else goto <D.29372>;
  <D.29371>:
  if (klass != 0B) goto <D.29373>; else goto <D.29374>;
  <D.29373>:
  {
    char * s;

    D.29375 = &klass->byval_arg;
    s = mono_type_full_name (D.29375);
    log_level.206 = log_level;
    D.29368 = log_level.206 > 1;
    D.29369 = (long int) D.29368;
    D.29370 = __builtin_expect (D.29369, 0);
    if (D.29370 != 0) goto <D.29376>; else goto <D.29377>;
    <D.29376>:
    log_file.207 = log_file;
    fprintf (log_file.207, "[dbg]   recv class [%s]\n", s);
    log_file.207 = log_file;
    fflush (log_file.207);
    <D.29377>:
    monoeg_g_free (s);
  }
  <D.29374>:
  <D.29372>:
  D.29379 = klass;
  return D.29379;
}


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

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


ss_create (struct MonoInternalThread * thread, StepSize size, StepDepth depth, struct EventRequest * req)
{
  int suspend_count.208;
  ErrorCode D.29386;
  struct SingleStepReq * ss_req.209;
  int log_level.210;
  _Bool D.29391;
  long int D.29392;
  long int D.29393;
  struct FILE * log_file.211;
  _Bool D.29397;
  long int D.29398;
  long int D.29399;
  const char * D.29402;
  void * ss_req.212;
  struct MonoGHashTable * thread_to_tls.213;
  _Bool D.29405;
  long int D.29406;
  long int D.29407;
  int D.29410;
  _Bool D.29411;
  long int D.29412;
  long int D.29413;
  int D.29416;
  void * D.29417;
  void * D.29418;
  int D.29419;
  struct MonoContext * D.29422;
  void * D.29423;
  void * D.29424;
  _Bool D.29425;
  long int D.29426;
  long int D.29427;
  <unnamed type> D.29430;
  _Bool D.29431;
  long int D.29432;
  long int D.29433;
  int D.29436;
  struct MonoMethod * D.29437;
  struct MonoDomain * D.29438;
  _Bool D.29441;
  long int D.29442;
  long int D.29443;
  <unnamed type> D.29448;
  int D.29451;
  struct StackFrame * * D.29454;
  struct MonoMethod * D.29455;
  unsigned int D.29458;
  unsigned int D.29463;
  int D.29464;
  unsigned int D.29471;
  unsigned int D.29474;
  int D.29475;
  struct MonoMethod * D.29476;
  struct MonoDomain * D.29477;
  struct MonoContext * D.29482;
  struct MonoSeqPointInfo * info.214;
  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.208 = suspend_count;
      if (suspend_count.208 == 0) goto <D.29384>; else goto <D.29385>;
      <D.29384>:
      D.29386 = 101;
      return D.29386;
      <D.29385>:
      wait_for_suspend ();
      ss_req.209 = ss_req;
      if (ss_req.209 != 0B) goto <D.29388>; else goto <D.29389>;
      <D.29388>:
      log_level.210 = log_level;
      D.29391 = log_level.210 >= 0;
      D.29392 = (long int) D.29391;
      D.29393 = __builtin_expect (D.29392, 0);
      if (D.29393 != 0) goto <D.29394>; else goto <D.29395>;
      <D.29394>:
      log_file.211 = log_file;
      fprintf (log_file.211, "Received a single step request while the previous one was still active.\n");
      log_file.211 = log_file;
      fflush (log_file.211);
      <D.29395>:
      D.29386 = 100;
      return D.29386;
      <D.29389>:
      log_level.210 = log_level;
      D.29397 = log_level.210 > 0;
      D.29398 = (long int) D.29397;
      D.29399 = __builtin_expect (D.29398, 0);
      if (D.29399 != 0) goto <D.29400>; else goto <D.29401>;
      <D.29400>:
      D.29402 = ss_depth_to_string (depth);
      log_file.211 = log_file;
      fprintf (log_file.211, "[dbg] Starting single step of thread %p (depth=%s).\n", thread, D.29402);
      log_file.211 = log_file;
      fflush (log_file.211);
      <D.29401>:
      ss_req.212 = monoeg_malloc0 (48);
      ss_req = ss_req.212;
      ss_req.209 = ss_req;
      ss_req.209->req = req;
      ss_req.209 = ss_req;
      ss_req.209->thread = thread;
      ss_req.209 = ss_req;
      ss_req.209->size = size;
      ss_req.209 = ss_req;
      ss_req.209->depth = depth;
      ss_req.209 = ss_req;
      req->info = ss_req.209;
      mono_loader_lock ();
      thread_to_tls.213 = thread_to_tls;
      tls = mono_g_hash_table_lookup (thread_to_tls.213, thread);
      mono_loader_unlock ();
      D.29405 = tls == 0B;
      D.29406 = (long int) D.29405;
      D.29407 = __builtin_expect (D.29406, 0);
      if (D.29407 != 0) goto <D.29408>; else goto <D.29409>;
      <D.29408>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 5168, "tls");
      <D.29409>:
      D.29410 = tls->context.valid;
      D.29411 = D.29410 == 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>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 5169, "tls->context.valid");
      <D.29415>:
      ss_req.209 = ss_req;
      ss_req.209 = ss_req;
      D.29416 = tls->context.ctx.esp;
      D.29417 = (void *) D.29416;
      ss_req.209->last_sp = D.29417;
      D.29418 = ss_req.209->last_sp;
      ss_req.209->start_sp = D.29418;
      D.29419 = tls->catch_state.valid;
      if (D.29419 != 0) goto <D.29420>; else goto <D.29421>;
      <D.29420>:
      {
        gboolean res;
        struct StackFrameInfo frame;
        struct MonoContext new_ctx;
        struct MonoLMF * lmf;

        try
          {
            lmf = 0B;
            D.29422 = &tls->catch_state.ctx;
            D.29423 = thread->jit_data;
            D.29424 = tls->catch_state.unwind_data[0];
            res = mono_find_jit_info_ext (D.29424, D.29423, 0B, D.29422, &new_ctx, 0B, &lmf, 0B, &frame);
            D.29425 = res == 0;
            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", 5184, "res");
            <D.29429>:
            D.29430 = frame.type;
            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", 5185, "frame.type == FRAME_TYPE_MANAGED");
            <D.29435>:
            D.29436 = frame.native_offset;
            D.29437 = frame.method;
            D.29438 = frame.domain;
            sp = find_next_seq_point_for_native_offset (D.29438, D.29437, D.29436, &info);
            if (sp == 0B) goto <D.29439>; else goto <D.29440>;
            <D.29439>:
            D.29437 = frame.method;
            no_seq_points_found (D.29437);
            <D.29440>:
            D.29441 = sp == 0B;
            D.29442 = (long int) D.29441;
            D.29443 = __builtin_expect (D.29442, 0);
            if (D.29443 != 0) goto <D.29444>; else goto <D.29445>;
            <D.29444>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 5194, "sp");
            <D.29445>:
            method = frame.method;
            step_to_catch = 1;
            ss_req.209 = ss_req;
            ss_req.209->last_sp = 0B;
          }
        finally
          {
            frame = {CLOBBER};
            new_ctx = {CLOBBER};
            lmf = {CLOBBER};
          }
      }
      <D.29421>:
      if (step_to_catch == 0) goto <D.29446>; else goto <D.29447>;
      <D.29446>:
      ss_req.209 = ss_req;
      D.29448 = ss_req.209->size;
      if (D.29448 == 1) goto <D.29449>; else goto <D.29450>;
      <D.29449>:
      {
        struct StackFrame * frame;

        compute_frame_info (thread, tls);
        D.29451 = tls->frame_count;
        if (D.29451 != 0) goto <D.29452>; else goto <D.29453>;
        <D.29452>:
        D.29454 = tls->frames;
        frame = *D.29454;
        ss_req.209 = ss_req;
        D.29455 = frame->method;
        ss_req.209->last_method = D.29455;
        ss_req.209 = ss_req;
        ss_req.209->last_line = -1;
        D.29455 = frame->method;
        minfo = mono_debug_lookup_method (D.29455);
        if (minfo != 0B) goto <D.29456>; else goto <D.29457>;
        <D.29456>:
        D.29458 = frame->il_offset;
        if (D.29458 != 4294967295) goto <D.29459>; else goto <D.29460>;
        <D.29459>:
        {
          struct MonoDebugSourceLocation * loc;

          D.29458 = frame->il_offset;
          loc = mono_debug_symfile_lookup_location (minfo, D.29458);
          if (loc != 0B) goto <D.29461>; else goto <D.29462>;
          <D.29461>:
          ss_req.209 = ss_req;
          D.29463 = loc->row;
          D.29464 = (int) D.29463;
          ss_req.209->last_line = D.29464;
          monoeg_g_free (loc);
          <D.29462>:
        }
        <D.29460>:
        <D.29457>:
        <D.29453>:
      }
      <D.29450>:
      <D.29447>:
      if (step_to_catch == 0) goto <D.29465>; else goto <D.29466>;
      <D.29465>:
      {
        struct StackFrame * frame;

        compute_frame_info (thread, tls);
        D.29451 = tls->frame_count;
        if (D.29451 != 0) goto <D.29467>; else goto <D.29468>;
        <D.29467>:
        D.29454 = tls->frames;
        frame = *D.29454;
        if (method == 0B) goto <D.29469>; else goto <D.29470>;
        <D.29469>:
        D.29471 = frame->il_offset;
        if (D.29471 != 4294967295) goto <D.29472>; else goto <D.29473>;
        <D.29472>:
        D.29474 = frame->native_offset;
        D.29475 = (int) D.29474;
        D.29476 = frame->method;
        D.29477 = frame->domain;
        sp = find_prev_seq_point_for_native_offset (D.29477, D.29476, D.29475, &info);
        if (sp == 0B) goto <D.29478>; else goto <D.29479>;
        <D.29478>:
        D.29476 = frame->method;
        no_seq_points_found (D.29476);
        <D.29479>:
        D.29441 = sp == 0B;
        D.29442 = (long int) D.29441;
        D.29443 = __builtin_expect (D.29442, 0);
        if (D.29443 != 0) goto <D.29480>; else goto <D.29481>;
        <D.29480>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 5240, "sp");
        <D.29481>:
        method = frame->method;
        <D.29473>:
        <D.29470>:
        <D.29468>:
      }
      <D.29466>:
      D.29482 = &tls->context.ctx;
      info.214 = info;
      ss_req.209 = ss_req;
      ss_start (ss_req.209, method, sp, info.214, D.29482, tls, step_to_catch);
      D.29386 = 0;
      return D.29386;
    }
  finally
    {
      info = {CLOBBER};
    }
}


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

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


find_next_seq_point_for_native_offset (struct MonoDomain * domain, struct MonoMethod * method, gint32 native_offset, struct MonoSeqPointInfo * * info)
{
  struct SeqPoint * D.29492;
  _Bool D.29493;
  long int D.29494;
  long int D.29495;
  int D.29500;
  int D.29503;
  struct MonoSeqPointInfo * seq_points;
  int i;

  seq_points = get_seq_points (domain, method);
  if (seq_points == 0B) goto <D.29488>; else goto <D.29489>;
  <D.29488>:
  if (info != 0B) goto <D.29490>; else goto <D.29491>;
  <D.29490>:
  *info = 0B;
  <D.29491>:
  D.29492 = 0B;
  return D.29492;
  <D.29489>:
  D.29493 = seq_points == 0B;
  D.29494 = (long int) D.29493;
  D.29495 = __builtin_expect (D.29494, 0);
  if (D.29495 != 0) goto <D.29496>; else goto <D.29497>;
  <D.29496>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 3028, "seq_points");
  <D.29497>:
  if (info != 0B) goto <D.29498>; else goto <D.29499>;
  <D.29498>:
  *info = seq_points;
  <D.29499>:
  i = 0;
  goto <D.25469>;
  <D.25468>:
  D.29500 = seq_points->seq_points[i].native_offset;
  if (D.29500 >= native_offset) goto <D.29501>; else goto <D.29502>;
  <D.29501>:
  D.29492 = &seq_points->seq_points[i];
  return D.29492;
  <D.29502>:
  i = i + 1;
  <D.25469>:
  D.29503 = seq_points->len;
  if (D.29503 > i) goto <D.25468>; else goto <D.25470>;
  <D.25470>:
  D.29492 = 0B;
  return D.29492;
}


get_seq_points (struct MonoDomain * domain, struct MonoMethod * method)
{
  union mono_mutex_t * D.29505;
  _Bool D.29508;
  long int D.29509;
  long int D.29510;
  void * D.29513;
  struct GHashTable * D.29514;
  unsigned char D.29517;
  unsigned char D.29518;
  struct MonoMethod * D.29521;
  struct MonoMethod * D.29524;
  _Bool D.29527;
  long int D.29528;
  long int D.29529;
  struct MonoSeqPointInfo * D.29532;
  struct MonoSeqPointInfo * seq_points;

  {
    int ret;

    D.29505 = &domain->lock.mutex;
    ret = pthread_mutex_lock (D.29505);
    if (ret != 0) goto <D.29506>; else goto <D.29507>;
    <D.29506>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.29507>:
    D.29508 = ret != 0;
    D.29509 = (long int) D.29508;
    D.29510 = __builtin_expect (D.29509, 0);
    if (D.29510 != 0) goto <D.29511>; else goto <D.29512>;
    <D.29511>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 2989, "ret == 0");
    <D.29512>:
  }
  D.29513 = domain->runtime_info;
  D.29514 = MEM[(struct MonoJitDomainInfo *)D.29513].seq_points;
  seq_points = monoeg_g_hash_table_lookup (D.29514, method);
  if (seq_points == 0B) goto <D.29515>; else goto <D.29516>;
  <D.29515>:
  D.29517 = BIT_FIELD_REF <*method, 8, 168>;
  D.29518 = D.29517 & 16;
  if (D.29518 != 0) goto <D.29519>; else goto <D.29520>;
  <D.29519>:
  D.29521 = mono_method_get_declaring_generic_method (method);
  D.29513 = domain->runtime_info;
  D.29514 = MEM[(struct MonoJitDomainInfo *)D.29513].seq_points;
  seq_points = monoeg_g_hash_table_lookup (D.29514, D.29521);
  if (seq_points == 0B) goto <D.29522>; else goto <D.29523>;
  <D.29522>:
  D.29524 = mini_get_shared_method (method);
  D.29513 = domain->runtime_info;
  D.29514 = MEM[(struct MonoJitDomainInfo *)D.29513].seq_points;
  seq_points = monoeg_g_hash_table_lookup (D.29514, D.29524);
  <D.29523>:
  <D.29520>:
  <D.29516>:
  {
    int ret;

    D.29505 = &domain->lock.mutex;
    ret = pthread_mutex_unlock (D.29505);
    if (ret != 0) goto <D.29525>; else goto <D.29526>;
    <D.29525>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.29526>:
    D.29527 = ret != 0;
    D.29528 = (long int) D.29527;
    D.29529 = __builtin_expect (D.29528, 0);
    if (D.29529 != 0) goto <D.29530>; else goto <D.29531>;
    <D.29530>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 2997, "ret == 0");
    <D.29531>:
  }
  D.29532 = seq_points;
  return D.29532;
}


compute_frame_info (struct MonoInternalThread * thread, struct DebuggerTlsData * tls)
{
  struct StackFrame * * D.29534;
  int D.29537;
  int log_level.215;
  _Bool D.29541;
  long int D.29542;
  long int D.29543;
  long long unsigned int D.29546;
  long int D.29547;
  struct FILE * log_file.216;
  int D.29549;
  int D.29554;
  int D.29556;
  struct StackFrameInfo * D.29558;
  struct MonoThreadUnwindState * D.29559;
  int D.29560;
  int D.29563;
  struct MonoThreadUnwindState * D.29566;
  struct MonoThreadUnwindState * D.29567;
  struct GSList * D.29572;
  unsigned int D.29573;
  unsigned int new_frame_count.217;
  unsigned int D.29575;
  unsigned int i.218;
  unsigned int D.29577;
  struct StackFrame * * D.29578;
  struct StackFrame * D.29579;
  int D.29580;
  void * D.29581;
  int D.29582;
  void * D.29583;
  int D.29586;
  int D.29587;
  int D.29590;
  int findex.219;
  unsigned int findex.220;
  unsigned int D.29593;
  struct StackFrame * * D.29594;
  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.29534 = tls->frames;
      if (D.29534 != 0B) goto <D.29535>; else goto <D.29536>;
      <D.29535>:
      D.29537 = tls->frames_up_to_date;
      if (D.29537 != 0) goto <D.29538>; else goto <D.29539>;
      <D.29538>:
      return;
      <D.29539>:
      <D.29536>:
      log_level.215 = log_level;
      D.29541 = log_level.215 > 0;
      D.29542 = (long int) D.29541;
      D.29543 = __builtin_expect (D.29542, 0);
      if (D.29543 != 0) goto <D.29544>; else goto <D.29545>;
      <D.29544>:
      D.29546 = thread->tid;
      D.29547 = (long int) D.29546;
      log_file.216 = log_file;
      fprintf (log_file.216, "Frames for %p(tid=%lx):\n", thread, D.29547);
      log_file.216 = log_file;
      fflush (log_file.216);
      <D.29545>:
      user_data.tls = tls;
      user_data.frames = 0B;
      D.29549 = tls->terminated;
      if (D.29549 != 0) goto <D.29550>; else goto <D.29551>;
      <D.29550>:
      tls->frame_count = 0;
      return;
      <D.29551>:
      D.29554 = tls->really_suspended;
      if (D.29554 == 0) goto <D.29555>; else goto <D.29552>;
      <D.29555>:
      D.29556 = tls->async_state.valid;
      if (D.29556 != 0) goto <D.29557>; else goto <D.29552>;
      <D.29557>:
      D.29558 = &tls->async_last_frame;
      process_frame (D.29558, 0B, &user_data);
      D.29559 = &tls->async_state;
      mono_walk_stack_with_state (process_frame, D.29559, opts, &user_data);
      goto <D.29553>;
      <D.29552>:
      D.29560 = tls->filter_state.valid;
      if (D.29560 != 0) goto <D.29561>; else goto <D.29562>;
      <D.29561>:
      D.29563 = tls->context.valid;
      if (D.29563 != 0) goto <D.29564>; else goto <D.29565>;
      <D.29564>:
      D.29566 = &tls->context;
      mono_walk_stack_with_state (process_filter_frame, D.29566, opts, &user_data);
      <D.29565>:
      D.29567 = &tls->filter_state;
      mono_walk_stack_with_state (process_frame, D.29567, opts, &user_data);
      goto <D.29568>;
      <D.29562>:
      D.29563 = tls->context.valid;
      if (D.29563 != 0) goto <D.29569>; else goto <D.29570>;
      <D.29569>:
      D.29566 = &tls->context;
      mono_walk_stack_with_state (process_frame, D.29566, opts, &user_data);
      goto <D.29571>;
      <D.29570>:
      tls->frame_count = 0;
      return;
      <D.29571>:
      <D.29568>:
      <D.29553>:
      D.29572 = user_data.frames;
      D.29573 = monoeg_g_slist_length (D.29572);
      new_frame_count = (int) D.29573;
      new_frame_count.217 = (unsigned int) new_frame_count;
      D.29575 = new_frame_count.217 * 4;
      new_frames = monoeg_malloc0 (D.29575);
      findex = 0;
      tmp = user_data.frames;
      goto <D.25531>;
      <D.25530>:
      f = tmp->data;
      i = 0;
      goto <D.25529>;
      <D.25528>:
      D.29534 = tls->frames;
      i.218 = (unsigned int) i;
      D.29577 = i.218 * 4;
      D.29578 = D.29534 + D.29577;
      D.29579 = *D.29578;
      D.29580 = D.29579->ctx.esp;
      D.29581 = (void *) D.29580;
      D.29582 = f->ctx.esp;
      D.29583 = (void *) D.29582;
      if (D.29581 == D.29583) goto <D.29584>; else goto <D.29585>;
      <D.29584>:
      D.29534 = tls->frames;
      i.218 = (unsigned int) i;
      D.29577 = i.218 * 4;
      D.29578 = D.29534 + D.29577;
      D.29579 = *D.29578;
      D.29586 = D.29579->id;
      f->id = D.29586;
      goto <D.25527>;
      <D.29585>:
      i = i + 1;
      <D.25529>:
      D.29587 = tls->frame_count;
      if (D.29587 > i) goto <D.25528>; else goto <D.25527>;
      <D.25527>:
      D.29587 = tls->frame_count;
      if (D.29587 <= i) goto <D.29588>; else goto <D.29589>;
      <D.29588>:
      D.29590 = InterlockedIncrement (&frame_id);
      f->id = D.29590;
      <D.29589>:
      findex.219 = findex;
      findex = findex.219 + 1;
      findex.220 = (unsigned int) findex.219;
      D.29593 = findex.220 * 4;
      D.29594 = new_frames + D.29593;
      *D.29594 = f;
      tmp = tmp->next;
      <D.25531>:
      if (tmp != 0B) goto <D.25530>; else goto <D.25532>;
      <D.25532>:
      D.29572 = user_data.frames;
      monoeg_g_slist_free (D.29572);
      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)
{
  int D.29598;
  void * D.29599;
  struct DebuggerTlsData * D.29600;
  int D.29601;
  void * D.29602;
  gboolean D.29605;
  struct ComputeFramesUserData * ud;

  ud = user_data;
  D.29598 = ctx->esp;
  D.29599 = (void *) D.29598;
  D.29600 = ud->tls;
  D.29601 = D.29600->filter_state.ctx.esp;
  D.29602 = (void *) D.29601;
  if (D.29599 >= D.29602) goto <D.29603>; else goto <D.29604>;
  <D.29603>:
  D.29605 = 1;
  return D.29605;
  <D.29604>:
  D.29605 = process_frame (info, ctx, user_data);
  return D.29605;
}


process_frame (struct StackFrameInfo * info, struct MonoContext * ctx, void * user_data)
{
  <unnamed type> D.29607;
  struct GSList * D.29612;
  struct GSList * D.29615;
  void * D.29616;
  int D.29617;
  int D.29618;
  gboolean D.29619;
  struct MonoJitInfo * D.29620;
  unsigned char D.29629;
  unsigned char D.29630;
  _Bool D.29631;
  _Bool D.29632;
  _Bool D.29633;
  unsigned char D.29635;
  int D.29636;
  int D.29641;
  struct MonoDomain * D.29642;
  int D.29645;
  unsigned int D.29648;
  int D.29649;
  int log_level.221;
  _Bool D.29651;
  long int D.29652;
  long int D.29653;
  int D.29656;
  char * D.29657;
  struct FILE * log_file.222;
  int protocol_version_set.223;
  int major_version.224;
  int minor_version.225;
  unsigned int D.29671;
  unsigned int D.29672;
  mgreg_t * * D.29673;
  mgreg_t *[8] * D.29676;
  struct GSList * D.29679;
  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.29607 = info->type;
  if (D.29607 != 0) goto <D.29608>; else goto <D.29609>;
  <D.29608>:
  D.29607 = info->type;
  if (D.29607 == 1) goto <D.29610>; else goto <D.29611>;
  <D.29610>:
  D.29612 = ud->frames;
  if (D.29612 != 0B) goto <D.29613>; else goto <D.29614>;
  <D.29613>:
  D.29612 = ud->frames;
  D.29615 = monoeg_g_slist_last (D.29612);
  D.29616 = D.29615->data;
  D.29617 = MEM[(struct StackFrame *)D.29616].flags;
  D.29618 = D.29617 | 1;
  MEM[(struct StackFrame *)D.29616].flags = D.29618;
  <D.29614>:
  <D.29611>:
  D.29619 = 0;
  return D.29619;
  <D.29609>:
  D.29620 = info->ji;
  if (D.29620 != 0B) goto <D.29621>; else goto <D.29622>;
  <D.29621>:
  D.29620 = info->ji;
  method = jinfo_get_method (D.29620);
  goto <D.29623>;
  <D.29622>:
  method = info->method;
  <D.29623>:
  actual_method = info->actual_method;
  api_method = method;
  if (method == 0B) goto <D.29624>; else goto <D.29625>;
  <D.29624>:
  D.29619 = 0;
  return D.29619;
  <D.29625>:
  if (method == 0B) goto <D.29626>; else goto <D.29628>;
  <D.29628>:
  D.29629 = BIT_FIELD_REF <*method, 8, 160>;
  D.29630 = D.29629 & 124;
  D.29631 = D.29630 != 0;
  D.29632 = D.29630 != 68;
  D.29633 = D.29631 & D.29632;
  if (D.29633 != 0) goto <D.29634>; else goto <D.29627>;
  <D.29634>:
  D.29629 = BIT_FIELD_REF <*method, 8, 160>;
  D.29635 = D.29629 & 124;
  if (D.29635 != 24) goto <D.29626>; else goto <D.29627>;
  <D.29626>:
  D.29619 = 0;
  return D.29619;
  <D.29627>:
  D.29636 = info->il_offset;
  if (D.29636 == -1) goto <D.29637>; else goto <D.29638>;
  <D.29637>:
  D.29612 = ud->frames;
  if (D.29612 == 0B) goto <D.29639>; else goto <D.29640>;
  <D.29639>:
  D.29641 = info->native_offset;
  D.29642 = info->domain;
  sp = find_prev_seq_point_for_native_offset (D.29642, method, D.29641, 0B);
  if (sp != 0B) goto <D.29643>; else goto <D.29644>;
  <D.29643>:
  D.29645 = sp->il_offset;
  info->il_offset = D.29645;
  <D.29644>:
  <D.29640>:
  D.29636 = info->il_offset;
  if (D.29636 == -1) goto <D.29646>; else goto <D.29647>;
  <D.29646>:
  D.29641 = info->native_offset;
  D.29648 = (unsigned int) D.29641;
  D.29642 = info->domain;
  D.29649 = mono_debug_il_offset_from_address (method, D.29642, D.29648);
  info->il_offset = D.29649;
  <D.29647>:
  <D.29638>:
  log_level.221 = log_level;
  D.29651 = log_level.221 > 0;
  D.29652 = (long int) D.29651;
  D.29653 = __builtin_expect (D.29652, 0);
  if (D.29653 != 0) goto <D.29654>; else goto <D.29655>;
  <D.29654>:
  D.29656 = info->managed;
  D.29641 = info->native_offset;
  D.29636 = info->il_offset;
  D.29657 = mono_method_full_name (method, 1);
  log_file.222 = log_file;
  fprintf (log_file.222, "\tFrame: %s:%x(%x) %d\n", D.29657, D.29636, D.29641, D.29656);
  log_file.222 = log_file;
  fflush (log_file.222);
  <D.29655>:
  D.29629 = BIT_FIELD_REF <*method, 8, 160>;
  D.29635 = D.29629 & 124;
  if (D.29635 == 24) goto <D.29659>; else goto <D.29660>;
  <D.29659>:
  protocol_version_set.223 = protocol_version_set;
  if (protocol_version_set.223 == 0) goto <D.29661>; else goto <D.29664>;
  <D.29664>:
  major_version.224 = major_version;
  if (major_version.224 <= 2) goto <D.29666>; else goto <D.29662>;
  <D.29666>:
  major_version.224 = major_version;
  if (major_version.224 != 2) goto <D.29661>; else goto <D.29667>;
  <D.29667>:
  minor_version.225 = minor_version;
  if (minor_version.225 <= 16) goto <D.29661>; else goto <D.29662>;
  <D.29661>:
  D.29619 = 0;
  return D.29619;
  <D.29662>:
  api_method = mono_marshal_method_from_wrapper (method);
  if (api_method == 0B) goto <D.29669>; else goto <D.29670>;
  <D.29669>:
  D.29619 = 0;
  return D.29619;
  <D.29670>:
  actual_method = api_method;
  flags = flags | 2;
  <D.29660>:
  frame = monoeg_malloc0 (112);
  frame->method = method;
  frame->actual_method = actual_method;
  frame->api_method = api_method;
  D.29636 = info->il_offset;
  D.29671 = (unsigned int) D.29636;
  frame->il_offset = D.29671;
  D.29641 = info->native_offset;
  D.29672 = (unsigned int) D.29641;
  frame->native_offset = D.29672;
  frame->flags = flags;
  D.29620 = info->ji;
  frame->ji = D.29620;
  D.29673 = info->reg_locations;
  if (D.29673 != 0B) goto <D.29674>; else goto <D.29675>;
  <D.29674>:
  D.29673 = info->reg_locations;
  D.29676 = &frame->reg_locations;
  memcpy (D.29676, D.29673, 32);
  <D.29675>:
  if (ctx != 0B) goto <D.29677>; else goto <D.29678>;
  <D.29677>:
  frame->ctx = *ctx;
  frame->has_ctx = 1;
  <D.29678>:
  D.29642 = info->domain;
  frame->domain = D.29642;
  D.29612 = ud->frames;
  D.29679 = monoeg_g_slist_append (D.29612, frame);
  ud->frames = D.29679;
  D.29619 = 0;
  return D.29619;
}


find_prev_seq_point_for_native_offset (struct MonoDomain * domain, struct MonoMethod * method, gint32 native_offset, struct MonoSeqPointInfo * * info)
{
  struct SeqPoint * D.29685;
  int D.29686;
  int D.29687;
  struct MonoSeqPointInfo * seq_points;
  int i;

  seq_points = get_seq_points (domain, method);
  if (info != 0B) goto <D.29681>; else goto <D.29682>;
  <D.29681>:
  *info = seq_points;
  <D.29682>:
  if (seq_points == 0B) goto <D.29683>; else goto <D.29684>;
  <D.29683>:
  D.29685 = 0B;
  return D.29685;
  <D.29684>:
  D.29686 = seq_points->len;
  i = D.29686 + -1;
  goto <D.25480>;
  <D.25479>:
  D.29687 = seq_points->seq_points[i].native_offset;
  if (D.29687 <= native_offset) goto <D.29688>; else goto <D.29689>;
  <D.29688>:
  D.29685 = &seq_points->seq_points[i];
  return D.29685;
  <D.29689>:
  i = i + -1;
  <D.25480>:
  if (i >= 0) goto <D.25479>; else goto <D.25481>;
  <D.25481>:
  D.29685 = 0B;
  return D.29685;
}


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

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


printf (const char * restrict __fmt)
{
  int D.29692;

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


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)
{
  struct EventRequest * D.29696;
  int D.29697;
  struct GSList * D.29698;
  struct GSList * D.29699;
  int D.29704;
  <unnamed type> D.29706;
  int D.29710;
  struct MonoThreadUnwindState * D.29713;
  struct MonoInternalThread * D.29714;
  struct StackFrame * * D.29717;
  unsigned int frame_index.226;
  unsigned int D.29719;
  struct StackFrame * * D.29720;
  unsigned int D.29721;
  int D.29722;
  struct MonoMethod * D.29723;
  struct MonoDomain * D.29724;
  int D.29728;
  unsigned int D.29734;
  int D.29735;
  struct MonoMethod * D.29736;
  struct MonoDomain * D.29737;
  struct MonoSeqPointInfo * info.227;
  int * D.29746;
  unsigned int i.228;
  unsigned int D.29748;
  int * D.29749;
  int D.29750;
  int D.29751;
  struct GSList * D.29752;
  int D.29755;
  struct StackFrame * * D.29758;
  struct MonoJitInfo * D.29759;
  void * D.29762;
  int D.29763;
  void * D.29764;
  int D.29765;
  int D.29766;
  struct MonoMethod * D.29767;
  struct MonoDomain * D.29768;
  struct GSList * D.29771;
  <unnamed-unsigned:15> D.29772;
  int D.29773;
  int log_level.229;
  _Bool D.29779;
  long int D.29780;
  long int D.29781;
  struct FILE * log_file.230;
  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.29694>; else goto <D.29695>;
  <D.29694>:
  D.29696 = ss_req->req;
  D.29697 = sp->il_offset;
  bp = set_breakpoint (method, D.29697, D.29696, 0B);
  D.29698 = ss_req->bps;
  D.29699 = monoeg_g_slist_append (D.29698, bp);
  ss_req->bps = D.29699;
  goto <D.29700>;
  <D.29695>:
  frame_index = 1;
  if (sp == 0B) goto <D.29701>; else goto <D.29703>;
  <D.29703>:
  D.29704 = sp->next_len;
  if (D.29704 == 0) goto <D.29701>; else goto <D.29705>;
  <D.29705>:
  D.29706 = ss_req->depth;
  if (D.29706 == 2) goto <D.29701>; else goto <D.29707>;
  <D.29707>:
  D.29706 = ss_req->depth;
  if (D.29706 == 1) goto <D.29701>; else goto <D.29702>;
  <D.29701>:
  if (ctx != 0B) goto <D.29708>; else goto <D.29709>;
  <D.29708>:
  D.29710 = tls->context.valid;
  if (D.29710 == 0) goto <D.29711>; else goto <D.29712>;
  <D.29711>:
  D.29713 = &tls->context;
  mono_thread_state_init_from_monoctx (D.29713, ctx);
  <D.29712>:
  D.29714 = tls->thread;
  compute_frame_info (D.29714, tls);
  <D.29709>:
  <D.29702>:
  D.29706 = ss_req->depth;
  if (D.29706 == 2) goto <D.29715>; else goto <D.29716>;
  <D.29715>:
  goto <D.26088>;
  <D.26087>:
  {
    struct StackFrame * frame;

    D.29717 = tls->frames;
    frame_index.226 = (unsigned int) frame_index;
    D.29719 = frame_index.226 * 4;
    D.29720 = D.29717 + D.29719;
    frame = *D.29720;
    method = frame->method;
    D.29721 = frame->native_offset;
    D.29722 = (int) D.29721;
    D.29723 = frame->method;
    D.29724 = frame->domain;
    sp = find_prev_seq_point_for_native_offset (D.29724, D.29723, D.29722, &info);
    frame_index = frame_index + 1;
    if (sp != 0B) goto <D.29725>; else goto <D.29726>;
    <D.29725>:
    D.29704 = sp->next_len;
    if (D.29704 != 0) goto <D.26086>; else goto <D.29727>;
    <D.29727>:
    <D.29726>:
  }
  <D.26088>:
  D.29728 = tls->frame_count;
  if (D.29728 > frame_index) goto <D.26087>; else goto <D.26086>;
  <D.26086>:
  goto <D.29729>;
  <D.29716>:
  if (sp != 0B) goto <D.29730>; else goto <D.29731>;
  <D.29730>:
  D.29704 = sp->next_len;
  if (D.29704 == 0) goto <D.29732>; else goto <D.29733>;
  <D.29732>:
  sp = 0B;
  goto <D.26092>;
  <D.26091>:
  {
    struct StackFrame * frame;

    D.29717 = tls->frames;
    frame_index.226 = (unsigned int) frame_index;
    D.29719 = frame_index.226 * 4;
    D.29720 = D.29717 + D.29719;
    frame = *D.29720;
    method = frame->method;
    D.29734 = frame->native_offset;
    D.29735 = (int) D.29734;
    D.29736 = frame->method;
    D.29737 = frame->domain;
    sp = find_prev_seq_point_for_native_offset (D.29737, D.29736, D.29735, &info);
    if (sp != 0B) goto <D.29738>; else goto <D.29739>;
    <D.29738>:
    D.29704 = sp->next_len;
    if (D.29704 != 0) goto <D.26090>; else goto <D.29740>;
    <D.29740>:
    <D.29739>:
    sp = 0B;
    frame_index = frame_index + 1;
  }
  <D.26092>:
  D.29728 = tls->frame_count;
  if (D.29728 > frame_index) goto <D.26091>; else goto <D.26090>;
  <D.26090>:
  <D.29733>:
  <D.29731>:
  <D.29729>:
  if (sp != 0B) goto <D.29741>; else goto <D.29742>;
  <D.29741>:
  D.29704 = sp->next_len;
  if (D.29704 > 0) goto <D.29743>; else goto <D.29744>;
  <D.29743>:
  i = 0;
  goto <D.26094>;
  <D.26093>:
  info.227 = info;
  D.29746 = sp->next;
  i.228 = (unsigned int) i;
  D.29748 = i.228 * 4;
  D.29749 = D.29746 + D.29748;
  D.29750 = *D.29749;
  next_sp = &info.227->seq_points[D.29750];
  D.29696 = ss_req->req;
  D.29751 = next_sp->il_offset;
  bp = set_breakpoint (method, D.29751, D.29696, 0B);
  D.29698 = ss_req->bps;
  D.29752 = monoeg_g_slist_append (D.29698, bp);
  ss_req->bps = D.29752;
  i = i + 1;
  <D.26094>:
  D.29704 = sp->next_len;
  if (D.29704 > i) goto <D.26093>; else goto <D.26095>;
  <D.26095>:
  <D.29744>:
  <D.29742>:
  D.29706 = ss_req->depth;
  if (D.29706 == 1) goto <D.29753>; else goto <D.29754>;
  <D.29753>:
  D.29755 = ss_req->nframes;
  if (D.29755 == 0) goto <D.29756>; else goto <D.29757>;
  <D.29756>:
  D.29728 = tls->frame_count;
  ss_req->nframes = D.29728;
  <D.29757>:
  i = 0;
  goto <D.26103>;
  <D.26102>:
  {
    struct StackFrame * frame;

    D.29717 = tls->frames;
    i.228 = (unsigned int) i;
    D.29748 = i.228 * 4;
    D.29758 = D.29717 + D.29748;
    frame = *D.29758;
    D.29759 = frame->ji;
    if (D.29759 != 0B) goto <D.29760>; else goto <D.29761>;
    <D.29760>:
    {
      struct MonoJitInfo * jinfo;

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

        ei = &jinfo->clauses[j];
        D.29762 = ei->handler_start;
        D.29763 = (int) D.29762;
        D.29764 = jinfo->code_start;
        D.29765 = (int) D.29764;
        D.29766 = D.29763 - D.29765;
        D.29767 = frame->method;
        D.29768 = frame->domain;
        sp = find_next_seq_point_for_native_offset (D.29768, D.29767, D.29766, 0B);
        if (sp != 0B) goto <D.29769>; else goto <D.29770>;
        <D.29769>:
        D.29696 = ss_req->req;
        D.29697 = sp->il_offset;
        D.29767 = frame->method;
        bp = set_breakpoint (D.29767, D.29697, D.29696, 0B);
        D.29698 = ss_req->bps;
        D.29771 = monoeg_g_slist_append (D.29698, bp);
        ss_req->bps = D.29771;
        <D.29770>:
      }
      j = j + 1;
      <D.26100>:
      D.29772 = jinfo->num_clauses;
      D.29773 = (int) D.29772;
      if (D.29773 > j) goto <D.26099>; else goto <D.26101>;
      <D.26101>:
    }
    <D.29761>:
  }
  i = i + 1;
  <D.26103>:
  D.29728 = tls->frame_count;
  if (D.29728 > i) goto <D.26102>; else goto <D.26104>;
  <D.26104>:
  <D.29754>:
  D.29706 = ss_req->depth;
  if (D.29706 == 0) goto <D.29774>; else goto <D.29775>;
  <D.29774>:
  enable_global = 1;
  <D.29775>:
  tls->context.valid = 0;
  tls->async_state.valid = 0;
  invalidate_frames (tls);
  <D.29700>:
  if (enable_global != 0) goto <D.29776>; else goto <D.29777>;
  <D.29776>:
  log_level.229 = log_level;
  D.29779 = log_level.229 > 0;
  D.29780 = (long int) D.29779;
  D.29781 = __builtin_expect (D.29780, 0);
  if (D.29781 != 0) goto <D.29782>; else goto <D.29783>;
  <D.29782>:
  log_file.230 = log_file;
  fprintf (log_file.230, "[dbg] Turning on global single stepping.\n");
  log_file.230 = log_file;
  fflush (log_file.230);
  <D.29783>:
  ss_req->global = 1;
  start_single_stepping ();
  goto <D.29785>;
  <D.29777>:
  D.29698 = ss_req->bps;
  if (D.29698 == 0B) goto <D.29786>; else goto <D.29787>;
  <D.29786>:
  log_level.229 = log_level;
  D.29779 = log_level.229 > 0;
  D.29780 = (long int) D.29779;
  D.29781 = __builtin_expect (D.29780, 0);
  if (D.29781 != 0) goto <D.29788>; else goto <D.29789>;
  <D.29788>:
  log_file.230 = log_file;
  fprintf (log_file.230, "[dbg] Turning on global single stepping.\n");
  log_file.230 = log_file;
  fflush (log_file.230);
  <D.29789>:
  ss_req->global = 1;
  start_single_stepping ();
  goto <D.29790>;
  <D.29787>:
  ss_req->global = 0;
  <D.29790>:
  <D.29785>:
}


start_single_stepping ()
{
  struct SingleStepReq * ss_req.231;
  void * ss_invoke_addr.232;
  struct MonoInternalThread * D.29799;
  struct MonoGHashTable * thread_to_tls.233;
  void * ss_invoke_addr.234;
  int val;

  val = InterlockedIncrement (&ss_count);
  if (val == 1) goto <D.29791>; else goto <D.29792>;
  <D.29791>:
  mono_arch_start_single_stepping ();
  <D.29792>:
  ss_req.231 = ss_req;
  if (ss_req.231 != 0B) goto <D.29794>; else goto <D.29795>;
  <D.29794>:
  ss_invoke_addr.232 = ss_invoke_addr;
  if (ss_invoke_addr.232 == 0B) goto <D.29797>; else goto <D.29798>;
  <D.29797>:
  {
    struct DebuggerTlsData * tls;

    mono_loader_lock ();
    ss_req.231 = ss_req;
    D.29799 = ss_req.231->thread;
    thread_to_tls.233 = thread_to_tls;
    tls = mono_g_hash_table_lookup (thread_to_tls.233, D.29799);
    ss_invoke_addr.234 = tls->invoke_addr;
    ss_invoke_addr = ss_invoke_addr.234;
    mono_loader_unlock ();
  }
  <D.29798>:
  <D.29795>:
}


set_breakpoint (struct MonoMethod * method, long int il_offset, struct EventRequest * req, struct MonoError * error)
{
  struct GPtrArray * D.29804;
  int log_level.235;
  _Bool D.29806;
  long int D.29807;
  long int D.29808;
  const char * iftmp.236;
  const char * iftmp.237;
  int D.29816;
  struct FILE * log_file.238;
  struct GHashTable * domains.239;
  struct MonoDomain * domain.240;
  union mono_mutex_t * D.29823;
  _Bool D.29826;
  long int D.29827;
  long int D.29828;
  void * D.29831;
  struct GHashTable * D.29832;
  struct MonoMethod * m.241;
  int D.29834;
  struct MonoSeqPointInfo * seq_points.242;
  int D.29838;
  _Bool D.29841;
  long int D.29842;
  long int D.29843;
  int D.29846;
  struct GPtrArray * breakpoints.243;
  int D.29850;
  struct MonoBreakpoint * D.29853;
  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.29802>; else goto <D.29803>;
      <D.29802>:
      mono_error_init (error);
      <D.29803>:
      bp = monoeg_malloc0 (16);
      bp->method = method;
      bp->il_offset = il_offset;
      bp->req = req;
      D.29804 = monoeg_g_ptr_array_new ();
      bp->children = D.29804;
      log_level.235 = log_level;
      D.29806 = log_level.235 > 0;
      D.29807 = (long int) D.29806;
      D.29808 = __builtin_expect (D.29807, 0);
      if (D.29808 != 0) goto <D.29809>; else goto <D.29810>;
      <D.29809>:
      if (method != 0B) goto <D.29812>; else goto <D.29813>;
      <D.29812>:
      iftmp.236 = mono_method_full_name (method, 1);
      goto <D.29814>;
      <D.29813>:
      iftmp.236 = "<all>";
      <D.29814>:
      D.29816 = req->event_kind;
      if (D.29816 == 11) goto <D.29817>; else goto <D.29818>;
      <D.29817>:
      iftmp.237 = "single step ";
      goto <D.29819>;
      <D.29818>:
      iftmp.237 = "";
      <D.29819>:
      log_file.238 = log_file;
      fprintf (log_file.238, "[dbg] Setting %sbreakpoint at %s:0x%x.\n", iftmp.237, iftmp.236, il_offset);
      log_file.238 = log_file;
      fflush (log_file.238);
      <D.29810>:
      mono_loader_lock ();
      domains.239 = domains;
      monoeg_g_hash_table_iter_init (&iter, domains.239);
      goto <D.25883>;
      <D.25882>:
      {
        int ret;

        domain.240 = domain;
        D.29823 = &domain.240->lock.mutex;
        ret = pthread_mutex_lock (D.29823);
        if (ret != 0) goto <D.29824>; else goto <D.29825>;
        <D.29824>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
        <D.29825>:
        D.29826 = ret != 0;
        D.29827 = (long int) D.29826;
        D.29828 = __builtin_expect (D.29827, 0);
        if (D.29828 != 0) goto <D.29829>; else goto <D.29830>;
        <D.29829>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 4353, "ret == 0");
        <D.29830>:
      }
      domain.240 = domain;
      D.29831 = domain.240->runtime_info;
      D.29832 = MEM[(struct MonoJitDomainInfo *)D.29831].seq_points;
      monoeg_g_hash_table_iter_init (&iter2, D.29832);
      goto <D.25879>;
      <D.25878>:
      m.241 = m;
      D.29834 = bp_matches_method (bp, m.241);
      if (D.29834 != 0) goto <D.29835>; else goto <D.29836>;
      <D.29835>:
      seq_points.242 = seq_points;
      m.241 = m;
      domain.240 = domain;
      set_bp_in_method (domain.240, m.241, seq_points.242, bp, error);
      <D.29836>:
      <D.25879>:
      D.29838 = monoeg_g_hash_table_iter_next (&iter2, &m, &seq_points);
      if (D.29838 != 0) goto <D.25878>; else goto <D.25880>;
      <D.25880>:
      {
        int ret;

        domain.240 = domain;
        D.29823 = &domain.240->lock.mutex;
        ret = pthread_mutex_unlock (D.29823);
        if (ret != 0) goto <D.29839>; else goto <D.29840>;
        <D.29839>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.29840>:
        D.29841 = ret != 0;
        D.29842 = (long int) D.29841;
        D.29843 = __builtin_expect (D.29842, 0);
        if (D.29843 != 0) goto <D.29844>; else goto <D.29845>;
        <D.29844>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 4361, "ret == 0");
        <D.29845>:
      }
      <D.25883>:
      D.29846 = monoeg_g_hash_table_iter_next (&iter, &domain, 0B);
      if (D.29846 != 0) goto <D.25882>; else goto <D.25884>;
      <D.25884>:
      mono_loader_unlock ();
      mono_loader_lock ();
      breakpoints.243 = breakpoints;
      monoeg_g_ptr_array_add (breakpoints.243, bp);
      mono_loader_unlock ();
      if (error != 0B) goto <D.29848>; else goto <D.29849>;
      <D.29848>:
      D.29850 = mono_error_ok (error);
      if (D.29850 == 0) goto <D.29851>; else goto <D.29852>;
      <D.29851>:
      clear_breakpoint (bp);
      D.29853 = 0B;
      return D.29853;
      <D.29852>:
      <D.29849>:
      D.29853 = bp;
      return D.29853;
    }
  finally
    {
      iter = {CLOBBER};
      iter2 = {CLOBBER};
      domain = {CLOBBER};
      m = {CLOBBER};
      seq_points = {CLOBBER};
    }
}


bp_matches_method (struct MonoBreakpoint * bp, struct MonoMethod * method)
{
  struct MonoMethod * D.29856;
  gboolean D.29859;
  unsigned char D.29862;
  unsigned char D.29863;
  struct MonoMethod * D.29866;
  unsigned char D.29869;
  unsigned char D.29870;
  struct MonoMethod * D.29875;
  struct MonoMethod * D.29876;
  struct MonoGenericInst * D.29879;
  struct MonoGenericInst * D.29880;
  struct MonoGenericInst * D.29883;
  unsigned char D.29886;
  unsigned char D.29887;
  unsigned char D.29890;
  <unnamed-unsigned:22> D.29893;
  int D.29894;
  int i;

  D.29856 = bp->method;
  if (D.29856 == 0B) goto <D.29857>; else goto <D.29858>;
  <D.29857>:
  D.29859 = 1;
  return D.29859;
  <D.29858>:
  D.29856 = bp->method;
  if (D.29856 == method) goto <D.29860>; else goto <D.29861>;
  <D.29860>:
  D.29859 = 1;
  return D.29859;
  <D.29861>:
  D.29862 = BIT_FIELD_REF <*method, 8, 168>;
  D.29863 = D.29862 & 16;
  if (D.29863 != 0) goto <D.29864>; else goto <D.29865>;
  <D.29864>:
  D.29866 = MEM[(struct MonoMethodInflated *)method].declaring;
  D.29856 = bp->method;
  if (D.29866 == D.29856) goto <D.29867>; else goto <D.29868>;
  <D.29867>:
  D.29859 = 1;
  return D.29859;
  <D.29868>:
  <D.29865>:
  D.29856 = bp->method;
  D.29869 = BIT_FIELD_REF <*D.29856, 8, 168>;
  D.29870 = D.29869 & 16;
  if (D.29870 != 0) goto <D.29871>; else goto <D.29872>;
  <D.29871>:
  D.29862 = BIT_FIELD_REF <*method, 8, 168>;
  D.29863 = D.29862 & 16;
  if (D.29863 != 0) goto <D.29873>; else goto <D.29874>;
  <D.29873>:
  {
    struct MonoMethodInflated * bpimethod;
    struct MonoMethodInflated * imethod;

    bpimethod = bp->method;
    imethod = method;
    D.29875 = bpimethod->declaring;
    D.29876 = imethod->declaring;
    if (D.29875 == D.29876) goto <D.29877>; else goto <D.29878>;
    <D.29877>:
    D.29879 = bpimethod->context.class_inst;
    D.29880 = imethod->context.class_inst;
    if (D.29879 == D.29880) goto <D.29881>; else goto <D.29882>;
    <D.29881>:
    D.29883 = bpimethod->context.method_inst;
    if (D.29883 != 0B) goto <D.29884>; else goto <D.29885>;
    <D.29884>:
    D.29883 = bpimethod->context.method_inst;
    D.29886 = BIT_FIELD_REF <*D.29883, 8, 48>;
    D.29887 = D.29886 & 64;
    if (D.29887 != 0) goto <D.29888>; else goto <D.29889>;
    <D.29888>:
    i = 0;
    goto <D.25831>;
    <D.25830>:
    {
      struct MonoType * t1;

      D.29883 = bpimethod->context.method_inst;
      t1 = D.29883->type_argv[i];
      D.29890 = t1->type;
      if (D.29890 != 30) goto <D.29891>; else goto <D.29892>;
      <D.29891>:
      D.29859 = 0;
      return D.29859;
      <D.29892>:
    }
    i = i + 1;
    <D.25831>:
    D.29883 = bpimethod->context.method_inst;
    D.29893 = D.29883->type_argc;
    D.29894 = (int) D.29893;
    if (D.29894 > i) goto <D.25830>; else goto <D.25832>;
    <D.25832>:
    D.29859 = 1;
    return D.29859;
    <D.29889>:
    <D.29885>:
    <D.29882>:
    <D.29878>:
  }
  <D.29874>:
  <D.29872>:
  D.29859 = 0;
  return D.29859;
}


set_bp_in_method (struct MonoDomain * domain, struct MonoMethod * method, struct MonoSeqPointInfo * seq_points, struct MonoBreakpoint * bp, struct MonoError * error)
{
  _Bool D.29900;
  long int D.29901;
  long int D.29902;
  struct MonoJitInfo * ji.244;
  struct MonoJitInfo * ji.245;
  _Bool D.29907;
  long int D.29908;
  long int D.29909;
  void * code;
  struct MonoJitInfo * ji;

  try
    {
      if (error != 0B) goto <D.29896>; else goto <D.29897>;
      <D.29896>:
      mono_error_init (error);
      <D.29897>:
      code = mono_jit_find_compiled_method_with_jit_info (domain, method, &ji);
      if (code == 0B) goto <D.29898>; else goto <D.29899>;
      <D.29898>:
      code = mono_aot_get_method (domain, method);
      D.29900 = code == 0B;
      D.29901 = (long int) D.29900;
      D.29902 = __builtin_expect (D.29901, 0);
      if (D.29902 != 0) goto <D.29903>; else goto <D.29904>;
      <D.29903>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 4301, "code");
      <D.29904>:
      ji.244 = mono_jit_info_table_find (domain, code);
      ji = ji.244;
      ji.245 = ji;
      D.29907 = ji.245 == 0B;
      D.29908 = (long int) D.29907;
      D.29909 = __builtin_expect (D.29908, 0);
      if (D.29909 != 0) goto <D.29910>; else goto <D.29911>;
      <D.29910>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 4303, "ji");
      <D.29911>:
      <D.29899>:
      D.29900 = code == 0B;
      D.29901 = (long int) D.29900;
      D.29902 = __builtin_expect (D.29901, 0);
      if (D.29902 != 0) goto <D.29912>; else goto <D.29913>;
      <D.29912>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 4305, "code");
      <D.29913>:
      ji.245 = ji;
      insert_breakpoint (seq_points, domain, ji.245, 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.29916;
  long int D.29917;
  int D.29919;
  int D.29922;
  _Bool D.29923;
  _Bool D.29924;
  _Bool D.29925;
  int D.29928;
  struct MonoMethod * D.29932;
  char * D.29933;
  int log_level.246;
  _Bool D.29935;
  long int D.29936;
  long int D.29937;
  int D.29940;
  struct FILE * log_file.247;
  int D.29944;
  void * D.29945;
  sizetype D.29946;
  guint8 * D.29947;
  struct GPtrArray * D.29948;
  guint8 * D.29949;
  struct GHashTable * bp_locs.248;
  void * D.29951;
  int D.29952;
  void * D.29953;
  struct MonoMethod * D.29963;
  char * D.29964;
  int i;
  int count;
  struct BreakpointInstance * inst;
  struct SeqPoint * sp;

  sp = 0B;
  if (error != 0B) goto <D.29914>; else goto <D.29915>;
  <D.29914>:
  mono_error_init (error);
  <D.29915>:
  i = 0;
  goto <D.25808>;
  <D.25807>:
  sp = &seq_points->seq_points[i];
  D.29916 = sp->il_offset;
  D.29917 = bp->il_offset;
  if (D.29916 == D.29917) goto <D.25806>; else goto <D.29918>;
  <D.29918>:
  i = i + 1;
  <D.25808>:
  D.29919 = seq_points->len;
  if (D.29919 > i) goto <D.25807>; else goto <D.25806>;
  <D.25806>:
  D.29919 = seq_points->len;
  if (D.29919 == i) goto <D.29920>; else goto <D.29921>;
  <D.29920>:
  i = 0;
  goto <D.25811>;
  <D.25810>:
  sp = &seq_points->seq_points[i];
  D.29922 = sp->il_offset;
  D.29923 = D.29922 != -1;
  D.29924 = D.29922 != 16777215;
  D.29925 = D.29923 & D.29924;
  if (D.29925 != 0) goto <D.29926>; else goto <D.29927>;
  <D.29926>:
  D.29916 = sp->il_offset;
  D.29928 = D.29916 + 1;
  D.29917 = bp->il_offset;
  if (D.29928 == D.29917) goto <D.25809>; else goto <D.29929>;
  <D.29929>:
  <D.29927>:
  i = i + 1;
  <D.25811>:
  D.29919 = seq_points->len;
  if (D.29919 > i) goto <D.25810>; else goto <D.25809>;
  <D.25809>:
  <D.29921>:
  D.29919 = seq_points->len;
  if (D.29919 == i) goto <D.29930>; else goto <D.29931>;
  <D.29930>:
  {
    char * s;

    D.29919 = seq_points->len;
    D.29917 = bp->il_offset;
    D.29932 = jinfo_get_method (ji);
    D.29933 = mono_method_full_name (D.29932, 1);
    s = monoeg_g_strdup_printf ("Unable to insert breakpoint at %s:%d, seq_points=%d\n", D.29933, D.29917, D.29919);
    i = 0;
    goto <D.25814>;
    <D.25813>:
    log_level.246 = log_level;
    D.29935 = log_level.246 > 0;
    D.29936 = (long int) D.29935;
    D.29937 = __builtin_expect (D.29936, 0);
    if (D.29937 != 0) goto <D.29938>; else goto <D.29939>;
    <D.29938>:
    D.29940 = seq_points->seq_points[i].il_offset;
    log_file.247 = log_file;
    fprintf (log_file.247, "%d\n", D.29940);
    log_file.247 = log_file;
    fflush (log_file.247);
    <D.29939>:
    i = i + 1;
    <D.25814>:
    D.29919 = seq_points->len;
    if (D.29919 > i) goto <D.25813>; else goto <D.25815>;
    <D.25815>:
    if (error != 0B) goto <D.29942>; else goto <D.29943>;
    <D.29942>:
    mono_error_set_error (error, 9, "%s", s);
    monoeg_g_log (0B, 16, "%s", s);
    monoeg_g_free (s);
    return;
    <D.29943>:
    monoeg_g_log (0B, 16, "%s", s);
    monoeg_g_free (s);
    return;
  }
  <D.29931>:
  inst = monoeg_malloc0 (24);
  inst->sp = sp;
  D.29944 = sp->native_offset;
  inst->native_offset = D.29944;
  D.29945 = ji->code_start;
  D.29944 = sp->native_offset;
  D.29946 = (sizetype) D.29944;
  D.29947 = D.29945 + D.29946;
  inst->ip = D.29947;
  inst->ji = ji;
  inst->domain = domain;
  mono_loader_lock ();
  D.29948 = bp->children;
  monoeg_g_ptr_array_add (D.29948, inst);
  D.29949 = inst->ip;
  bp_locs.248 = bp_locs;
  D.29951 = monoeg_g_hash_table_lookup (bp_locs.248, D.29949);
  count = (int) D.29951;
  D.29952 = count + 1;
  D.29953 = (void *) D.29952;
  D.29949 = inst->ip;
  bp_locs.248 = bp_locs;
  monoeg_g_hash_table_insert_replace (bp_locs.248, D.29949, D.29953, 0);
  mono_loader_unlock ();
  D.29944 = sp->native_offset;
  if (D.29944 == -1) goto <D.29954>; else goto <D.29955>;
  <D.29954>:
  log_level.246 = log_level;
  D.29935 = log_level.246 > 0;
  D.29936 = (long int) D.29935;
  D.29937 = __builtin_expect (D.29936, 0);
  if (D.29937 != 0) goto <D.29956>; else goto <D.29957>;
  <D.29956>:
  D.29917 = bp->il_offset;
  log_file.247 = log_file;
  fprintf (log_file.247, "[dbg] Attempting to insert seq point at dead IL offset %d, ignoring.\n", D.29917);
  log_file.247 = log_file;
  fflush (log_file.247);
  <D.29957>:
  goto <D.29958>;
  <D.29955>:
  if (count == 0) goto <D.29959>; else goto <D.29960>;
  <D.29959>:
  D.29949 = inst->ip;
  mono_arch_set_breakpoint (ji, D.29949);
  <D.29960>:
  <D.29958>:
  log_level.246 = log_level;
  D.29935 = log_level.246 > 0;
  D.29936 = (long int) D.29935;
  D.29937 = __builtin_expect (D.29936, 0);
  if (D.29937 != 0) goto <D.29961>; else goto <D.29962>;
  <D.29961>:
  D.29916 = sp->il_offset;
  D.29963 = jinfo_get_method (ji);
  D.29964 = mono_method_full_name (D.29963, 1);
  log_file.247 = log_file;
  fprintf (log_file.247, "[dbg] Inserted breakpoint at %s:0x%x.\n", D.29964, D.29916);
  log_file.247 = log_file;
  fflush (log_file.247);
  <D.29962>:
}


domain_commands (int command, guint8 * p, guint8 * end, struct Buffer * buf)
{
  struct MonoDomain * D.29966;
  guint8 * p.249;
  int err.250;
  ErrorCode D.29971;
  char * D.29972;
  unsigned int count.251;
  struct MonoAssembly * D.29978;
  struct MonoAppDomain * D.29981;
  struct MonoVTable * D.29982;
  struct MonoClass * D.29983;
  struct MonoImage * D.29984;
  struct MonoAssembly * D.29985;
  struct MonoDomain * domain2.252;
  _Bool D.29993;
  long int D.29994;
  long int D.29995;
  void * D.29998;
  struct MonoType * D.29999;
  <unnamed type> D.30000;
  int err.253;
  int err;
  struct MonoDomain * domain;

  try
    {
      switch (command) <default: <D.26808>, case 1: <D.26786>, case 2: <D.26788>, case 3: <D.26789>, case 4: <D.26799>, case 5: <D.26801>, case 6: <D.26800>, case 7: <D.26804>>
      <D.26786>:
      D.29966 = mono_get_root_domain ();
      buffer_add_domainid (buf, D.29966);
      goto <D.26787>;
      <D.26788>:
      p.249 = p;
      domain = decode_domainid (p.249, &p, end, 0B, &err);
      err.250 = err;
      if (err.250 != 0) goto <D.29969>; else goto <D.29970>;
      <D.29969>:
      err.250 = err;
      D.29971 = (ErrorCode) err.250;
      return D.29971;
      <D.29970>:
      D.29972 = domain->friendly_name;
      buffer_add_string (buf, D.29972);
      goto <D.26787>;
      <D.26789>:
      {
        struct GSList * tmp;
        struct MonoAssembly * ass;
        int count;

        p.249 = p;
        domain = decode_domainid (p.249, &p, end, 0B, &err);
        err.250 = err;
        if (err.250 != 0) goto <D.29973>; else goto <D.29974>;
        <D.29973>:
        err.250 = err;
        D.29971 = (ErrorCode) err.250;
        return D.29971;
        <D.29974>:
        mono_loader_lock ();
        count = 0;
        tmp = domain->domain_assemblies;
        goto <D.26794>;
        <D.26793>:
        count = count + 1;
        tmp = tmp->next;
        <D.26794>:
        if (tmp != 0B) goto <D.26793>; else goto <D.26795>;
        <D.26795>:
        count.251 = (unsigned int) count;
        buffer_add_int (buf, count.251);
        tmp = domain->domain_assemblies;
        goto <D.26797>;
        <D.26796>:
        ass = tmp->data;
        buffer_add_assemblyid (buf, domain, ass);
        tmp = tmp->next;
        <D.26797>:
        if (tmp != 0B) goto <D.26796>; else goto <D.26798>;
        <D.26798>:
        mono_loader_unlock ();
        goto <D.26787>;
      }
      <D.26799>:
      p.249 = p;
      domain = decode_domainid (p.249, &p, end, 0B, &err);
      err.250 = err;
      if (err.250 != 0) goto <D.29976>; else goto <D.29977>;
      <D.29976>:
      err.250 = err;
      D.29971 = (ErrorCode) err.250;
      return D.29971;
      <D.29977>:
      D.29978 = domain->entry_assembly;
      buffer_add_assemblyid (buf, domain, D.29978);
      goto <D.26787>;
      <D.26800>:
      p.249 = p;
      domain = decode_domainid (p.249, &p, end, 0B, &err);
      err.250 = err;
      if (err.250 != 0) goto <D.29979>; else goto <D.29980>;
      <D.29979>:
      err.250 = err;
      D.29971 = (ErrorCode) err.250;
      return D.29971;
      <D.29980>:
      D.29981 = domain->domain;
      D.29982 = D.29981->mbr.obj.vtable;
      D.29983 = D.29982->klass;
      D.29984 = D.29983->image;
      D.29985 = D.29984->assembly;
      buffer_add_assemblyid (buf, domain, D.29985);
      goto <D.26787>;
      <D.26801>:
      {
        char * s;
        struct MonoString * o;

        p.249 = p;
        domain = decode_domainid (p.249, &p, end, 0B, &err);
        err.250 = err;
        if (err.250 != 0) goto <D.29986>; else goto <D.29987>;
        <D.29986>:
        err.250 = err;
        D.29971 = (ErrorCode) err.250;
        return D.29971;
        <D.29987>:
        p.249 = p;
        s = decode_string (p.249, &p, end);
        o = mono_string_new (domain, s);
        buffer_add_objid (buf, o);
        goto <D.26787>;
      }
      <D.26804>:
      {
        struct MonoClass * klass;
        struct MonoDomain * domain2;
        struct MonoObject * o;

        try
          {
            p.249 = p;
            domain = decode_domainid (p.249, &p, end, 0B, &err);
            err.250 = err;
            if (err.250 != 0) goto <D.29988>; else goto <D.29989>;
            <D.29988>:
            err.250 = err;
            D.29971 = (ErrorCode) err.250;
            return D.29971;
            <D.29989>:
            p.249 = p;
            klass = decode_typeid (p.249, &p, end, &domain2, &err);
            err.250 = err;
            if (err.250 != 0) goto <D.29990>; else goto <D.29991>;
            <D.29990>:
            err.250 = err;
            D.29971 = (ErrorCode) err.250;
            return D.29971;
            <D.29991>:
            domain2.252 = domain2;
            D.29993 = domain != domain2.252;
            D.29994 = (long int) D.29993;
            D.29995 = __builtin_expect (D.29994, 0);
            if (D.29995 != 0) goto <D.29996>; else goto <D.29997>;
            <D.29996>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 7271, "domain == domain2");
            <D.29997>:
            o = mono_object_new (domain, klass);
            p.249 = p;
            D.29998 = mono_object_unbox (o);
            D.29999 = &klass->byval_arg;
            D.30000 = decode_value (D.29999, domain, D.29998, p.249, &p, end);
            err.253 = (int) D.30000;
            err = err.253;
            err.250 = err;
            if (err.250 != 0) goto <D.30002>; else goto <D.30003>;
            <D.30002>:
            err.250 = err;
            D.29971 = (ErrorCode) err.250;
            return D.29971;
            <D.30003>:
            buffer_add_objid (buf, o);
            goto <D.26787>;
          }
        finally
          {
            domain2 = {CLOBBER};
          }
      }
      <D.26808>:
      D.29971 = 100;
      return D.29971;
      <D.26787>:
      D.29971 = 0;
      return D.29971;
    }
  finally
    {
      err = {CLOBBER};
    }
}


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

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


decode_value (struct MonoType * t, struct MonoDomain * domain, guint8 * addr, guint8 * buf, guint8 * * endbuf, guint8 * limit)
{
  guint8 * buf.254;
  unsigned char D.30011;
  struct MonoClass * D.30014;
  int D.30015;
  struct MonoGenericClass * D.30018;
  struct MonoGenericInst * D.30019;
  <unnamed type> D.30020;
  ErrorCode D.30023;
  unsigned char D.30024;
  int D.30025;
  struct MonoClass * D.30028;
  int D.30029;
  unsigned int D.30030;
  <unnamed type> D.30031;
  struct MonoClass * D.30034;
  struct MonoClass * D.30035;
  struct MonoObject * D.30036;
  struct MonoClass * D.30039;
  int err;
  int type;

  buf.254 = buf;
  type = decode_byte (buf.254, &buf, limit);
  D.30011 = t->type;
  if (D.30011 == 21) goto <D.30012>; else goto <D.30013>;
  <D.30012>:
  D.30014 = mono_class_from_mono_type (t);
  D.30015 = mono_class_is_nullable (D.30014);
  if (D.30015 != 0) goto <D.30016>; else goto <D.30017>;
  <D.30016>:
  {
    struct MonoType * targ;
    guint8 * nullable_buf;

    D.30018 = t->data.generic_class;
    D.30019 = D.30018->context.class_inst;
    targ = D.30019->type_argv[0];
    buf.254 = buf;
    D.30020 = decode_value_internal (t, type, domain, addr, buf.254, endbuf, limit);
    err = (int) D.30020;
    if (err == 0) goto <D.30021>; else goto <D.30022>;
    <D.30021>:
    D.30023 = (ErrorCode) err;
    return D.30023;
    <D.30022>:
    D.30024 = targ->type;
    D.30025 = (int) D.30024;
    if (D.30025 == type) goto <D.30026>; else goto <D.30027>;
    <D.30026>:
    D.30028 = mono_class_from_mono_type (targ);
    D.30029 = mono_class_instance_size (D.30028);
    D.30030 = (unsigned int) D.30029;
    nullable_buf = monoeg_malloc (D.30030);
    buf.254 = buf;
    D.30031 = decode_value_internal (targ, type, domain, nullable_buf, buf.254, endbuf, limit);
    err = (int) D.30031;
    if (err != 0) goto <D.30032>; else goto <D.30033>;
    <D.30032>:
    monoeg_g_free (nullable_buf);
    D.30023 = (ErrorCode) err;
    return D.30023;
    <D.30033>:
    D.30034 = mono_class_from_mono_type (t);
    D.30035 = mono_class_from_mono_type (targ);
    D.30036 = mono_value_box (domain, D.30035, nullable_buf);
    mono_nullable_init (addr, D.30036, D.30034);
    monoeg_g_free (nullable_buf);
    buf.254 = buf;
    *endbuf = buf.254;
    D.30023 = 0;
    return D.30023;
    <D.30027>:
    if (type == 240) goto <D.30037>; else goto <D.30038>;
    <D.30037>:
    D.30039 = mono_class_from_mono_type (t);
    mono_nullable_init (addr, 0B, D.30039);
    buf.254 = buf;
    *endbuf = buf.254;
    D.30023 = 0;
    return D.30023;
    <D.30038>:
  }
  <D.30017>:
  <D.30013>:
  buf.254 = buf;
  D.30023 = decode_value_internal (t, type, domain, addr, buf.254, endbuf, limit);
  return D.30023;
}


decode_value_internal (struct MonoType * t, int type, struct MonoDomain * domain, guint8 * addr, guint8 * buf, guint8 * * endbuf, guint8 * limit)
{
  unsigned char D.30046;
  int D.30047;
  int D.30050;
  int log_level.255;
  _Bool D.30058;
  long int D.30059;
  long int D.30060;
  unsigned int D.30063;
  void * D.30064;
  struct FILE * log_file.256;
  ErrorCode D.30066;
  guint8 * buf.257;
  int D.30068;
  unsigned char D.30069;
  int D.30070;
  short unsigned int D.30071;
  int D.30072;
  signed char D.30073;
  int D.30074;
  unsigned char D.30075;
  int D.30076;
  short int D.30077;
  int D.30078;
  short unsigned int D.30079;
  int D.30080;
  int D.30081;
  unsigned int D.30082;
  long long int D.30083;
  long long int D.30084;
  long long unsigned int D.30085;
  int D.30086;
  unsigned int D.30087;
  long long int D.30088;
  long long unsigned int D.30089;
  _Bool D.30090;
  long int D.30091;
  long int D.30092;
  long long int D.30095;
  int D.30096;
  int D.30097;
  _Bool D.30098;
  long int D.30099;
  long int D.30100;
  <unnamed type> D.30103;
  int err.258;
  int err.259;
  int D.30108;
  <unnamed type> D.30113;
  struct MonoObject * obj.260;
  int D.30119;
  struct MonoVTable * D.30124;
  struct MonoClass * D.30125;
  const char * D.30126;
  char * D.30127;
  struct MonoDomain * D.30130;
  unsigned int vtype_buf_size.261;
  _Bool D.30144;
  long int D.30145;
  long int D.30146;
  <unnamed type> D.30149;
  int err.262;
  struct MonoDomain * d.263;
  struct MonoObject * D.30154;
  unsigned int D.30158;
  void * D.30159;
  int err;
  void handle_vtype = <<< error >>>;
  void handle_ref = <<< error >>>;

  try
    {
      D.30046 = t->type;
      D.30047 = (int) D.30046;
      if (D.30047 != type) goto <D.30048>; else goto <D.30049>;
      <D.30048>:
      D.30050 = mono_type_is_reference (t);
      if (D.30050 == 0) goto <D.30051>; else goto <D.30052>;
      <D.30051>:
      D.30046 = t->type;
      if (D.30046 != 24) goto <D.30045>; else goto <D.30053>;
      <D.30053>:
      if (type != 17) goto <D.30045>; else goto <D.30042>;
      <D.30045>:
      D.30046 = t->type;
      if (D.30046 != 25) goto <D.30044>; else goto <D.30054>;
      <D.30054>:
      if (type != 17) goto <D.30044>; else goto <D.30042>;
      <D.30044>:
      D.30046 = t->type;
      if (D.30046 != 15) goto <D.30043>; else goto <D.30055>;
      <D.30055>:
      if (type != 10) goto <D.30043>; else goto <D.30042>;
      <D.30043>:
      D.30046 = t->type;
      if (D.30046 != 21) goto <D.30041>; else goto <D.30056>;
      <D.30056>:
      if (type != 17) goto <D.30041>; else goto <D.30042>;
      <D.30041>:
      {
        char * name;

        name = mono_type_full_name (t);
        log_level.255 = log_level;
        D.30058 = log_level.255 > 0;
        D.30059 = (long int) D.30058;
        D.30060 = __builtin_expect (D.30059, 0);
        if (D.30060 != 0) goto <D.30061>; else goto <D.30062>;
        <D.30061>:
        D.30063 = GetCurrentThreadId ();
        D.30064 = (void *) D.30063;
        log_file.256 = log_file;
        fprintf (log_file.256, "[%p] Expected value of type %s, got 0x%0x.\n", D.30064, name, type);
        log_file.256 = log_file;
        fflush (log_file.256);
        <D.30062>:
        monoeg_g_free (name);
        D.30066 = 102;
        return D.30066;
      }
      <D.30042>:
      <D.30052>:
      <D.30049>:
      D.30046 = t->type;
      D.30047 = (int) D.30046;
      switch (D.30047) <default: <D.26363>, case 2: <D.26343>, case 3: <D.26345>, case 4: <D.26346>, case 5: <D.26347>, case 6: <D.26348>, case 7: <D.26349>, case 8: <D.26350>, case 9: <D.26351>, case 10: <D.26352>, case 11: <D.26353>, case 12: <D.26354>, case 13: <D.26355>, case 15: <D.26356>, case 17: <D.26362>, case 21: <D.26357>, case 24: <D.26360>, case 25: <D.26361>>
      <D.26343>:
      buf.257 = buf;
      D.30068 = decode_int (buf.257, &buf, limit);
      D.30069 = (unsigned char) D.30068;
      *addr = D.30069;
      goto <D.26344>;
      <D.26345>:
      buf.257 = buf;
      D.30070 = decode_int (buf.257, &buf, limit);
      D.30071 = (short unsigned int) D.30070;
      MEM[(gunichar2 *)addr] = D.30071;
      goto <D.26344>;
      <D.26346>:
      buf.257 = buf;
      D.30072 = decode_int (buf.257, &buf, limit);
      D.30073 = (signed char) D.30072;
      MEM[(gint8 *)addr] = D.30073;
      goto <D.26344>;
      <D.26347>:
      buf.257 = buf;
      D.30074 = decode_int (buf.257, &buf, limit);
      D.30075 = (unsigned char) D.30074;
      *addr = D.30075;
      goto <D.26344>;
      <D.26348>:
      buf.257 = buf;
      D.30076 = decode_int (buf.257, &buf, limit);
      D.30077 = (short int) D.30076;
      MEM[(gint16 *)addr] = D.30077;
      goto <D.26344>;
      <D.26349>:
      buf.257 = buf;
      D.30078 = decode_int (buf.257, &buf, limit);
      D.30079 = (short unsigned int) D.30078;
      MEM[(guint16 *)addr] = D.30079;
      goto <D.26344>;
      <D.26350>:
      buf.257 = buf;
      D.30080 = decode_int (buf.257, &buf, limit);
      MEM[(gint32 *)addr] = D.30080;
      goto <D.26344>;
      <D.26351>:
      buf.257 = buf;
      D.30081 = decode_int (buf.257, &buf, limit);
      D.30082 = (unsigned int) D.30081;
      MEM[(guint32 *)addr] = D.30082;
      goto <D.26344>;
      <D.26352>:
      buf.257 = buf;
      D.30083 = decode_long (buf.257, &buf, limit);
      MEM[(gint64 *)addr] = D.30083;
      goto <D.26344>;
      <D.26353>:
      buf.257 = buf;
      D.30084 = decode_long (buf.257, &buf, limit);
      D.30085 = (long long unsigned int) D.30084;
      MEM[(guint64 *)addr] = D.30085;
      goto <D.26344>;
      <D.26354>:
      buf.257 = buf;
      D.30086 = decode_int (buf.257, &buf, limit);
      D.30087 = (unsigned int) D.30086;
      MEM[(guint32 *)addr] = D.30087;
      goto <D.26344>;
      <D.26355>:
      buf.257 = buf;
      D.30088 = decode_long (buf.257, &buf, limit);
      D.30089 = (long long unsigned int) D.30088;
      MEM[(guint64 *)addr] = D.30089;
      goto <D.26344>;
      <D.26356>:
      D.30090 = type != 10;
      D.30091 = (long int) D.30090;
      D.30092 = __builtin_expect (D.30091, 0);
      if (D.30092 != 0) goto <D.30093>; else goto <D.30094>;
      <D.30093>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 5775, "type == MONO_TYPE_I8");
      <D.30094>:
      buf.257 = buf;
      D.30095 = decode_long (buf.257, &buf, limit);
      D.30096 = (int) D.30095;
      MEM[(gssize *)addr] = D.30096;
      goto <D.26344>;
      <D.26357>:
      D.30097 = mono_type_is_struct (t);
      if (D.30097 != 0) goto handle_vtype; else goto handle_ref;
      <D.26360>:
      <D.26361>:
      D.30098 = type != 17;
      D.30099 = (long int) D.30098;
      D.30100 = __builtin_expect (D.30099, 0);
      if (D.30100 != 0) goto <D.30101>; else goto <D.30102>;
      <D.30101>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 5789, "type == MONO_TYPE_VALUETYPE");
      <D.30102>:
      handle_vtype:
      <D.26362>:
      buf.257 = buf;
      D.30103 = decode_vtype (t, domain, addr, buf.257, &buf, limit);
      err.258 = (int) D.30103;
      err = err.258;
      err.259 = err;
      if (err.259 != 0) goto <D.30106>; else goto <D.30107>;
      <D.30106>:
      err.259 = err;
      D.30066 = (ErrorCode) err.259;
      return D.30066;
      <D.30107>:
      goto <D.26344>;
      handle_ref:
      <D.26363>:
      D.30108 = mono_type_is_reference (t);
      if (D.30108 != 0) goto <D.30109>; else goto <D.30110>;
      <D.30109>:
      if (type == 28) goto <D.30111>; else goto <D.30112>;
      <D.30111>:
      {
        int objid;
        int err;
        struct MonoObject * obj;

        try
          {
            buf.257 = buf;
            objid = decode_objid (buf.257, &buf, limit);
            D.30113 = get_object (objid, &obj);
            err = (int) D.30113;
            if (err != 0) goto <D.30114>; else goto <D.30115>;
            <D.30114>:
            D.30066 = (ErrorCode) err;
            return D.30066;
            <D.30115>:
            obj.260 = obj;
            if (obj.260 != 0B) goto <D.30117>; else goto <D.30118>;
            <D.30117>:
            obj.260 = obj;
            D.30119 = obj_is_of_type (obj.260, t);
            if (D.30119 == 0) goto <D.30120>; else goto <D.30121>;
            <D.30120>:
            log_level.255 = log_level;
            D.30058 = log_level.255 > 0;
            D.30059 = (long int) D.30058;
            D.30060 = __builtin_expect (D.30059, 0);
            if (D.30060 != 0) goto <D.30122>; else goto <D.30123>;
            <D.30122>:
            obj.260 = obj;
            D.30124 = obj.260->vtable;
            D.30125 = D.30124->klass;
            D.30126 = D.30125->name;
            D.30127 = mono_type_full_name (t);
            log_file.256 = log_file;
            fprintf (log_file.256, "Expected type \'%s\', got \'%s\'\n", D.30127, D.30126);
            log_file.256 = log_file;
            fflush (log_file.256);
            <D.30123>:
            D.30066 = 102;
            return D.30066;
            <D.30121>:
            <D.30118>:
            obj.260 = obj;
            if (obj.260 != 0B) goto <D.30128>; else goto <D.30129>;
            <D.30128>:
            obj.260 = obj;
            D.30124 = obj.260->vtable;
            D.30130 = D.30124->domain;
            if (D.30130 != domain) goto <D.30131>; else goto <D.30132>;
            <D.30131>:
            D.30066 = 102;
            return D.30066;
            <D.30132>:
            <D.30129>:
            obj.260 = obj;
            mono_gc_wbarrier_generic_store (addr, obj.260);
          }
        finally
          {
            obj = {CLOBBER};
          }
      }
      goto <D.30133>;
      <D.30112>:
      if (type == 240) goto <D.30134>; else goto <D.30135>;
      <D.30134>:
      MEM[(struct MonoObject * *)addr] = 0B;
      goto <D.30136>;
      <D.30135>:
      if (type == 17) goto <D.30137>; else goto <D.30138>;
      <D.30137>:
      {
        guint8 * buf2;
        gboolean is_enum;
        struct MonoClass * klass;
        struct MonoDomain * d;
        guint8 * vtype_buf;
        int vtype_buf_size;

        try
          {
            buf2 = buf;
            buf.257 = buf;
            is_enum = decode_byte (buf.257, &buf, limit);
            if (is_enum != 0) goto <D.30139>; else goto <D.30140>;
            <D.30139>:
            D.30066 = 100;
            return D.30066;
            <D.30140>:
            buf.257 = buf;
            klass = decode_typeid (buf.257, &buf, limit, &d, &err);
            err.259 = err;
            if (err.259 != 0) goto <D.30141>; else goto <D.30142>;
            <D.30141>:
            err.259 = err;
            D.30066 = (ErrorCode) err.259;
            return D.30066;
            <D.30142>:
            vtype_buf_size = mono_class_value_size (klass, 0B);
            vtype_buf_size.261 = (unsigned int) vtype_buf_size;
            vtype_buf = monoeg_malloc0 (vtype_buf_size.261);
            D.30144 = vtype_buf == 0B;
            D.30145 = (long int) D.30144;
            D.30146 = __builtin_expect (D.30145, 0);
            if (D.30146 != 0) goto <D.30147>; else goto <D.30148>;
            <D.30147>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 5845, "vtype_buf");
            <D.30148>:
            buf = buf2;
            buf.257 = buf;
            D.30149 = decode_vtype (0B, domain, vtype_buf, buf.257, &buf, limit);
            err.262 = (int) D.30149;
            err = err.262;
            err.259 = err;
            if (err.259 != 0) goto <D.30151>; else goto <D.30152>;
            <D.30151>:
            monoeg_g_free (vtype_buf);
            err.259 = err;
            D.30066 = (ErrorCode) err.259;
            return D.30066;
            <D.30152>:
            d.263 = d;
            D.30154 = mono_value_box (d.263, klass, vtype_buf);
            MEM[(struct MonoObject * *)addr] = D.30154;
            monoeg_g_free (vtype_buf);
          }
        finally
          {
            d = {CLOBBER};
          }
      }
      goto <D.30155>;
      <D.30138>:
      {
        char * name;

        name = mono_type_full_name (t);
        log_level.255 = log_level;
        D.30058 = log_level.255 > 0;
        D.30059 = (long int) D.30058;
        D.30060 = __builtin_expect (D.30059, 0);
        if (D.30060 != 0) goto <D.30156>; else goto <D.30157>;
        <D.30156>:
        D.30158 = GetCurrentThreadId ();
        D.30159 = (void *) D.30158;
        log_file.256 = log_file;
        fprintf (log_file.256, "[%p] Expected value of type %s, got 0x%0x.\n", D.30159, name, type);
        log_file.256 = log_file;
        fflush (log_file.256);
        <D.30157>:
        monoeg_g_free (name);
        D.30066 = 102;
        return D.30066;
      }
      <D.30155>:
      <D.30136>:
      <D.30133>:
      goto <D.30160>;
      <D.30110>:
      monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "debugger-agent.c", 5862);
      <D.30160>:
      goto <D.26344>;
      <D.26344>:
      buf.257 = buf;
      *endbuf = buf.257;
      D.30066 = 0;
      return D.30066;
    }
  finally
    {
      err = {CLOBBER};
    }
}


obj_is_of_type (struct MonoObject * obj, struct MonoType * t)
{
  struct MonoVTable * D.30167;
  struct MonoClass * D.30168;
  int D.30169;
  struct MonoClass * D.30172;
  struct MonoRemoteClass * D.30175;
  struct MonoClass * D.30176;
  int D.30177;
  gboolean D.30180;
  struct MonoClass * klass;

  D.30167 = obj->vtable;
  klass = D.30167->klass;
  D.30168 = mono_class_from_mono_type (t);
  D.30169 = mono_class_is_assignable_from (D.30168, klass);
  if (D.30169 == 0) goto <D.30170>; else goto <D.30171>;
  <D.30170>:
  D.30172 = mono_defaults.transparent_proxy_class;
  if (D.30172 == klass) goto <D.30173>; else goto <D.30174>;
  <D.30173>:
  D.30175 = MEM[(struct MonoTransparentProxy *)obj].remote_class;
  klass = D.30175->proxy_class;
  D.30176 = mono_class_from_mono_type (t);
  D.30177 = mono_class_is_assignable_from (D.30176, klass);
  if (D.30177 != 0) goto <D.30178>; else goto <D.30179>;
  <D.30178>:
  D.30180 = 1;
  return D.30180;
  <D.30179>:
  <D.30174>:
  D.30180 = 0;
  return D.30180;
  <D.30171>:
  D.30180 = 1;
  return D.30180;
}


decode_vtype (struct MonoType * t, struct MonoDomain * domain, guint8 * addr, guint8 * buf, guint8 * * endbuf, guint8 * limit)
{
  guint8 * buf.264;
  ErrorCode D.30185;
  int err.265;
  struct MonoClass * D.30191;
  struct MonoType * D.30194;
  int log_level.266;
  _Bool D.30196;
  long int D.30197;
  long int D.30198;
  unsigned int D.30201;
  void * D.30202;
  struct FILE * log_file.267;
  struct MonoType * D.30204;
  short unsigned int D.30205;
  int D.30206;
  int D.30207;
  int D.30210;
  int D.26329;
  int iftmp.268;
  int D.26328;
  const char[9] * D.30216;
  unsigned char D.30217;
  int D.30218;
  unsigned char D.30219;
  int D.30220;
  _Bool D.30221;
  _Bool D.30222;
  _Bool D.30223;
  const unsigned char * D.30226;
  unsigned char D.30227;
  int D.30228;
  const unsigned char * D.30229;
  unsigned char D.30230;
  int D.30231;
  _Bool D.30232;
  _Bool D.30233;
  const unsigned char * D.30236;
  unsigned char D.30237;
  int D.30238;
  const unsigned char * D.30239;
  unsigned char D.30240;
  int D.30241;
  _Bool D.30242;
  _Bool D.30243;
  const unsigned char * D.30246;
  unsigned char D.30247;
  int D.30248;
  const unsigned char * D.30249;
  unsigned char D.30250;
  int D.30251;
  const char * D.30253;
  int D.30256;
  sizetype D.30257;
  sizetype D.30258;
  guint8 * D.30259;
  <unnamed type> D.30260;
  int err.269;
  _Bool D.30264;
  long int D.30265;
  long int D.30266;
  gboolean is_enum;
  struct MonoClass * klass;
  struct MonoClassField * f;
  int nfields;
  void * iter;
  struct MonoDomain * d;
  int err;

  try
    {
      iter = 0B;
      buf.264 = buf;
      is_enum = decode_byte (buf.264, &buf, limit);
      if (is_enum != 0) goto <D.30183>; else goto <D.30184>;
      <D.30183>:
      D.30185 = 100;
      return D.30185;
      <D.30184>:
      buf.264 = buf;
      klass = decode_typeid (buf.264, &buf, limit, &d, &err);
      err.265 = err;
      if (err.265 != 0) goto <D.30187>; else goto <D.30188>;
      <D.30187>:
      err.265 = err;
      D.30185 = (ErrorCode) err.265;
      return D.30185;
      <D.30188>:
      if (t != 0B) goto <D.30189>; else goto <D.30190>;
      <D.30189>:
      D.30191 = mono_class_from_mono_type (t);
      if (D.30191 != klass) goto <D.30192>; else goto <D.30193>;
      <D.30192>:
      {
        char * name;
        char * name2;

        name = mono_type_full_name (t);
        D.30194 = &klass->byval_arg;
        name2 = mono_type_full_name (D.30194);
        log_level.266 = log_level;
        D.30196 = log_level.266 > 0;
        D.30197 = (long int) D.30196;
        D.30198 = __builtin_expect (D.30197, 0);
        if (D.30198 != 0) goto <D.30199>; else goto <D.30200>;
        <D.30199>:
        D.30201 = GetCurrentThreadId ();
        D.30202 = (void *) D.30201;
        log_file.267 = log_file;
        fprintf (log_file.267, "[%p] Expected value of type %s, got %s.\n", D.30202, name, name2);
        log_file.267 = log_file;
        fflush (log_file.267);
        <D.30200>:
        monoeg_g_free (name);
        monoeg_g_free (name2);
        D.30185 = 102;
        return D.30185;
      }
      <D.30193>:
      <D.30190>:
      buf.264 = buf;
      nfields = decode_int (buf.264, &buf, limit);
      goto <D.26320>;
      <D.26330>:
      D.30204 = f->type;
      D.30205 = D.30204->attrs;
      D.30206 = (int) D.30205;
      D.30207 = D.30206 & 16;
      if (D.30207 != 0) goto <D.30208>; else goto <D.30209>;
      <D.30208>:
      // predicted unlikely by continue predictor.
      goto <D.26320>;
      <D.30209>:
      D.30204 = f->type;
      D.30205 = D.30204->attrs;
      D.30206 = (int) D.30205;
      D.30210 = D.30206 & 1536;
      if (D.30210 != 0) goto <D.30211>; else goto <D.30212>;
      <D.30211>:
      {
        size_t __s1_len;
        size_t __s2_len;

        __s2_len = 8;
        if (__s2_len <= 3) goto <D.30214>; else goto <D.30215>;
        <D.30214>:
        {
          const unsigned char * __s2;
          int __result;

          __s2 = mono_field_get_name (f);
          D.30216 = "_Deleted";
          D.30217 = MEM[(const unsigned char *)D.30216];
          D.30218 = (int) D.30217;
          D.30219 = *__s2;
          D.30220 = (int) D.30219;
          __result = D.30218 - D.30220;
          {
            D.30221 = __s2_len != 0;
            D.30222 = __result == 0;
            D.30223 = D.30221 & D.30222;
            if (D.30223 != 0) goto <D.30224>; else goto <D.30225>;
            <D.30224>:
            D.30226 = &MEM[(void *)"_Deleted" + 1B];
            D.30227 = *D.30226;
            D.30228 = (int) D.30227;
            D.30229 = __s2 + 1;
            D.30230 = *D.30229;
            D.30231 = (int) D.30230;
            __result = D.30228 - D.30231;
            D.30232 = __s2_len > 1;
            D.30222 = __result == 0;
            D.30233 = D.30232 & D.30222;
            if (D.30233 != 0) goto <D.30234>; else goto <D.30235>;
            <D.30234>:
            D.30236 = &MEM[(void *)"_Deleted" + 2B];
            D.30237 = *D.30236;
            D.30238 = (int) D.30237;
            D.30239 = __s2 + 2;
            D.30240 = *D.30239;
            D.30241 = (int) D.30240;
            __result = D.30238 - D.30241;
            D.30242 = __s2_len > 2;
            D.30222 = __result == 0;
            D.30243 = D.30242 & D.30222;
            if (D.30243 != 0) goto <D.30244>; else goto <D.30245>;
            <D.30244>:
            D.30246 = &MEM[(void *)"_Deleted" + 3B];
            D.30247 = *D.30246;
            D.30248 = (int) D.30247;
            D.30249 = __s2 + 3;
            D.30250 = *D.30249;
            D.30251 = (int) D.30250;
            __result = D.30248 - D.30251;
            <D.30245>:
            <D.30235>:
            <D.30225>:
          }
          D.26328 = __result;
        }
        iftmp.268 = -D.26328;
        goto <D.30252>;
        <D.30215>:
        D.30253 = mono_field_get_name (f);
        iftmp.268 = __builtin_strcmp (D.30253, "_Deleted");
        <D.30252>:
        D.26329 = iftmp.268;
      }
      if (D.26329 == 0) goto <D.30254>; else goto <D.30255>;
      <D.30254>:
      // predicted unlikely by continue predictor.
      goto <D.26320>;
      <D.30255>:
      <D.30212>:
      buf.264 = buf;
      D.30256 = f->offset;
      D.30257 = (sizetype) D.30256;
      D.30258 = D.30257 + 4294967288;
      D.30259 = addr + D.30258;
      D.30204 = f->type;
      D.30260 = decode_value (D.30204, domain, D.30259, buf.264, &buf, limit);
      err.269 = (int) D.30260;
      err = err.269;
      err.265 = err;
      if (err.265 != 0) goto <D.30262>; else goto <D.30263>;
      <D.30262>:
      err.265 = err;
      D.30185 = (ErrorCode) err.265;
      return D.30185;
      <D.30263>:
      nfields = nfields + -1;
      <D.26320>:
      f = mono_class_get_fields (klass, &iter);
      if (f != 0B) goto <D.26330>; else goto <D.26331>;
      <D.26331>:
      D.30264 = nfields != 0;
      D.30265 = (long int) D.30264;
      D.30266 = __builtin_expect (D.30265, 0);
      if (D.30266 != 0) goto <D.30267>; else goto <D.30268>;
      <D.30267>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 5713, "nfields == 0");
      <D.30268>:
      buf.264 = buf;
      *endbuf = buf.264;
      D.30185 = 0;
      return D.30185;
    }
  finally
    {
      iter = {CLOBBER};
      d = {CLOBBER};
      err = {CLOBBER};
    }
}


assembly_commands (int command, guint8 * p, guint8 * end, struct Buffer * buf)
{
  guint8 * p.270;
  int err.271;
  ErrorCode D.30275;
  struct MonoImage * D.30276;
  const char * D.30277;
  unsigned char D.30278;
  unsigned char D.30279;
  struct MonoDomain * domain.272;
  _Bool D.30287;
  long int D.30288;
  long int D.30289;
  int D.30292;
  const char * D.30296;
  struct MonoClass * iftmp.273;
  const char * iftmp.274;
  unsigned int D.30304;
  unsigned int D.30305;
  const char * iftmp.275;
  unsigned char D.30310;
  const char * iftmp.276;
  const char * D.30317;
  char D.30319;
  short unsigned int D.30321;
  int D.30322;
  short unsigned int D.30323;
  int D.30324;
  short unsigned int D.30325;
  int D.30326;
  short unsigned int D.30327;
  int D.30328;
  const char * D.30329;
  int err;
  struct MonoAssembly * ass;
  struct MonoDomain * domain;

  try
    {
      p.270 = p;
      ass = decode_assemblyid (p.270, &p, end, &domain, &err);
      err.271 = err;
      if (err.271 != 0) goto <D.30273>; else goto <D.30274>;
      <D.30273>:
      err.271 = err;
      D.30275 = (ErrorCode) err.271;
      return D.30275;
      <D.30274>:
      switch (command) <default: <D.26837>, case 1: <D.26818>, case 2: <D.26820>, case 3: <D.26823>, case 4: <D.26824>, case 5: <D.26826>, case 6: <D.26834>>
      <D.26818>:
      D.30276 = ass->image;
      D.30277 = mono_image_get_filename (D.30276);
      buffer_add_string (buf, D.30277);
      goto <D.26819>;
      <D.26820>:
      {
        guint32 token;
        struct MonoMethod * m;

        D.30276 = ass->image;
        D.30278 = BIT_FIELD_REF <*D.30276, 8, 128>;
        D.30279 = D.30278 & 8;
        if (D.30279 != 0) goto <D.30280>; else goto <D.30281>;
        <D.30280>:
        buffer_add_id (buf, 0);
        goto <D.30282>;
        <D.30281>:
        D.30276 = ass->image;
        token = mono_image_get_entry_point (D.30276);
        if (token == 0) goto <D.30283>; else goto <D.30284>;
        <D.30283>:
        buffer_add_id (buf, 0);
        goto <D.30285>;
        <D.30284>:
        D.30276 = ass->image;
        m = mono_get_method (D.30276, token, 0B);
        domain.272 = domain;
        buffer_add_methodid (buf, domain.272, m);
        <D.30285>:
        <D.30282>:
        goto <D.26819>;
      }
      <D.26823>:
      D.30276 = ass->image;
      domain.272 = domain;
      buffer_add_moduleid (buf, domain.272, D.30276);
      goto <D.26819>;
      <D.26824>:
      {
        struct MonoObject * o;

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

        try
          {
            p.270 = p;
            s = decode_string (p.270, &p, end);
            p.270 = p;
            ignorecase = decode_byte (p.270, &p, end);
            d = mono_domain_get ();
            domain.272 = domain;
            res = mono_domain_set (domain.272, 0);
            D.30287 = res == 0;
            D.30288 = (long int) D.30287;
            D.30289 = __builtin_expect (D.30288, 0);
            if (D.30289 != 0) goto <D.30290>; else goto <D.30291>;
            <D.30290>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 7341, "res");
            <D.30291>:
            D.30292 = mono_reflection_parse_type (s, &info);
            if (D.30292 == 0) goto <D.30293>; else goto <D.30294>;
            <D.30293>:
            t = 0B;
            goto <D.30295>;
            <D.30294>:
            D.30296 = info.assembly.name;
            if (D.30296 != 0B) goto <D.30297>; else goto <D.30298>;
            <D.30297>:
            monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "debugger-agent.c", 7347);
            <D.30298>:
            D.30276 = ass->image;
            t = mono_reflection_get_type (D.30276, &info, ignorecase, &type_resolve);
            <D.30295>:
            if (t != 0B) goto <D.30300>; else goto <D.30301>;
            <D.30300>:
            iftmp.273 = mono_class_from_mono_type (t);
            goto <D.30302>;
            <D.30301>:
            iftmp.273 = 0B;
            <D.30302>:
            domain.272 = domain;
            buffer_add_typeid (buf, domain.272, iftmp.273);
            mono_reflection_free_type_info (&info);
            monoeg_g_free (s);
            mono_domain_set (d, 1);
            goto <D.26819>;
          }
        finally
          {
            info = {CLOBBER};
            type_resolve = {CLOBBER};
          }
      }
      <D.26834>:
      {
        gchar * name;
        struct MonoAssembly * mass;

        mass = ass;
        D.30304 = mass->aname.flags;
        D.30305 = D.30304 & 256;
        if (D.30305 != 0) goto <D.30306>; else goto <D.30307>;
        <D.30306>:
        iftmp.274 = ", Retargetable=Yes";
        goto <D.30308>;
        <D.30307>:
        iftmp.274 = "";
        <D.30308>:
        D.30310 = mass->aname.public_key_token[0];
        if (D.30310 != 0) goto <D.30311>; else goto <D.30312>;
        <D.30311>:
        iftmp.275 = &mass->aname.public_key_token;
        goto <D.30313>;
        <D.30312>:
        iftmp.275 = "null";
        <D.30313>:
        D.30317 = mass->aname.culture;
        if (D.30317 != 0B) goto <D.30318>; else goto <D.30315>;
        <D.30318>:
        D.30317 = mass->aname.culture;
        D.30319 = *D.30317;
        if (D.30319 != 0) goto <D.30320>; else goto <D.30315>;
        <D.30320>:
        iftmp.276 = mass->aname.culture;
        goto <D.30316>;
        <D.30315>:
        iftmp.276 = "neutral";
        <D.30316>:
        D.30321 = mass->aname.revision;
        D.30322 = (int) D.30321;
        D.30323 = mass->aname.build;
        D.30324 = (int) D.30323;
        D.30325 = mass->aname.minor;
        D.30326 = (int) D.30325;
        D.30327 = mass->aname.major;
        D.30328 = (int) D.30327;
        D.30329 = mass->aname.name;
        name = monoeg_g_strdup_printf ("%s, Version=%d.%d.%d.%d, Culture=%s, PublicKeyToken=%s%s", D.30329, D.30328, D.30326, D.30324, D.30322, iftmp.276, iftmp.275, iftmp.274);
        buffer_add_string (buf, name);
        monoeg_g_free (name);
        goto <D.26819>;
      }
      <D.26837>:
      D.30275 = 100;
      return D.30275;
      <D.26819>:
      D.30275 = 0;
      return D.30275;
    }
  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.277;
  char * D.30334;
  const char * D.30335;
  const char * D.30336;
  struct MonoAssembly * D.30337;
  struct MonoDomain * domain.278;
  ErrorCode D.30339;
  int err;
  struct MonoDomain * domain;

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

        p.277 = p;
        image = decode_moduleid (p.277, &p, end, &domain, &err);
        D.30334 = image->name;
        basename = monoeg_g_path_get_basename (D.30334);
        buffer_add_string (buf, basename);
        D.30335 = image->module_name;
        buffer_add_string (buf, D.30335);
        D.30334 = image->name;
        buffer_add_string (buf, D.30334);
        D.30336 = mono_image_get_guid (image);
        buffer_add_string (buf, D.30336);
        D.30337 = image->assembly;
        domain.278 = domain;
        buffer_add_assemblyid (buf, domain.278, D.30337);
        monoeg_g_free (basename);
        goto <D.26849>;
      }
      <D.26850>:
      D.30339 = 100;
      return D.30339;
      <D.26849>:
      D.30339 = 0;
      return D.30339;
    }
  finally
    {
      err = {CLOBBER};
      domain = {CLOBBER};
    }
}


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

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


type_commands (int command, guint8 * p, guint8 * end, struct Buffer * buf)
{
  guint8 * p.279;
  int err.280;
  ErrorCode D.30348;
  struct MonoDomain * domain.281;
  <unnamed type> D.30350;
  int err.282;
  struct MonoClass * klass;
  struct MonoDomain * old_domain;
  struct MonoDomain * domain;
  int err;

  try
    {
      p.279 = p;
      klass = decode_typeid (p.279, &p, end, &domain, &err);
      err.280 = err;
      if (err.280 != 0) goto <D.30346>; else goto <D.30347>;
      <D.30346>:
      err.280 = err;
      D.30348 = (ErrorCode) err.280;
      return D.30348;
      <D.30347>:
      old_domain = mono_domain_get ();
      domain.281 = domain;
      mono_domain_set (domain.281, 1);
      p.279 = p;
      domain.281 = domain;
      D.30350 = type_commands_internal (command, klass, domain.281, p.279, end, buf);
      err.282 = (int) D.30350;
      err = err.282;
      mono_domain_set (old_domain, 1);
      err.280 = err;
      D.30348 = (ErrorCode) err.280;
      return D.30348;
    }
  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.30354;
  const char * D.30355;
  struct MonoType * D.30356;
  struct MonoImage * D.30357;
  struct MonoAssembly * D.30358;
  struct MonoClass * D.30359;
  unsigned char D.30363;
  unsigned char D.30365;
  struct MonoClass * D.30366;
  unsigned int D.30367;
  int D.30368;
  unsigned int D.30369;
  unsigned char D.30372;
  unsigned char D.30377;
  unsigned char D.30378;
  unsigned char D.30381;
  unsigned char D.30382;
  _Bool D.30383;
  _Bool D.30384;
  _Bool D.30385;
  unsigned char D.30389;
  unsigned char D.30390;
  struct MonoGenericContainer * D.30393;
  struct MonoGenericClass * D.30399;
  int D.30400;
  unsigned int nnested.283;
  int protocol_version_set.284;
  int major_version.285;
  int minor_version.286;
  struct MonoClass * D.30416;
  <unnamed-unsigned:22> D.30426;
  unsigned int count.287;
  struct MonoType * D.30428;
  struct MonoClass * D.30429;
  <unnamed-signed:31> D.30433;
  struct MonoGenericParamFull * D.30434;
  unsigned int i.288;
  unsigned int D.30436;
  struct MonoGenericParam * D.30437;
  unsigned int nmethods.289;
  _Bool D.30440;
  long int D.30441;
  long int D.30442;
  unsigned int nfields.290;
  const char * D.30446;
  struct MonoType * D.30447;
  struct MonoClass * D.30448;
  short unsigned int D.30449;
  unsigned int D.30450;
  _Bool D.30451;
  long int D.30452;
  long int D.30453;
  unsigned int nprops.291;
  const char * D.30457;
  struct MonoMethod * D.30458;
  struct MonoMethod * D.30459;
  unsigned int D.30460;
  _Bool D.30461;
  long int D.30462;
  long int D.30463;
  guint8 * p.292;
  int err.293;
  ErrorCode D.30470;
  <unnamed type> D.30481;
  struct MonoThread * thread_obj.294;
  struct MonoType * D.30487;
  short unsigned int D.30488;
  int D.30489;
  int D.30490;
  _Bool D.30495;
  _Bool D.30496;
  _Bool D.30497;
  struct MonoClass * D.30500;
  struct MonoClass * D.30505;
  int D.30506;
  unsigned int D.30507;
  struct MonoInternalThread * iftmp.295;
  struct MonoType * D.30514;
  short unsigned int D.30515;
  int D.30516;
  int D.30517;
  int D.30520;
  struct MonoClass * D.30523;
  struct MonoClass * D.30528;
  int D.30529;
  unsigned int D.30530;
  <unnamed type> D.30531;
  int err.296;
  int D.30535;
  void * D.30538;
  unsigned int D.30540;
  void * * D.30541;
  unsigned int i.297;
  unsigned int D.30543;
  void * * D.30544;
  unsigned int i.298;
  int D.30551;
  int D.30555;
  _Bool D.30556;
  int D.30557;
  unsigned int flags.299;
  unsigned int D.30559;
  unsigned int D.30562;
  void * * D.30563;
  unsigned int i.300;
  unsigned int D.30565;
  void * * D.30566;
  unsigned int i.301;
  int D.30568;
  int D.30571;
  unsigned int D.30574;
  struct MonoClass * iface.302;
  int D.30576;
  unsigned int nmethods.303;
  struct MonoMethod * * D.30582;
  int D.30583;
  unsigned int D.30584;
  unsigned int D.30585;
  struct MonoMethod * * D.30586;
  struct MonoMethod * D.30587;
  unsigned char D.30590;
  unsigned char D.30591;
  _Bool D.30592;
  unsigned int D.30593;
  struct MonoClass * nested;
  struct MonoType * type;
  void * iter;
  guint8 b;
  int err;
  int nnested;
  char * name;

  try
    {
      switch (command) <default: <D.27057>, case 1: <D.26912>, case 2: <D.26931>, case 3: <D.26939>, case 4: <D.26966>, case 5: <D.27000>, case 6: <D.27002>, case 7: <D.26986>, case 8: <D.27011>, case 9: <D.26947>, case 10: <D.26955>, case 11: <D.26958>, case 12: <D.26962>, case 13: <D.27003>, case 14: <D.26967>, case 15: <D.27013>, case 16: <D.27023>, case 17: <D.27036>, case 18: <D.27055>>
      <D.26912>:
      D.30354 = klass->name_space;
      buffer_add_string (buf, D.30354);
      D.30355 = klass->name;
      buffer_add_string (buf, D.30355);
      D.30356 = &klass->byval_arg;
      name = mono_type_get_name_full (D.30356, 2);
      buffer_add_string (buf, name);
      monoeg_g_free (name);
      D.30357 = klass->image;
      D.30358 = D.30357->assembly;
      buffer_add_assemblyid (buf, domain, D.30358);
      D.30357 = klass->image;
      buffer_add_moduleid (buf, domain, D.30357);
      D.30359 = klass->parent;
      buffer_add_typeid (buf, domain, D.30359);
      D.30363 = klass->rank;
      if (D.30363 != 0) goto <D.30360>; else goto <D.30364>;
      <D.30364>:
      D.30365 = klass->byval_arg.type;
      if (D.30365 == 15) goto <D.30360>; else goto <D.30361>;
      <D.30360>:
      D.30366 = klass->element_class;
      buffer_add_typeid (buf, domain, D.30366);
      goto <D.30362>;
      <D.30361>:
      buffer_add_id (buf, 0);
      <D.30362>:
      D.30367 = klass->type_token;
      buffer_add_int (buf, D.30367);
      D.30363 = klass->rank;
      D.30368 = (int) D.30363;
      buffer_add_byte (buf, D.30368);
      D.30369 = klass->flags;
      buffer_add_int (buf, D.30369);
      b = 0;
      type = &klass->byval_arg;
      if (0 != 0) goto <D.30370>; else goto <D.30371>;
      <D.30370>:
      b = b | 1;
      <D.30371>:
      D.30372 = type->type;
      if (D.30372 == 15) goto <D.30373>; else goto <D.30374>;
      <D.30373>:
      b = b | 2;
      <D.30374>:
      D.30377 = BIT_FIELD_REF <*type, 8, 56>;
      D.30378 = D.30377 & 64;
      if (D.30378 == 0) goto <D.30379>; else goto <D.30380>;
      <D.30379>:
      D.30381 = type->type;
      D.30382 = D.30381 + 254;
      D.30383 = D.30382 <= 11;
      D.30384 = D.30381 == 24;
      D.30385 = D.30383 | D.30384;
      if (D.30385 != 0) goto <D.30375>; else goto <D.30386>;
      <D.30386>:
      D.30372 = type->type;
      if (D.30372 == 25) goto <D.30375>; else goto <D.30376>;
      <D.30375>:
      b = b | 4;
      <D.30376>:
      <D.30380>:
      D.30372 = type->type;
      if (D.30372 == 17) goto <D.30387>; else goto <D.30388>;
      <D.30387>:
      b = b | 8;
      <D.30388>:
      D.30389 = BIT_FIELD_REF <*klass, 8, 160>;
      D.30390 = D.30389 & 16;
      if (D.30390 != 0) goto <D.30391>; else goto <D.30392>;
      <D.30391>:
      b = b | 16;
      <D.30392>:
      D.30393 = klass->generic_container;
      if (D.30393 != 0B) goto <D.30394>; else goto <D.30395>;
      <D.30394>:
      b = b | 32;
      <D.30395>:
      D.30393 = klass->generic_container;
      if (D.30393 != 0B) goto <D.30396>; else goto <D.30398>;
      <D.30398>:
      D.30399 = klass->generic_class;
      if (D.30399 != 0B) goto <D.30396>; else goto <D.30397>;
      <D.30396>:
      b = b | 64;
      <D.30397>:
      D.30400 = (int) b;
      buffer_add_byte (buf, D.30400);
      nnested = 0;
      iter = 0B;
      goto <D.26914>;
      <D.26913>:
      nnested = nnested + 1;
      <D.26914>:
      nested = mono_class_get_nested_types (klass, &iter);
      if (nested != 0B) goto <D.26913>; else goto <D.26915>;
      <D.26915>:
      nnested.283 = (unsigned int) nnested;
      buffer_add_int (buf, nnested.283);
      iter = 0B;
      goto <D.26917>;
      <D.26916>:
      buffer_add_typeid (buf, domain, nested);
      <D.26917>:
      nested = mono_class_get_nested_types (klass, &iter);
      if (nested != 0B) goto <D.26916>; else goto <D.26918>;
      <D.26918>:
      protocol_version_set.284 = protocol_version_set;
      if (protocol_version_set.284 != 0) goto <D.30405>; else goto <D.30406>;
      <D.30405>:
      major_version.285 = major_version;
      if (major_version.285 > 2) goto <D.30402>; else goto <D.30408>;
      <D.30408>:
      major_version.285 = major_version;
      if (major_version.285 == 2) goto <D.30409>; else goto <D.30403>;
      <D.30409>:
      minor_version.286 = minor_version;
      if (minor_version.286 > 11) goto <D.30402>; else goto <D.30403>;
      <D.30402>:
      D.30393 = klass->generic_container;
      if (D.30393 != 0B) goto <D.30411>; else goto <D.30412>;
      <D.30411>:
      buffer_add_typeid (buf, domain, klass);
      goto <D.30413>;
      <D.30412>:
      D.30399 = klass->generic_class;
      if (D.30399 != 0B) goto <D.30414>; else goto <D.30415>;
      <D.30414>:
      D.30399 = klass->generic_class;
      D.30416 = D.30399->container_class;
      buffer_add_typeid (buf, domain, D.30416);
      goto <D.30417>;
      <D.30415>:
      buffer_add_id (buf, 0);
      <D.30417>:
      <D.30413>:
      <D.30403>:
      <D.30406>:
      protocol_version_set.284 = protocol_version_set;
      if (protocol_version_set.284 != 0) goto <D.30420>; else goto <D.30421>;
      <D.30420>:
      major_version.285 = major_version;
      if (major_version.285 > 2) goto <D.30418>; else goto <D.30422>;
      <D.30422>:
      major_version.285 = major_version;
      if (major_version.285 == 2) goto <D.30423>; else goto <D.30419>;
      <D.30423>:
      minor_version.286 = minor_version;
      if (minor_version.286 > 14) goto <D.30418>; else goto <D.30419>;
      <D.30418>:
      {
        int count;
        int i;

        D.30399 = klass->generic_class;
        if (D.30399 != 0B) goto <D.30424>; else goto <D.30425>;
        <D.30424>:
        {
          struct MonoGenericInst * inst;

          D.30399 = klass->generic_class;
          inst = D.30399->context.class_inst;
          D.30426 = inst->type_argc;
          count = (int) D.30426;
          count.287 = (unsigned int) count;
          buffer_add_int (buf, count.287);
          i = 0;
          goto <D.26923>;
          <D.26922>:
          D.30428 = inst->type_argv[i];
          D.30429 = mono_class_from_mono_type (D.30428);
          buffer_add_typeid (buf, domain, D.30429);
          i = i + 1;
          <D.26923>:
          if (i < count) goto <D.26922>; else goto <D.26924>;
          <D.26924>:
        }
        goto <D.30430>;
        <D.30425>:
        D.30393 = klass->generic_container;
        if (D.30393 != 0B) goto <D.30431>; else goto <D.30432>;
        <D.30431>:
        {
          struct MonoGenericContainer * container;
          struct MonoClass * pklass;

          container = klass->generic_container;
          D.30433 = container->type_argc;
          count = (int) D.30433;
          count.287 = (unsigned int) count;
          buffer_add_int (buf, count.287);
          i = 0;
          goto <D.26928>;
          <D.26927>:
          D.30357 = klass->image;
          D.30434 = container->type_params;
          i.288 = (unsigned int) i;
          D.30436 = i.288 * 32;
          D.30437 = D.30434 + D.30436;
          pklass = mono_class_from_generic_parameter (D.30437, D.30357, 0);
          buffer_add_typeid (buf, domain, pklass);
          i = i + 1;
          <D.26928>:
          if (i < count) goto <D.26927>; else goto <D.26929>;
          <D.26929>:
        }
        goto <D.30438>;
        <D.30432>:
        buffer_add_int (buf, 0);
        <D.30438>:
        <D.30430>:
      }
      <D.30419>:
      <D.30421>:
      goto <D.26930>;
      <D.26931>:
      {
        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.289 = (unsigned int) nmethods;
            buffer_add_int (buf, nmethods.289);
            goto <D.26937>;
            <D.26936>:
            buffer_add_methodid (buf, domain, m);
            i = i + 1;
            <D.26937>:
            m = mono_class_get_methods (klass, &iter);
            if (m != 0B) goto <D.26936>; else goto <D.26938>;
            <D.26938>:
            D.30440 = i != nmethods;
            D.30441 = (long int) D.30440;
            D.30442 = __builtin_expect (D.30441, 0);
            if (D.30442 != 0) goto <D.30443>; else goto <D.30444>;
            <D.30443>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 7618, "i == nmethods");
            <D.30444>:
            goto <D.26930>;
          }
        finally
          {
            iter = {CLOBBER};
          }
      }
      <D.26939>:
      {
        int nfields;
        int i;
        void * iter;
        struct MonoClassField * f;

        try
          {
            i = 0;
            iter = 0B;
            nfields = mono_class_num_fields (klass);
            nfields.290 = (unsigned int) nfields;
            buffer_add_int (buf, nfields.290);
            goto <D.26945>;
            <D.26944>:
            buffer_add_fieldid (buf, domain, f);
            D.30446 = f->name;
            buffer_add_string (buf, D.30446);
            D.30447 = f->type;
            D.30448 = mono_class_from_mono_type (D.30447);
            buffer_add_typeid (buf, domain, D.30448);
            D.30447 = f->type;
            D.30449 = D.30447->attrs;
            D.30450 = (unsigned int) D.30449;
            buffer_add_int (buf, D.30450);
            i = i + 1;
            <D.26945>:
            f = mono_class_get_fields (klass, &iter);
            if (f != 0B) goto <D.26944>; else goto <D.26946>;
            <D.26946>:
            D.30451 = i != nfields;
            D.30452 = (long int) D.30451;
            D.30453 = __builtin_expect (D.30452, 0);
            if (D.30453 != 0) goto <D.30454>; else goto <D.30455>;
            <D.30454>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 7638, "i == nfields");
            <D.30455>:
            goto <D.26930>;
          }
        finally
          {
            iter = {CLOBBER};
          }
      }
      <D.26947>:
      {
        int nprops;
        int i;
        void * iter;
        struct MonoProperty * p;

        try
          {
            i = 0;
            iter = 0B;
            nprops = mono_class_num_properties (klass);
            nprops.291 = (unsigned int) nprops;
            buffer_add_int (buf, nprops.291);
            goto <D.26953>;
            <D.26952>:
            buffer_add_propertyid (buf, domain, p);
            D.30457 = p->name;
            buffer_add_string (buf, D.30457);
            D.30458 = p->get;
            buffer_add_methodid (buf, domain, D.30458);
            D.30459 = p->set;
            buffer_add_methodid (buf, domain, D.30459);
            D.30460 = p->attrs;
            buffer_add_int (buf, D.30460);
            i = i + 1;
            <D.26953>:
            p = mono_class_get_properties (klass, &iter);
            if (p != 0B) goto <D.26952>; else goto <D.26954>;
            <D.26954>:
            D.30461 = i != nprops;
            D.30462 = (long int) D.30461;
            D.30463 = __builtin_expect (D.30462, 0);
            if (D.30463 != 0) goto <D.30464>; else goto <D.30465>;
            <D.30464>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 7659, "i == nprops");
            <D.30465>:
            goto <D.26930>;
          }
        finally
          {
            iter = {CLOBBER};
          }
      }
      <D.26955>:
      {
        struct MonoClass * attr_klass;
        struct MonoCustomAttrInfo * cinfo;

        p.292 = p;
        attr_klass = decode_typeid (p.292, &p, end, 0B, &err);
        err.293 = err;
        if (err.293 != 0) goto <D.30468>; else goto <D.30469>;
        <D.30468>:
        err.293 = err;
        D.30470 = (ErrorCode) err.293;
        return D.30470;
        <D.30469>:
        cinfo = mono_custom_attrs_from_class (klass);
        D.30357 = klass->image;
        buffer_add_cattrs (buf, domain, D.30357, attr_klass, cinfo);
        goto <D.26930>;
      }
      <D.26958>:
      {
        struct MonoClass * attr_klass;
        struct MonoCustomAttrInfo * cinfo;
        struct MonoClassField * field;

        p.292 = p;
        field = decode_fieldid (p.292, &p, end, 0B, &err);
        err.293 = err;
        if (err.293 != 0) goto <D.30471>; else goto <D.30472>;
        <D.30471>:
        err.293 = err;
        D.30470 = (ErrorCode) err.293;
        return D.30470;
        <D.30472>:
        p.292 = p;
        attr_klass = decode_typeid (p.292, &p, end, 0B, &err);
        err.293 = err;
        if (err.293 != 0) goto <D.30473>; else goto <D.30474>;
        <D.30473>:
        err.293 = err;
        D.30470 = (ErrorCode) err.293;
        return D.30470;
        <D.30474>:
        cinfo = mono_custom_attrs_from_field (klass, field);
        D.30357 = klass->image;
        buffer_add_cattrs (buf, domain, D.30357, attr_klass, cinfo);
        goto <D.26930>;
      }
      <D.26962>:
      {
        struct MonoClass * attr_klass;
        struct MonoCustomAttrInfo * cinfo;
        struct MonoProperty * prop;

        p.292 = p;
        prop = decode_propertyid (p.292, &p, end, 0B, &err);
        err.293 = err;
        if (err.293 != 0) goto <D.30475>; else goto <D.30476>;
        <D.30475>:
        err.293 = err;
        D.30470 = (ErrorCode) err.293;
        return D.30470;
        <D.30476>:
        p.292 = p;
        attr_klass = decode_typeid (p.292, &p, end, 0B, &err);
        err.293 = err;
        if (err.293 != 0) goto <D.30477>; else goto <D.30478>;
        <D.30477>:
        err.293 = err;
        D.30470 = (ErrorCode) err.293;
        return D.30470;
        <D.30478>:
        cinfo = mono_custom_attrs_from_property (klass, prop);
        D.30357 = klass->image;
        buffer_add_cattrs (buf, domain, D.30357, attr_klass, cinfo);
        goto <D.26930>;
      }
      <D.26966>:
      <D.26967>:
      {
        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.30479>; else goto <D.30480>;
            <D.30479>:
            {
              int objid;
              int err;

              p.292 = p;
              objid = decode_objid (p.292, &p, end);
              D.30481 = get_object (objid, &thread_obj);
              err = (int) D.30481;
              if (err != 0) goto <D.30482>; else goto <D.30483>;
              <D.30482>:
              D.30470 = (ErrorCode) err;
              return D.30470;
              <D.30483>:
              thread_obj.294 = thread_obj;
              thread = thread_obj.294->internal_thread;
            }
            <D.30480>:
            p.292 = p;
            len = decode_int (p.292, &p, end);
            i = 0;
            goto <D.26984>;
            <D.26983>:
            p.292 = p;
            f = decode_fieldid (p.292, &p, end, 0B, &err);
            err.293 = err;
            if (err.293 != 0) goto <D.30485>; else goto <D.30486>;
            <D.30485>:
            err.293 = err;
            D.30470 = (ErrorCode) err.293;
            return D.30470;
            <D.30486>:
            D.30487 = f->type;
            D.30488 = D.30487->attrs;
            D.30489 = (int) D.30488;
            D.30490 = D.30489 & 16;
            if (D.30490 == 0) goto <D.30491>; else goto <D.30492>;
            <D.30491>:
            D.30470 = 25;
            return D.30470;
            <D.30492>:
            special_static_type = mono_class_field_get_special_static_type (f);
            if (special_static_type != 0) goto <D.30493>; else goto <D.30494>;
            <D.30493>:
            D.30495 = thread == 0B;
            D.30496 = special_static_type != 1;
            D.30497 = D.30495 | D.30496;
            if (D.30497 != 0) goto <D.30498>; else goto <D.30499>;
            <D.30498>:
            D.30470 = 25;
            return D.30470;
            <D.30499>:
            <D.30494>:
            found = 0;
            k = klass;
            goto <D.26982>;
            <D.26981>:
            D.30500 = f->parent;
            if (D.30500 == k) goto <D.30501>; else goto <D.30502>;
            <D.30501>:
            found = 1;
            goto <D.26980>;
            <D.30502>:
            k = k->parent;
            <D.26982>:
            if (k != 0B) goto <D.26981>; else goto <D.26980>;
            <D.26980>:
            if (found == 0) goto <D.30503>; else goto <D.30504>;
            <D.30503>:
            D.30470 = 25;
            return D.30470;
            <D.30504>:
            D.30500 = f->parent;
            vtable = mono_class_vtable (domain, D.30500);
            D.30487 = f->type;
            D.30505 = mono_class_from_mono_type (D.30487);
            D.30506 = mono_class_instance_size (D.30505);
            D.30507 = (unsigned int) D.30506;
            val = monoeg_malloc (D.30507);
            if (thread == 0B) goto <D.30509>; else goto <D.30510>;
            <D.30509>:
            iftmp.295 = mono_thread_internal_current ();
            goto <D.30511>;
            <D.30510>:
            iftmp.295 = thread;
            <D.30511>:
            mono_field_static_get_value_for_thread (iftmp.295, vtable, f, val);
            D.30487 = f->type;
            buffer_add_value (buf, D.30487, val, domain);
            monoeg_g_free (val);
            i = i + 1;
            <D.26984>:
            if (i < len) goto <D.26983>; else goto <D.26985>;
            <D.26985>:
            goto <D.26930>;
          }
        finally
          {
            thread_obj = {CLOBBER};
          }
      }
      <D.26986>:
      {
        guint8 * val;
        struct MonoClassField * f;
        struct MonoVTable * vtable;
        struct MonoClass * k;
        int len;
        int i;
        gboolean found;

        p.292 = p;
        len = decode_int (p.292, &p, end);
        i = 0;
        goto <D.26998>;
        <D.26997>:
        p.292 = p;
        f = decode_fieldid (p.292, &p, end, 0B, &err);
        err.293 = err;
        if (err.293 != 0) goto <D.30512>; else goto <D.30513>;
        <D.30512>:
        err.293 = err;
        D.30470 = (ErrorCode) err.293;
        return D.30470;
        <D.30513>:
        D.30514 = f->type;
        D.30515 = D.30514->attrs;
        D.30516 = (int) D.30515;
        D.30517 = D.30516 & 16;
        if (D.30517 == 0) goto <D.30518>; else goto <D.30519>;
        <D.30518>:
        D.30470 = 25;
        return D.30470;
        <D.30519>:
        D.30520 = mono_class_field_is_special_static (f);
        if (D.30520 != 0) goto <D.30521>; else goto <D.30522>;
        <D.30521>:
        D.30470 = 25;
        return D.30470;
        <D.30522>:
        found = 0;
        k = klass;
        goto <D.26996>;
        <D.26995>:
        D.30523 = f->parent;
        if (D.30523 == k) goto <D.30524>; else goto <D.30525>;
        <D.30524>:
        found = 1;
        goto <D.26994>;
        <D.30525>:
        k = k->parent;
        <D.26996>:
        if (k != 0B) goto <D.26995>; else goto <D.26994>;
        <D.26994>:
        if (found == 0) goto <D.30526>; else goto <D.30527>;
        <D.30526>:
        D.30470 = 25;
        return D.30470;
        <D.30527>:
        D.30523 = f->parent;
        vtable = mono_class_vtable (domain, D.30523);
        D.30514 = f->type;
        D.30528 = mono_class_from_mono_type (D.30514);
        D.30529 = mono_class_instance_size (D.30528);
        D.30530 = (unsigned int) D.30529;
        val = monoeg_malloc (D.30530);
        p.292 = p;
        D.30514 = f->type;
        D.30531 = decode_value (D.30514, domain, val, p.292, &p, end);
        err.296 = (int) D.30531;
        err = err.296;
        err.293 = err;
        if (err.293 != 0) goto <D.30533>; else goto <D.30534>;
        <D.30533>:
        monoeg_g_free (val);
        err.293 = err;
        D.30470 = (ErrorCode) err.293;
        return D.30470;
        <D.30534>:
        D.30514 = f->type;
        D.30535 = mono_type_is_reference (D.30514);
        if (D.30535 != 0) goto <D.30536>; else goto <D.30537>;
        <D.30536>:
        D.30538 = MEM[(void * *)val];
        mono_field_static_set_value (vtable, f, D.30538);
        goto <D.30539>;
        <D.30537>:
        mono_field_static_set_value (vtable, f, val);
        <D.30539>:
        monoeg_g_free (val);
        i = i + 1;
        <D.26998>:
        if (i < len) goto <D.26997>; else goto <D.26999>;
        <D.26999>:
        goto <D.26930>;
      }
      <D.27000>:
      {
        struct MonoObject * o;

        D.30356 = &klass->byval_arg;
        o = mono_type_get_object (domain, D.30356);
        buffer_add_objid (buf, o);
        goto <D.26930>;
      }
      <D.27002>:
      <D.27003>:
      {
        char * source_file;
        char * base;
        struct GPtrArray * files;
        int i;

        files = get_source_files_for_type (klass);
        D.30540 = files->len;
        buffer_add_int (buf, D.30540);
        i = 0;
        goto <D.27009>;
        <D.27008>:
        D.30541 = files->pdata;
        i.297 = (unsigned int) i;
        D.30543 = i.297 * 4;
        D.30544 = D.30541 + D.30543;
        source_file = *D.30544;
        if (command == 13) goto <D.30545>; else goto <D.30546>;
        <D.30545>:
        buffer_add_string (buf, source_file);
        goto <D.30547>;
        <D.30546>:
        base = monoeg_g_path_get_basename (source_file);
        buffer_add_string (buf, base);
        monoeg_g_free (base);
        <D.30547>:
        monoeg_g_free (source_file);
        i = i + 1;
        <D.27009>:
        i.298 = (unsigned int) i;
        D.30540 = files->len;
        if (i.298 < D.30540) goto <D.27008>; else goto <D.27010>;
        <D.27010>:
        monoeg_g_ptr_array_free (files, 1);
        goto <D.26930>;
      }
      <D.27011>:
      {
        struct MonoClass * oklass;

        p.292 = p;
        oklass = decode_typeid (p.292, &p, end, 0B, &err);
        err.293 = err;
        if (err.293 != 0) goto <D.30549>; else goto <D.30550>;
        <D.30549>:
        err.293 = err;
        D.30470 = (ErrorCode) err.293;
        return D.30470;
        <D.30550>:
        D.30551 = mono_class_is_assignable_from (klass, oklass);
        if (D.30551 != 0) goto <D.30552>; else goto <D.30553>;
        <D.30552>:
        buffer_add_byte (buf, 1);
        goto <D.30554>;
        <D.30553>:
        buffer_add_byte (buf, 0);
        <D.30554>:
        goto <D.26930>;
      }
      <D.27013>:
      {
        char * name;
        int i;
        int flags;
        struct MonoException * ex;
        struct GPtrArray * array;

        try
          {
            p.292 = p;
            name = decode_string (p.292, &p, end);
            p.292 = p;
            flags = decode_int (p.292, &p, end);
            ex = 0B;
            D.30555 = flags & 1879048192;
            D.30556 = D.30555 != 0;
            D.30557 = (int) D.30556;
            flags.299 = (unsigned int) flags;
            D.30559 = flags.299 & 2415919103;
            array = mono_class_get_methods_by_name (klass, name, D.30559, D.30557, 1, &ex);
            if (array == 0B) goto <D.30560>; else goto <D.30561>;
            <D.30560>:
            D.30470 = 200;
            return D.30470;
            <D.30561>:
            D.30562 = array->len;
            buffer_add_int (buf, D.30562);
            i = 0;
            goto <D.27021>;
            <D.27020>:
            {
              struct MonoMethod * method;

              D.30563 = array->pdata;
              i.300 = (unsigned int) i;
              D.30565 = i.300 * 4;
              D.30566 = D.30563 + D.30565;
              method = *D.30566;
              buffer_add_methodid (buf, domain, method);
            }
            i = i + 1;
            <D.27021>:
            i.301 = (unsigned int) i;
            D.30562 = array->len;
            if (i.301 < D.30562) goto <D.27020>; else goto <D.27022>;
            <D.27022>:
            monoeg_g_ptr_array_free (array, 1);
            monoeg_g_free (name);
            goto <D.26930>;
          }
        finally
          {
            ex = {CLOBBER};
          }
      }
      <D.27023>:
      {
        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.27031>;
            <D.27030>:
            mono_class_setup_interfaces (parent, &error);
            D.30568 = mono_error_ok (&error);
            if (D.30568 == 0) goto <D.30569>; else goto <D.30570>;
            <D.30569>:
            D.30470 = 200;
            return D.30470;
            <D.30570>:
            collect_interfaces (parent, iface_hash, &error);
            D.30571 = mono_error_ok (&error);
            if (D.30571 == 0) goto <D.30572>; else goto <D.30573>;
            <D.30572>:
            D.30470 = 200;
            return D.30470;
            <D.30573>:
            parent = parent->parent;
            <D.27031>:
            if (parent != 0B) goto <D.27030>; else goto <D.27032>;
            <D.27032>:
            D.30574 = monoeg_g_hash_table_size (iface_hash);
            buffer_add_int (buf, D.30574);
            monoeg_g_hash_table_iter_init (&iter, iface_hash);
            goto <D.27034>;
            <D.27033>:
            iface.302 = iface;
            buffer_add_typeid (buf, domain, iface.302);
            <D.27034>:
            D.30576 = monoeg_g_hash_table_iter_next (&iter, 0B, &iface);
            if (D.30576 != 0) goto <D.27033>; else goto <D.27035>;
            <D.27035>:
            monoeg_g_hash_table_destroy (iface_hash);
            goto <D.26930>;
          }
        finally
          {
            error = {CLOBBER};
            iface = {CLOBBER};
            iter = {CLOBBER};
          }
      }
      <D.27036>:
      {
        int tindex;
        int ioffset;
        gboolean variance_used;
        struct MonoClass * iclass;
        int len;
        int nmethods;
        int i;
        void * iter;
        struct MonoMethod * method;

        try
          {
            p.292 = p;
            len = decode_int (p.292, &p, end);
            mono_class_setup_vtable (klass);
            tindex = 0;
            goto <D.27053>;
            <D.27052>:
            p.292 = p;
            iclass = decode_typeid (p.292, &p, end, 0B, &err);
            err.293 = err;
            if (err.293 != 0) goto <D.30577>; else goto <D.30578>;
            <D.30577>:
            err.293 = err;
            D.30470 = (ErrorCode) err.293;
            return D.30470;
            <D.30578>:
            ioffset = mono_class_interface_offset_with_variance (klass, iclass, &variance_used);
            if (ioffset == -1) goto <D.30579>; else goto <D.30580>;
            <D.30579>:
            D.30470 = 102;
            return D.30470;
            <D.30580>:
            nmethods = mono_class_num_methods (iclass);
            nmethods.303 = (unsigned int) nmethods;
            buffer_add_int (buf, nmethods.303);
            iter = 0B;
            goto <D.27047>;
            <D.27046>:
            buffer_add_methodid (buf, domain, method);
            <D.27047>:
            method = mono_class_get_methods (iclass, &iter);
            if (method != 0B) goto <D.27046>; else goto <D.27048>;
            <D.27048>:
            i = 0;
            goto <D.27050>;
            <D.27049>:
            D.30582 = klass->vtable;
            D.30583 = i + ioffset;
            D.30584 = (unsigned int) D.30583;
            D.30585 = D.30584 * 4;
            D.30586 = D.30582 + D.30585;
            D.30587 = *D.30586;
            buffer_add_methodid (buf, domain, D.30587);
            i = i + 1;
            <D.27050>:
            if (i < nmethods) goto <D.27049>; else goto <D.27051>;
            <D.27051>:
            tindex = tindex + 1;
            <D.27053>:
            if (tindex < len) goto <D.27052>; else goto <D.27054>;
            <D.27054>:
            goto <D.26930>;
          }
        finally
          {
            variance_used = {CLOBBER};
            iter = {CLOBBER};
          }
      }
      <D.27055>:
      {
        struct MonoVTable * vtable;

        vtable = mono_class_vtable (domain, klass);
        if (vtable != 0B) goto <D.30588>; else goto <D.30589>;
        <D.30588>:
        D.30590 = BIT_FIELD_REF <*vtable, 8, 184>;
        D.30591 = D.30590 & 6;
        D.30592 = D.30591 != 0;
        D.30593 = (unsigned int) D.30592;
        buffer_add_int (buf, D.30593);
        goto <D.30594>;
        <D.30589>:
        buffer_add_int (buf, 0);
        <D.30594>:
        goto <D.26930>;
      }
      <D.27057>:
      D.30470 = 100;
      return D.30470;
      <D.26930>:
      D.30470 = 0;
      return D.30470;
    }
  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.30608;

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


buffer_add_cattrs (struct Buffer * buf, struct MonoDomain * domain, struct MonoImage * image, struct MonoClass * attr_klass, struct MonoCustomAttrInfo * cinfo)
{
  struct MonoMethod * D.30615;
  struct MonoClass * D.30616;
  int D.30617;
  int D.30618;
  unsigned int nattrs.304;
  struct MonoMethod * D.30623;
  struct MonoClass * D.30624;
  int D.30625;
  unsigned int D.30626;
  const mono_byte * D.30627;
  int D.30628;
  _Bool D.30629;
  long int D.30630;
  long int D.30631;
  struct MonoArray * typed_args.305;
  unsigned int D.30637;
  unsigned int j.306;
  char * D.30639;
  struct MonoMethodSignature * D.30640;
  unsigned int D.30641;
  struct MonoArray * named_args.307;
  unsigned int D.30646;
  char * D.30647;
  struct CattrNamedArg * arginfo.308;
  unsigned int j.309;
  unsigned int D.30650;
  struct CattrNamedArg * D.30651;
  struct MonoProperty * D.30652;
  struct MonoClassField * D.30656;
  struct MonoType * D.30660;
  unsigned int D.30661;
  int i;
  int j;
  int nattrs;

  nattrs = 0;
  if (cinfo == 0B) goto <D.30610>; else goto <D.30611>;
  <D.30610>:
  buffer_add_int (buf, 0);
  return;
  <D.30611>:
  i = 0;
  goto <D.26868>;
  <D.26867>:
  if (attr_klass == 0B) goto <D.30612>; else goto <D.30614>;
  <D.30614>:
  D.30615 = cinfo->attrs[i].ctor;
  D.30616 = D.30615->klass;
  D.30617 = mono_class_has_parent (D.30616, attr_klass);
  if (D.30617 != 0) goto <D.30612>; else goto <D.30613>;
  <D.30612>:
  nattrs = nattrs + 1;
  <D.30613>:
  i = i + 1;
  <D.26868>:
  D.30618 = cinfo->num_attrs;
  if (D.30618 > i) goto <D.26867>; else goto <D.26869>;
  <D.26869>:
  nattrs.304 = (unsigned int) nattrs;
  buffer_add_int (buf, nattrs.304);
  i = 0;
  goto <D.26885>;
  <D.26884>:
  {
    struct MonoCustomAttrEntry * attr;

    attr = &cinfo->attrs[i];
    if (attr_klass == 0B) goto <D.30620>; else goto <D.30622>;
    <D.30622>:
    D.30623 = attr->ctor;
    D.30624 = D.30623->klass;
    D.30625 = mono_class_has_parent (D.30624, attr_klass);
    if (D.30625 != 0) goto <D.30620>; else goto <D.30621>;
    <D.30620>:
    {
      struct MonoArray * typed_args;
      struct MonoArray * named_args;
      struct MonoType * t;
      struct CattrNamedArg * arginfo;
      struct MonoError error;

      try
        {
          arginfo = 0B;
          D.30626 = attr->data_size;
          D.30627 = attr->data;
          D.30623 = attr->ctor;
          mono_reflection_create_custom_attr_data_args (image, D.30623, D.30627, D.30626, &typed_args, &named_args, &arginfo, &error);
          D.30628 = mono_error_ok (&error);
          D.30629 = D.30628 == 0;
          D.30630 = (long int) D.30629;
          D.30631 = __builtin_expect (D.30630, 0);
          if (D.30631 != 0) goto <D.30632>; else goto <D.30633>;
          <D.30632>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 7448, "mono_error_ok (&error)");
          <D.30633>:
          D.30623 = attr->ctor;
          buffer_add_methodid (buf, domain, D.30623);
          typed_args.305 = typed_args;
          if (typed_args.305 != 0B) goto <D.30635>; else goto <D.30636>;
          <D.30635>:
          typed_args.305 = typed_args;
          D.30637 = mono_array_length (typed_args.305);
          buffer_add_int (buf, D.30637);
          j = 0;
          goto <D.26878>;
          <D.26877>:
          {
            struct MonoObject * val;

            j.306 = (unsigned int) j;
            typed_args.305 = typed_args;
            D.30639 = mono_array_addr_with_size (typed_args.305, 4, j.306);
            val = MEM[(struct MonoObject * *)D.30639];
            D.30623 = attr->ctor;
            D.30640 = mono_method_signature (D.30623);
            t = D.30640->params[j];
            buffer_add_cattr_arg (buf, t, domain, val);
          }
          j = j + 1;
          <D.26878>:
          j.306 = (unsigned int) j;
          typed_args.305 = typed_args;
          D.30641 = mono_array_length (typed_args.305);
          if (j.306 < D.30641) goto <D.26877>; else goto <D.26879>;
          <D.26879>:
          goto <D.30642>;
          <D.30636>:
          buffer_add_int (buf, 0);
          <D.30642>:
          named_args.307 = named_args;
          if (named_args.307 != 0B) goto <D.30644>; else goto <D.30645>;
          <D.30644>:
          named_args.307 = named_args;
          D.30646 = mono_array_length (named_args.307);
          buffer_add_int (buf, D.30646);
          j = 0;
          goto <D.26882>;
          <D.26881>:
          {
            struct MonoObject * val;

            j.306 = (unsigned int) j;
            named_args.307 = named_args;
            D.30647 = mono_array_addr_with_size (named_args.307, 4, j.306);
            val = MEM[(struct MonoObject * *)D.30647];
            arginfo.308 = arginfo;
            j.309 = (unsigned int) j;
            D.30650 = j.309 * 12;
            D.30651 = arginfo.308 + D.30650;
            D.30652 = D.30651->prop;
            if (D.30652 != 0B) goto <D.30653>; else goto <D.30654>;
            <D.30653>:
            buffer_add_byte (buf, 84);
            arginfo.308 = arginfo;
            j.309 = (unsigned int) j;
            D.30650 = j.309 * 12;
            D.30651 = arginfo.308 + D.30650;
            D.30652 = D.30651->prop;
            buffer_add_propertyid (buf, domain, D.30652);
            goto <D.30655>;
            <D.30654>:
            arginfo.308 = arginfo;
            j.309 = (unsigned int) j;
            D.30650 = j.309 * 12;
            D.30651 = arginfo.308 + D.30650;
            D.30656 = D.30651->field;
            if (D.30656 != 0B) goto <D.30657>; else goto <D.30658>;
            <D.30657>:
            buffer_add_byte (buf, 83);
            arginfo.308 = arginfo;
            j.309 = (unsigned int) j;
            D.30650 = j.309 * 12;
            D.30651 = arginfo.308 + D.30650;
            D.30656 = D.30651->field;
            buffer_add_fieldid (buf, domain, D.30656);
            goto <D.30659>;
            <D.30658>:
            monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "debugger-agent.c", 7480);
            <D.30659>:
            <D.30655>:
            arginfo.308 = arginfo;
            j.309 = (unsigned int) j;
            D.30650 = j.309 * 12;
            D.30651 = arginfo.308 + D.30650;
            D.30660 = D.30651->type;
            buffer_add_cattr_arg (buf, D.30660, domain, val);
          }
          j = j + 1;
          <D.26882>:
          j.306 = (unsigned int) j;
          named_args.307 = named_args;
          D.30661 = mono_array_length (named_args.307);
          if (j.306 < D.30661) goto <D.26881>; else goto <D.26883>;
          <D.26883>:
          goto <D.30662>;
          <D.30645>:
          buffer_add_int (buf, 0);
          <D.30662>:
          arginfo.308 = arginfo;
          monoeg_g_free (arginfo.308);
        }
      finally
        {
          typed_args = {CLOBBER};
          named_args = {CLOBBER};
          arginfo = {CLOBBER};
          error = {CLOBBER};
        }
    }
    <D.30621>:
  }
  i = i + 1;
  <D.26885>:
  D.30618 = cinfo->num_attrs;
  if (D.30618 > i) goto <D.26884>; else goto <D.26886>;
  <D.26886>:
}


mono_class_has_parent (struct MonoClass * klass, struct MonoClass * parent)
{
  struct MonoClass * * D.30664;
  _Bool D.30665;
  long int D.30666;
  long int D.30667;
  struct MonoClass * * D.30670;
  _Bool D.30671;
  long int D.30672;
  long int D.30673;
  gboolean D.30676;

  D.30664 = klass->supertypes;
  D.30665 = D.30664 == 0B;
  D.30666 = (long int) D.30665;
  D.30667 = __builtin_expect (D.30666, 0);
  if (D.30667 != 0) goto <D.30668>; else goto <D.30669>;
  <D.30668>:
  mono_class_setup_supertypes (klass);
  <D.30669>:
  D.30670 = parent->supertypes;
  D.30671 = D.30670 == 0B;
  D.30672 = (long int) D.30671;
  D.30673 = __builtin_expect (D.30672, 0);
  if (D.30673 != 0) goto <D.30674>; else goto <D.30675>;
  <D.30674>:
  mono_class_setup_supertypes (parent);
  <D.30675>:
  D.30676 = mono_class_has_parent_fast (klass, parent);
  return D.30676;
}


mono_class_has_parent_fast (struct MonoClass * klass, struct MonoClass * parent)
{
  gboolean D.30678;
  int iftmp.310;
  short unsigned int D.30682;
  short unsigned int D.30683;
  struct MonoClass * * D.30685;
  sizetype D.30686;
  sizetype D.30687;
  sizetype D.30688;
  struct MonoClass * * D.30689;
  struct MonoClass * D.30690;

  D.30682 = klass->idepth;
  D.30683 = parent->idepth;
  if (D.30682 >= D.30683) goto <D.30684>; else goto <D.30680>;
  <D.30684>:
  D.30685 = klass->supertypes;
  D.30683 = parent->idepth;
  D.30686 = (sizetype) D.30683;
  D.30687 = D.30686 + 1073741823;
  D.30688 = D.30687 * 4;
  D.30689 = D.30685 + D.30688;
  D.30690 = *D.30689;
  if (D.30690 == parent) goto <D.30691>; else goto <D.30680>;
  <D.30691>:
  iftmp.310 = 1;
  goto <D.30681>;
  <D.30680>:
  iftmp.310 = 0;
  <D.30681>:
  D.30678 = iftmp.310;
  return D.30678;
}


buffer_add_cattr_arg (struct Buffer * buf, struct MonoType * t, struct MonoDomain * domain, struct MonoObject * val)
{
  struct MonoObject * val.311;
  struct MonoVTable * D.30697;
  struct MonoClass * D.30698;
  struct MonoClass * D.30699;
  struct MonoType * D.30701;
  struct MonoClass * D.30702;
  int D.30703;
  void * D.30707;

  val.311 = val;
  if (val.311 != 0B) goto <D.30696>; else goto <D.30693>;
  <D.30696>:
  val.311 = val;
  D.30697 = val.311->vtable;
  D.30698 = D.30697->klass;
  D.30699 = mono_defaults.monotype_class;
  if (D.30698 == D.30699) goto <D.30700>; else goto <D.30693>;
  <D.30700>:
  buffer_add_byte (buf, 241);
  val.311 = val;
  D.30701 = MEM[(struct MonoReflectionType *)val.311].type;
  D.30702 = mono_class_from_mono_type (D.30701);
  buffer_add_typeid (buf, domain, D.30702);
  goto <D.30694>;
  <D.30693>:
  D.30703 = mono_type_is_reference (t);
  if (D.30703 != 0) goto <D.30704>; else goto <D.30705>;
  <D.30704>:
  buffer_add_value (buf, t, &val, domain);
  goto <D.30706>;
  <D.30705>:
  val.311 = val;
  D.30707 = mono_object_unbox (val.311);
  buffer_add_value (buf, t, D.30707, domain);
  <D.30706>:
  <D.30694>:
}


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)
{
  unsigned char D.30708;
  unsigned char D.30709;
  void * D.30712;
  _Bool D.30715;
  long int D.30716;
  long int D.30717;
  unsigned char D.30722;
  int D.30723;
  signed char D.30724;
  unsigned int D.30725;
  short int D.30726;
  unsigned int D.30727;
  int D.30728;
  unsigned int D.30729;
  long long int D.30730;
  long long unsigned int D.30731;
  long long unsigned int D.30732;
  struct MonoVTable * D.30736;
  struct MonoClass * D.30737;
  unsigned char D.30738;
  unsigned char D.30739;
  unsigned char D.30742;
  unsigned char D.30745;
  int D.30746;
  <unnamed-unsigned:1> D.30751;
  int D.30752;
  struct MonoType * D.30753;
  short unsigned int D.30754;
  int D.30755;
  int D.30756;
  int D.30759;
  int D.26268;
  int iftmp.312;
  int D.26267;
  const char[9] * D.30765;
  unsigned char D.30766;
  int D.30767;
  unsigned char D.30768;
  int D.30769;
  _Bool D.30770;
  _Bool D.30771;
  _Bool D.30772;
  const unsigned char * D.30775;
  unsigned char D.30776;
  int D.30777;
  const unsigned char * D.30778;
  unsigned char D.30779;
  int D.30780;
  _Bool D.30781;
  _Bool D.30782;
  const unsigned char * D.30785;
  unsigned char D.30786;
  int D.30787;
  const unsigned char * D.30788;
  unsigned char D.30789;
  int D.30790;
  _Bool D.30791;
  _Bool D.30792;
  const unsigned char * D.30795;
  unsigned char D.30796;
  int D.30797;
  const unsigned char * D.30798;
  unsigned char D.30799;
  int D.30800;
  const char * D.30802;
  unsigned int nfields.313;
  int D.26280;
  int iftmp.314;
  int D.26279;
  unsigned char D.30813;
  int D.30814;
  _Bool D.30815;
  _Bool D.30816;
  _Bool D.30817;
  const unsigned char * D.30820;
  unsigned char D.30821;
  int D.30822;
  _Bool D.30823;
  _Bool D.30824;
  const unsigned char * D.30827;
  unsigned char D.30828;
  int D.30829;
  _Bool D.30830;
  _Bool D.30831;
  const unsigned char * D.30834;
  unsigned char D.30835;
  int D.30836;
  const char * D.30838;
  int D.30841;
  sizetype D.30842;
  sizetype D.30843;
  void * D.30844;
  int D.30845;
  struct MonoObject * obj;
  void handle_vtype = <<< error >>>;
  void handle_ref = <<< error >>>;

  D.30708 = BIT_FIELD_REF <*t, 8, 56>;
  D.30709 = D.30708 & 64;
  if (D.30709 != 0) goto <D.30710>; else goto <D.30711>;
  <D.30710>:
  D.30712 = MEM[(void * *)addr];
  if (D.30712 == 0B) goto <D.30713>; else goto <D.30714>;
  <D.30713>:
  buffer_add_byte (buf, 240);
  return;
  <D.30714>:
  D.30712 = MEM[(void * *)addr];
  D.30715 = D.30712 == 0B;
  D.30716 = (long int) D.30715;
  D.30717 = __builtin_expect (D.30716, 0);
  if (D.30717 != 0) goto <D.30718>; else goto <D.30719>;
  <D.30718>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 5513, "*(void**)addr");
  <D.30719>:
  addr = MEM[(void * *)addr];
  <D.30711>:
  if (as_vtype != 0) goto <D.30720>; else goto <D.30721>;
  <D.30720>:
  D.30722 = t->type;
  D.30723 = (int) D.30722;
  switch (D.30723) <default: <D.26228>, case 2: <D.26212>, case 3: <D.26215>, case 4: <D.26213>, case 5: <D.26214>, case 6: <D.26216>, case 7: <D.26217>, case 8: <D.26218>, case 9: <D.26219>, case 10: <D.26221>, case 11: <D.26222>, case 12: <D.26220>, case 13: <D.26223>, case 15: <D.26226>, case 24: <D.26224>, case 25: <D.26225>>
  <D.26212>:
  <D.26213>:
  <D.26214>:
  <D.26215>:
  <D.26216>:
  <D.26217>:
  <D.26218>:
  <D.26219>:
  <D.26220>:
  <D.26221>:
  <D.26222>:
  <D.26223>:
  <D.26224>:
  <D.26225>:
  <D.26226>:
  goto handle_vtype;
  <D.26228>:
  goto <D.26229>;
  <D.26229>:
  <D.30721>:
  D.30722 = t->type;
  D.30723 = (int) D.30722;
  switch (D.30723) <default: <D.26284>, case 1: <D.26230>, case 2: <D.26232>, case 3: <D.26235>, case 4: <D.26233>, case 5: <D.26234>, case 6: <D.26236>, case 7: <D.26237>, case 8: <D.26238>, case 9: <D.26239>, case 10: <D.26241>, case 11: <D.26242>, case 12: <D.26240>, case 13: <D.26243>, case 14: <D.26249>, case 15: <D.26246>, case 17: <D.26254>, case 18: <D.26252>, case 20: <D.26253>, case 21: <D.26283>, case 24: <D.26244>, case 25: <D.26245>, case 28: <D.26251>, case 29: <D.26250>>
  <D.26230>:
  D.30722 = t->type;
  D.30723 = (int) D.30722;
  buffer_add_byte (buf, D.30723);
  goto <D.26231>;
  <D.26232>:
  <D.26233>:
  <D.26234>:
  D.30722 = t->type;
  D.30723 = (int) D.30722;
  buffer_add_byte (buf, D.30723);
  D.30724 = MEM[(gint8 *)addr];
  D.30725 = (unsigned int) D.30724;
  buffer_add_int (buf, D.30725);
  goto <D.26231>;
  <D.26235>:
  <D.26236>:
  <D.26237>:
  D.30722 = t->type;
  D.30723 = (int) D.30722;
  buffer_add_byte (buf, D.30723);
  D.30726 = MEM[(gint16 *)addr];
  D.30727 = (unsigned int) D.30726;
  buffer_add_int (buf, D.30727);
  goto <D.26231>;
  <D.26238>:
  <D.26239>:
  <D.26240>:
  D.30722 = t->type;
  D.30723 = (int) D.30722;
  buffer_add_byte (buf, D.30723);
  D.30728 = MEM[(gint32 *)addr];
  D.30729 = (unsigned int) D.30728;
  buffer_add_int (buf, D.30729);
  goto <D.26231>;
  <D.26241>:
  <D.26242>:
  <D.26243>:
  D.30722 = t->type;
  D.30723 = (int) D.30722;
  buffer_add_byte (buf, D.30723);
  D.30730 = MEM[(gint64 *)addr];
  D.30731 = (long long unsigned int) D.30730;
  buffer_add_long (buf, D.30731);
  goto <D.26231>;
  <D.26244>:
  <D.26245>:
  goto handle_vtype;
  <D.26246>:
  {
    gssize val;

    val = MEM[(gssize *)addr];
    D.30722 = t->type;
    D.30723 = (int) D.30722;
    buffer_add_byte (buf, D.30723);
    D.30732 = (long long unsigned int) val;
    buffer_add_long (buf, D.30732);
    goto <D.26231>;
  }
  handle_ref:
  <D.26249>:
  <D.26250>:
  <D.26251>:
  <D.26252>:
  <D.26253>:
  obj = MEM[(struct MonoObject * *)addr];
  if (obj == 0B) goto <D.30733>; else goto <D.30734>;
  <D.30733>:
  buffer_add_byte (buf, 240);
  goto <D.30735>;
  <D.30734>:
  D.30736 = obj->vtable;
  D.30737 = D.30736->klass;
  D.30738 = BIT_FIELD_REF <*D.30737, 8, 160>;
  D.30739 = D.30738 & 8;
  if (D.30739 != 0) goto <D.30740>; else goto <D.30741>;
  <D.30740>:
  D.30736 = obj->vtable;
  D.30737 = D.30736->klass;
  t = &D.30737->byval_arg;
  addr = mono_object_unbox (obj);
  goto handle_vtype;
  <D.30741>:
  D.30736 = obj->vtable;
  D.30737 = D.30736->klass;
  D.30742 = D.30737->rank;
  if (D.30742 != 0) goto <D.30743>; else goto <D.30744>;
  <D.30743>:
  D.30736 = obj->vtable;
  D.30737 = D.30736->klass;
  D.30745 = D.30737->byval_arg.type;
  D.30746 = (int) D.30745;
  buffer_add_byte (buf, D.30746);
  goto <D.30747>;
  <D.30744>:
  D.30736 = obj->vtable;
  D.30737 = D.30736->klass;
  D.30745 = D.30737->byval_arg.type;
  if (D.30745 == 21) goto <D.30748>; else goto <D.30749>;
  <D.30748>:
  buffer_add_byte (buf, 18);
  goto <D.30750>;
  <D.30749>:
  D.30736 = obj->vtable;
  D.30737 = D.30736->klass;
  D.30745 = D.30737->byval_arg.type;
  D.30746 = (int) D.30745;
  buffer_add_byte (buf, D.30746);
  <D.30750>:
  <D.30747>:
  buffer_add_objid (buf, obj);
  <D.30735>:
  goto <D.26231>;
  handle_vtype:
  <D.26254>:
  {
    int nfields;
    void * iter;
    struct MonoClassField * f;
    struct MonoClass * klass;

    try
      {
        klass = mono_class_from_mono_type (t);
        buffer_add_byte (buf, 17);
        D.30751 = klass->enumtype;
        D.30752 = (int) D.30751;
        buffer_add_byte (buf, D.30752);
        buffer_add_typeid (buf, domain, klass);
        nfields = 0;
        iter = 0B;
        goto <D.26259>;
        <D.26269>:
        D.30753 = f->type;
        D.30754 = D.30753->attrs;
        D.30755 = (int) D.30754;
        D.30756 = D.30755 & 16;
        if (D.30756 != 0) goto <D.30757>; else goto <D.30758>;
        <D.30757>:
        // predicted unlikely by continue predictor.
        goto <D.26259>;
        <D.30758>:
        D.30753 = f->type;
        D.30754 = D.30753->attrs;
        D.30755 = (int) D.30754;
        D.30759 = D.30755 & 1536;
        if (D.30759 != 0) goto <D.30760>; else goto <D.30761>;
        <D.30760>:
        {
          size_t __s1_len;
          size_t __s2_len;

          __s2_len = 8;
          if (__s2_len <= 3) goto <D.30763>; else goto <D.30764>;
          <D.30763>:
          {
            const unsigned char * __s2;
            int __result;

            __s2 = mono_field_get_name (f);
            D.30765 = "_Deleted";
            D.30766 = MEM[(const unsigned char *)D.30765];
            D.30767 = (int) D.30766;
            D.30768 = *__s2;
            D.30769 = (int) D.30768;
            __result = D.30767 - D.30769;
            {
              D.30770 = __s2_len != 0;
              D.30771 = __result == 0;
              D.30772 = D.30770 & D.30771;
              if (D.30772 != 0) goto <D.30773>; else goto <D.30774>;
              <D.30773>:
              D.30775 = &MEM[(void *)"_Deleted" + 1B];
              D.30776 = *D.30775;
              D.30777 = (int) D.30776;
              D.30778 = __s2 + 1;
              D.30779 = *D.30778;
              D.30780 = (int) D.30779;
              __result = D.30777 - D.30780;
              D.30781 = __s2_len > 1;
              D.30771 = __result == 0;
              D.30782 = D.30781 & D.30771;
              if (D.30782 != 0) goto <D.30783>; else goto <D.30784>;
              <D.30783>:
              D.30785 = &MEM[(void *)"_Deleted" + 2B];
              D.30786 = *D.30785;
              D.30787 = (int) D.30786;
              D.30788 = __s2 + 2;
              D.30789 = *D.30788;
              D.30790 = (int) D.30789;
              __result = D.30787 - D.30790;
              D.30791 = __s2_len > 2;
              D.30771 = __result == 0;
              D.30792 = D.30791 & D.30771;
              if (D.30792 != 0) goto <D.30793>; else goto <D.30794>;
              <D.30793>:
              D.30795 = &MEM[(void *)"_Deleted" + 3B];
              D.30796 = *D.30795;
              D.30797 = (int) D.30796;
              D.30798 = __s2 + 3;
              D.30799 = *D.30798;
              D.30800 = (int) D.30799;
              __result = D.30797 - D.30800;
              <D.30794>:
              <D.30784>:
              <D.30774>:
            }
            D.26267 = __result;
          }
          iftmp.312 = -D.26267;
          goto <D.30801>;
          <D.30764>:
          D.30802 = mono_field_get_name (f);
          iftmp.312 = __builtin_strcmp (D.30802, "_Deleted");
          <D.30801>:
          D.26268 = iftmp.312;
        }
        if (D.26268 == 0) goto <D.30803>; else goto <D.30804>;
        <D.30803>:
        // predicted unlikely by continue predictor.
        goto <D.26259>;
        <D.30804>:
        <D.30761>:
        nfields = nfields + 1;
        <D.26259>:
        f = mono_class_get_fields (klass, &iter);
        if (f != 0B) goto <D.26269>; else goto <D.26270>;
        <D.26270>:
        nfields.313 = (unsigned int) nfields;
        buffer_add_int (buf, nfields.313);
        iter = 0B;
        goto <D.26271>;
        <D.26281>:
        D.30753 = f->type;
        D.30754 = D.30753->attrs;
        D.30755 = (int) D.30754;
        D.30756 = D.30755 & 16;
        if (D.30756 != 0) goto <D.30806>; else goto <D.30807>;
        <D.30806>:
        // predicted unlikely by continue predictor.
        goto <D.26271>;
        <D.30807>:
        D.30753 = f->type;
        D.30754 = D.30753->attrs;
        D.30755 = (int) D.30754;
        D.30759 = D.30755 & 1536;
        if (D.30759 != 0) goto <D.30808>; else goto <D.30809>;
        <D.30808>:
        {
          size_t __s1_len;
          size_t __s2_len;

          __s2_len = 8;
          if (__s2_len <= 3) goto <D.30811>; else goto <D.30812>;
          <D.30811>:
          {
            const unsigned char * __s2;
            int __result;

            __s2 = mono_field_get_name (f);
            D.30765 = "_Deleted";
            D.30766 = MEM[(const unsigned char *)D.30765];
            D.30767 = (int) D.30766;
            D.30813 = *__s2;
            D.30814 = (int) D.30813;
            __result = D.30767 - D.30814;
            {
              D.30815 = __s2_len != 0;
              D.30816 = __result == 0;
              D.30817 = D.30815 & D.30816;
              if (D.30817 != 0) goto <D.30818>; else goto <D.30819>;
              <D.30818>:
              D.30775 = &MEM[(void *)"_Deleted" + 1B];
              D.30776 = *D.30775;
              D.30777 = (int) D.30776;
              D.30820 = __s2 + 1;
              D.30821 = *D.30820;
              D.30822 = (int) D.30821;
              __result = D.30777 - D.30822;
              D.30823 = __s2_len > 1;
              D.30816 = __result == 0;
              D.30824 = D.30823 & D.30816;
              if (D.30824 != 0) goto <D.30825>; else goto <D.30826>;
              <D.30825>:
              D.30785 = &MEM[(void *)"_Deleted" + 2B];
              D.30786 = *D.30785;
              D.30787 = (int) D.30786;
              D.30827 = __s2 + 2;
              D.30828 = *D.30827;
              D.30829 = (int) D.30828;
              __result = D.30787 - D.30829;
              D.30830 = __s2_len > 2;
              D.30816 = __result == 0;
              D.30831 = D.30830 & D.30816;
              if (D.30831 != 0) goto <D.30832>; else goto <D.30833>;
              <D.30832>:
              D.30795 = &MEM[(void *)"_Deleted" + 3B];
              D.30796 = *D.30795;
              D.30797 = (int) D.30796;
              D.30834 = __s2 + 3;
              D.30835 = *D.30834;
              D.30836 = (int) D.30835;
              __result = D.30797 - D.30836;
              <D.30833>:
              <D.30826>:
              <D.30819>:
            }
            D.26279 = __result;
          }
          iftmp.314 = -D.26279;
          goto <D.30837>;
          <D.30812>:
          D.30838 = mono_field_get_name (f);
          iftmp.314 = __builtin_strcmp (D.30838, "_Deleted");
          <D.30837>:
          D.26280 = iftmp.314;
        }
        if (D.26280 == 0) goto <D.30839>; else goto <D.30840>;
        <D.30839>:
        // predicted unlikely by continue predictor.
        goto <D.26271>;
        <D.30840>:
        <D.30809>:
        D.30841 = f->offset;
        D.30842 = (sizetype) D.30841;
        D.30843 = D.30842 + 4294967288;
        D.30844 = addr + D.30843;
        D.30753 = f->type;
        buffer_add_value_full (buf, D.30753, D.30844, domain, 0);
        <D.26271>:
        f = mono_class_get_fields (klass, &iter);
        if (f != 0B) goto <D.26281>; else goto <D.26282>;
        <D.26282>:
        goto <D.26231>;
      }
    finally
      {
        iter = {CLOBBER};
      }
  }
  <D.26283>:
  D.30845 = mono_type_generic_inst_is_valuetype (t);
  if (D.30845 != 0) goto handle_vtype; else goto handle_ref;
  <D.26284>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "debugger-agent.c", 5645);
  <D.26231>:
}


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

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


collect_interfaces (struct MonoClass * klass, struct GHashTable * ifaces, struct MonoError * error)
{
  int D.30851;
  struct MonoClass * * D.30854;
  unsigned int i.315;
  unsigned int D.30856;
  struct MonoClass * * D.30857;
  int D.30858;
  short unsigned int D.30861;
  int D.30862;
  int i;
  struct MonoClass * ic;

  mono_class_setup_interfaces (klass, error);
  D.30851 = mono_error_ok (error);
  if (D.30851 == 0) goto <D.30852>; else goto <D.30853>;
  <D.30852>:
  return;
  <D.30853>:
  i = 0;
  goto <D.26895>;
  <D.26894>:
  D.30854 = klass->interfaces;
  i.315 = (unsigned int) i;
  D.30856 = i.315 * 4;
  D.30857 = D.30854 + D.30856;
  ic = *D.30857;
  monoeg_g_hash_table_insert_replace (ifaces, ic, ic, 0);
  collect_interfaces (ic, ifaces, error);
  D.30858 = mono_error_ok (error);
  if (D.30858 == 0) goto <D.30859>; else goto <D.30860>;
  <D.30859>:
  return;
  <D.30860>:
  i = i + 1;
  <D.26895>:
  D.30861 = klass->interface_count;
  D.30862 = (int) D.30861;
  if (D.30862 > i) goto <D.26894>; else goto <D.26896>;
  <D.26896>:
}


method_commands (int command, guint8 * p, guint8 * end, struct Buffer * buf)
{
  guint8 * p.316;
  int err.317;
  ErrorCode D.30868;
  struct MonoDomain * domain.318;
  <unnamed type> D.30870;
  int err.319;
  int err;
  struct MonoDomain * old_domain;
  struct MonoDomain * domain;
  struct MonoMethod * method;

  try
    {
      p.316 = p;
      method = decode_methodid (p.316, &p, end, &domain, &err);
      err.317 = err;
      if (err.317 != 0) goto <D.30866>; else goto <D.30867>;
      <D.30866>:
      err.317 = err;
      D.30868 = (ErrorCode) err.317;
      return D.30868;
      <D.30867>:
      old_domain = mono_domain_get ();
      domain.318 = domain;
      mono_domain_set (domain.318, 1);
      p.316 = p;
      domain.318 = domain;
      D.30870 = method_commands_internal (command, method, domain.318, p.316, end, buf);
      err.319 = (int) D.30870;
      err = err.319;
      mono_domain_set (old_domain, 1);
      err.317 = err;
      D.30868 = (ErrorCode) err.317;
      return D.30868;
    }
  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.30874;
  struct MonoClass * D.30875;
  unsigned int D.30880;
  int protocol_version_set.320;
  int major_version.321;
  int minor_version.322;
  struct GPtrArray * source_file_list.323;
  unsigned int D.30891;
  void * * D.30892;
  unsigned int i.324;
  unsigned int D.30894;
  void * * D.30895;
  char * D.30896;
  guint8 * D.30902;
  sizetype j.325;
  guint8 * D.30904;
  unsigned char D.30905;
  int D.30906;
  unsigned int i.326;
  char * source_file.327;
  int n_il_offsets.328;
  unsigned int n_il_offsets.329;
  int log_level.330;
  _Bool D.30912;
  long int D.30913;
  long int D.30914;
  char * D.30917;
  struct FILE * log_file.331;
  int * source_files.332;
  int * D.30920;
  int D.30921;
  unsigned int D.30924;
  unsigned int D.30925;
  void * * D.30926;
  int iftmp.333;
  int * column_numbers.334;
  int * D.30933;
  int * line_numbers.335;
  int * D.30936;
  int D.30937;
  int * il_offsets.336;
  int * D.30939;
  int D.30940;
  unsigned int D.30941;
  unsigned int D.30942;
  unsigned int D.30949;
  guint32 iftmp.337;
  int D.30959;
  <unnamed-unsigned:6> D.30961;
  unsigned int D.30962;
  short unsigned int D.30963;
  unsigned int D.30964;
  short unsigned int D.30965;
  unsigned int D.30966;
  struct MonoType * D.30967;
  struct MonoClass * D.30968;
  struct MonoType * D.30969;
  struct MonoClass * D.30970;
  unsigned int D.30971;
  unsigned int D.30972;
  unsigned int D.30973;
  char * * D.30974;
  char * D.30975;
  ErrorCode D.30978;
  short unsigned int D.30979;
  unsigned int D.30980;
  struct MonoType * D.30981;
  struct MonoClass * D.30982;
  int D.30983;
  struct MonoDebugLocalVar * D.30987;
  unsigned int j.338;
  unsigned int D.30989;
  struct MonoDebugLocalVar * D.30990;
  int D.30991;
  char * D.30995;
  struct MonoDebugCodeBlock * D.31001;
  int D.31003;
  unsigned int D.31004;
  int D.31005;
  unsigned int D.31006;
  short unsigned int D.31009;
  unsigned int D.31010;
  short unsigned int D.31011;
  unsigned int D.31012;
  unsigned int D.31013;
  unsigned char D.31020;
  unsigned char D.31021;
  struct MonoMethodSignature * D.31024;
  short unsigned int D.31025;
  int D.31028;
  unsigned char D.31029;
  struct MonoGenericInst * D.31035;
  struct MonoGenericContext * D.31038;
  struct MonoGenericContext * D.31041;
  struct MonoMethodSignature * D.31049;
  short unsigned int D.31050;
  unsigned char D.31053;
  struct MonoGenericContext * D.31056;
  <unnamed-unsigned:22> D.31059;
  unsigned int count.339;
  struct MonoType * D.31061;
  struct MonoClass * D.31062;
  struct MonoMethodSignature * D.31067;
  short unsigned int D.31068;
  struct MonoGenericParamFull * D.31069;
  unsigned int i.340;
  unsigned int D.31071;
  struct MonoImage * D.31072;
  const unsigned char * D.31084;
  sizetype i.341;
  const unsigned char * D.31086;
  unsigned char D.31087;
  int D.31088;
  unsigned int i.342;
  <unnamed-unsigned:15> D.31095;
  unsigned int D.31096;
  struct MonoExceptionClause * D.31097;
  unsigned int i.343;
  unsigned int D.31099;
  unsigned int D.31100;
  unsigned int D.31101;
  unsigned int D.31102;
  unsigned int D.31103;
  unsigned int D.31104;
  struct MonoClass * D.31107;
  unsigned int D.31111;
  int D.31112;
  guint8 * p.344;
  int D.31114;
  unsigned int D.31115;
  unsigned int D.31116;
  _Bool D.31117;
  long int D.31118;
  long int D.31119;
  unsigned char D.31122;
  unsigned char D.31123;
  unsigned int D.31126;
  void * handle_class.345;
  struct MonoClass * handle_class.346;
  _Bool D.31132;
  long int D.31133;
  long int D.31134;
  struct MonoClass * D.31137;
  struct MonoClass * D.31143;
  struct MonoClass * D.31145;
  struct MonoClass * D.31149;
  struct MonoClass * D.31153;
  int err.347;
  unsigned int type_argc.348;
  unsigned int D.31161;
  struct MonoDomain * d.349;
  unsigned int i.350;
  unsigned int D.31168;
  struct MonoType * * D.31169;
  struct MonoType * D.31170;
  struct MonoGenericInst * iftmp.351;
  struct MonoGenericClass * D.31172;
  int D.31176;
  struct MonoMethodHeader * header;
  int err;

  try
    {
      switch (command) <default: <D.27185>, case 1: <D.27078>, case 2: <D.27080>, case 3: <D.27081>, case 4: <D.27104>, case 5: <D.27114>, case 6: <D.27134>, case 7: <D.27151>, case 8: <D.27160>, case 9: <D.27170>, case 10: <D.27173>>
      <D.27078>:
      D.30874 = method->name;
      buffer_add_string (buf, D.30874);
      goto <D.27079>;
      <D.27080>:
      D.30875 = method->klass;
      buffer_add_typeid (buf, domain, D.30875);
      goto <D.27079>;
      <D.27081>:
      {
        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.30876>; else goto <D.30877>;
            <D.30876>:
            buffer_add_int (buf, 0);
            buffer_add_string (buf, "");
            buffer_add_int (buf, 0);
            goto <D.27079>;
            <D.30877>:
            minfo = mono_debug_lookup_method (method);
            if (minfo == 0B) goto <D.30878>; else goto <D.30879>;
            <D.30878>:
            D.30880 = header->code_size;
            buffer_add_int (buf, D.30880);
            buffer_add_string (buf, "");
            buffer_add_int (buf, 0);
            mono_metadata_free_mh (header);
            goto <D.27079>;
            <D.30879>:
            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.30880 = header->code_size;
            buffer_add_int (buf, D.30880);
            protocol_version_set.320 = protocol_version_set;
            if (protocol_version_set.320 != 0) goto <D.30885>; else goto <D.30881>;
            <D.30885>:
            major_version.321 = major_version;
            if (major_version.321 > 2) goto <D.30882>; else goto <D.30887>;
            <D.30887>:
            major_version.321 = major_version;
            if (major_version.321 == 2) goto <D.30888>; else goto <D.30881>;
            <D.30888>:
            minor_version.322 = minor_version;
            if (minor_version.322 > 12) goto <D.30882>; else goto <D.30881>;
            <D.30882>:
            source_file_list.323 = source_file_list;
            D.30891 = source_file_list.323->len;
            buffer_add_int (buf, D.30891);
            i = 0;
            goto <D.27097>;
            <D.27096>:
            {
              struct MonoDebugSourceInfo * sinfo;

              source_file_list.323 = source_file_list;
              D.30892 = source_file_list.323->pdata;
              i.324 = (unsigned int) i;
              D.30894 = i.324 * 4;
              D.30895 = D.30892 + D.30894;
              sinfo = *D.30895;
              D.30896 = sinfo->source_file;
              buffer_add_string (buf, D.30896);
              protocol_version_set.320 = protocol_version_set;
              if (protocol_version_set.320 != 0) goto <D.30898>; else goto <D.30899>;
              <D.30898>:
              major_version.321 = major_version;
              if (major_version.321 > 2) goto <D.30897>; else goto <D.30900>;
              <D.30900>:
              major_version.321 = major_version;
              if (major_version.321 == 2) goto <D.30901>; else goto <D.27095>;
              <D.30901>:
              minor_version.322 = minor_version;
              if (minor_version.322 > 13) goto <D.30897>; else goto <D.27095>;
              <D.30897>:
              j = 0;
              goto <D.27094>;
              <D.27093>:
              D.30902 = sinfo->hash;
              j.325 = (sizetype) j;
              D.30904 = D.30902 + j.325;
              D.30905 = *D.30904;
              D.30906 = (int) D.30905;
              buffer_add_byte (buf, D.30906);
              j = j + 1;
              <D.27094>:
              if (j <= 15) goto <D.27093>; else goto <D.27095>;
              <D.27095>:
              <D.30899>:
            }
            i = i + 1;
            <D.27097>:
            i.326 = (unsigned int) i;
            source_file_list.323 = source_file_list;
            D.30891 = source_file_list.323->len;
            if (i.326 < D.30891) goto <D.27096>; else goto <D.27098>;
            <D.27098>:
            goto <D.30883>;
            <D.30881>:
            source_file.327 = source_file;
            buffer_add_string (buf, source_file.327);
            <D.30883>:
            n_il_offsets.328 = n_il_offsets;
            n_il_offsets.329 = (unsigned int) n_il_offsets.328;
            buffer_add_int (buf, n_il_offsets.329);
            log_level.330 = log_level;
            D.30912 = log_level.330 > 9;
            D.30913 = (long int) D.30912;
            D.30914 = __builtin_expect (D.30913, 0);
            if (D.30914 != 0) goto <D.30915>; else goto <D.30916>;
            <D.30915>:
            D.30917 = mono_method_full_name (method, 1);
            log_file.331 = log_file;
            fprintf (log_file.331, "Line number table for method %s:\n", D.30917);
            log_file.331 = log_file;
            fflush (log_file.331);
            <D.30916>:
            i = 0;
            goto <D.27102>;
            <D.27101>:
            {
              const char * srcfile;

              srcfile = "";
              source_files.332 = source_files;
              i.324 = (unsigned int) i;
              D.30894 = i.324 * 4;
              D.30920 = source_files.332 + D.30894;
              D.30921 = *D.30920;
              if (D.30921 != -1) goto <D.30922>; else goto <D.30923>;
              <D.30922>:
              {
                struct MonoDebugSourceInfo * sinfo;

                source_file_list.323 = source_file_list;
                D.30892 = source_file_list.323->pdata;
                source_files.332 = source_files;
                i.324 = (unsigned int) i;
                D.30894 = i.324 * 4;
                D.30920 = source_files.332 + D.30894;
                D.30921 = *D.30920;
                D.30924 = (unsigned int) D.30921;
                D.30925 = D.30924 * 4;
                D.30926 = D.30892 + D.30925;
                sinfo = *D.30926;
                srcfile = sinfo->source_file;
              }
              <D.30923>:
              log_level.330 = log_level;
              D.30912 = log_level.330 > 9;
              D.30913 = (long int) D.30912;
              D.30914 = __builtin_expect (D.30913, 0);
              if (D.30914 != 0) goto <D.30927>; else goto <D.30928>;
              <D.30927>:
              column_numbers.334 = column_numbers;
              if (column_numbers.334 != 0B) goto <D.30931>; else goto <D.30932>;
              <D.30931>:
              column_numbers.334 = column_numbers;
              i.324 = (unsigned int) i;
              D.30894 = i.324 * 4;
              D.30933 = column_numbers.334 + D.30894;
              iftmp.333 = *D.30933;
              goto <D.30934>;
              <D.30932>:
              iftmp.333 = -1;
              <D.30934>:
              line_numbers.335 = line_numbers;
              i.324 = (unsigned int) i;
              D.30894 = i.324 * 4;
              D.30936 = line_numbers.335 + D.30894;
              D.30937 = *D.30936;
              il_offsets.336 = il_offsets;
              i.324 = (unsigned int) i;
              D.30894 = i.324 * 4;
              D.30939 = il_offsets.336 + D.30894;
              D.30940 = *D.30939;
              log_file.331 = log_file;
              fprintf (log_file.331, "IL%x -> %s:%d %d\n", D.30940, srcfile, D.30937, iftmp.333);
              log_file.331 = log_file;
              fflush (log_file.331);
              <D.30928>:
              il_offsets.336 = il_offsets;
              i.324 = (unsigned int) i;
              D.30894 = i.324 * 4;
              D.30939 = il_offsets.336 + D.30894;
              D.30940 = *D.30939;
              D.30941 = (unsigned int) D.30940;
              buffer_add_int (buf, D.30941);
              line_numbers.335 = line_numbers;
              i.324 = (unsigned int) i;
              D.30894 = i.324 * 4;
              D.30936 = line_numbers.335 + D.30894;
              D.30937 = *D.30936;
              D.30942 = (unsigned int) D.30937;
              buffer_add_int (buf, D.30942);
              protocol_version_set.320 = protocol_version_set;
              if (protocol_version_set.320 != 0) goto <D.30945>; else goto <D.30946>;
              <D.30945>:
              major_version.321 = major_version;
              if (major_version.321 > 2) goto <D.30943>; else goto <D.30947>;
              <D.30947>:
              major_version.321 = major_version;
              if (major_version.321 == 2) goto <D.30948>; else goto <D.30944>;
              <D.30948>:
              minor_version.322 = minor_version;
              if (minor_version.322 > 12) goto <D.30943>; else goto <D.30944>;
              <D.30943>:
              source_files.332 = source_files;
              i.324 = (unsigned int) i;
              D.30894 = i.324 * 4;
              D.30920 = source_files.332 + D.30894;
              D.30921 = *D.30920;
              D.30949 = (unsigned int) D.30921;
              buffer_add_int (buf, D.30949);
              <D.30944>:
              <D.30946>:
              protocol_version_set.320 = protocol_version_set;
              if (protocol_version_set.320 != 0) goto <D.30952>; else goto <D.30953>;
              <D.30952>:
              major_version.321 = major_version;
              if (major_version.321 > 2) goto <D.30950>; else goto <D.30954>;
              <D.30954>:
              major_version.321 = major_version;
              if (major_version.321 == 2) goto <D.30955>; else goto <D.30951>;
              <D.30955>:
              minor_version.322 = minor_version;
              if (minor_version.322 > 18) goto <D.30950>; else goto <D.30951>;
              <D.30950>:
              column_numbers.334 = column_numbers;
              if (column_numbers.334 != 0B) goto <D.30957>; else goto <D.30958>;
              <D.30957>:
              column_numbers.334 = column_numbers;
              i.324 = (unsigned int) i;
              D.30894 = i.324 * 4;
              D.30933 = column_numbers.334 + D.30894;
              D.30959 = *D.30933;
              iftmp.337 = (guint32) D.30959;
              goto <D.30960>;
              <D.30958>:
              iftmp.337 = 4294967295;
              <D.30960>:
              buffer_add_int (buf, iftmp.337);
              <D.30951>:
              <D.30953>:
            }
            i = i + 1;
            <D.27102>:
            n_il_offsets.328 = n_il_offsets;
            if (i < n_il_offsets.328) goto <D.27101>; else goto <D.27103>;
            <D.27103>:
            source_file.327 = source_file;
            monoeg_g_free (source_file.327);
            il_offsets.336 = il_offsets;
            monoeg_g_free (il_offsets.336);
            line_numbers.335 = line_numbers;
            monoeg_g_free (line_numbers.335);
            source_files.332 = source_files;
            monoeg_g_free (source_files.332);
            source_file_list.323 = source_file_list;
            monoeg_g_ptr_array_free (source_file_list.323, 1);
            mono_metadata_free_mh (header);
            goto <D.27079>;
          }
        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.27104>:
      {
        struct MonoMethodSignature * sig;
        guint32 i;
        char * * names;

        sig = mono_method_signature (method);
        D.30961 = sig->call_convention;
        D.30962 = (unsigned int) D.30961;
        buffer_add_int (buf, D.30962);
        D.30963 = sig->param_count;
        D.30964 = (unsigned int) D.30963;
        buffer_add_int (buf, D.30964);
        D.30965 = sig->generic_param_count;
        D.30966 = (unsigned int) D.30965;
        buffer_add_int (buf, D.30966);
        D.30967 = sig->ret;
        D.30968 = mono_class_from_mono_type (D.30967);
        buffer_add_typeid (buf, domain, D.30968);
        i = 0;
        goto <D.27109>;
        <D.27108>:
        D.30969 = sig->params[i];
        D.30970 = mono_class_from_mono_type (D.30969);
        buffer_add_typeid (buf, domain, D.30970);
        i = i + 1;
        <D.27109>:
        D.30963 = sig->param_count;
        D.30964 = (unsigned int) D.30963;
        if (D.30964 > i) goto <D.27108>; else goto <D.27110>;
        <D.27110>:
        D.30963 = sig->param_count;
        D.30971 = (unsigned int) D.30963;
        D.30972 = D.30971 * 4;
        names = monoeg_malloc (D.30972);
        mono_method_get_param_names (method, names);
        i = 0;
        goto <D.27112>;
        <D.27111>:
        D.30973 = i * 4;
        D.30974 = names + D.30973;
        D.30975 = *D.30974;
        buffer_add_string (buf, D.30975);
        i = i + 1;
        <D.27112>:
        D.30963 = sig->param_count;
        D.30964 = (unsigned int) D.30963;
        if (D.30964 > i) goto <D.27111>; else goto <D.27113>;
        <D.27113>:
        monoeg_g_free (names);
        goto <D.27079>;
      }
      <D.27114>:
      {
        int i;
        int j;
        int num_locals;
        struct MonoDebugLocalsInfo * locals;

        header = mono_method_get_header (method);
        if (header == 0B) goto <D.30976>; else goto <D.30977>;
        <D.30976>:
        D.30978 = 102;
        return D.30978;
        <D.30977>:
        D.30979 = header->num_locals;
        D.30980 = (unsigned int) D.30979;
        buffer_add_int (buf, D.30980);
        i = 0;
        goto <D.27120>;
        <D.27119>:
        D.30981 = header->locals[i];
        D.30982 = mono_class_from_mono_type (D.30981);
        buffer_add_typeid (buf, domain, D.30982);
        i = i + 1;
        <D.27120>:
        D.30979 = header->num_locals;
        D.30983 = (int) D.30979;
        if (D.30983 > i) goto <D.27119>; else goto <D.27121>;
        <D.27121>:
        locals = mono_debug_lookup_locals (method);
        if (locals != 0B) goto <D.30984>; else goto <D.30985>;
        <D.30984>:
        num_locals = locals->num_locals;
        goto <D.30986>;
        <D.30985>:
        num_locals = 0;
        <D.30986>:
        i = 0;
        goto <D.27126>;
        <D.27125>:
        j = 0;
        goto <D.27124>;
        <D.27123>:
        D.30987 = locals->locals;
        j.338 = (unsigned int) j;
        D.30989 = j.338 * 12;
        D.30990 = D.30987 + D.30989;
        D.30991 = D.30990->index;
        if (D.30991 == i) goto <D.27122>; else goto <D.30992>;
        <D.30992>:
        j = j + 1;
        <D.27124>:
        if (j < num_locals) goto <D.27123>; else goto <D.27122>;
        <D.27122>:
        if (j < num_locals) goto <D.30993>; else goto <D.30994>;
        <D.30993>:
        D.30987 = locals->locals;
        j.338 = (unsigned int) j;
        D.30989 = j.338 * 12;
        D.30990 = D.30987 + D.30989;
        D.30995 = D.30990->name;
        buffer_add_string (buf, D.30995);
        goto <D.30996>;
        <D.30994>:
        buffer_add_string (buf, "");
        <D.30996>:
        i = i + 1;
        <D.27126>:
        D.30979 = header->num_locals;
        D.30983 = (int) D.30979;
        if (D.30983 > i) goto <D.27125>; else goto <D.27127>;
        <D.27127>:
        i = 0;
        goto <D.27132>;
        <D.27131>:
        j = 0;
        goto <D.27130>;
        <D.27129>:
        D.30987 = locals->locals;
        j.338 = (unsigned int) j;
        D.30989 = j.338 * 12;
        D.30990 = D.30987 + D.30989;
        D.30991 = D.30990->index;
        if (D.30991 == i) goto <D.27128>; else goto <D.30997>;
        <D.30997>:
        j = j + 1;
        <D.27130>:
        if (j < num_locals) goto <D.27129>; else goto <D.27128>;
        <D.27128>:
        if (j < num_locals) goto <D.31000>; else goto <D.30998>;
        <D.31000>:
        D.30987 = locals->locals;
        j.338 = (unsigned int) j;
        D.30989 = j.338 * 12;
        D.30990 = D.30987 + D.30989;
        D.31001 = D.30990->block;
        if (D.31001 != 0B) goto <D.31002>; else goto <D.30998>;
        <D.31002>:
        D.30987 = locals->locals;
        j.338 = (unsigned int) j;
        D.30989 = j.338 * 12;
        D.30990 = D.30987 + D.30989;
        D.31001 = D.30990->block;
        D.31003 = D.31001->start_offset;
        D.31004 = (unsigned int) D.31003;
        buffer_add_int (buf, D.31004);
        D.30987 = locals->locals;
        j.338 = (unsigned int) j;
        D.30989 = j.338 * 12;
        D.30990 = D.30987 + D.30989;
        D.31001 = D.30990->block;
        D.31005 = D.31001->end_offset;
        D.31006 = (unsigned int) D.31005;
        buffer_add_int (buf, D.31006);
        goto <D.30999>;
        <D.30998>:
        buffer_add_int (buf, 0);
        D.30880 = header->code_size;
        buffer_add_int (buf, D.30880);
        <D.30999>:
        i = i + 1;
        <D.27132>:
        D.30979 = header->num_locals;
        D.30983 = (int) D.30979;
        if (D.30983 > i) goto <D.27131>; else goto <D.27133>;
        <D.27133>:
        mono_metadata_free_mh (header);
        if (locals != 0B) goto <D.31007>; else goto <D.31008>;
        <D.31007>:
        mono_debug_symfile_free_locals (locals);
        <D.31008>:
        goto <D.27079>;
      }
      <D.27134>:
      D.31009 = method->flags;
      D.31010 = (unsigned int) D.31009;
      buffer_add_int (buf, D.31010);
      D.31011 = method->iflags;
      D.31012 = (unsigned int) D.31011;
      buffer_add_int (buf, D.31012);
      D.31013 = method->token;
      buffer_add_int (buf, D.31013);
      protocol_version_set.320 = protocol_version_set;
      if (protocol_version_set.320 != 0) goto <D.31016>; else goto <D.31017>;
      <D.31016>:
      major_version.321 = major_version;
      if (major_version.321 > 2) goto <D.31014>; else goto <D.31018>;
      <D.31018>:
      major_version.321 = major_version;
      if (major_version.321 == 2) goto <D.31019>; else goto <D.31015>;
      <D.31019>:
      minor_version.322 = minor_version;
      if (minor_version.322 > 11) goto <D.31014>; else goto <D.31015>;
      <D.31014>:
      {
        guint8 attrs;

        attrs = 0;
        D.31020 = BIT_FIELD_REF <*method, 8, 168>;
        D.31021 = D.31020 & 8;
        if (D.31021 != 0) goto <D.31022>; else goto <D.31023>;
        <D.31022>:
        attrs = attrs | 1;
        <D.31023>:
        D.31024 = mono_method_signature (method);
        D.31025 = D.31024->generic_param_count;
        if (D.31025 != 0) goto <D.31026>; else goto <D.31027>;
        <D.31026>:
        attrs = attrs | 2;
        <D.31027>:
        D.31028 = (int) attrs;
        buffer_add_byte (buf, D.31028);
        D.31020 = BIT_FIELD_REF <*method, 8, 168>;
        D.31029 = D.31020 & 24;
        if (D.31029 != 0) goto <D.31030>; else goto <D.31031>;
        <D.31030>:
        {
          struct MonoMethod * result;

          D.31020 = BIT_FIELD_REF <*method, 8, 168>;
          D.31021 = D.31020 & 8;
          if (D.31021 != 0) goto <D.31032>; else goto <D.31033>;
          <D.31032>:
          result = method;
          goto <D.31034>;
          <D.31033>:
          {
            struct MonoMethodInflated * imethod;

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

              klass = MEM[(struct MonoMethod *)imethod].klass;
              D.31038 = mono_class_get_context (klass);
              if (D.31038 != 0B) goto <D.31039>; else goto <D.31040>;
              <D.31039>:
              D.31041 = mono_class_get_context (klass);
              result = mono_class_inflate_generic_method_full (result, klass, D.31041);
              <D.31040>:
            }
            <D.31037>:
          }
          <D.31034>:
          buffer_add_methodid (buf, domain, result);
        }
        goto <D.31042>;
        <D.31031>:
        buffer_add_id (buf, 0);
        <D.31042>:
        protocol_version_set.320 = protocol_version_set;
        if (protocol_version_set.320 != 0) goto <D.31045>; else goto <D.31046>;
        <D.31045>:
        major_version.321 = major_version;
        if (major_version.321 > 2) goto <D.31043>; else goto <D.31047>;
        <D.31047>:
        major_version.321 = major_version;
        if (major_version.321 == 2) goto <D.31048>; else goto <D.31044>;
        <D.31048>:
        minor_version.322 = minor_version;
        if (minor_version.322 > 14) goto <D.31043>; else goto <D.31044>;
        <D.31043>:
        D.31049 = mono_method_signature (method);
        D.31050 = D.31049->generic_param_count;
        if (D.31050 != 0) goto <D.31051>; else goto <D.31052>;
        <D.31051>:
        {
          int count;
          int i;

          D.31020 = BIT_FIELD_REF <*method, 8, 168>;
          D.31053 = D.31020 & 16;
          if (D.31053 != 0) goto <D.31054>; else goto <D.31055>;
          <D.31054>:
          {
            struct MonoGenericInst * inst;

            D.31056 = mono_method_get_context (method);
            inst = D.31056->method_inst;
            if (inst != 0B) goto <D.31057>; else goto <D.31058>;
            <D.31057>:
            D.31059 = inst->type_argc;
            count = (int) D.31059;
            count.339 = (unsigned int) count;
            buffer_add_int (buf, count.339);
            i = 0;
            goto <D.27143>;
            <D.27142>:
            D.31061 = inst->type_argv[i];
            D.31062 = mono_class_from_mono_type (D.31061);
            buffer_add_typeid (buf, domain, D.31062);
            i = i + 1;
            <D.27143>:
            if (i < count) goto <D.27142>; else goto <D.27144>;
            <D.27144>:
            goto <D.31063>;
            <D.31058>:
            buffer_add_int (buf, 0);
            <D.31063>:
          }
          goto <D.31064>;
          <D.31055>:
          D.31020 = BIT_FIELD_REF <*method, 8, 168>;
          D.31021 = D.31020 & 8;
          if (D.31021 != 0) goto <D.31065>; else goto <D.31066>;
          <D.31065>:
          {
            struct MonoGenericContainer * container;

            container = mono_method_get_generic_container (method);
            D.31067 = mono_method_signature (method);
            D.31068 = D.31067->generic_param_count;
            count = (int) D.31068;
            count.339 = (unsigned int) count;
            buffer_add_int (buf, count.339);
            i = 0;
            goto <D.27149>;
            <D.27148>:
            {
              struct MonoGenericParam * param;
              struct MonoClass * pklass;

              D.31069 = container->type_params;
              i.340 = (unsigned int) i;
              D.31071 = i.340 * 32;
              param = D.31069 + D.31071;
              D.30875 = method->klass;
              D.31072 = D.30875->image;
              pklass = mono_class_from_generic_parameter (param, D.31072, 1);
              buffer_add_typeid (buf, domain, pklass);
            }
            i = i + 1;
            <D.27149>:
            if (i < count) goto <D.27148>; else goto <D.27150>;
            <D.27150>:
          }
          goto <D.31073>;
          <D.31066>:
          buffer_add_int (buf, 0);
          <D.31073>:
          <D.31064>:
        }
        goto <D.31074>;
        <D.31052>:
        buffer_add_int (buf, 0);
        <D.31074>:
        <D.31044>:
        <D.31046>:
      }
      <D.31015>:
      <D.31017>:
      goto <D.27079>;
      <D.27151>:
      {
        int i;

        header = mono_method_get_header (method);
        if (header == 0B) goto <D.31075>; else goto <D.31076>;
        <D.31075>:
        buffer_add_int (buf, 0);
        protocol_version_set.320 = protocol_version_set;
        if (protocol_version_set.320 != 0) goto <D.31079>; else goto <D.31080>;
        <D.31079>:
        major_version.321 = major_version;
        if (major_version.321 > 2) goto <D.31077>; else goto <D.31081>;
        <D.31081>:
        major_version.321 = major_version;
        if (major_version.321 == 2) goto <D.31082>; else goto <D.31078>;
        <D.31082>:
        minor_version.322 = minor_version;
        if (minor_version.322 > 17) goto <D.31077>; else goto <D.31078>;
        <D.31077>:
        buffer_add_int (buf, 0);
        <D.31078>:
        <D.31080>:
        goto <D.31083>;
        <D.31076>:
        D.30880 = header->code_size;
        buffer_add_int (buf, D.30880);
        i = 0;
        goto <D.27154>;
        <D.27153>:
        D.31084 = header->code;
        i.341 = (sizetype) i;
        D.31086 = D.31084 + i.341;
        D.31087 = *D.31086;
        D.31088 = (int) D.31087;
        buffer_add_byte (buf, D.31088);
        i = i + 1;
        <D.27154>:
        i.342 = (unsigned int) i;
        D.30880 = header->code_size;
        if (i.342 < D.30880) goto <D.27153>; else goto <D.27155>;
        <D.27155>:
        protocol_version_set.320 = protocol_version_set;
        if (protocol_version_set.320 != 0) goto <D.31091>; else goto <D.31092>;
        <D.31091>:
        major_version.321 = major_version;
        if (major_version.321 > 2) goto <D.31090>; else goto <D.31093>;
        <D.31093>:
        major_version.321 = major_version;
        if (major_version.321 == 2) goto <D.31094>; else goto <D.27159>;
        <D.31094>:
        minor_version.322 = minor_version;
        if (minor_version.322 > 17) goto <D.31090>; else goto <D.27159>;
        <D.31090>:
        D.31095 = header->num_clauses;
        D.31096 = (unsigned int) D.31095;
        buffer_add_int (buf, D.31096);
        i = 0;
        goto <D.27158>;
        <D.27157>:
        {
          struct MonoExceptionClause * clause;

          D.31097 = header->clauses;
          i.343 = (unsigned int) i;
          D.31099 = i.343 * 24;
          clause = D.31097 + D.31099;
          D.31100 = clause->flags;
          buffer_add_int (buf, D.31100);
          D.31101 = clause->try_offset;
          buffer_add_int (buf, D.31101);
          D.31102 = clause->try_len;
          buffer_add_int (buf, D.31102);
          D.31103 = clause->handler_offset;
          buffer_add_int (buf, D.31103);
          D.31104 = clause->handler_len;
          buffer_add_int (buf, D.31104);
          D.31100 = clause->flags;
          if (D.31100 == 0) goto <D.31105>; else goto <D.31106>;
          <D.31105>:
          D.31107 = clause->data.catch_class;
          buffer_add_typeid (buf, domain, D.31107);
          goto <D.31108>;
          <D.31106>:
          D.31100 = clause->flags;
          if (D.31100 == 1) goto <D.31109>; else goto <D.31110>;
          <D.31109>:
          D.31111 = clause->data.filter_offset;
          buffer_add_int (buf, D.31111);
          <D.31110>:
          <D.31108>:
        }
        i = i + 1;
        <D.27158>:
        D.31095 = header->num_clauses;
        D.31112 = (int) D.31095;
        if (D.31112 > i) goto <D.27157>; else goto <D.27159>;
        <D.27159>:
        <D.31092>:
        mono_metadata_free_mh (header);
        <D.31083>:
        goto <D.27079>;
      }
      <D.27160>:
      {
        guint32 token;

        p.344 = p;
        D.31114 = decode_int (p.344, &p, end);
        token = (guint32) D.31114;
        D.31115 = token & 4278190080;
        switch (D.31115) <default: <D.27166>, case 1879048192: <D.27162>>
        <D.27162>:
        {
          struct MonoString * s;
          char * s2;

          D.31116 = token & 16777215;
          D.30875 = method->klass;
          D.31072 = D.30875->image;
          s = mono_ldstr (domain, D.31072, D.31116);
          D.31117 = s == 0B;
          D.31118 = (long int) D.31117;
          D.31119 = __builtin_expect (D.31118, 0);
          if (D.31119 != 0) goto <D.31120>; else goto <D.31121>;
          <D.31120>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 8237, "s");
          <D.31121>:
          s2 = mono_string_to_utf8 (s);
          buffer_add_byte (buf, 0);
          buffer_add_string (buf, s2);
          monoeg_g_free (s2);
          goto <D.27165>;
        }
        <D.27166>:
        {
          void * val;
          struct MonoClass * handle_class;

          try
            {
              D.31122 = BIT_FIELD_REF <*method, 8, 160>;
              D.31123 = D.31122 & 124;
              if (D.31123 == 68) goto <D.31124>; else goto <D.31125>;
              <D.31124>:
              val = mono_method_get_wrapper_data (method, token);
              D.31126 = token + 1;
              handle_class.345 = mono_method_get_wrapper_data (method, D.31126);
              handle_class = handle_class.345;
              handle_class.346 = handle_class;
              if (handle_class.346 == 0B) goto <D.31129>; else goto <D.31130>;
              <D.31129>:
              buffer_add_byte (buf, 4);
              goto <D.27165>;
              <D.31130>:
              goto <D.31131>;
              <D.31125>:
              D.30875 = method->klass;
              D.31072 = D.30875->image;
              val = mono_ldtoken (D.31072, token, &handle_class, 0B);
              D.31132 = val == 0B;
              D.31133 = (long int) D.31132;
              D.31134 = __builtin_expect (D.31133, 0);
              if (D.31134 != 0) goto <D.31135>; else goto <D.31136>;
              <D.31135>:
              monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 8261, "val");
              <D.31136>:
              <D.31131>:
              D.31137 = mono_defaults.typehandle_class;
              handle_class.346 = handle_class;
              if (D.31137 == handle_class.346) goto <D.31138>; else goto <D.31139>;
              <D.31138>:
              buffer_add_byte (buf, 1);
              D.31122 = BIT_FIELD_REF <*method, 8, 160>;
              D.31123 = D.31122 & 124;
              if (D.31123 == 68) goto <D.31140>; else goto <D.31141>;
              <D.31140>:
              buffer_add_typeid (buf, domain, val);
              goto <D.31142>;
              <D.31141>:
              D.31143 = mono_class_from_mono_type (val);
              buffer_add_typeid (buf, domain, D.31143);
              <D.31142>:
              goto <D.31144>;
              <D.31139>:
              D.31145 = mono_defaults.fieldhandle_class;
              handle_class.346 = handle_class;
              if (D.31145 == handle_class.346) goto <D.31146>; else goto <D.31147>;
              <D.31146>:
              buffer_add_byte (buf, 2);
              buffer_add_fieldid (buf, domain, val);
              goto <D.31148>;
              <D.31147>:
              D.31149 = mono_defaults.methodhandle_class;
              handle_class.346 = handle_class;
              if (D.31149 == handle_class.346) goto <D.31150>; else goto <D.31151>;
              <D.31150>:
              buffer_add_byte (buf, 3);
              buffer_add_methodid (buf, domain, val);
              goto <D.31152>;
              <D.31151>:
              D.31153 = mono_defaults.string_class;
              handle_class.346 = handle_class;
              if (D.31153 == handle_class.346) goto <D.31154>; else goto <D.31155>;
              <D.31154>:
              {
                char * s;

                s = mono_string_to_utf8 (val);
                buffer_add_byte (buf, 0);
                buffer_add_string (buf, s);
                monoeg_g_free (s);
              }
              goto <D.31156>;
              <D.31155>:
              monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "debugger-agent.c", 8284);
              <D.31156>:
              <D.31152>:
              <D.31148>:
              <D.31144>:
              goto <D.27165>;
            }
          finally
            {
              handle_class = {CLOBBER};
            }
        }
        <D.27165>:
        goto <D.27079>;
      }
      <D.27170>:
      {
        struct MonoClass * attr_klass;
        struct MonoCustomAttrInfo * cinfo;

        p.344 = p;
        attr_klass = decode_typeid (p.344, &p, end, 0B, &err);
        err.347 = err;
        if (err.347 != 0) goto <D.31158>; else goto <D.31159>;
        <D.31158>:
        err.347 = err;
        D.30978 = (ErrorCode) err.347;
        return D.30978;
        <D.31159>:
        cinfo = mono_custom_attrs_from_method (method);
        D.30875 = method->klass;
        D.31072 = D.30875->image;
        buffer_add_cattrs (buf, domain, D.31072, attr_klass, cinfo);
        goto <D.27079>;
      }
      <D.27173>:
      {
        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.344 = p;
            type_argc = decode_int (p.344, &p, end);
            type_argc.348 = (unsigned int) type_argc;
            D.31161 = type_argc.348 * 4;
            type_argv = monoeg_malloc0 (D.31161);
            i = 0;
            goto <D.27183>;
            <D.27182>:
            p.344 = p;
            klass = decode_typeid (p.344, &p, end, &d, &err);
            err.347 = err;
            if (err.347 != 0) goto <D.31162>; else goto <D.31163>;
            <D.31162>:
            monoeg_g_free (type_argv);
            err.347 = err;
            D.30978 = (ErrorCode) err.347;
            return D.30978;
            <D.31163>:
            d.349 = d;
            if (domain != d.349) goto <D.31165>; else goto <D.31166>;
            <D.31165>:
            monoeg_g_free (type_argv);
            D.30978 = 102;
            return D.30978;
            <D.31166>:
            i.350 = (unsigned int) i;
            D.31168 = i.350 * 4;
            D.31169 = type_argv + D.31168;
            D.31170 = &klass->byval_arg;
            *D.31169 = D.31170;
            i = i + 1;
            <D.27183>:
            if (i < type_argc) goto <D.27182>; else goto <D.27184>;
            <D.27184>:
            ginst = mono_metadata_get_generic_inst (type_argc, type_argv);
            monoeg_g_free (type_argv);
            D.30875 = method->klass;
            D.31172 = D.30875->generic_class;
            if (D.31172 != 0B) goto <D.31173>; else goto <D.31174>;
            <D.31173>:
            D.30875 = method->klass;
            D.31172 = D.30875->generic_class;
            iftmp.351 = D.31172->context.class_inst;
            goto <D.31175>;
            <D.31174>:
            iftmp.351 = 0B;
            <D.31175>:
            tmp_context.class_inst = iftmp.351;
            tmp_context.method_inst = ginst;
            inflated = mono_class_inflate_generic_method (method, &tmp_context);
            D.31176 = mono_verifier_is_method_valid_generic_instantiation (inflated);
            if (D.31176 == 0) goto <D.31177>; else goto <D.31178>;
            <D.31177>:
            D.30978 = 102;
            return D.30978;
            <D.31178>:
            buffer_add_methodid (buf, domain, inflated);
            goto <D.27079>;
          }
        finally
          {
            d = {CLOBBER};
            tmp_context = {CLOBBER};
          }
      }
      <D.27185>:
      D.30978 = 100;
      return D.30978;
      <D.27079>:
      D.30978 = 0;
      return D.30978;
    }
  finally
    {
      err = {CLOBBER};
    }
}


thread_commands (int command, guint8 * p, guint8 * end, struct Buffer * buf)
{
  guint8 * p.352;
  <unnamed type> D.31186;
  ErrorCode D.31189;
  struct MonoThread * thread_obj.353;
  unsigned int name_len.354;
  long int name_len.355;
  _Bool D.31196;
  long int D.31197;
  long int D.31198;
  long int len.356;
  unsigned int len.357;
  int suspend_count.358;
  int D.31206;
  _Bool D.31207;
  _Bool D.31208;
  _Bool D.31209;
  struct MonoGHashTable * thread_to_tls.359;
  _Bool D.31213;
  long int D.31214;
  long int D.31215;
  int D.31218;
  unsigned int D.31219;
  struct StackFrame * * D.31220;
  unsigned int i.360;
  unsigned int D.31222;
  struct StackFrame * * D.31223;
  struct StackFrame * D.31224;
  int D.31225;
  unsigned int D.31226;
  struct MonoMethod * D.31227;
  struct MonoDomain * D.31228;
  unsigned int D.31229;
  int D.31230;
  unsigned char D.31231;
  int D.31232;
  unsigned int D.31233;
  unsigned char D.31234;
  int D.31235;
  unsigned int thread.361;
  long long unsigned int D.31237;
  long long unsigned int D.31238;
  int objid;
  int err;
  struct MonoThread * thread_obj;
  struct MonoInternalThread * thread;

  try
    {
      p.352 = p;
      objid = decode_objid (p.352, &p, end);
      D.31186 = get_object (objid, &thread_obj);
      err = (int) D.31186;
      if (err != 0) goto <D.31187>; else goto <D.31188>;
      <D.31187>:
      D.31189 = (ErrorCode) err;
      return D.31189;
      <D.31188>:
      thread_obj.353 = thread_obj;
      thread = thread_obj.353->internal_thread;
      switch (command) <default: <D.27227>, case 1: <D.27212>, case 2: <D.27206>, case 3: <D.27223>, case 4: <D.27224>, case 5: <D.27225>, case 6: <D.27226>>
      <D.27206>:
      {
        guint32 name_len;
        gunichar2 * s;

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

              try
                {
                  name_len.354 = name_len;
                  name_len.355 = (long int) name_len.354;
                  name = monoeg_g_utf16_to_utf8 (s, name_len.355, 0B, &len, 0B);
                  D.31196 = name == 0B;
                  D.31197 = (long int) D.31196;
                  D.31198 = __builtin_expect (D.31197, 0);
                  if (D.31198 != 0) goto <D.31199>; else goto <D.31200>;
                  <D.31199>:
                  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 8395, "name");
                  <D.31200>:
                  len.356 = len;
                  len.357 = (unsigned int) len.356;
                  buffer_add_int (buf, len.357);
                  len.356 = len;
                  buffer_add_data (buf, name, len.356);
                  monoeg_g_free (s);
                }
              finally
                {
                  len = {CLOBBER};
                }
            }
            <D.31193>:
            goto <D.27211>;
          }
        finally
          {
            name_len = {CLOBBER};
          }
      }
      <D.27212>:
      {
        struct DebuggerTlsData * tls;
        int i;
        int start_frame;
        int length;

        goto <D.27218>;
        <D.27217>:
        suspend_count.358 = suspend_count;
        if (suspend_count.358 != 0) goto <D.31204>; else goto <D.31205>;
        <D.31204>:
        wait_for_suspend ();
        <D.31205>:
        <D.27218>:
        D.31206 = is_suspended ();
        if (D.31206 == 0) goto <D.27217>; else goto <D.27219>;
        <D.27219>:
        p.352 = p;
        start_frame = decode_int (p.352, &p, end);
        p.352 = p;
        length = decode_int (p.352, &p, end);
        D.31207 = start_frame != 0;
        D.31208 = length != -1;
        D.31209 = D.31207 | D.31208;
        if (D.31209 != 0) goto <D.31210>; else goto <D.31211>;
        <D.31210>:
        D.31189 = 100;
        return D.31189;
        <D.31211>:
        mono_loader_lock ();
        thread_to_tls.359 = thread_to_tls;
        tls = mono_g_hash_table_lookup (thread_to_tls.359, thread);
        mono_loader_unlock ();
        D.31213 = tls == 0B;
        D.31214 = (long int) D.31213;
        D.31215 = __builtin_expect (D.31214, 0);
        if (D.31215 != 0) goto <D.31216>; else goto <D.31217>;
        <D.31216>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 8428, "tls");
        <D.31217>:
        compute_frame_info (thread, tls);
        D.31218 = tls->frame_count;
        D.31219 = (unsigned int) D.31218;
        buffer_add_int (buf, D.31219);
        i = 0;
        goto <D.27221>;
        <D.27220>:
        D.31220 = tls->frames;
        i.360 = (unsigned int) i;
        D.31222 = i.360 * 4;
        D.31223 = D.31220 + D.31222;
        D.31224 = *D.31223;
        D.31225 = D.31224->id;
        D.31226 = (unsigned int) D.31225;
        buffer_add_int (buf, D.31226);
        D.31220 = tls->frames;
        i.360 = (unsigned int) i;
        D.31222 = i.360 * 4;
        D.31223 = D.31220 + D.31222;
        D.31224 = *D.31223;
        D.31227 = D.31224->actual_method;
        D.31220 = tls->frames;
        i.360 = (unsigned int) i;
        D.31222 = i.360 * 4;
        D.31223 = D.31220 + D.31222;
        D.31224 = *D.31223;
        D.31228 = D.31224->domain;
        buffer_add_methodid (buf, D.31228, D.31227);
        D.31220 = tls->frames;
        i.360 = (unsigned int) i;
        D.31222 = i.360 * 4;
        D.31223 = D.31220 + D.31222;
        D.31224 = *D.31223;
        D.31229 = D.31224->il_offset;
        buffer_add_int (buf, D.31229);
        D.31220 = tls->frames;
        i.360 = (unsigned int) i;
        D.31222 = i.360 * 4;
        D.31223 = D.31220 + D.31222;
        D.31224 = *D.31223;
        D.31230 = D.31224->flags;
        D.31231 = (unsigned char) D.31230;
        D.31232 = (int) D.31231;
        buffer_add_byte (buf, D.31232);
        i = i + 1;
        <D.27221>:
        D.31218 = tls->frame_count;
        if (D.31218 > i) goto <D.27220>; else goto <D.27222>;
        <D.27222>:
        goto <D.27211>;
      }
      <D.27223>:
      D.31233 = thread->state;
      buffer_add_int (buf, D.31233);
      goto <D.27211>;
      <D.27224>:
      D.31234 = thread->threadpool_thread;
      D.31235 = (int) D.31234;
      buffer_add_byte (buf, D.31235);
      goto <D.27211>;
      <D.27225>:
      thread.361 = (unsigned int) thread;
      D.31237 = (long long unsigned int) thread.361;
      buffer_add_long (buf, D.31237);
      goto <D.27211>;
      <D.27226>:
      D.31238 = thread->tid;
      buffer_add_long (buf, D.31238);
      goto <D.27211>;
      <D.27227>:
      D.31189 = 100;
      return D.31189;
      <D.27211>:
      D.31189 = 0;
      return D.31189;
    }
  finally
    {
      thread_obj = {CLOBBER};
    }
}


frame_commands (int command, guint8 * p, guint8 * end, struct Buffer * buf)
{
  guint8 * p.362;
  <unnamed type> D.31244;
  ErrorCode D.31247;
  struct MonoThread * thread_obj.363;
  struct MonoGHashTable * thread_to_tls.364;
  _Bool D.31250;
  long int D.31251;
  long int D.31252;
  struct StackFrame * * D.31255;
  unsigned int i.365;
  unsigned int D.31257;
  struct StackFrame * * D.31258;
  struct StackFrame * D.31259;
  int D.31260;
  int D.31262;
  unsigned int frame_idx.366;
  unsigned int D.31266;
  struct StackFrame * * D.31267;
  int D.31268;
  struct MonoDebugMethodJitInfo * D.31271;
  struct MonoDomain * D.31274;
  struct MonoMethod * D.31275;
  struct MonoDebugMethodJitInfo * D.31276;
  unsigned char D.31279;
  unsigned char D.31280;
  struct MonoMethod * D.31283;
  struct MonoDebugMethodJitInfo * D.31284;
  int log_level.367;
  _Bool D.31288;
  long int D.31289;
  long int D.31290;
  struct FILE * log_file.368;
  struct MonoMethod * D.31294;
  struct MonoSeqPointInfo * D.31295;
  int iftmp.369;
  unsigned int pos.370;
  unsigned int D.31306;
  _Bool D.31307;
  long int D.31308;
  long int D.31309;
  struct MonoDebugVarInfo * D.31312;
  unsigned int pos.371;
  unsigned int D.31314;
  struct MonoContext * D.31315;
  struct MonoDebugVarInfo * D.31316;
  struct MonoType * D.31317;
  int iftmp.372;
  unsigned int D.31324;
  _Bool D.31325;
  long int D.31326;
  long int D.31327;
  struct MonoDebugVarInfo * D.31330;
  struct MonoDebugVarInfo * D.31331;
  struct MonoType * D.31332;
  struct MonoClass * D.31333;
  unsigned char D.31334;
  unsigned char D.31335;
  unsigned char D.31338;
  unsigned char D.31339;
  struct MonoClass * D.31342;
  struct MonoType * D.31343;
  struct MonoDebugVarInfo * D.31345;
  struct MonoClass * D.31346;
  struct MonoType * D.31347;
  struct MonoType * D.31351;
  struct MonoType * D.31353;
  int iftmp.373;
  _Bool D.31361;
  long int D.31362;
  long int D.31363;
  int iftmp.374;
  _Bool D.31372;
  long int D.31373;
  long int D.31374;
  int D.31377;
  struct MonoClass * D.31381;
  int D.31382;
  unsigned int D.31383;
  <unnamed type> D.31384;
  struct MonoContext * D.31387;
  mgreg_t *[8] * D.31388;
  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.362 = p;
      objid = decode_objid (p.362, &p, end);
      D.31244 = get_object (objid, &thread_obj);
      err = (int) D.31244;
      if (err != 0) goto <D.31245>; else goto <D.31246>;
      <D.31245>:
      D.31247 = (ErrorCode) err;
      return D.31247;
      <D.31246>:
      thread_obj.363 = thread_obj;
      thread = thread_obj.363->internal_thread;
      p.362 = p;
      id = decode_id (p.362, &p, end);
      mono_loader_lock ();
      thread_to_tls.364 = thread_to_tls;
      tls = mono_g_hash_table_lookup (thread_to_tls.364, thread);
      mono_loader_unlock ();
      D.31250 = tls == 0B;
      D.31251 = (long int) D.31250;
      D.31252 = __builtin_expect (D.31251, 0);
      if (D.31252 != 0) goto <D.31253>; else goto <D.31254>;
      <D.31253>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 8495, "tls");
      <D.31254>:
      i = 0;
      goto <D.27251>;
      <D.27250>:
      D.31255 = tls->frames;
      i.365 = (unsigned int) i;
      D.31257 = i.365 * 4;
      D.31258 = D.31255 + D.31257;
      D.31259 = *D.31258;
      D.31260 = D.31259->id;
      if (D.31260 == id) goto <D.27249>; else goto <D.31261>;
      <D.31261>:
      i = i + 1;
      <D.27251>:
      D.31262 = tls->frame_count;
      if (D.31262 > i) goto <D.27250>; else goto <D.27249>;
      <D.27249>:
      D.31262 = tls->frame_count;
      if (D.31262 == i) goto <D.31263>; else goto <D.31264>;
      <D.31263>:
      D.31247 = 30;
      return D.31247;
      <D.31264>:
      frame_idx = i;
      D.31255 = tls->frames;
      frame_idx.366 = (unsigned int) frame_idx;
      D.31266 = frame_idx.366 * 4;
      D.31267 = D.31255 + D.31266;
      frame = *D.31267;
      D.31268 = frame->has_ctx;
      if (D.31268 == 0) goto <D.31269>; else goto <D.31270>;
      <D.31269>:
      D.31247 = 105;
      return D.31247;
      <D.31270>:
      D.31271 = frame->jit;
      if (D.31271 == 0B) goto <D.31272>; else goto <D.31273>;
      <D.31272>:
      D.31274 = frame->domain;
      D.31275 = frame->api_method;
      D.31276 = mono_debug_find_method (D.31275, D.31274);
      frame->jit = D.31276;
      D.31271 = frame->jit;
      if (D.31271 == 0B) goto <D.31277>; else goto <D.31278>;
      <D.31277>:
      D.31275 = frame->api_method;
      D.31279 = BIT_FIELD_REF <*D.31275, 8, 168>;
      D.31280 = D.31279 & 16;
      if (D.31280 != 0) goto <D.31281>; else goto <D.31282>;
      <D.31281>:
      D.31274 = frame->domain;
      D.31275 = frame->api_method;
      D.31283 = mono_method_get_declaring_generic_method (D.31275);
      D.31284 = mono_debug_find_method (D.31283, D.31274);
      frame->jit = D.31284;
      <D.31282>:
      <D.31278>:
      D.31271 = frame->jit;
      if (D.31271 == 0B) goto <D.31285>; else goto <D.31286>;
      <D.31285>:
      {
        char * s;

        D.31275 = frame->api_method;
        s = mono_method_full_name (D.31275, 1);
        log_level.367 = log_level;
        D.31288 = log_level.367 > 0;
        D.31289 = (long int) D.31288;
        D.31290 = __builtin_expect (D.31289, 0);
        if (D.31290 != 0) goto <D.31291>; else goto <D.31292>;
        <D.31291>:
        log_file.368 = log_file;
        fprintf (log_file.368, "[dbg] No debug information found for \'%s\'.\n", s);
        log_file.368 = log_file;
        fflush (log_file.368);
        <D.31292>:
        monoeg_g_free (s);
        D.31247 = 105;
        return D.31247;
      }
      <D.31286>:
      <D.31273>:
      jit = frame->jit;
      D.31294 = frame->actual_method;
      sig = mono_method_signature (D.31294);
      D.31294 = frame->actual_method;
      D.31274 = frame->domain;
      D.31295 = get_seq_points (D.31274, D.31294);
      if (D.31295 == 0B) goto <D.31296>; else goto <D.31297>;
      <D.31296>:
      D.31247 = 105;
      return D.31247;
      <D.31297>:
      switch (command) <default: <D.27268>, case 1: <D.27253>, case 2: <D.27258>, case 3: <D.27261>>
      <D.27253>:
      p.362 = p;
      len = decode_int (p.362, &p, end);
      D.31294 = frame->actual_method;
      header = mono_method_get_header (D.31294);
      i = 0;
      goto <D.27255>;
      <D.27254>:
      p.362 = p;
      pos = decode_int (p.362, &p, end);
      if (pos < 0) goto <D.31298>; else goto <D.31299>;
      <D.31298>:
      pos = ~pos;
      if (pos < 0) goto <D.31301>; else goto <D.31304>;
      <D.31304>:
      pos.370 = (unsigned int) pos;
      D.31306 = jit->num_params;
      if (pos.370 >= D.31306) goto <D.31301>; else goto <D.31302>;
      <D.31301>:
      iftmp.369 = 1;
      goto <D.31303>;
      <D.31302>:
      iftmp.369 = 0;
      <D.31303>:
      D.31307 = iftmp.369 != 0;
      D.31308 = (long int) D.31307;
      D.31309 = __builtin_expect (D.31308, 0);
      if (D.31309 != 0) goto <D.31310>; else goto <D.31311>;
      <D.31310>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 8545, "pos >= 0 && pos < jit->num_params");
      <D.31311>:
      D.31312 = jit->params;
      pos.371 = (unsigned int) pos;
      D.31314 = pos.371 * 24;
      var = D.31312 + D.31314;
      D.31274 = frame->domain;
      D.31315 = &frame->ctx;
      D.31312 = jit->params;
      pos.371 = (unsigned int) pos;
      D.31314 = pos.371 * 24;
      D.31316 = D.31312 + D.31314;
      D.31317 = sig->params[pos];
      add_var (buf, jit, D.31317, D.31316, D.31315, D.31274, 0);
      goto <D.31318>;
      <D.31299>:
      if (pos < 0) goto <D.31320>; else goto <D.31323>;
      <D.31323>:
      pos.370 = (unsigned int) pos;
      D.31324 = jit->num_locals;
      if (pos.370 >= D.31324) goto <D.31320>; else goto <D.31321>;
      <D.31320>:
      iftmp.372 = 1;
      goto <D.31322>;
      <D.31321>:
      iftmp.372 = 0;
      <D.31322>:
      D.31325 = iftmp.372 != 0;
      D.31326 = (long int) D.31325;
      D.31327 = __builtin_expect (D.31326, 0);
      if (D.31327 != 0) goto <D.31328>; else goto <D.31329>;
      <D.31328>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 8551, "pos >= 0 && pos < jit->num_locals");
      <D.31329>:
      D.31330 = jit->locals;
      pos.371 = (unsigned int) pos;
      D.31314 = pos.371 * 24;
      var = D.31330 + D.31314;
      D.31274 = frame->domain;
      D.31315 = &frame->ctx;
      D.31330 = jit->locals;
      pos.371 = (unsigned int) pos;
      D.31314 = pos.371 * 24;
      D.31331 = D.31330 + D.31314;
      D.31332 = header->locals[pos];
      add_var (buf, jit, D.31332, D.31331, D.31315, D.31274, 0);
      <D.31318>:
      i = i + 1;
      <D.27255>:
      if (i < len) goto <D.27254>; else goto <D.27256>;
      <D.27256>:
      mono_metadata_free_mh (header);
      goto <D.27257>;
      <D.27258>:
      D.31275 = frame->api_method;
      D.31333 = D.31275->klass;
      D.31334 = BIT_FIELD_REF <*D.31333, 8, 160>;
      D.31335 = D.31334 & 8;
      if (D.31335 != 0) goto <D.31336>; else goto <D.31337>;
      <D.31336>:
      D.31338 = BIT_FIELD_REF <*sig, 8, 80>;
      D.31339 = D.31338 & 64;
      if (D.31339 == 0) goto <D.31340>; else goto <D.31341>;
      <D.31340>:
      {
        struct MonoObject * p;

        try
          {
            p = 0B;
            D.31274 = frame->domain;
            D.31342 = mono_defaults.object_class;
            D.31343 = &D.31342->byval_arg;
            buffer_add_value (buf, D.31343, &p, D.31274);
          }
        finally
          {
            p = {CLOBBER};
          }
      }
      goto <D.31344>;
      <D.31341>:
      D.31274 = frame->domain;
      D.31315 = &frame->ctx;
      D.31345 = jit->this_var;
      D.31294 = frame->actual_method;
      D.31346 = D.31294->klass;
      D.31347 = &D.31346->this_arg;
      add_var (buf, jit, D.31347, D.31345, D.31315, D.31274, 1);
      <D.31344>:
      goto <D.31348>;
      <D.31337>:
      D.31338 = BIT_FIELD_REF <*sig, 8, 80>;
      D.31339 = D.31338 & 64;
      if (D.31339 == 0) goto <D.31349>; else goto <D.31350>;
      <D.31349>:
      {
        struct MonoObject * p;

        try
          {
            p = 0B;
            D.31274 = frame->domain;
            D.31294 = frame->actual_method;
            D.31346 = D.31294->klass;
            D.31351 = &D.31346->byval_arg;
            buffer_add_value (buf, D.31351, &p, D.31274);
          }
        finally
          {
            p = {CLOBBER};
          }
      }
      goto <D.31352>;
      <D.31350>:
      D.31274 = frame->domain;
      D.31315 = &frame->ctx;
      D.31345 = jit->this_var;
      D.31275 = frame->api_method;
      D.31333 = D.31275->klass;
      D.31353 = &D.31333->byval_arg;
      add_var (buf, jit, D.31353, D.31345, D.31315, D.31274, 1);
      <D.31352>:
      <D.31348>:
      goto <D.27257>;
      <D.27261>:
      {
        guint8 * val_buf;
        struct MonoType * t;
        struct MonoDebugVarInfo * var;

        p.362 = p;
        len = decode_int (p.362, &p, end);
        D.31294 = frame->actual_method;
        header = mono_method_get_header (D.31294);
        i = 0;
        goto <D.27266>;
        <D.27265>:
        p.362 = p;
        pos = decode_int (p.362, &p, end);
        if (pos < 0) goto <D.31354>; else goto <D.31355>;
        <D.31354>:
        pos = ~pos;
        if (pos < 0) goto <D.31357>; else goto <D.31360>;
        <D.31360>:
        pos.370 = (unsigned int) pos;
        D.31306 = jit->num_params;
        if (pos.370 >= D.31306) goto <D.31357>; else goto <D.31358>;
        <D.31357>:
        iftmp.373 = 1;
        goto <D.31359>;
        <D.31358>:
        iftmp.373 = 0;
        <D.31359>:
        D.31361 = iftmp.373 != 0;
        D.31362 = (long int) D.31361;
        D.31363 = __builtin_expect (D.31362, 0);
        if (D.31363 != 0) goto <D.31364>; else goto <D.31365>;
        <D.31364>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 8593, "pos >= 0 && pos < jit->num_params");
        <D.31365>:
        t = sig->params[pos];
        D.31312 = jit->params;
        pos.371 = (unsigned int) pos;
        D.31314 = pos.371 * 24;
        var = D.31312 + D.31314;
        goto <D.31366>;
        <D.31355>:
        if (pos < 0) goto <D.31368>; else goto <D.31371>;
        <D.31371>:
        pos.370 = (unsigned int) pos;
        D.31324 = jit->num_locals;
        if (pos.370 >= D.31324) goto <D.31368>; else goto <D.31369>;
        <D.31368>:
        iftmp.374 = 1;
        goto <D.31370>;
        <D.31369>:
        iftmp.374 = 0;
        <D.31370>:
        D.31372 = iftmp.374 != 0;
        D.31373 = (long int) D.31372;
        D.31374 = __builtin_expect (D.31373, 0);
        if (D.31374 != 0) goto <D.31375>; else goto <D.31376>;
        <D.31375>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 8598, "pos >= 0 && pos < jit->num_locals");
        <D.31376>:
        t = header->locals[pos];
        D.31330 = jit->locals;
        pos.371 = (unsigned int) pos;
        D.31314 = pos.371 * 24;
        var = D.31330 + D.31314;
        <D.31366>:
        D.31377 = mono_type_is_reference (t);
        if (D.31377 != 0) goto <D.31378>; else goto <D.31379>;
        <D.31378>:
        val_buf = __builtin_alloca (4);
        goto <D.31380>;
        <D.31379>:
        D.31381 = mono_class_from_mono_type (t);
        D.31382 = mono_class_instance_size (D.31381);
        D.31383 = (unsigned int) D.31382;
        val_buf = __builtin_alloca (D.31383);
        <D.31380>:
        p.362 = p;
        D.31274 = frame->domain;
        D.31384 = decode_value (t, D.31274, val_buf, p.362, &p, end);
        err = (int) D.31384;
        if (err != 0) goto <D.31385>; else goto <D.31386>;
        <D.31385>:
        D.31247 = (ErrorCode) err;
        return D.31247;
        <D.31386>:
        D.31387 = &tls->restore_ctx;
        D.31388 = &frame->reg_locations;
        D.31274 = frame->domain;
        D.31315 = &frame->ctx;
        set_var (t, var, D.31315, D.31274, val_buf, D.31388, D.31387);
        i = i + 1;
        <D.27266>:
        if (i < len) goto <D.27265>; else goto <D.27267>;
        <D.27267>:
        mono_metadata_free_mh (header);
        goto <D.27257>;
      }
      <D.27268>:
      D.31247 = 100;
      return D.31247;
      <D.27257>:
      D.31247 = 0;
      return D.31247;
    }
  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.31391;
  int D.31392;
  int reg_val.375;
  int D.31394;
  unsigned int D.31395;
  int D.31396;
  _Bool D.31397;
  long int D.31398;
  long int D.31399;
  _Bool D.31402;
  long int D.31403;
  long int D.31404;
  _Bool D.31407;
  long int D.31408;
  long int D.31409;
  unsigned int D.31412;
  int D.31413;
  int D.31416;
  unsigned int D.31417;
  int D.31421;
  _Bool D.31423;
  long int D.31424;
  long int D.31425;
  unsigned int D.31428;
  int D.31429;
  int D.31432;
  unsigned int D.31433;
  int D.31437;
  _Bool D.31439;
  long int D.31440;
  long int D.31441;
  void * D.31444;
  sizetype D.31445;
  guint32 flags;
  int reg;
  guint8 * addr;
  guint8 * gaddr;
  mgreg_t reg_val;

  try
    {
      D.31391 = var->index;
      flags = D.31391 & 4026531840;
      D.31391 = var->index;
      D.31392 = (int) D.31391;
      reg = D.31392 & 268435455;
      switch (flags) <default: <D.26412>, case 0: <D.26400>, case 268435456: <D.26402>, case 805306368: <D.26403>, case 1073741824: <D.26404>, case 1342177280: <D.26406>, case 1610612736: <D.26405>>
      <D.26400>:
      reg_val.375 = mono_arch_context_get_int_reg (ctx, reg);
      reg_val = reg_val.375;
      buffer_add_value_full (buf, t, &reg_val, domain, as_vtype);
      goto <D.26401>;
      <D.26402>:
      D.31394 = mono_arch_context_get_int_reg (ctx, reg);
      addr = (guint8 *) D.31394;
      D.31395 = var->offset;
      addr = addr + D.31395;
      buffer_add_value_full (buf, t, addr, domain, as_vtype);
      goto <D.26401>;
      <D.26403>:
      monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "debugger-agent.c", 5939);
      <D.26404>:
      <D.26405>:
      D.31396 = mono_arch_context_get_int_reg (ctx, reg);
      addr = (guint8 *) D.31396;
      D.31395 = var->offset;
      addr = addr + D.31395;
      gaddr = MEM[(void * *)addr];
      D.31397 = gaddr == 0B;
      D.31398 = (long int) D.31397;
      D.31399 = __builtin_expect (D.31398, 0);
      if (D.31399 != 0) goto <D.31400>; else goto <D.31401>;
      <D.31400>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 5948, "gaddr");
      <D.31401>:
      buffer_add_value_full (buf, t, gaddr, domain, as_vtype);
      goto <D.26401>;
      <D.26406>:
      {
        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.31402 = info_var == 0B;
        D.31403 = (long int) D.31402;
        D.31404 = __builtin_expect (D.31403, 0);
        if (D.31404 != 0) goto <D.31405>; else goto <D.31406>;
        <D.31405>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 5960, "info_var");
        <D.31406>:
        D.31407 = locals_var == 0B;
        D.31408 = (long int) D.31407;
        D.31409 = __builtin_expect (D.31408, 0);
        if (D.31409 != 0) goto <D.31410>; else goto <D.31411>;
        <D.31410>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 5961, "locals_var");
        <D.31411>:
        D.31412 = info_var->index;
        flags = D.31412 & 4026531840;
        D.31412 = info_var->index;
        D.31413 = (int) D.31412;
        reg = D.31413 & 268435455;
        if (flags == 268435456) goto <D.31414>; else goto <D.31415>;
        <D.31414>:
        D.31416 = mono_arch_context_get_int_reg (ctx, reg);
        addr = (guint8 *) D.31416;
        D.31417 = info_var->offset;
        addr = addr + D.31417;
        info = MEM[(void * *)addr];
        goto <D.31418>;
        <D.31415>:
        if (flags == 0) goto <D.31419>; else goto <D.31420>;
        <D.31419>:
        D.31421 = mono_arch_context_get_int_reg (ctx, reg);
        info = (struct MonoGSharedVtMethodRuntimeInfo *) D.31421;
        goto <D.31422>;
        <D.31420>:
        monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "debugger-agent.c", 5972);
        <D.31422>:
        <D.31418>:
        D.31423 = info == 0B;
        D.31424 = (long int) D.31423;
        D.31425 = __builtin_expect (D.31424, 0);
        if (D.31425 != 0) goto <D.31426>; else goto <D.31427>;
        <D.31426>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 5974, "info");
        <D.31427>:
        D.31428 = locals_var->index;
        flags = D.31428 & 4026531840;
        D.31428 = locals_var->index;
        D.31429 = (int) D.31428;
        reg = D.31429 & 268435455;
        if (flags == 268435456) goto <D.31430>; else goto <D.31431>;
        <D.31430>:
        D.31432 = mono_arch_context_get_int_reg (ctx, reg);
        addr = (guint8 *) D.31432;
        D.31433 = locals_var->offset;
        addr = addr + D.31433;
        locals = MEM[(void * *)addr];
        goto <D.31434>;
        <D.31431>:
        if (flags == 0) goto <D.31435>; else goto <D.31436>;
        <D.31435>:
        D.31437 = mono_arch_context_get_int_reg (ctx, reg);
        locals = (guint8 *) D.31437;
        goto <D.31438>;
        <D.31436>:
        monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "debugger-agent.c", 5985);
        <D.31438>:
        <D.31434>:
        D.31439 = locals == 0B;
        D.31440 = (long int) D.31439;
        D.31441 = __builtin_expect (D.31440, 0);
        if (D.31441 != 0) goto <D.31442>; else goto <D.31443>;
        <D.31442>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 5987, "locals");
        <D.31443>:
        D.31444 = info->entries[idx];
        D.31445 = (sizetype) D.31444;
        addr = locals + D.31445;
        buffer_add_value_full (buf, t, addr, domain, as_vtype);
        goto <D.26401>;
      }
      <D.26412>:
      monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "debugger-agent.c", 5996);
      <D.26401>:
    }
  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.31446;
  int D.31447;
  int D.31448;
  struct MonoClass * D.31452;
  unsigned char D.31453;
  unsigned char D.31454;
  int D.31457;
  unsigned int size.376;
  unsigned char D.31465;
  _Bool D.31466;
  _Bool D.31467;
  _Bool D.31468;
  unsigned char D.31470;
  int iftmp.377;
  signed char D.31475;
  unsigned char D.31477;
  int iftmp.378;
  short int D.31481;
  short unsigned int D.31483;
  mgreg_t iftmp.379;
  long long int D.31487;
  long long unsigned int D.31489;
  unsigned int reg.380;
  unsigned int D.31491;
  mgreg_t * * D.31492;
  mgreg_t * D.31493;
  int log_level.381;
  _Bool D.31497;
  long int D.31498;
  long int D.31499;
  void * v.382;
  struct FILE * log_file.383;
  int D.31507;
  unsigned int D.31508;
  int D.31512;
  _Bool D.31513;
  long int D.31514;
  long int D.31515;
  guint32 flags;
  int reg;
  int size;
  guint8 * addr;
  guint8 * gaddr;

  D.31446 = var->index;
  flags = D.31446 & 4026531840;
  D.31446 = var->index;
  D.31447 = (int) D.31446;
  reg = D.31447 & 268435455;
  D.31448 = mono_type_is_reference (t);
  if (D.31448 != 0) goto <D.31449>; else goto <D.31450>;
  <D.31449>:
  size = 4;
  goto <D.31451>;
  <D.31450>:
  D.31452 = mono_class_from_mono_type (t);
  size = mono_class_value_size (D.31452, 0B);
  <D.31451>:
  switch (flags) <default: <D.26440>, case 0: <D.26427>, case 268435456: <D.26437>, case 805306368: <D.26439>, case 1073741824: <D.26438>>
  <D.26427>:
  {
    mgreg_t v;
    gboolean is_signed;

    is_signed = 0;
    D.31453 = BIT_FIELD_REF <*t, 8, 56>;
    D.31454 = D.31453 & 64;
    if (D.31454 != 0) goto <D.31455>; else goto <D.31456>;
    <D.31455>:
    D.31457 = mono_arch_context_get_int_reg (ctx, reg);
    addr = (guint8 *) D.31457;
    if (addr != 0B) goto <D.31458>; else goto <D.31459>;
    <D.31458>:
    size.376 = (unsigned int) size;
    mono_gc_memmove_atomic (addr, val, size.376);
    <D.31459>:
    goto <D.26430>;
    <D.31456>:
    D.31453 = BIT_FIELD_REF <*t, 8, 56>;
    D.31454 = D.31453 & 64;
    if (D.31454 == 0) goto <D.31463>; else goto <D.31464>;
    <D.31463>:
    D.31465 = t->type;
    D.31466 = D.31465 == 4;
    D.31467 = D.31465 == 6;
    D.31468 = D.31466 | D.31467;
    if (D.31468 != 0) goto <D.31461>; else goto <D.31469>;
    <D.31469>:
    D.31470 = t->type;
    if (D.31470 == 8) goto <D.31461>; else goto <D.31471>;
    <D.31471>:
    D.31470 = t->type;
    if (D.31470 == 10) goto <D.31461>; else goto <D.31462>;
    <D.31461>:
    is_signed = 1;
    <D.31462>:
    <D.31464>:
    switch (size) <default: <D.26436>, case 1: <D.26431>, case 2: <D.26433>, case 4: <D.26434>, case 8: <D.26435>>
    <D.26431>:
    if (is_signed != 0) goto <D.31473>; else goto <D.31474>;
    <D.31473>:
    D.31475 = MEM[(gint8 *)val];
    iftmp.377 = (int) D.31475;
    goto <D.31476>;
    <D.31474>:
    D.31477 = *val;
    iftmp.377 = (int) D.31477;
    <D.31476>:
    v = iftmp.377;
    goto <D.26432>;
    <D.26433>:
    if (is_signed != 0) goto <D.31479>; else goto <D.31480>;
    <D.31479>:
    D.31481 = MEM[(gint16 *)val];
    iftmp.378 = (int) D.31481;
    goto <D.31482>;
    <D.31480>:
    D.31483 = MEM[(guint16 *)val];
    iftmp.378 = (int) D.31483;
    <D.31482>:
    v = iftmp.378;
    goto <D.26432>;
    <D.26434>:
    v = MEM[(gint32 *)val];
    goto <D.26432>;
    <D.26435>:
    if (is_signed != 0) goto <D.31485>; else goto <D.31486>;
    <D.31485>:
    D.31487 = MEM[(gint64 *)val];
    iftmp.379 = (mgreg_t) D.31487;
    goto <D.31488>;
    <D.31486>:
    D.31489 = MEM[(guint64 *)val];
    iftmp.379 = (mgreg_t) D.31489;
    <D.31488>:
    v = iftmp.379;
    goto <D.26432>;
    <D.26436>:
    monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "debugger-agent.c", 6048);
    <D.26432>:
    reg.380 = (unsigned int) reg;
    D.31491 = reg.380 * 4;
    D.31492 = reg_locations + D.31491;
    D.31493 = *D.31492;
    if (D.31493 != 0B) goto <D.31494>; else goto <D.31495>;
    <D.31494>:
    log_level.381 = log_level;
    D.31497 = log_level.381 > 0;
    D.31498 = (long int) D.31497;
    D.31499 = __builtin_expect (D.31498, 0);
    if (D.31499 != 0) goto <D.31500>; else goto <D.31501>;
    <D.31500>:
    v.382 = (void *) v;
    reg.380 = (unsigned int) reg;
    D.31491 = reg.380 * 4;
    D.31492 = reg_locations + D.31491;
    D.31493 = *D.31492;
    log_file.383 = log_file;
    fprintf (log_file.383, "[dbg] Setting stack location %p for reg %x to %p.\n", D.31493, reg, v.382);
    log_file.383 = log_file;
    fflush (log_file.383);
    <D.31501>:
    reg.380 = (unsigned int) reg;
    D.31491 = reg.380 * 4;
    D.31492 = reg_locations + D.31491;
    D.31493 = *D.31492;
    *D.31493 = v;
    goto <D.31504>;
    <D.31495>:
    log_level.381 = log_level;
    D.31497 = log_level.381 > 0;
    D.31498 = (long int) D.31497;
    D.31499 = __builtin_expect (D.31498, 0);
    if (D.31499 != 0) goto <D.31505>; else goto <D.31506>;
    <D.31505>:
    v.382 = (void *) v;
    log_file.383 = log_file;
    fprintf (log_file.383, "[dbg] Setting context location for reg %x to %p.\n", reg, v.382);
    log_file.383 = log_file;
    fflush (log_file.383);
    <D.31506>:
    mono_arch_context_set_int_reg (restore_ctx, reg, v);
    <D.31504>:
    mono_arch_context_set_int_reg (ctx, reg, v);
    goto <D.26430>;
  }
  <D.26437>:
  D.31507 = mono_arch_context_get_int_reg (ctx, reg);
  addr = (guint8 *) D.31507;
  D.31508 = var->offset;
  addr = addr + D.31508;
  D.31453 = BIT_FIELD_REF <*t, 8, 56>;
  D.31454 = D.31453 & 64;
  if (D.31454 != 0) goto <D.31509>; else goto <D.31510>;
  <D.31509>:
  addr = MEM[(guint8 * *)addr];
  if (addr == 0B) goto <D.26430>; else goto <D.31511>;
  <D.31511>:
  <D.31510>:
  size.376 = (unsigned int) size;
  mono_gc_memmove_atomic (addr, val, size.376);
  goto <D.26430>;
  <D.26438>:
  D.31512 = mono_arch_context_get_int_reg (ctx, reg);
  addr = (guint8 *) D.31512;
  D.31508 = var->offset;
  addr = addr + D.31508;
  gaddr = MEM[(void * *)addr];
  D.31513 = gaddr == 0B;
  D.31514 = (long int) D.31513;
  D.31515 = __builtin_expect (D.31514, 0);
  if (D.31515 != 0) goto <D.31516>; else goto <D.31517>;
  <D.31516>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 6092, "gaddr");
  <D.31517>:
  size.376 = (unsigned int) size;
  mono_gc_memmove_atomic (gaddr, val, size.376);
  goto <D.26430>;
  <D.26439>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "debugger-agent.c", 6097);
  <D.26440>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "debugger-agent.c", 6100);
  <D.26430>:
}


array_commands (int command, guint8 * p, guint8 * end, struct Buffer * buf)
{
  guint8 * p.384;
  <unnamed type> D.31519;
  ErrorCode D.31522;
  struct MonoArray * arr.385;
  struct MonoVTable * D.31524;
  struct MonoClass * D.31525;
  unsigned char D.31526;
  unsigned int D.31527;
  struct MonoArrayBounds * D.31528;
  unsigned int D.31531;
  unsigned int i.386;
  unsigned int D.31534;
  struct MonoArrayBounds * D.31535;
  unsigned int D.31536;
  int D.31537;
  unsigned int D.31538;
  int D.31539;
  _Bool D.31540;
  _Bool D.31541;
  _Bool D.31542;
  int D.31543;
  _Bool D.31544;
  long int D.31545;
  long int D.31546;
  unsigned int index.387;
  unsigned int len.388;
  unsigned int D.31551;
  _Bool D.31552;
  long int D.31553;
  long int D.31554;
  double[0:] * D.31557;
  int D.31558;
  sizetype D.31559;
  struct MonoDomain * D.31560;
  struct MonoClass * D.31561;
  struct MonoType * D.31562;
  int D.31563;
  struct MonoArray * arr;
  int objid;
  int err;
  int index;
  int len;
  int i;
  int esize;
  void * elem;

  try
    {
      p.384 = p;
      objid = decode_objid (p.384, &p, end);
      D.31519 = get_object (objid, &arr);
      err = (int) D.31519;
      if (err != 0) goto <D.31520>; else goto <D.31521>;
      <D.31520>:
      D.31522 = (ErrorCode) err;
      return D.31522;
      <D.31521>:
      switch (command) <default: <D.27296>, case 1: <D.27283>, case 2: <D.27288>, case 3: <D.27292>>
      <D.27283>:
      arr.385 = arr;
      D.31524 = arr.385->obj.vtable;
      D.31525 = D.31524->klass;
      D.31526 = D.31525->rank;
      D.31527 = (unsigned int) D.31526;
      buffer_add_int (buf, D.31527);
      arr.385 = arr;
      D.31528 = arr.385->bounds;
      if (D.31528 == 0B) goto <D.31529>; else goto <D.31530>;
      <D.31529>:
      arr.385 = arr;
      D.31531 = arr.385->max_length;
      buffer_add_int (buf, D.31531);
      buffer_add_int (buf, 0);
      goto <D.31532>;
      <D.31530>:
      i = 0;
      goto <D.27285>;
      <D.27284>:
      arr.385 = arr;
      D.31528 = arr.385->bounds;
      i.386 = (unsigned int) i;
      D.31534 = i.386 * 8;
      D.31535 = D.31528 + D.31534;
      D.31536 = D.31535->length;
      buffer_add_int (buf, D.31536);
      arr.385 = arr;
      D.31528 = arr.385->bounds;
      i.386 = (unsigned int) i;
      D.31534 = i.386 * 8;
      D.31535 = D.31528 + D.31534;
      D.31537 = D.31535->lower_bound;
      D.31538 = (unsigned int) D.31537;
      buffer_add_int (buf, D.31538);
      i = i + 1;
      <D.27285>:
      arr.385 = arr;
      D.31524 = arr.385->obj.vtable;
      D.31525 = D.31524->klass;
      D.31526 = D.31525->rank;
      D.31539 = (int) D.31526;
      if (D.31539 > i) goto <D.27284>; else goto <D.27286>;
      <D.27286>:
      <D.31532>:
      goto <D.27287>;
      <D.27288>:
      p.384 = p;
      index = decode_int (p.384, &p, end);
      p.384 = p;
      len = decode_int (p.384, &p, end);
      D.31540 = index < 0;
      D.31541 = len < 0;
      D.31542 = D.31540 | D.31541;
      D.31543 = (int) D.31542;
      D.31544 = D.31543 != 0;
      D.31545 = (long int) D.31544;
      D.31546 = __builtin_expect (D.31545, 0);
      if (D.31546 != 0) goto <D.31547>; else goto <D.31548>;
      <D.31547>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 8653, "index >= 0 && len >= 0");
      <D.31548>:
      index.387 = (unsigned int) index;
      arr.385 = arr;
      D.31531 = arr.385->max_length;
      len.388 = (unsigned int) len;
      D.31551 = D.31531 - len.388;
      D.31552 = index.387 > D.31551;
      D.31553 = (long int) D.31552;
      D.31554 = __builtin_expect (D.31553, 0);
      if (D.31554 != 0) goto <D.31555>; else goto <D.31556>;
      <D.31555>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 8655, "!(index > arr->max_length - len)");
      <D.31556>:
      arr.385 = arr;
      D.31524 = arr.385->obj.vtable;
      D.31525 = D.31524->klass;
      esize = mono_array_element_size (D.31525);
      i = index;
      goto <D.27290>;
      <D.27289>:
      arr.385 = arr;
      D.31557 = &arr.385->vector;
      D.31558 = i * esize;
      D.31559 = (sizetype) D.31558;
      elem = D.31557 + D.31559;
      arr.385 = arr;
      D.31524 = arr.385->obj.vtable;
      D.31560 = D.31524->domain;
      arr.385 = arr;
      D.31524 = arr.385->obj.vtable;
      D.31525 = D.31524->klass;
      D.31561 = D.31525->element_class;
      D.31562 = &D.31561->byval_arg;
      buffer_add_value (buf, D.31562, elem, D.31560);
      i = i + 1;
      <D.27290>:
      D.31563 = index + len;
      if (D.31563 > i) goto <D.27289>; else goto <D.27291>;
      <D.27291>:
      goto <D.27287>;
      <D.27292>:
      p.384 = p;
      index = decode_int (p.384, &p, end);
      p.384 = p;
      len = decode_int (p.384, &p, end);
      D.31540 = index < 0;
      D.31541 = len < 0;
      D.31542 = D.31540 | D.31541;
      D.31543 = (int) D.31542;
      D.31544 = D.31543 != 0;
      D.31545 = (long int) D.31544;
      D.31546 = __builtin_expect (D.31545, 0);
      if (D.31546 != 0) goto <D.31564>; else goto <D.31565>;
      <D.31564>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 8667, "index >= 0 && len >= 0");
      <D.31565>:
      index.387 = (unsigned int) index;
      arr.385 = arr;
      D.31531 = arr.385->max_length;
      len.388 = (unsigned int) len;
      D.31551 = D.31531 - len.388;
      D.31552 = index.387 > D.31551;
      D.31553 = (long int) D.31552;
      D.31554 = __builtin_expect (D.31553, 0);
      if (D.31554 != 0) goto <D.31566>; else goto <D.31567>;
      <D.31566>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 8669, "!(index > arr->max_length - len)");
      <D.31567>:
      arr.385 = arr;
      D.31524 = arr.385->obj.vtable;
      D.31525 = D.31524->klass;
      esize = mono_array_element_size (D.31525);
      i = index;
      goto <D.27294>;
      <D.27293>:
      arr.385 = arr;
      D.31557 = &arr.385->vector;
      D.31558 = i * esize;
      D.31559 = (sizetype) D.31558;
      elem = D.31557 + D.31559;
      p.384 = p;
      arr.385 = arr;
      D.31524 = arr.385->obj.vtable;
      D.31560 = D.31524->domain;
      arr.385 = arr;
      D.31524 = arr.385->obj.vtable;
      D.31525 = D.31524->klass;
      D.31561 = D.31525->element_class;
      D.31562 = &D.31561->byval_arg;
      decode_value (D.31562, D.31560, elem, p.384, &p, end);
      i = i + 1;
      <D.27294>:
      D.31563 = index + len;
      if (D.31563 > i) goto <D.27293>; else goto <D.27295>;
      <D.27295>:
      goto <D.27287>;
      <D.27296>:
      D.31522 = 100;
      return D.31522;
      <D.27287>:
      D.31522 = 0;
      return D.31522;
    }
  finally
    {
      arr = {CLOBBER};
    }
}


string_commands (int command, guint8 * p, guint8 * end, struct Buffer * buf)
{
  guint8 * p.389;
  <unnamed type> D.31571;
  ErrorCode D.31574;
  struct MonoString * str.390;
  int D.31576;
  long long unsigned int D.31577;
  long long int D.31578;
  long long int D.31579;
  int D.31580;
  int D.31581;
  mono_unichar2 * D.31584;
  unsigned int index.391;
  unsigned int D.31586;
  unsigned int i.392;
  unsigned int D.31588;
  gunichar2 * D.31589;
  short unsigned int D.31590;
  unsigned int D.31591;
  int objid;
  int err;
  struct MonoString * str;
  char * s;
  int i;
  int index;
  int length;
  gunichar2 * c;

  try
    {
      p.389 = p;
      objid = decode_objid (p.389, &p, end);
      D.31571 = get_object (objid, &str);
      err = (int) D.31571;
      if (err != 0) goto <D.31572>; else goto <D.31573>;
      <D.31572>:
      D.31574 = (ErrorCode) err;
      return D.31574;
      <D.31573>:
      switch (command) <default: <D.27318>, case 1: <D.27311>, case 2: <D.27313>, case 3: <D.27314>>
      <D.27311>:
      str.390 = str;
      s = mono_string_to_utf8 (str.390);
      buffer_add_string (buf, s);
      monoeg_g_free (s);
      goto <D.27312>;
      <D.27313>:
      str.390 = str;
      D.31576 = mono_string_length (str.390);
      D.31577 = (long long unsigned int) D.31576;
      buffer_add_long (buf, D.31577);
      goto <D.27312>;
      <D.27314>:
      p.389 = p;
      D.31578 = decode_long (p.389, &p, end);
      index = (int) D.31578;
      p.389 = p;
      D.31579 = decode_long (p.389, &p, end);
      length = (int) D.31579;
      str.390 = str;
      D.31580 = mono_string_length (str.390);
      D.31581 = D.31580 - length;
      if (D.31581 < index) goto <D.31582>; else goto <D.31583>;
      <D.31582>:
      D.31574 = 102;
      return D.31574;
      <D.31583>:
      str.390 = str;
      D.31584 = mono_string_chars (str.390);
      index.391 = (unsigned int) index;
      D.31586 = index.391 * 2;
      c = D.31584 + D.31586;
      i = 0;
      goto <D.27316>;
      <D.27315>:
      i.392 = (unsigned int) i;
      D.31588 = i.392 * 2;
      D.31589 = c + D.31588;
      D.31590 = *D.31589;
      D.31591 = (unsigned int) D.31590;
      buffer_add_short (buf, D.31591);
      i = i + 1;
      <D.27316>:
      if (i < length) goto <D.27315>; else goto <D.27317>;
      <D.27317>:
      goto <D.27312>;
      <D.27318>:
      D.31574 = 100;
      return D.31574;
      <D.27312>:
      D.31574 = 0;
      return D.31574;
    }
  finally
    {
      str = {CLOBBER};
    }
}


buffer_add_short (struct Buffer * buf, guint32 val)
{
  guint8 * D.31594;
  unsigned int D.31595;
  unsigned char D.31596;
  guint8 * D.31597;
  unsigned char D.31598;
  guint8 * D.31599;

  buffer_make_room (buf, 2);
  D.31594 = buf->p;
  D.31595 = val >> 8;
  D.31596 = (unsigned char) D.31595;
  *D.31594 = D.31596;
  D.31594 = buf->p;
  D.31597 = D.31594 + 1;
  D.31598 = (unsigned char) val;
  *D.31597 = D.31598;
  D.31594 = buf->p;
  D.31599 = D.31594 + 2;
  buf->p = D.31599;
}


object_commands (int command, guint8 * p, guint8 * end, struct Buffer * buf)
{
  guint8 * p.393;
  <unnamed type> D.31603;
  int err.394;
  int err.395;
  ErrorCode D.31609;
  <unnamed type> D.31610;
  int err.396;
  struct MonoObject * obj.397;
  struct MonoVTable * D.31615;
  void * D.31616;
  struct MonoType * D.31617;
  struct MonoClass * D.31618;
  struct MonoDomain * D.31619;
  struct MonoClass * D.31622;
  struct MonoType * D.31627;
  short unsigned int D.31628;
  int D.31629;
  int D.31630;
  int D.31633;
  _Bool D.31636;
  long int D.31637;
  long int D.31638;
  struct MonoClass * D.31641;
  int D.31642;
  unsigned int D.31643;
  int D.31645;
  sizetype D.31646;
  void * D.31647;
  struct MonoClass * D.31650;
  struct MonoType * D.31655;
  short unsigned int D.31656;
  int D.31657;
  int D.31658;
  int D.31661;
  _Bool D.31664;
  long int D.31665;
  long int D.31666;
  struct MonoClass * D.31669;
  int D.31670;
  unsigned int D.31671;
  <unnamed type> D.31672;
  int err.398;
  int D.31677;
  sizetype D.31678;
  guint8 * D.31679;
  <unnamed type> D.31680;
  int err.399;
  int obj.400;
  long long unsigned int D.31685;
  struct MonoClass * D.31686;
  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.31600>; else goto <D.31601>;
      <D.31600>:
      p.393 = p;
      objid = decode_objid (p.393, &p, end);
      D.31603 = get_object (objid, &obj);
      err.394 = (int) D.31603;
      err = err.394;
      err.395 = err;
      if (err.395 != 0) goto <D.31606>; else goto <D.31607>;
      <D.31606>:
      buffer_add_int (buf, 1);
      goto <D.31608>;
      <D.31607>:
      buffer_add_int (buf, 0);
      <D.31608>:
      D.31609 = 0;
      return D.31609;
      <D.31601>:
      p.393 = p;
      objid = decode_objid (p.393, &p, end);
      D.31610 = get_object (objid, &obj);
      err.396 = (int) D.31610;
      err = err.396;
      err.395 = err;
      if (err.395 != 0) goto <D.31612>; else goto <D.31613>;
      <D.31612>:
      err.395 = err;
      D.31609 = (ErrorCode) err.395;
      return D.31609;
      <D.31613>:
      switch (command) <default: <D.27357>, case 1: <D.27333>, case 2: <D.27335>, case 4: <D.27354>, case 5: <D.27355>, case 6: <D.27345>, case 7: <D.27356>>
      <D.27333>:
      obj.397 = obj;
      D.31615 = obj.397->vtable;
      D.31616 = D.31615->type;
      D.31617 = MEM[(struct MonoReflectionType *)D.31616].type;
      D.31618 = mono_class_from_mono_type (D.31617);
      obj.397 = obj;
      D.31615 = obj.397->vtable;
      D.31619 = D.31615->domain;
      buffer_add_typeid (buf, D.31619, D.31618);
      goto <D.27334>;
      <D.27335>:
      p.393 = p;
      len = decode_int (p.393, &p, end);
      i = 0;
      goto <D.27343>;
      <D.27342>:
      {
        struct MonoClassField * f;

        p.393 = p;
        f = decode_fieldid (p.393, &p, end, 0B, &err);
        err.395 = err;
        if (err.395 != 0) goto <D.31620>; else goto <D.31621>;
        <D.31620>:
        err.395 = err;
        D.31609 = (ErrorCode) err.395;
        return D.31609;
        <D.31621>:
        found = 0;
        obj.397 = obj;
        D.31615 = obj.397->vtable;
        k = D.31615->klass;
        goto <D.27339>;
        <D.27338>:
        D.31622 = f->parent;
        if (D.31622 == k) goto <D.31623>; else goto <D.31624>;
        <D.31623>:
        found = 1;
        goto <D.27337>;
        <D.31624>:
        k = k->parent;
        <D.27339>:
        if (k != 0B) goto <D.27338>; else goto <D.27337>;
        <D.27337>:
        if (found == 0) goto <D.31625>; else goto <D.31626>;
        <D.31625>:
        D.31609 = 25;
        return D.31609;
        <D.31626>:
        D.31627 = f->type;
        D.31628 = D.31627->attrs;
        D.31629 = (int) D.31628;
        D.31630 = D.31629 & 16;
        if (D.31630 != 0) goto <D.31631>; else goto <D.31632>;
        <D.31631>:
        {
          guint8 * val;
          struct MonoVTable * vtable;

          D.31633 = mono_class_field_is_special_static (f);
          if (D.31633 != 0) goto <D.31634>; else goto <D.31635>;
          <D.31634>:
          D.31609 = 25;
          return D.31609;
          <D.31635>:
          D.31627 = f->type;
          D.31628 = D.31627->attrs;
          D.31629 = (int) D.31628;
          D.31630 = D.31629 & 16;
          D.31636 = D.31630 == 0;
          D.31637 = (long int) D.31636;
          D.31638 = __builtin_expect (D.31637, 0);
          if (D.31638 != 0) goto <D.31639>; else goto <D.31640>;
          <D.31639>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 8780, "f->type->attrs & FIELD_ATTRIBUTE_STATIC");
          <D.31640>:
          D.31622 = f->parent;
          obj.397 = obj;
          D.31615 = obj.397->vtable;
          D.31619 = D.31615->domain;
          vtable = mono_class_vtable (D.31619, D.31622);
          D.31627 = f->type;
          D.31641 = mono_class_from_mono_type (D.31627);
          D.31642 = mono_class_instance_size (D.31641);
          D.31643 = (unsigned int) D.31642;
          val = monoeg_malloc (D.31643);
          mono_field_static_get_value (vtable, f, val);
          obj.397 = obj;
          D.31615 = obj.397->vtable;
          D.31619 = D.31615->domain;
          D.31627 = f->type;
          buffer_add_value (buf, D.31627, val, D.31619);
          monoeg_g_free (val);
        }
        goto <D.31644>;
        <D.31632>:
        obj.397 = obj;
        D.31615 = obj.397->vtable;
        D.31619 = D.31615->domain;
        obj.397 = obj;
        D.31645 = f->offset;
        D.31646 = (sizetype) D.31645;
        D.31647 = obj.397 + D.31646;
        D.31627 = f->type;
        buffer_add_value (buf, D.31627, D.31647, D.31619);
        <D.31644>:
      }
      i = i + 1;
      <D.27343>:
      if (i < len) goto <D.27342>; else goto <D.27344>;
      <D.27344>:
      goto <D.27334>;
      <D.27345>:
      p.393 = p;
      len = decode_int (p.393, &p, end);
      i = 0;
      goto <D.27352>;
      <D.27351>:
      p.393 = p;
      f = decode_fieldid (p.393, &p, end, 0B, &err);
      err.395 = err;
      if (err.395 != 0) goto <D.31648>; else goto <D.31649>;
      <D.31648>:
      err.395 = err;
      D.31609 = (ErrorCode) err.395;
      return D.31609;
      <D.31649>:
      found = 0;
      obj.397 = obj;
      D.31615 = obj.397->vtable;
      k = D.31615->klass;
      goto <D.27348>;
      <D.27347>:
      D.31650 = f->parent;
      if (D.31650 == k) goto <D.31651>; else goto <D.31652>;
      <D.31651>:
      found = 1;
      goto <D.27346>;
      <D.31652>:
      k = k->parent;
      <D.27348>:
      if (k != 0B) goto <D.27347>; else goto <D.27346>;
      <D.27346>:
      if (found == 0) goto <D.31653>; else goto <D.31654>;
      <D.31653>:
      D.31609 = 25;
      return D.31609;
      <D.31654>:
      D.31655 = f->type;
      D.31656 = D.31655->attrs;
      D.31657 = (int) D.31656;
      D.31658 = D.31657 & 16;
      if (D.31658 != 0) goto <D.31659>; else goto <D.31660>;
      <D.31659>:
      {
        guint8 * val;
        struct MonoVTable * vtable;

        D.31661 = mono_class_field_is_special_static (f);
        if (D.31661 != 0) goto <D.31662>; else goto <D.31663>;
        <D.31662>:
        D.31609 = 25;
        return D.31609;
        <D.31663>:
        D.31655 = f->type;
        D.31656 = D.31655->attrs;
        D.31657 = (int) D.31656;
        D.31658 = D.31657 & 16;
        D.31664 = D.31658 == 0;
        D.31665 = (long int) D.31664;
        D.31666 = __builtin_expect (D.31665, 0);
        if (D.31666 != 0) goto <D.31667>; else goto <D.31668>;
        <D.31667>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 8817, "f->type->attrs & FIELD_ATTRIBUTE_STATIC");
        <D.31668>:
        D.31650 = f->parent;
        obj.397 = obj;
        D.31615 = obj.397->vtable;
        D.31619 = D.31615->domain;
        vtable = mono_class_vtable (D.31619, D.31650);
        D.31655 = f->type;
        D.31669 = mono_class_from_mono_type (D.31655);
        D.31670 = mono_class_instance_size (D.31669);
        D.31671 = (unsigned int) D.31670;
        val = monoeg_malloc (D.31671);
        p.393 = p;
        obj.397 = obj;
        D.31615 = obj.397->vtable;
        D.31619 = D.31615->domain;
        D.31655 = f->type;
        D.31672 = decode_value (D.31655, D.31619, val, p.393, &p, end);
        err.398 = (int) D.31672;
        err = err.398;
        err.395 = err;
        if (err.395 != 0) goto <D.31674>; else goto <D.31675>;
        <D.31674>:
        monoeg_g_free (val);
        err.395 = err;
        D.31609 = (ErrorCode) err.395;
        return D.31609;
        <D.31675>:
        mono_field_static_set_value (vtable, f, val);
        monoeg_g_free (val);
      }
      goto <D.31676>;
      <D.31660>:
      p.393 = p;
      obj.397 = obj;
      D.31677 = f->offset;
      D.31678 = (sizetype) D.31677;
      D.31679 = obj.397 + D.31678;
      obj.397 = obj;
      D.31615 = obj.397->vtable;
      D.31619 = D.31615->domain;
      D.31655 = f->type;
      D.31680 = decode_value (D.31655, D.31619, D.31679, p.393, &p, end);
      err.399 = (int) D.31680;
      err = err.399;
      err.395 = err;
      if (err.395 != 0) goto <D.31682>; else goto <D.31683>;
      <D.31682>:
      err.395 = err;
      D.31609 = (ErrorCode) err.395;
      return D.31609;
      <D.31683>:
      <D.31676>:
      i = i + 1;
      <D.27352>:
      if (i < len) goto <D.27351>; else goto <D.27353>;
      <D.27353>:
      goto <D.27334>;
      <D.27354>:
      obj.397 = obj;
      obj.400 = (int) obj.397;
      D.31685 = (long long unsigned int) obj.400;
      buffer_add_long (buf, D.31685);
      goto <D.27334>;
      <D.27355>:
      obj.397 = obj;
      D.31615 = obj.397->vtable;
      D.31619 = D.31615->domain;
      buffer_add_domainid (buf, D.31619);
      goto <D.27334>;
      <D.27356>:
      obj.397 = obj;
      D.31615 = obj.397->vtable;
      D.31616 = D.31615->type;
      D.31617 = MEM[(struct MonoReflectionType *)D.31616].type;
      D.31686 = mono_class_from_mono_type (D.31617);
      obj.397 = obj;
      D.31615 = obj.397->vtable;
      D.31619 = D.31615->domain;
      buffer_add_typeid (buf, D.31619, D.31686);
      obj.397 = obj;
      D.31615 = obj.397->vtable;
      D.31619 = D.31615->domain;
      buffer_add_domainid (buf, D.31619);
      goto <D.27334>;
      <D.27357>:
      D.31609 = 100;
      return D.31609;
      <D.27334>:
      D.31609 = 0;
      return D.31609;
    }
  finally
    {
      err = {CLOBBER};
      obj = {CLOBBER};
    }
}


send_reply_packet (int id, int error, struct Buffer * data)
{
  guint8 * D.31689;
  int D.31690;
  guint8 * D.31691;
  int D.31692;
  int D.31693;
  unsigned int len.401;
  unsigned int id.402;
  int D.31696;
  unsigned char D.31697;
  int D.31698;
  unsigned char D.31699;
  int D.31700;
  unsigned int D.31701;
  guint8 * D.31702;
  guint8 * D.31703;
  gboolean D.31704;
  struct Buffer buf;
  int len;
  gboolean res;

  try
    {
      D.31689 = data->p;
      D.31690 = (int) D.31689;
      D.31691 = data->buf;
      D.31692 = (int) D.31691;
      D.31693 = D.31690 - D.31692;
      len = D.31693 + 11;
      buffer_init (&buf, len);
      len.401 = (unsigned int) len;
      buffer_add_int (&buf, len.401);
      id.402 = (unsigned int) id;
      buffer_add_int (&buf, id.402);
      buffer_add_byte (&buf, 128);
      D.31696 = error >> 8;
      D.31697 = (unsigned char) D.31696;
      D.31698 = (int) D.31697;
      buffer_add_byte (&buf, D.31698);
      D.31699 = (unsigned char) error;
      D.31700 = (int) D.31699;
      buffer_add_byte (&buf, D.31700);
      D.31689 = data->p;
      D.31690 = (int) D.31689;
      D.31691 = data->buf;
      D.31692 = (int) D.31691;
      D.31693 = D.31690 - D.31692;
      D.31701 = (unsigned int) D.31693;
      D.31691 = data->buf;
      D.31702 = buf.buf;
      D.31703 = D.31702 + 11;
      memcpy (D.31703, D.31691, D.31701);
      D.31702 = buf.buf;
      res = transport_send (D.31702, len);
      buffer_free (&buf);
      D.31704 = res;
      return D.31704;
    }
  finally
    {
      buf = {CLOBBER};
    }
}


save_thread_context (struct MonoContext * ctx)
{
  unsigned int debugger_tls_id.403;
  _Bool D.31708;
  long int D.31709;
  long int D.31710;
  struct MonoThreadUnwindState * D.31715;
  struct DebuggerTlsData * tls;

  debugger_tls_id.403 = debugger_tls_id;
  tls = pthread_getspecific (debugger_tls_id.403);
  D.31708 = tls == 0B;
  D.31709 = (long int) D.31708;
  D.31710 = __builtin_expect (D.31709, 0);
  if (D.31710 != 0) goto <D.31711>; else goto <D.31712>;
  <D.31711>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 2357, "tls");
  <D.31712>:
  if (ctx != 0B) goto <D.31713>; else goto <D.31714>;
  <D.31713>:
  D.31715 = &tls->context;
  mono_thread_state_init_from_monoctx (D.31715, ctx);
  goto <D.31716>;
  <D.31714>:
  D.31715 = &tls->context;
  mono_thread_state_init_from_current (D.31715);
  <D.31716>:
}


suspend_vm ()
{
  int suspend_count.404;
  int suspend_count.405;
  int log_level.406;
  _Bool D.31720;
  long int D.31721;
  long int D.31722;
  unsigned int D.31725;
  void * D.31726;
  struct FILE * log_file.407;
  struct MonoGHashTable * thread_to_tls.408;

  mono_loader_lock ();
  pthread_mutex_lock (&suspend_mutex);
  suspend_count.404 = suspend_count;
  suspend_count.405 = suspend_count.404 + 1;
  suspend_count = suspend_count.405;
  log_level.406 = log_level;
  D.31720 = log_level.406 > 0;
  D.31721 = (long int) D.31720;
  D.31722 = __builtin_expect (D.31721, 0);
  if (D.31722 != 0) goto <D.31723>; else goto <D.31724>;
  <D.31723>:
  D.31725 = GetCurrentThreadId ();
  D.31726 = (void *) D.31725;
  log_file.407 = log_file;
  fprintf (log_file.407, "[%p] Suspending vm...\n", D.31726);
  log_file.407 = log_file;
  fflush (log_file.407);
  <D.31724>:
  suspend_count.404 = suspend_count;
  if (suspend_count.404 == 1) goto <D.31728>; else goto <D.31729>;
  <D.31728>:
  start_single_stepping ();
  thread_to_tls.408 = thread_to_tls;
  mono_g_hash_table_foreach (thread_to_tls.408, notify_thread, 0B);
  <D.31729>:
  pthread_mutex_unlock (&suspend_mutex);
  suspend_count.404 = suspend_count;
  if (suspend_count.404 == 1) goto <D.31731>; else goto <D.31732>;
  <D.31731>:
  mono_thread_pool_suspend ();
  <D.31732>:
  mono_loader_unlock ();
}


notify_thread (void * key, void * value, void * user_data)
{
  long long unsigned int D.31733;
  unsigned int D.31736;
  int D.31738;
  int log_level.409;
  _Bool D.31740;
  long int D.31741;
  long int D.31742;
  void * tid.410;
  unsigned int D.31746;
  void * D.31747;
  struct FILE * log_file.411;
  gint32 * D.31749;
  int D.31750;
  long unsigned int D.31753;
  unsigned int D.31758;
  void * D.31759;
  int D.31761;
  char * D.31762;
  void * D.31763;
  unsigned int D.31764;
  int D.31766;
  unsigned int D.31771;
  void * D.31772;
  struct MonoInternalThread * thread;
  struct DebuggerTlsData * tls;
  gsize tid;
  int res;

  thread = key;
  tls = value;
  D.31733 = thread->tid;
  tid = (gsize) D.31733;
  D.31736 = GetCurrentThreadId ();
  if (D.31736 == tid) goto <D.31734>; else goto <D.31737>;
  <D.31737>:
  D.31738 = tls->terminated;
  if (D.31738 != 0) goto <D.31734>; else goto <D.31735>;
  <D.31734>:
  return;
  <D.31735>:
  log_level.409 = log_level;
  D.31740 = log_level.409 > 0;
  D.31741 = (long int) D.31740;
  D.31742 = __builtin_expect (D.31741, 0);
  if (D.31742 != 0) goto <D.31743>; else goto <D.31744>;
  <D.31743>:
  tid.410 = (void *) tid;
  D.31746 = GetCurrentThreadId ();
  D.31747 = (void *) D.31746;
  log_file.411 = log_file;
  fprintf (log_file.411, "[%p] Interrupting %p...\n", D.31747, tid.410);
  log_file.411 = log_file;
  fflush (log_file.411);
  <D.31744>:
  D.31749 = &tls->interrupt_count;
  InterlockedIncrement (D.31749);
  D.31750 = mono_thread_info_new_interrupt_enabled ();
  if (D.31750 != 0) goto <D.31751>; else goto <D.31752>;
  <D.31751>:
  {
    struct MonoThreadInfo * info;
    struct MonoJitInfo * ji;

    D.31733 = thread->tid;
    D.31753 = (long unsigned int) D.31733;
    info = mono_thread_info_safe_suspend_sync (D.31753, 0);
    if (info == 0B) goto <D.31754>; else goto <D.31755>;
    <D.31754>:
    log_level.409 = log_level;
    D.31740 = log_level.409 > 0;
    D.31741 = (long int) D.31740;
    D.31742 = __builtin_expect (D.31741, 0);
    if (D.31742 != 0) goto <D.31756>; else goto <D.31757>;
    <D.31756>:
    tid.410 = (void *) tid;
    D.31758 = GetCurrentThreadId ();
    D.31759 = (void *) D.31758;
    log_file.411 = log_file;
    fprintf (log_file.411, "[%p] mono_thread_info_suspend_sync () failed for %p...\n", D.31759, tid.410);
    log_file.411 = log_file;
    fflush (log_file.411);
    <D.31757>:
    tls->terminated = 1;
    goto <D.31760>;
    <D.31755>:
    D.31761 = info->suspend_state.ctx.eip;
    D.31762 = (char *) D.31761;
    D.31763 = info->suspend_state.unwind_data[0];
    ji = mono_jit_info_table_find (D.31763, D.31762);
    thread_interrupt (tls, info, 0B, ji);
    D.31764 = info->node.key;
    mono_thread_info_resume (D.31764);
    <D.31760>:
  }
  goto <D.31765>;
  <D.31752>:
  D.31766 = mono_thread_get_abort_signal ();
  res = mono_thread_kill (thread, D.31766);
  if (res != 0) goto <D.31767>; else goto <D.31768>;
  <D.31767>:
  log_level.409 = log_level;
  D.31740 = log_level.409 > 0;
  D.31741 = (long int) D.31740;
  D.31742 = __builtin_expect (D.31741, 0);
  if (D.31742 != 0) goto <D.31769>; else goto <D.31770>;
  <D.31769>:
  tid.410 = (void *) tid;
  D.31771 = GetCurrentThreadId ();
  D.31772 = (void *) D.31771;
  log_file.411 = log_file;
  fprintf (log_file.411, "[%p] mono_thread_kill () failed for %p: %d...\n", D.31772, tid.410, res);
  log_file.411 = log_file;
  fflush (log_file.411);
  <D.31770>:
  tls->terminated = 1;
  <D.31768>:
  <D.31765>:
}


thread_interrupt (struct DebuggerTlsData * tls, struct MonoThreadInfo * info, void * sigctx, struct MonoJitInfo * ji)
{
  int D.31774;
  gboolean D.31777;
  gint32 * D.31778;
  int D.31784;
  int log_level.412;
  _Bool D.31792;
  long int D.31793;
  long int D.31794;
  struct MonoMethod * D.31797;
  const char * D.31798;
  void * tid.413;
  struct FILE * log_file.414;
  int D.31801;
  int D.31804;
  struct MonoInternalThread * D.31811;
  struct MonoRuntimeExceptionHandlingCallbacks * D.31819;
  void (*<T278c>) (gboolean (*MonoInternalStackWalk) (struct MonoStackFrameInfo *, struct MonoContext *, void *), struct MonoThreadUnwindState *, MonoUnwindOptions, void *) D.31820;
  struct MonoThreadUnwindState * D.31821;
  int D.31822;
  struct StackFrameInfo * D.31825;
  struct MonoThreadUnwindState * D.31826;
  _Bool D.31827;
  long int D.31828;
  long int D.31829;
  struct MonoThreadUnwindState * D.31832;
  struct MonoContext * D.31835;
  void * D.31836;
  void * D.31837;
  gboolean res;
  void * ip;
  MonoNativeThreadId tid;

  D.31774 = tls->interrupt_count;
  if (D.31774 == 0) goto <D.31775>; else goto <D.31776>;
  <D.31775>:
  D.31777 = 0;
  return D.31777;
  <D.31776>:
  D.31778 = &tls->interrupt_count;
  InterlockedDecrement (D.31778);
  if (sigctx != 0B) goto <D.31779>; else goto <D.31780>;
  <D.31779>:
  ip = mono_arch_ip_from_context (sigctx);
  goto <D.31781>;
  <D.31780>:
  if (info != 0B) goto <D.31782>; else goto <D.31783>;
  <D.31782>:
  D.31784 = info->suspend_state.ctx.eip;
  ip = (void *) D.31784;
  goto <D.31785>;
  <D.31783>:
  ip = 0B;
  <D.31785>:
  <D.31781>:
  if (info != 0B) goto <D.31786>; else goto <D.31787>;
  <D.31786>:
  tid = info->node.key;
  goto <D.31788>;
  <D.31787>:
  tid = GetCurrentThreadId ();
  <D.31788>:
  if (ji != 0B) goto <D.31789>; else goto <D.31790>;
  <D.31789>:
  log_level.412 = log_level;
  D.31792 = log_level.412 > 0;
  D.31793 = (long int) D.31792;
  D.31794 = __builtin_expect (D.31793, 0);
  if (D.31794 != 0) goto <D.31795>; else goto <D.31796>;
  <D.31795>:
  D.31797 = jinfo_get_method (ji);
  D.31798 = D.31797->name;
  tid.413 = (void *) tid;
  log_file.414 = log_file;
  fprintf (log_file.414, "[%p] Received interrupt while at %s(%p), continuing.\n", tid.413, D.31798, ip);
  log_file.414 = log_file;
  fflush (log_file.414);
  <D.31796>:
  D.31777 = 1;
  return D.31777;
  <D.31790>:
  D.31801 = tls->suspended;
  if (D.31801 == 0) goto <D.31802>; else goto <D.31803>;
  <D.31802>:
  D.31804 = tls->suspending;
  if (D.31804 == 0) goto <D.31805>; else goto <D.31806>;
  <D.31805>:
  {
    struct MonoContext ctx;
    struct GetLastFrameUserData data;

    try
      {
        if (ip != 0B) goto <D.31807>; else goto <D.31808>;
        <D.31807>:
        log_level.412 = log_level;
        D.31792 = log_level.412 > 0;
        D.31793 = (long int) D.31792;
        D.31794 = __builtin_expect (D.31793, 0);
        if (D.31794 != 0) goto <D.31809>; else goto <D.31810>;
        <D.31809>:
        tid.413 = (void *) tid;
        log_file.414 = log_file;
        fprintf (log_file.414, "[%p] Received interrupt while at %p, treating as suspended.\n", tid.413, ip);
        log_file.414 = log_file;
        fflush (log_file.414);
        <D.31810>:
        <D.31808>:
        D.31811 = tls->thread;
        if (D.31811 == 0B) goto <D.31812>; else goto <D.31813>;
        <D.31812>:
        D.31777 = 1;
        return D.31777;
        <D.31813>:
        data.last_frame_set = 0;
        if (sigctx != 0B) goto <D.31814>; else goto <D.31815>;
        <D.31814>:
        mono_arch_sigctx_to_monoctx (sigctx, &ctx);
        mono_walk_stack_with_ctx (get_last_frame, &ctx, 0, &data);
        goto <D.31816>;
        <D.31815>:
        if (info != 0B) goto <D.31817>; else goto <D.31818>;
        <D.31817>:
        D.31819 = mono_get_eh_callbacks ();
        D.31820 = D.31819->mono_walk_stack_with_state;
        D.31821 = &info->suspend_state;
        D.31820 (get_last_frame, D.31821, 0, &data);
        <D.31818>:
        <D.31816>:
        D.31822 = data.last_frame_set;
        if (D.31822 != 0) goto <D.31823>; else goto <D.31824>;
        <D.31823>:
        D.31825 = &tls->async_last_frame;
        memcpy (D.31825, &data.last_frame, 52);
        D.31826 = &tls->async_state;
        res = mono_thread_state_init_from_monoctx (D.31826, &ctx);
        D.31827 = res == 0;
        D.31828 = (long int) D.31827;
        D.31829 = __builtin_expect (D.31828, 0);
        if (D.31829 != 0) goto <D.31830>; else goto <D.31831>;
        <D.31830>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 2519, "res");
        <D.31831>:
        D.31832 = &tls->context;
        mono_thread_state_init_from_monoctx (D.31832, &ctx);
        D.31827 = res == 0;
        D.31828 = (long int) D.31827;
        D.31829 = __builtin_expect (D.31828, 0);
        if (D.31829 != 0) goto <D.31833>; else goto <D.31834>;
        <D.31833>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 2521, "res");
        <D.31834>:
        D.31835 = &tls->async_state.ctx;
        memcpy (D.31835, &data.ctx, 36);
        D.31836 = data.lmf;
        tls->async_state.unwind_data[1] = D.31836;
        D.31811 = tls->thread;
        D.31837 = D.31811->jit_data;
        tls->async_state.unwind_data[2] = D.31837;
        goto <D.31838>;
        <D.31824>:
        tls->async_state.valid = 0;
        <D.31838>:
        mono_memory_barrier ();
        tls->suspended = 1;
        mono_sem_post (&suspend_sem);
      }
    finally
      {
        ctx = {CLOBBER};
        data = {CLOBBER};
      }
  }
  <D.31806>:
  <D.31803>:
  D.31777 = 1;
  return D.31777;
}


get_last_frame (struct StackFrameInfo * info, struct MonoContext * ctx, void * user_data)
{
  <unnamed type> D.31842;
  gboolean D.31845;
  int D.31846;
  struct StackFrameInfo * D.31849;
  struct MonoContext * D.31850;
  void * D.31851;
  struct GetLastFrameUserData * data;

  data = user_data;
  D.31842 = info->type;
  if (D.31842 == 2) goto <D.31843>; else goto <D.31844>;
  <D.31843>:
  D.31845 = 0;
  return D.31845;
  <D.31844>:
  D.31846 = data->last_frame_set;
  if (D.31846 == 0) goto <D.31847>; else goto <D.31848>;
  <D.31847>:
  D.31849 = &data->last_frame;
  memcpy (D.31849, info, 52);
  data->last_frame_set = 1;
  D.31845 = 0;
  return D.31845;
  <D.31848>:
  D.31850 = &data->ctx;
  memcpy (D.31850, ctx, 36);
  D.31851 = info->lmf;
  data->lmf = D.31851;
  D.31845 = 1;
  return D.31845;
}


mono_memory_barrier ()
{
  __sync_synchronize ();
}


get_objref (struct MonoObject * obj)
{
  struct ObjRef * D.31855;
  struct GHashTable * obj_to_objref.415;
  struct GHashTable * obj_to_objref.416;
  struct MonoGHashTable * suspended_objs.417;
  int D.31861;
  int suspend_count.418;
  struct MonoGHashTable * suspended_objs.419;
  int D.31868;
  const void * hash.420;
  unsigned int D.31874;
  struct MonoObject * D.31875;
  unsigned int obj.421;
  unsigned int D.31880;
  const void * D.31881;
  struct MonoObject * D.31884;
  int D.31887;
  unsigned int D.31888;
  int D.31889;
  void * D.31890;
  struct GHashTable * objrefs.422;
  int D.31892;
  void * hash.423;
  void * D.31897;
  struct ObjRef * ref;
  struct GSList * reflist;
  struct GSList * l;
  int hash;

  reflist = 0B;
  hash = 0;
  if (obj == 0B) goto <D.31853>; else goto <D.31854>;
  <D.31853>:
  D.31855 = 0B;
  return D.31855;
  <D.31854>:
  mono_loader_lock ();
  obj_to_objref.415 = obj_to_objref;
  if (obj_to_objref.415 == 0B) goto <D.31857>; else goto <D.31858>;
  <D.31857>:
  obj_to_objref.416 = monoeg_g_hash_table_new (0B, 0B);
  obj_to_objref = obj_to_objref.416;
  suspended_objs.417 = mono_g_hash_table_new_type (0B, 0B, 1);
  suspended_objs = suspended_objs.417;
  D.31861 = mono_gc_is_moving ();
  if (D.31861 == 0) goto <D.31862>; else goto <D.31863>;
  <D.31862>:
  mono_gc_register_root (&suspended_objs, 4, 0B);
  <D.31863>:
  <D.31858>:
  suspend_count.418 = suspend_count;
  if (suspend_count.418 != 0) goto <D.31865>; else goto <D.31866>;
  <D.31865>:
  suspended_objs.419 = suspended_objs;
  mono_g_hash_table_insert (suspended_objs.419, obj, 0B);
  <D.31866>:
  D.31868 = mono_gc_is_moving ();
  if (D.31868 != 0) goto <D.31869>; else goto <D.31870>;
  <D.31869>:
  hash = mono_object_hash (obj);
  hash.420 = (const void *) hash;
  obj_to_objref.415 = obj_to_objref;
  reflist = monoeg_g_hash_table_lookup (obj_to_objref.415, hash.420);
  l = reflist;
  goto <D.25092>;
  <D.25091>:
  ref = l->data;
  if (ref != 0B) goto <D.31872>; else goto <D.31873>;
  <D.31872>:
  D.31874 = ref->handle;
  D.31875 = mono_gchandle_get_target (D.31874);
  if (D.31875 == obj) goto <D.31876>; else goto <D.31877>;
  <D.31876>:
  mono_loader_unlock ();
  D.31855 = ref;
  return D.31855;
  <D.31877>:
  <D.31873>:
  l = l->next;
  <D.25092>:
  if (l != 0B) goto <D.25091>; else goto <D.25093>;
  <D.25093>:
  goto <D.31878>;
  <D.31870>:
  obj.421 = (unsigned int) obj;
  D.31880 = ~obj.421;
  D.31881 = (const void *) D.31880;
  obj_to_objref.415 = obj_to_objref;
  ref = monoeg_g_hash_table_lookup (obj_to_objref.415, D.31881);
  if (ref != 0B) goto <D.31882>; else goto <D.31883>;
  <D.31882>:
  D.31874 = ref->handle;
  D.31884 = mono_gchandle_get_target (D.31874);
  if (D.31884 == obj) goto <D.31885>; else goto <D.31886>;
  <D.31885>:
  mono_loader_unlock ();
  D.31855 = ref;
  return D.31855;
  <D.31886>:
  <D.31883>:
  <D.31878>:
  ref = monoeg_malloc0 (8);
  D.31887 = InterlockedIncrement (&objref_id);
  ref->id = D.31887;
  D.31888 = mono_gchandle_new_weakref (obj, 0);
  ref->handle = D.31888;
  D.31889 = ref->id;
  D.31890 = (void *) D.31889;
  objrefs.422 = objrefs;
  monoeg_g_hash_table_insert_replace (objrefs.422, D.31890, ref, 0);
  D.31892 = mono_gc_is_moving ();
  if (D.31892 != 0) goto <D.31893>; else goto <D.31894>;
  <D.31893>:
  reflist = monoeg_g_slist_append (reflist, ref);
  hash.423 = (void *) hash;
  obj_to_objref.415 = obj_to_objref;
  monoeg_g_hash_table_insert_replace (obj_to_objref.415, hash.423, reflist, 0);
  goto <D.31896>;
  <D.31894>:
  obj.421 = (unsigned int) obj;
  D.31880 = ~obj.421;
  D.31897 = (void *) D.31880;
  obj_to_objref.415 = obj_to_objref;
  monoeg_g_hash_table_insert_replace (obj_to_objref.415, D.31897, ref, 0);
  <D.31896>:
  mono_loader_unlock ();
  D.31855 = ref;
  return D.31855;
}


send_packet (int command_set, int command, struct Buffer * data)
{
  guint8 * D.31899;
  int D.31900;
  guint8 * D.31901;
  int D.31902;
  int D.31903;
  unsigned int len.424;
  unsigned int id.425;
  unsigned char D.31906;
  int D.31907;
  unsigned char D.31908;
  int D.31909;
  unsigned int D.31910;
  guint8 * D.31911;
  guint8 * D.31912;
  gboolean D.31913;
  struct Buffer buf;
  int len;
  int id;
  gboolean res;

  try
    {
      id = InterlockedIncrement (&packet_id);
      D.31899 = data->p;
      D.31900 = (int) D.31899;
      D.31901 = data->buf;
      D.31902 = (int) D.31901;
      D.31903 = D.31900 - D.31902;
      len = D.31903 + 11;
      buffer_init (&buf, len);
      len.424 = (unsigned int) len;
      buffer_add_int (&buf, len.424);
      id.425 = (unsigned int) id;
      buffer_add_int (&buf, id.425);
      buffer_add_byte (&buf, 0);
      D.31906 = (unsigned char) command_set;
      D.31907 = (int) D.31906;
      buffer_add_byte (&buf, D.31907);
      D.31908 = (unsigned char) command;
      D.31909 = (int) D.31908;
      buffer_add_byte (&buf, D.31909);
      D.31899 = data->p;
      D.31900 = (int) D.31899;
      D.31901 = data->buf;
      D.31902 = (int) D.31901;
      D.31903 = D.31900 - D.31902;
      D.31910 = (unsigned int) D.31903;
      D.31901 = data->buf;
      D.31911 = buf.buf;
      D.31912 = D.31911 + 11;
      memcpy (D.31912, D.31901, D.31910);
      D.31911 = buf.buf;
      res = transport_send (D.31911, len);
      buffer_free (&buf);
      D.31913 = res;
      return D.31913;
    }
  finally
    {
      buf = {CLOBBER};
    }
}


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

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


event_to_string (EventKind event)
{
  const char * D.31917;

  switch (event) <default: <D.25639>, case 0: <D.25622>, case 1: <D.25623>, case 2: <D.25624>, case 3: <D.25625>, case 4: <D.25626>, case 5: <D.25627>, case 6: <D.25628>, case 7: <D.25629>, case 8: <D.25630>, case 9: <D.25631>, case 10: <D.25632>, case 11: <D.25633>, case 12: <D.25634>, case 13: <D.25635>, case 14: <D.25636>, case 15: <D.25637>, case 16: <D.25638>>
  <D.25622>:
  D.31917 = "VM_START";
  return D.31917;
  <D.25623>:
  D.31917 = "VM_DEATH";
  return D.31917;
  <D.25624>:
  D.31917 = "THREAD_START";
  return D.31917;
  <D.25625>:
  D.31917 = "THREAD_DEATH";
  return D.31917;
  <D.25626>:
  D.31917 = "APPDOMAIN_CREATE";
  return D.31917;
  <D.25627>:
  D.31917 = "APPDOMAIN_UNLOAD";
  return D.31917;
  <D.25628>:
  D.31917 = "METHOD_ENTRY";
  return D.31917;
  <D.25629>:
  D.31917 = "METHOD_EXIT";
  return D.31917;
  <D.25630>:
  D.31917 = "ASSEMBLY_LOAD";
  return D.31917;
  <D.25631>:
  D.31917 = "ASSEMBLY_UNLOAD";
  return D.31917;
  <D.25632>:
  D.31917 = "BREAKPOINT";
  return D.31917;
  <D.25633>:
  D.31917 = "STEP";
  return D.31917;
  <D.25634>:
  D.31917 = "TYPE_LOAD";
  return D.31917;
  <D.25635>:
  D.31917 = "EXCEPTION";
  return D.31917;
  <D.25636>:
  D.31917 = "KEEPALIVE";
  return D.31917;
  <D.25637>:
  D.31917 = "USER_BREAK";
  return D.31917;
  <D.25638>:
  D.31917 = "USER_LOG";
  return D.31917;
  <D.25639>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "debugger-agent.c", 3535);
  D.31917 = "";
  return D.31917;
}


suspend_current ()
{
  unsigned int D.31919;
  unsigned int debugger_thread_id.426;
  _Bool D.31921;
  long int D.31922;
  long int D.31923;
  int D.31926;
  unsigned int debugger_tls_id.427;
  _Bool D.31930;
  long int D.31931;
  long int D.31932;
  int D.31935;
  int log_level.428;
  _Bool D.31939;
  long int D.31940;
  long int D.31941;
  unsigned int D.31944;
  void * D.31945;
  struct FILE * log_file.429;
  _Bool D.31947;
  long int D.31948;
  long int D.31949;
  int suspend_count.430;
  unsigned int suspend_count.431;
  unsigned int D.31954;
  int threads_suspend_count.432;
  int threads_suspend_count.433;
  unsigned int D.31959;
  void * D.31960;
  struct InvokeData * D.31961;
  int err;
  struct DebuggerTlsData * tls;

  D.31919 = GetCurrentThreadId ();
  debugger_thread_id.426 = debugger_thread_id;
  D.31921 = D.31919 == debugger_thread_id.426;
  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", 2855, "debugger_thread_id != GetCurrentThreadId ()");
  <D.31925>:
  D.31926 = mono_loader_lock_is_owned_by_self ();
  if (D.31926 != 0) goto <D.31927>; else goto <D.31928>;
  <D.31927>:
  return;
  <D.31928>:
  debugger_tls_id.427 = debugger_tls_id;
  tls = pthread_getspecific (debugger_tls_id.427);
  D.31930 = tls == 0B;
  D.31931 = (long int) D.31930;
  D.31932 = __builtin_expect (D.31931, 0);
  if (D.31932 != 0) goto <D.31933>; else goto <D.31934>;
  <D.31933>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 2866, "tls");
  <D.31934>:
  pthread_mutex_lock (&suspend_mutex);
  tls->suspending = 0;
  tls->really_suspended = 1;
  D.31935 = tls->suspended;
  if (D.31935 == 0) goto <D.31936>; else goto <D.31937>;
  <D.31936>:
  tls->suspended = 1;
  mono_sem_post (&suspend_sem);
  <D.31937>:
  log_level.428 = log_level;
  D.31939 = log_level.428 > 0;
  D.31940 = (long int) D.31939;
  D.31941 = __builtin_expect (D.31940, 0);
  if (D.31941 != 0) goto <D.31942>; else goto <D.31943>;
  <D.31942>:
  D.31944 = GetCurrentThreadId ();
  D.31945 = (void *) D.31944;
  log_file.429 = log_file;
  fprintf (log_file.429, "[%p] Suspended.\n", D.31945);
  log_file.429 = log_file;
  fflush (log_file.429);
  <D.31943>:
  goto <D.25426>;
  <D.25425>:
  err = pthread_cond_wait (&suspend_cond, &suspend_mutex);
  D.31947 = err != 0;
  D.31948 = (long int) D.31947;
  D.31949 = __builtin_expect (D.31948, 0);
  if (D.31949 != 0) goto <D.31950>; else goto <D.31951>;
  <D.31950>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 2893, "err == 0");
  <D.31951>:
  <D.25426>:
  suspend_count.430 = suspend_count;
  suspend_count.431 = (unsigned int) suspend_count.430;
  D.31954 = tls->resume_count;
  if (suspend_count.431 != D.31954) goto <D.25425>; else goto <D.25427>;
  <D.25427>:
  tls->suspended = 0;
  tls->really_suspended = 0;
  threads_suspend_count.432 = threads_suspend_count;
  threads_suspend_count.433 = threads_suspend_count.432 + -1;
  threads_suspend_count = threads_suspend_count.433;
  pthread_mutex_unlock (&suspend_mutex);
  log_level.428 = log_level;
  D.31939 = log_level.428 > 0;
  D.31940 = (long int) D.31939;
  D.31941 = __builtin_expect (D.31940, 0);
  if (D.31941 != 0) goto <D.31957>; else goto <D.31958>;
  <D.31957>:
  D.31959 = GetCurrentThreadId ();
  D.31960 = (void *) D.31959;
  log_file.429 = log_file;
  fprintf (log_file.429, "[%p] Resumed.\n", D.31960);
  log_file.429 = log_file;
  fflush (log_file.429);
  <D.31958>:
  D.31961 = tls->pending_invoke;
  if (D.31961 != 0B) goto <D.31962>; else goto <D.31963>;
  <D.31962>:
  D.31961 = tls->pending_invoke;
  D.31961->has_ctx = 1;
  D.31961 = tls->pending_invoke;
  D.31961->ctx = tls->context.ctx;
  invoke_method ();
  <D.31963>:
  tls->context.valid = 0;
  tls->async_state.valid = 0;
  invalidate_frames (tls);
}


invoke_method ()
{
  unsigned int debugger_tls_id.434;
  _Bool D.31966;
  long int D.31967;
  long int D.31968;
  _Bool D.31971;
  long int D.31972;
  long int D.31973;
  struct InvokeData * D.31976;
  guint8 * p.435;
  guint8 * p.436;
  <unnamed type> D.31982;
  int D.31983;
  int D.31984;
  int D.31987;
  int D.31988;
  unsigned int i.437;
  unsigned int D.31992;
  struct MonoContext * D.31993;
  int D.31994;
  unsigned int D.31999;
  _Bool D.32000;
  long int D.32001;
  long int D.32002;
  unsigned int D.32005;
  int log_level.438;
  _Bool D.32007;
  long int D.32008;
  long int D.32009;
  unsigned int D.32012;
  void * D.32013;
  struct FILE * log_file.439;
  int D.32015;
  struct MonoInternalThread * D.32018;
  struct InvokeData * D.32019;
  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.434 = debugger_tls_id;
      tls = pthread_getspecific (debugger_tls_id.434);
      D.31966 = tls == 0B;
      D.31967 = (long int) D.31966;
      D.31968 = __builtin_expect (D.31967, 0);
      if (D.31968 != 0) goto <D.31969>; else goto <D.31970>;
      <D.31969>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 6421, "tls");
      <D.31970>:
      mono_loader_lock ();
      invoke = tls->pending_invoke;
      D.31971 = invoke == 0B;
      D.31972 = (long int) D.31971;
      D.31973 = __builtin_expect (D.31972, 0);
      if (D.31973 != 0) goto <D.31974>; else goto <D.31975>;
      <D.31974>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 6431, "invoke");
      <D.31975>:
      tls->pending_invoke = 0B;
      D.31976 = tls->invoke;
      invoke->last_invoke = D.31976;
      tls->invoke = invoke;
      mono_loader_unlock ();
      tls->frames_up_to_date = 0;
      id = invoke->id;
      p.435 = invoke->p;
      p = p.435;
      err = 0;
      mindex = 0;
      goto <D.26555>;
      <D.26554>:
      buffer_init (&buf, 128);
      if (err != 0) goto <D.31978>; else goto <D.31979>;
      <D.31978>:
      goto <D.31980>;
      <D.31979>:
      p.436 = p;
      D.31982 = do_invoke_method (tls, &buf, invoke, p.436, &p);
      err = (int) D.31982;
      <D.31980>:
      D.31983 = invoke->nmethods;
      D.31984 = D.31983 + -1;
      if (D.31984 == mindex) goto <D.31985>; else goto <D.31986>;
      <D.31985>:
      D.31987 = invoke->flags;
      D.31988 = D.31987 & 2;
      if (D.31988 == 0) goto <D.31989>; else goto <D.31990>;
      <D.31989>:
      i = 0;
      goto <D.26552>;
      <D.26551>:
      suspend_vm ();
      i = i + 1;
      <D.26552>:
      i.437 = (unsigned int) i;
      D.31992 = invoke->suspend_count;
      if (i.437 < D.31992) goto <D.26551>; else goto <D.26553>;
      <D.26553>:
      <D.31990>:
      <D.31986>:
      send_reply_packet (id, err, &buf);
      buffer_free (&buf);
      mindex = mindex + 1;
      <D.26555>:
      D.31983 = invoke->nmethods;
      if (D.31983 > mindex) goto <D.26554>; else goto <D.26556>;
      <D.26556>:
      D.31993 = &invoke->ctx;
      memcpy (&restore_ctx, D.31993, 36);
      D.31994 = invoke->has_ctx;
      if (D.31994 != 0) goto <D.31995>; else goto <D.31996>;
      <D.31995>:
      save_thread_context (&restore_ctx);
      <D.31996>:
      D.31987 = invoke->flags;
      D.31988 = D.31987 & 2;
      if (D.31988 != 0) goto <D.31997>; else goto <D.31998>;
      <D.31997>:
      D.31999 = tls->resume_count;
      D.32000 = D.31999 == 0;
      D.32001 = (long int) D.32000;
      D.32002 = __builtin_expect (D.32001, 0);
      if (D.32002 != 0) goto <D.32003>; else goto <D.32004>;
      <D.32003>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 6473, "tls->resume_count");
      <D.32004>:
      D.31999 = tls->resume_count;
      D.31992 = invoke->suspend_count;
      D.32005 = D.31999 - D.31992;
      tls->resume_count = D.32005;
      <D.31998>:
      log_level.438 = log_level;
      D.32007 = log_level.438 > 0;
      D.32008 = (long int) D.32007;
      D.32009 = __builtin_expect (D.32008, 0);
      if (D.32009 != 0) goto <D.32010>; else goto <D.32011>;
      <D.32010>:
      D.31999 = tls->resume_count;
      D.32012 = GetCurrentThreadId ();
      D.32013 = (void *) D.32012;
      log_file.439 = log_file;
      fprintf (log_file.439, "[%p] Invoke finished (%d), resume_count = %d.\n", D.32013, err, D.31999);
      log_file.439 = log_file;
      fflush (log_file.439);
      <D.32011>:
      mono_loader_lock ();
      D.32015 = tls->abort_requested;
      if (D.32015 != 0) goto <D.32016>; else goto <D.32017>;
      <D.32016>:
      D.32018 = tls->thread;
      mono_thread_internal_reset_abort (D.32018);
      <D.32017>:
      D.31976 = tls->invoke;
      D.32019 = D.31976->last_invoke;
      tls->invoke = D.32019;
      tls->abort_requested = 0;
      mono_loader_unlock ();
      p.435 = invoke->p;
      monoeg_g_free (p.435);
      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.32020;
  int log_level.440;
  _Bool D.32024;
  long int D.32025;
  long int D.32026;
  const char * iftmp.441;
  struct MonoObject * this.442;
  struct MonoVTable * D.32033;
  struct MonoClass * D.32034;
  char * D.32036;
  unsigned int D.32037;
  void * D.32038;
  struct FILE * log_file.443;
  void * * D.32040;
  guint8 * p.444;
  int err.445;
  ErrorCode D.32045;
  struct MonoClass * D.32046;
  unsigned char D.32047;
  unsigned char D.32048;
  int D.32051;
  unsigned int D.32052;
  short unsigned int D.32057;
  int D.32058;
  int D.32059;
  unsigned int D.32065;
  void * D.32066;
  int D.32067;
  unsigned int D.32068;
  struct MonoDomain * domain.446;
  struct MonoType * D.32070;
  <unnamed type> D.32071;
  int err.447;
  struct MonoObject * this.448;
  unsigned int D.32081;
  unsigned int D.32082;
  unsigned char D.32084;
  unsigned int D.32090;
  void * D.32091;
  const char * iftmp.449;
  char * D.32098;
  unsigned int D.32099;
  void * D.32100;
  struct MonoDomain * D.32103;
  int D.26523;
  int iftmp.450;
  int D.26522;
  const char[6] * D.32115;
  unsigned char D.32116;
  int D.32117;
  unsigned char D.32118;
  int D.32119;
  _Bool D.32120;
  _Bool D.32121;
  _Bool D.32122;
  const unsigned char * D.32125;
  unsigned char D.32126;
  int D.32127;
  const unsigned char * D.32128;
  unsigned char D.32129;
  int D.32130;
  _Bool D.32131;
  _Bool D.32132;
  const unsigned char * D.32135;
  unsigned char D.32136;
  int D.32137;
  const unsigned char * D.32138;
  unsigned char D.32139;
  int D.32140;
  _Bool D.32141;
  _Bool D.32142;
  const unsigned char * D.32145;
  unsigned char D.32146;
  int D.32147;
  const unsigned char * D.32148;
  unsigned char D.32149;
  int D.32150;
  const char * D.32152;
  unsigned int D.32155;
  struct MonoObject * this.451;
  int D.32162;
  short unsigned int D.32165;
  int D.32166;
  unsigned int nargs.452;
  unsigned int D.32170;
  struct MonoType * D.32171;
  int D.32172;
  unsigned int i.453;
  unsigned int D.32176;
  guint8 * D.32177;
  <unnamed type> D.32178;
  int err.454;
  void * * D.32181;
  void * D.32182;
  struct MonoVTable * D.32185;
  struct MonoDomain * D.32186;
  guint8 * * D.32190;
  struct MonoClass * D.32191;
  int D.32192;
  unsigned int D.32193;
  void * D.32194;
  guint8 * D.32195;
  <unnamed type> D.32196;
  int err.455;
  int D.32201;
  int D.32202;
  int D.32206;
  struct MonoLMF * D.32209;
  struct MonoContext * D.32210;
  struct MonoObject * res.456;
  struct MonoObject * res.457;
  long long unsigned int D.32218;
  long int D.32219;
  const char * iftmp.458;
  struct MonoObject * exc.459;
  struct MonoVTable * D.32224;
  struct MonoClass * D.32225;
  struct MonoObject * res.460;
  unsigned int D.32228;
  void * D.32229;
  struct MonoClass * D.32232;
  struct MonoType * D.32233;
  struct MonoType * D.32235;
  unsigned char D.32236;
  int D.26536;
  int iftmp.461;
  int D.26535;
  unsigned char D.32244;
  int D.32245;
  _Bool D.32246;
  _Bool D.32247;
  _Bool D.32248;
  const unsigned char * D.32251;
  unsigned char D.32252;
  int D.32253;
  _Bool D.32254;
  _Bool D.32255;
  const unsigned char * D.32258;
  unsigned char D.32259;
  int D.32260;
  _Bool D.32261;
  _Bool D.32262;
  const unsigned char * D.32265;
  unsigned char D.32266;
  int D.32267;
  struct MonoClass * D.32271;
  struct MonoType * D.32272;
  int D.32274;
  struct MonoClass * D.32281;
  unsigned char D.32282;
  unsigned char D.32283;
  struct MonoClass * D.32286;
  int D.32287;
  int D.32290;
  unsigned int D.32291;
  _Bool D.32292;
  long int D.32293;
  long int D.32294;
  _Bool D.32298;
  long int D.32299;
  long int D.32300;
  void * D.32303;
  unsigned int D.32306;
  int D.32307;
  int D.32308;
  struct MonoLMF * D.32309;
  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.32020 = invoke->method;
      if (D.32020 != 0B) goto <D.32021>; else goto <D.32022>;
      <D.32021>:
      this = 0B;
      log_level.440 = log_level;
      D.32024 = log_level.440 > 0;
      D.32025 = (long int) D.32024;
      D.32026 = __builtin_expect (D.32025, 0);
      if (D.32026 != 0) goto <D.32027>; else goto <D.32028>;
      <D.32027>:
      this.442 = this;
      if (this.442 != 0B) goto <D.32031>; else goto <D.32032>;
      <D.32031>:
      this.442 = this;
      D.32033 = this.442->vtable;
      D.32034 = D.32033->klass;
      iftmp.441 = D.32034->name;
      goto <D.32035>;
      <D.32032>:
      iftmp.441 = "<null>";
      <D.32035>:
      D.32020 = invoke->method;
      D.32036 = mono_method_full_name (D.32020, 1);
      D.32037 = GetCurrentThreadId ();
      D.32038 = (void *) D.32037;
      log_file.443 = log_file;
      fprintf (log_file.443, "[%p] Invoking method \'%s\' on receiver \'%s\'.\n", D.32038, D.32036, iftmp.441);
      log_file.443 = log_file;
      fflush (log_file.443);
      <D.32028>:
      D.32040 = invoke->args;
      D.32020 = invoke->method;
      mono_runtime_invoke (D.32020, 0B, D.32040, &exc);
      monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "debugger-agent.c", 6243);
      <D.32022>:
      p.444 = p;
      m = decode_methodid (p.444, &p, end, &domain, &err);
      err.445 = err;
      if (err.445 != 0) goto <D.32043>; else goto <D.32044>;
      <D.32043>:
      err.445 = err;
      D.32045 = (ErrorCode) err.445;
      return D.32045;
      <D.32044>:
      sig = mono_method_signature (m);
      D.32046 = m->klass;
      D.32047 = BIT_FIELD_REF <*D.32046, 8, 160>;
      D.32048 = D.32047 & 8;
      if (D.32048 != 0) goto <D.32049>; else goto <D.32050>;
      <D.32049>:
      D.32046 = m->klass;
      D.32051 = mono_class_instance_size (D.32046);
      D.32052 = (unsigned int) D.32051;
      this_buf = __builtin_alloca (D.32052);
      goto <D.32053>;
      <D.32050>:
      this_buf = __builtin_alloca (4);
      <D.32053>:
      D.32046 = m->klass;
      D.32047 = BIT_FIELD_REF <*D.32046, 8, 160>;
      D.32048 = D.32047 & 8;
      if (D.32048 != 0) goto <D.32056>; else goto <D.32054>;
      <D.32056>:
      D.32057 = m->flags;
      D.32058 = (int) D.32057;
      D.32059 = D.32058 & 16;
      if (D.32059 != 0) goto <D.32060>; else goto <D.32054>;
      <D.32060>:
      {
        int type;

        p.444 = p;
        type = decode_byte (p.444, &p, end);
        if (type != 240) goto <D.32061>; else goto <D.32062>;
        <D.32061>:
        log_level.440 = log_level;
        D.32024 = log_level.440 > 0;
        D.32025 = (long int) D.32024;
        D.32026 = __builtin_expect (D.32025, 0);
        if (D.32026 != 0) goto <D.32063>; else goto <D.32064>;
        <D.32063>:
        D.32065 = GetCurrentThreadId ();
        D.32066 = (void *) D.32065;
        log_file.443 = log_file;
        fprintf (log_file.443, "[%p] Error: Static vtype method invoked with this argument.\n", D.32066);
        log_file.443 = log_file;
        fflush (log_file.443);
        <D.32064>:
        D.32045 = 102;
        return D.32045;
        <D.32062>:
        D.32046 = m->klass;
        D.32067 = mono_class_instance_size (D.32046);
        D.32068 = (unsigned int) D.32067;
        memset (this_buf, 0, D.32068);
      }
      goto <D.32055>;
      <D.32054>:
      p.444 = p;
      domain.446 = domain;
      D.32046 = m->klass;
      D.32070 = &D.32046->byval_arg;
      D.32071 = decode_value (D.32070, domain.446, this_buf, p.444, &p, end);
      err.447 = (int) D.32071;
      err = err.447;
      err.445 = err;
      if (err.445 != 0) goto <D.32073>; else goto <D.32074>;
      <D.32073>:
      err.445 = err;
      D.32045 = (ErrorCode) err.445;
      return D.32045;
      <D.32074>:
      <D.32055>:
      D.32046 = m->klass;
      D.32047 = BIT_FIELD_REF <*D.32046, 8, 160>;
      D.32048 = D.32047 & 8;
      if (D.32048 == 0) goto <D.32075>; else goto <D.32076>;
      <D.32075>:
      this.448 = MEM[(struct MonoObject * *)this_buf];
      this = this.448;
      goto <D.32078>;
      <D.32076>:
      this = 0B;
      <D.32078>:
      D.32046 = m->klass;
      D.32081 = D.32046->flags;
      D.32082 = D.32081 & 32;
      if (D.32082 != 0) goto <D.32079>; else goto <D.32083>;
      <D.32083>:
      D.32046 = m->klass;
      D.32084 = D.32046->byval_arg.type;
      if (D.32084 == 19) goto <D.32079>; else goto <D.32085>;
      <D.32085>:
      D.32046 = m->klass;
      D.32084 = D.32046->byval_arg.type;
      if (D.32084 == 30) goto <D.32079>; else goto <D.32080>;
      <D.32079>:
      this.442 = this;
      if (this.442 == 0B) goto <D.32086>; else goto <D.32087>;
      <D.32086>:
      log_level.440 = log_level;
      D.32024 = log_level.440 > 0;
      D.32025 = (long int) D.32024;
      D.32026 = __builtin_expect (D.32025, 0);
      if (D.32026 != 0) goto <D.32088>; else goto <D.32089>;
      <D.32088>:
      D.32090 = GetCurrentThreadId ();
      D.32091 = (void *) D.32090;
      log_file.443 = log_file;
      fprintf (log_file.443, "[%p] Error: Interface method invoked without this argument.\n", D.32091);
      log_file.443 = log_file;
      fflush (log_file.443);
      <D.32089>:
      D.32045 = 102;
      return D.32045;
      <D.32087>:
      this.442 = this;
      m = mono_object_get_virtual_method (this.442, m);
      <D.32080>:
      log_level.440 = log_level;
      D.32024 = log_level.440 > 0;
      D.32025 = (long int) D.32024;
      D.32026 = __builtin_expect (D.32025, 0);
      if (D.32026 != 0) goto <D.32092>; else goto <D.32093>;
      <D.32092>:
      this.442 = this;
      if (this.442 != 0B) goto <D.32095>; else goto <D.32096>;
      <D.32095>:
      this.442 = this;
      D.32033 = this.442->vtable;
      D.32034 = D.32033->klass;
      iftmp.449 = D.32034->name;
      goto <D.32097>;
      <D.32096>:
      iftmp.449 = "<null>";
      <D.32097>:
      D.32098 = mono_method_full_name (m, 1);
      D.32099 = GetCurrentThreadId ();
      D.32100 = (void *) D.32099;
      log_file.443 = log_file;
      fprintf (log_file.443, "[%p] Invoking method \'%s\' on receiver \'%s\'.\n", D.32100, D.32098, iftmp.449);
      log_file.443 = log_file;
      fflush (log_file.443);
      <D.32093>:
      this.442 = this;
      if (this.442 != 0B) goto <D.32101>; else goto <D.32102>;
      <D.32101>:
      this.442 = this;
      D.32033 = this.442->vtable;
      D.32103 = D.32033->domain;
      domain.446 = domain;
      if (D.32103 != domain.446) goto <D.32104>; else goto <D.32105>;
      <D.32104>:
      monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "debugger-agent.c", 6285);
      <D.32105>:
      <D.32102>:
      D.32046 = m->klass;
      D.32047 = BIT_FIELD_REF <*D.32046, 8, 160>;
      D.32048 = D.32047 & 8;
      if (D.32048 == 0) goto <D.32106>; else goto <D.32107>;
      <D.32106>:
      D.32057 = m->flags;
      D.32058 = (int) D.32057;
      D.32059 = D.32058 & 16;
      if (D.32059 == 0) goto <D.32108>; else goto <D.32109>;
      <D.32108>:
      this.442 = this;
      if (this.442 == 0B) goto <D.32110>; else goto <D.32111>;
      <D.32110>:
      {
        size_t __s1_len;
        size_t __s2_len;

        __s2_len = 5;
        if (__s2_len <= 3) goto <D.32113>; else goto <D.32114>;
        <D.32113>:
        {
          const unsigned char * __s2;
          int __result;

          __s2 = m->name;
          D.32115 = ".ctor";
          D.32116 = MEM[(const unsigned char *)D.32115];
          D.32117 = (int) D.32116;
          D.32118 = *__s2;
          D.32119 = (int) D.32118;
          __result = D.32117 - D.32119;
          {
            D.32120 = __s2_len != 0;
            D.32121 = __result == 0;
            D.32122 = D.32120 & D.32121;
            if (D.32122 != 0) goto <D.32123>; else goto <D.32124>;
            <D.32123>:
            D.32125 = &MEM[(void *)".ctor" + 1B];
            D.32126 = *D.32125;
            D.32127 = (int) D.32126;
            D.32128 = __s2 + 1;
            D.32129 = *D.32128;
            D.32130 = (int) D.32129;
            __result = D.32127 - D.32130;
            D.32131 = __s2_len > 1;
            D.32121 = __result == 0;
            D.32132 = D.32131 & D.32121;
            if (D.32132 != 0) goto <D.32133>; else goto <D.32134>;
            <D.32133>:
            D.32135 = &MEM[(void *)".ctor" + 2B];
            D.32136 = *D.32135;
            D.32137 = (int) D.32136;
            D.32138 = __s2 + 2;
            D.32139 = *D.32138;
            D.32140 = (int) D.32139;
            __result = D.32137 - D.32140;
            D.32141 = __s2_len > 2;
            D.32121 = __result == 0;
            D.32142 = D.32141 & D.32121;
            if (D.32142 != 0) goto <D.32143>; else goto <D.32144>;
            <D.32143>:
            D.32145 = &MEM[(void *)".ctor" + 3B];
            D.32146 = *D.32145;
            D.32147 = (int) D.32146;
            D.32148 = __s2 + 3;
            D.32149 = *D.32148;
            D.32150 = (int) D.32149;
            __result = D.32147 - D.32150;
            <D.32144>:
            <D.32134>:
            <D.32124>:
          }
          D.26522 = __result;
        }
        iftmp.450 = -D.26522;
        goto <D.32151>;
        <D.32114>:
        D.32152 = m->name;
        iftmp.450 = __builtin_strcmp (D.32152, ".ctor");
        <D.32151>:
        D.26523 = iftmp.450;
      }
      if (D.26523 == 0) goto <D.32153>; else goto <D.32154>;
      <D.32153>:
      D.32046 = m->klass;
      D.32081 = D.32046->flags;
      D.32155 = D.32081 & 128;
      if (D.32155 != 0) goto <D.32156>; else goto <D.32157>;
      <D.32156>:
      D.32045 = 102;
      return D.32045;
      <D.32157>:
      D.32046 = m->klass;
      domain.446 = domain;
      this.451 = mono_object_new (domain.446, D.32046);
      this = this.451;
      goto <D.32159>;
      <D.32154>:
      D.32045 = 102;
      return D.32045;
      <D.32159>:
      <D.32111>:
      <D.32109>:
      <D.32107>:
      this.442 = this;
      if (this.442 != 0B) goto <D.32160>; else goto <D.32161>;
      <D.32160>:
      D.32046 = m->klass;
      D.32070 = &D.32046->byval_arg;
      this.442 = this;
      D.32162 = obj_is_of_type (this.442, D.32070);
      if (D.32162 == 0) goto <D.32163>; else goto <D.32164>;
      <D.32163>:
      D.32045 = 102;
      return D.32045;
      <D.32164>:
      <D.32161>:
      p.444 = p;
      nargs = decode_int (p.444, &p, end);
      D.32165 = sig->param_count;
      D.32166 = (int) D.32165;
      if (D.32166 != nargs) goto <D.32167>; else goto <D.32168>;
      <D.32167>:
      D.32045 = 102;
      return D.32045;
      <D.32168>:
      nargs.452 = (unsigned int) nargs;
      D.32170 = nargs.452 * 4;
      arg_buf = __builtin_alloca (D.32170);
      nargs.452 = (unsigned int) nargs;
      D.32170 = nargs.452 * 4;
      memset (arg_buf, 0, D.32170);
      nargs.452 = (unsigned int) nargs;
      D.32170 = nargs.452 * 4;
      args = __builtin_alloca (D.32170);
      i = 0;
      goto <D.26526>;
      <D.26525>:
      D.32171 = sig->params[i];
      D.32172 = mono_type_is_reference (D.32171);
      if (D.32172 != 0) goto <D.32173>; else goto <D.32174>;
      <D.32173>:
      p.444 = p;
      i.453 = (unsigned int) i;
      D.32176 = i.453 * 4;
      D.32177 = args + D.32176;
      domain.446 = domain;
      D.32171 = sig->params[i];
      D.32178 = decode_value (D.32171, domain.446, D.32177, p.444, &p, end);
      err.454 = (int) D.32178;
      err = err.454;
      err.445 = err;
      if (err.445 != 0) goto <D.26524>; else goto <D.32180>;
      <D.32180>:
      i.453 = (unsigned int) i;
      D.32176 = i.453 * 4;
      D.32181 = args + D.32176;
      D.32182 = *D.32181;
      if (D.32182 != 0B) goto <D.32183>; else goto <D.32184>;
      <D.32183>:
      i.453 = (unsigned int) i;
      D.32176 = i.453 * 4;
      D.32181 = args + D.32176;
      D.32182 = *D.32181;
      D.32185 = MEM[(struct MonoObject *)D.32182].vtable;
      D.32186 = D.32185->domain;
      domain.446 = domain;
      if (D.32186 != domain.446) goto <D.32187>; else goto <D.32188>;
      <D.32187>:
      monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "debugger-agent.c", 6315);
      <D.32188>:
      <D.32184>:
      goto <D.32189>;
      <D.32174>:
      i.453 = (unsigned int) i;
      D.32176 = i.453 * 4;
      D.32190 = arg_buf + D.32176;
      D.32171 = sig->params[i];
      D.32191 = mono_class_from_mono_type (D.32171);
      D.32192 = mono_class_instance_size (D.32191);
      D.32193 = (unsigned int) D.32192;
      D.32194 = __builtin_alloca (D.32193);
      *D.32190 = D.32194;
      p.444 = p;
      i.453 = (unsigned int) i;
      D.32176 = i.453 * 4;
      D.32190 = arg_buf + D.32176;
      D.32195 = *D.32190;
      domain.446 = domain;
      D.32171 = sig->params[i];
      D.32196 = decode_value (D.32171, domain.446, D.32195, p.444, &p, end);
      err.455 = (int) D.32196;
      err = err.455;
      err.445 = err;
      if (err.445 != 0) goto <D.26524>; else goto <D.32198>;
      <D.32198>:
      i.453 = (unsigned int) i;
      D.32176 = i.453 * 4;
      D.32181 = args + D.32176;
      i.453 = (unsigned int) i;
      D.32176 = i.453 * 4;
      D.32190 = arg_buf + D.32176;
      D.32195 = *D.32190;
      *D.32181 = D.32195;
      <D.32189>:
      i = i + 1;
      <D.26526>:
      if (i < nargs) goto <D.26525>; else goto <D.26524>;
      <D.26524>:
      if (i < nargs) goto <D.32199>; else goto <D.32200>;
      <D.32199>:
      err.445 = err;
      D.32045 = (ErrorCode) err.445;
      return D.32045;
      <D.32200>:
      D.32201 = invoke->flags;
      D.32202 = D.32201 & 1;
      if (D.32202 != 0) goto <D.32203>; else goto <D.32204>;
      <D.32203>:
      tls->disable_breakpoints = 1;
      goto <D.32205>;
      <D.32204>:
      tls->disable_breakpoints = 0;
      <D.32205>:
      D.32206 = invoke->has_ctx;
      if (D.32206 != 0) goto <D.32207>; else goto <D.32208>;
      <D.32207>:
      {
        struct MonoLMF * * lmf_addr;

        lmf_addr = mono_get_lmf_addr ();
        memset (&ext, 0, 76);
        D.32209 = *lmf_addr;
        mono_arch_init_lmf_ext (&ext, D.32209);
        ext.debugger_invoke = 1;
        D.32210 = &invoke->ctx;
        memcpy (&ext.ctx, D.32210, 36);
        mono_set_lmf (&ext);
      }
      <D.32208>:
      mono_stopwatch_start (&watch);
      D.32046 = m->klass;
      D.32047 = BIT_FIELD_REF <*D.32046, 8, 160>;
      D.32048 = D.32047 & 8;
      if (D.32048 != 0) goto <D.32211>; else goto <D.32212>;
      <D.32211>:
      res.456 = mono_runtime_invoke (m, this_buf, args, &exc);
      res = res.456;
      goto <D.32214>;
      <D.32212>:
      this.442 = this;
      res.457 = mono_runtime_invoke (m, this.442, args, &exc);
      res = res.457;
      <D.32214>:
      mono_stopwatch_stop (&watch);
      log_level.440 = log_level;
      D.32024 = log_level.440 > 0;
      D.32025 = (long int) D.32024;
      D.32026 = __builtin_expect (D.32025, 0);
      if (D.32026 != 0) goto <D.32216>; else goto <D.32217>;
      <D.32216>:
      D.32218 = mono_stopwatch_elapsed_ms (&watch);
      D.32219 = (long int) D.32218;
      exc.459 = exc;
      if (exc.459 != 0B) goto <D.32222>; else goto <D.32223>;
      <D.32222>:
      exc.459 = exc;
      D.32224 = exc.459->vtable;
      D.32225 = D.32224->klass;
      iftmp.458 = D.32225->name;
      goto <D.32226>;
      <D.32223>:
      iftmp.458 = 0B;
      <D.32226>:
      res.460 = res;
      D.32228 = GetCurrentThreadId ();
      D.32229 = (void *) D.32228;
      log_file.443 = log_file;
      fprintf (log_file.443, "[%p] Invoke result: %p, exc: %s, time: %ld ms.\n", D.32229, res.460, iftmp.458, D.32219);
      log_file.443 = log_file;
      fflush (log_file.443);
      <D.32217>:
      exc.459 = exc;
      if (exc.459 != 0B) goto <D.32230>; else goto <D.32231>;
      <D.32230>:
      buffer_add_byte (buf, 0);
      domain.446 = domain;
      D.32232 = mono_defaults.object_class;
      D.32233 = &D.32232->byval_arg;
      buffer_add_value (buf, D.32233, &exc, domain.446);
      goto <D.32234>;
      <D.32231>:
      buffer_add_byte (buf, 1);
      D.32235 = sig->ret;
      D.32236 = D.32235->type;
      if (D.32236 == 1) goto <D.32237>; else goto <D.32238>;
      <D.32237>:
      {
        size_t __s1_len;
        size_t __s2_len;

        __s2_len = 5;
        if (__s2_len <= 3) goto <D.32242>; else goto <D.32243>;
        <D.32242>:
        {
          const unsigned char * __s2;
          int __result;

          __s2 = m->name;
          D.32115 = ".ctor";
          D.32116 = MEM[(const unsigned char *)D.32115];
          D.32117 = (int) D.32116;
          D.32244 = *__s2;
          D.32245 = (int) D.32244;
          __result = D.32117 - D.32245;
          {
            D.32246 = __s2_len != 0;
            D.32247 = __result == 0;
            D.32248 = D.32246 & D.32247;
            if (D.32248 != 0) goto <D.32249>; else goto <D.32250>;
            <D.32249>:
            D.32125 = &MEM[(void *)".ctor" + 1B];
            D.32126 = *D.32125;
            D.32127 = (int) D.32126;
            D.32251 = __s2 + 1;
            D.32252 = *D.32251;
            D.32253 = (int) D.32252;
            __result = D.32127 - D.32253;
            D.32254 = __s2_len > 1;
            D.32247 = __result == 0;
            D.32255 = D.32254 & D.32247;
            if (D.32255 != 0) goto <D.32256>; else goto <D.32257>;
            <D.32256>:
            D.32135 = &MEM[(void *)".ctor" + 2B];
            D.32136 = *D.32135;
            D.32137 = (int) D.32136;
            D.32258 = __s2 + 2;
            D.32259 = *D.32258;
            D.32260 = (int) D.32259;
            __result = D.32137 - D.32260;
            D.32261 = __s2_len > 2;
            D.32247 = __result == 0;
            D.32262 = D.32261 & D.32247;
            if (D.32262 != 0) goto <D.32263>; else goto <D.32264>;
            <D.32263>:
            D.32145 = &MEM[(void *)".ctor" + 3B];
            D.32146 = *D.32145;
            D.32147 = (int) D.32146;
            D.32265 = __s2 + 3;
            D.32266 = *D.32265;
            D.32267 = (int) D.32266;
            __result = D.32147 - D.32267;
            <D.32264>:
            <D.32257>:
            <D.32250>:
          }
          D.26535 = __result;
        }
        iftmp.461 = -D.26535;
        goto <D.32268>;
        <D.32243>:
        D.32152 = m->name;
        iftmp.461 = __builtin_strcmp (D.32152, ".ctor");
        <D.32268>:
        D.26536 = iftmp.461;
      }
      if (D.26536 == 0) goto <D.32269>; else goto <D.32239>;
      <D.32269>:
      D.32046 = m->klass;
      D.32047 = BIT_FIELD_REF <*D.32046, 8, 160>;
      D.32048 = D.32047 & 8;
      if (D.32048 == 0) goto <D.32270>; else goto <D.32239>;
      <D.32270>:
      domain.446 = domain;
      D.32232 = mono_defaults.object_class;
      D.32233 = &D.32232->byval_arg;
      buffer_add_value (buf, D.32233, &this, domain.446);
      goto <D.32240>;
      <D.32239>:
      domain.446 = domain;
      D.32271 = mono_defaults.void_class;
      D.32272 = &D.32271->byval_arg;
      buffer_add_value (buf, D.32272, 0B, domain.446);
      <D.32240>:
      goto <D.32273>;
      <D.32238>:
      D.32235 = sig->ret;
      D.32274 = mono_type_is_reference (D.32235);
      if (D.32274 != 0) goto <D.32275>; else goto <D.32276>;
      <D.32275>:
      domain.446 = domain;
      D.32235 = sig->ret;
      buffer_add_value (buf, D.32235, &res, domain.446);
      goto <D.32277>;
      <D.32276>:
      D.32235 = sig->ret;
      D.32281 = mono_class_from_mono_type (D.32235);
      D.32282 = BIT_FIELD_REF <*D.32281, 8, 160>;
      D.32283 = D.32282 & 8;
      if (D.32283 != 0) goto <D.32278>; else goto <D.32284>;
      <D.32284>:
      D.32235 = sig->ret;
      D.32236 = D.32235->type;
      if (D.32236 == 15) goto <D.32278>; else goto <D.32285>;
      <D.32285>:
      D.32235 = sig->ret;
      D.32236 = D.32235->type;
      if (D.32236 == 27) goto <D.32278>; else goto <D.32279>;
      <D.32278>:
      D.32235 = sig->ret;
      D.32286 = mono_class_from_mono_type (D.32235);
      D.32287 = mono_class_is_nullable (D.32286);
      if (D.32287 != 0) goto <D.32288>; else goto <D.32289>;
      <D.32288>:
      {
        struct MonoClass * k;
        guint8 * nullable_buf;

        D.32235 = sig->ret;
        k = mono_class_from_mono_type (D.32235);
        D.32290 = mono_class_value_size (k, 0B);
        D.32291 = (unsigned int) D.32290;
        nullable_buf = __builtin_alloca (D.32291);
        D.32292 = nullable_buf == 0B;
        D.32293 = (long int) D.32292;
        D.32294 = __builtin_expect (D.32293, 0);
        if (D.32294 != 0) goto <D.32295>; else goto <D.32296>;
        <D.32295>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 6379, "nullable_buf");
        <D.32296>:
        res.460 = res;
        mono_nullable_init (nullable_buf, res.460, k);
        domain.446 = domain;
        D.32235 = sig->ret;
        buffer_add_value (buf, D.32235, nullable_buf, domain.446);
      }
      goto <D.32297>;
      <D.32289>:
      res.460 = res;
      D.32298 = res.460 == 0B;
      D.32299 = (long int) D.32298;
      D.32300 = __builtin_expect (D.32299, 0);
      if (D.32300 != 0) goto <D.32301>; else goto <D.32302>;
      <D.32301>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 6383, "res");
      <D.32302>:
      domain.446 = domain;
      res.460 = res;
      D.32303 = mono_object_unbox (res.460);
      D.32235 = sig->ret;
      buffer_add_value (buf, D.32235, D.32303, domain.446);
      <D.32297>:
      goto <D.32280>;
      <D.32279>:
      monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "debugger-agent.c", 6387);
      <D.32280>:
      <D.32277>:
      <D.32273>:
      <D.32234>:
      tls->disable_breakpoints = 0;
      D.32206 = invoke->has_ctx;
      if (D.32206 != 0) goto <D.32304>; else goto <D.32305>;
      <D.32304>:
      D.32306 = ext.lmf.previous_lmf;
      D.32307 = (int) D.32306;
      D.32308 = D.32307 & -4;
      D.32309 = (struct MonoLMF *) D.32308;
      mono_set_lmf (D.32309);
      <D.32305>:
      p.444 = p;
      *endp = p.444;
      D.32045 = 0;
      return D.32045;
    }
  finally
    {
      err = {CLOBBER};
      this = {CLOBBER};
      res = {CLOBBER};
      exc = {CLOBBER};
      domain = {CLOBBER};
      ext = {CLOBBER};
      watch = {CLOBBER};
    }
}


memset (void * __dest, int __ch, size_t __len)
{
  int D.32314;
  int D.32319;
  void * D.32321;
  unsigned int D.32322;

  D.32314 = __builtin_constant_p (__len);
  if (D.32314 != 0) goto <D.32315>; else goto <D.32316>;
  <D.32315>:
  if (__len == 0) goto <D.32317>; else goto <D.32318>;
  <D.32317>:
  D.32319 = __builtin_constant_p (__ch);
  if (D.32319 == 0) goto <D.32312>; else goto <D.32320>;
  <D.32320>:
  if (__ch != 0) goto <D.32312>; else goto <D.32313>;
  <D.32312>:
  __warn_memset_zero_len ();
  D.32321 = __dest;
  return D.32321;
  <D.32313>:
  <D.32318>:
  <D.32316>:
  D.32322 = __builtin_object_size (__dest, 0);
  D.32321 = __builtin___memset_chk (__dest, __ch, __len, D.32322);
  return D.32321;
}


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

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


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

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


mono_stopwatch_elapsed_ms (struct MonoStopwatch * w)
{
  guint64 D.32326;
  long long unsigned int D.32327;
  long long unsigned int D.32328;

  D.32327 = mono_stopwatch_elapsed (w);
  D.32328 = D.32327 + 500;
  D.32326 = D.32328 / 1000;
  return D.32326;
}


mono_stopwatch_elapsed (struct MonoStopwatch * w)
{
  guint64 D.32330;
  long long int D.32331;
  long long int D.32332;
  long long int D.32333;
  long long int D.32334;

  D.32331 = w->stop;
  D.32332 = w->start;
  D.32333 = D.32331 - D.32332;
  D.32334 = D.32333 / 10;
  D.32330 = (guint64) D.32334;
  return D.32330;
}


send_type_load (struct MonoClass * klass)
{
  union mono_mutex_t * D.32336;
  _Bool D.32339;
  long int D.32340;
  long int D.32341;
  struct GHashTable * D.32344;
  void * D.32345;
  _Bool D.32350;
  long int D.32351;
  long int D.32352;
  gboolean type_load;
  struct MonoDomain * domain;
  struct AgentDomainInfo * info;

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

    D.32336 = &domain->lock.mutex;
    ret = pthread_mutex_lock (D.32336);
    if (ret != 0) goto <D.32337>; else goto <D.32338>;
    <D.32337>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.32338>:
    D.32339 = ret != 0;
    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", 3983, "ret == 0");
    <D.32343>:
  }
  info = get_agent_domain_info (domain);
  D.32344 = info->loaded_classes;
  D.32345 = monoeg_g_hash_table_lookup (D.32344, klass);
  if (D.32345 == 0B) goto <D.32346>; else goto <D.32347>;
  <D.32346>:
  type_load = 1;
  D.32344 = info->loaded_classes;
  monoeg_g_hash_table_insert_replace (D.32344, klass, klass, 0);
  <D.32347>:
  {
    int ret;

    D.32336 = &domain->lock.mutex;
    ret = pthread_mutex_unlock (D.32336);
    if (ret != 0) goto <D.32348>; else goto <D.32349>;
    <D.32348>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.32349>:
    D.32350 = ret != 0;
    D.32351 = (long int) D.32350;
    D.32352 = __builtin_expect (D.32351, 0);
    if (D.32352 != 0) goto <D.32353>; else goto <D.32354>;
    <D.32353>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 3992, "ret == 0");
    <D.32354>:
  }
  mono_loader_unlock ();
  if (type_load != 0) goto <D.32355>; else goto <D.32356>;
  <D.32355>:
  emit_type_load (klass, klass, 0B);
  <D.32356>:
}


add_pending_breakpoints (struct MonoMethod * method, struct MonoJitInfo * ji)
{
  struct GPtrArray * breakpoints.462;
  void * * D.32360;
  unsigned int i.463;
  unsigned int D.32362;
  void * * D.32363;
  int D.32364;
  struct GPtrArray * D.32367;
  void * * D.32368;
  unsigned int j.464;
  unsigned int D.32370;
  void * * D.32371;
  struct MonoJitInfo * D.32372;
  unsigned int j.465;
  unsigned int D.32376;
  union mono_mutex_t * D.32379;
  _Bool D.32382;
  long int D.32383;
  long int D.32384;
  void * D.32387;
  struct GHashTable * D.32388;
  unsigned char D.32391;
  unsigned char D.32392;
  struct MonoMethod * D.32395;
  _Bool D.32398;
  long int D.32399;
  long int D.32400;
  _Bool D.32405;
  long int D.32406;
  long int D.32407;
  unsigned int i.466;
  unsigned int D.32411;
  int i;
  int j;
  struct MonoSeqPointInfo * seq_points;
  struct MonoDomain * domain;
  struct MonoMethod * jmethod;

  breakpoints.462 = breakpoints;
  if (breakpoints.462 == 0B) goto <D.32358>; else goto <D.32359>;
  <D.32358>:
  return;
  <D.32359>:
  domain = mono_domain_get ();
  mono_loader_lock ();
  i = 0;
  goto <D.25852>;
  <D.25851>:
  {
    struct MonoBreakpoint * bp;
    gboolean found;

    breakpoints.462 = breakpoints;
    D.32360 = breakpoints.462->pdata;
    i.463 = (unsigned int) i;
    D.32362 = i.463 * 4;
    D.32363 = D.32360 + D.32362;
    bp = *D.32363;
    found = 0;
    D.32364 = bp_matches_method (bp, method);
    if (D.32364 == 0) goto <D.32365>; else goto <D.32366>;
    <D.32365>:
    // predicted unlikely by continue predictor.
    goto <D.25844>;
    <D.32366>:
    j = 0;
    goto <D.25847>;
    <D.25846>:
    {
      struct BreakpointInstance * inst;

      D.32367 = bp->children;
      D.32368 = D.32367->pdata;
      j.464 = (unsigned int) j;
      D.32370 = j.464 * 4;
      D.32371 = D.32368 + D.32370;
      inst = *D.32371;
      D.32372 = inst->ji;
      if (D.32372 == ji) goto <D.32373>; else goto <D.32374>;
      <D.32373>:
      found = 1;
      <D.32374>:
    }
    j = j + 1;
    <D.25847>:
    j.465 = (unsigned int) j;
    D.32367 = bp->children;
    D.32376 = D.32367->len;
    if (j.465 < D.32376) goto <D.25846>; else goto <D.25848>;
    <D.25848>:
    if (found == 0) goto <D.32377>; else goto <D.32378>;
    <D.32377>:
    jmethod = jinfo_get_method (ji);
    {
      int ret;

      D.32379 = &domain->lock.mutex;
      ret = pthread_mutex_lock (D.32379);
      if (ret != 0) goto <D.32380>; else goto <D.32381>;
      <D.32380>:
      monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
      <D.32381>:
      D.32382 = ret != 0;
      D.32383 = (long int) D.32382;
      D.32384 = __builtin_expect (D.32383, 0);
      if (D.32384 != 0) goto <D.32385>; else goto <D.32386>;
      <D.32385>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 4271, "ret == 0");
      <D.32386>:
    }
    D.32387 = domain->runtime_info;
    D.32388 = MEM[(struct MonoJitDomainInfo *)D.32387].seq_points;
    seq_points = monoeg_g_hash_table_lookup (D.32388, jmethod);
    if (seq_points == 0B) goto <D.32389>; else goto <D.32390>;
    <D.32389>:
    D.32391 = BIT_FIELD_REF <*jmethod, 8, 168>;
    D.32392 = D.32391 & 16;
    if (D.32392 != 0) goto <D.32393>; else goto <D.32394>;
    <D.32393>:
    D.32395 = mono_method_get_declaring_generic_method (jmethod);
    D.32387 = domain->runtime_info;
    D.32388 = MEM[(struct MonoJitDomainInfo *)D.32387].seq_points;
    seq_points = monoeg_g_hash_table_lookup (D.32388, D.32395);
    <D.32394>:
    <D.32390>:
    {
      int ret;

      D.32379 = &domain->lock.mutex;
      ret = pthread_mutex_unlock (D.32379);
      if (ret != 0) goto <D.32396>; else goto <D.32397>;
      <D.32396>:
      monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
      <D.32397>:
      D.32398 = ret != 0;
      D.32399 = (long int) D.32398;
      D.32400 = __builtin_expect (D.32399, 0);
      if (D.32400 != 0) goto <D.32401>; else goto <D.32402>;
      <D.32401>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 4275, "ret == 0");
      <D.32402>:
    }
    if (seq_points == 0B) goto <D.32403>; else goto <D.32404>;
    <D.32403>:
    // predicted unlikely by continue predictor.
    goto <D.25844>;
    <D.32404>:
    D.32405 = seq_points == 0B;
    D.32406 = (long int) D.32405;
    D.32407 = __builtin_expect (D.32406, 0);
    if (D.32407 != 0) goto <D.32408>; else goto <D.32409>;
    <D.32408>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 4279, "seq_points");
    <D.32409>:
    insert_breakpoint (seq_points, domain, ji, bp, 0B);
    <D.32378>:
  }
  <D.25844>:
  i = i + 1;
  <D.25852>:
  i.466 = (unsigned int) i;
  breakpoints.462 = breakpoints;
  D.32411 = breakpoints.462->len;
  if (i.466 < D.32411) goto <D.25851>; else goto <D.25853>;
  <D.25853>:
  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.467;
  void * * D.32414;
  unsigned int i.468;
  unsigned int D.32416;
  void * * D.32417;
  int D.32418;
  int D.32421;
  int D.32422;
  unsigned int i.469;
  unsigned int D.32424;
  int i;
  gboolean found;

  mono_loader_lock ();
  found = 1;
  goto <D.26473>;
  <D.26472>:
  found = 0;
  i = 0;
  goto <D.26471>;
  <D.26470>:
  {
    struct EventRequest * req;

    event_requests.467 = event_requests;
    D.32414 = event_requests.467->pdata;
    i.468 = (unsigned int) i;
    D.32416 = i.468 * 4;
    D.32417 = D.32414 + D.32416;
    req = *D.32417;
    D.32418 = event_req_matches_assembly (req, assembly);
    if (D.32418 != 0) goto <D.32419>; else goto <D.32420>;
    <D.32419>:
    D.32421 = req->event_kind;
    D.32422 = req->id;
    clear_event_request (D.32422, D.32421);
    found = 1;
    goto <D.26469>;
    <D.32420>:
  }
  i = i + 1;
  <D.26471>:
  i.469 = (unsigned int) i;
  event_requests.467 = event_requests;
  D.32424 = event_requests.467->len;
  if (i.469 < D.32424) goto <D.26470>; else goto <D.26469>;
  <D.26469>:
  <D.26473>:
  if (found != 0) goto <D.26472>; else goto <D.26474>;
  <D.26474>:
  mono_loader_unlock ();
}


event_req_matches_assembly (struct EventRequest * req, struct MonoAssembly * assembly)
{
  int D.32425;
  gboolean D.32428;
  void * D.32429;
  <unnamed type> D.32430;
  struct MonoClass * D.32433;
  struct MonoImage * D.32436;
  struct MonoAssembly * D.32437;
  struct MonoAssembly * * D.32442;
  unsigned int j.470;
  unsigned int D.32446;
  struct MonoAssembly * * D.32447;
  struct MonoAssembly * D.32448;
  int D.32451;

  D.32425 = req->event_kind;
  if (D.32425 == 10) goto <D.32426>; else goto <D.32427>;
  <D.32426>:
  D.32429 = req->info;
  D.32428 = breakpoint_matches_assembly (D.32429, assembly);
  return D.32428;
  <D.32427>:
  {
    int i;
    int j;

    i = 0;
    goto <D.26461>;
    <D.26460>:
    {
      struct Modifier * m;

      m = &req->modifiers[i];
      D.32430 = m->kind;
      if (D.32430 == 8) goto <D.32431>; else goto <D.32432>;
      <D.32431>:
      D.32433 = m->data.exc_class;
      if (D.32433 != 0B) goto <D.32434>; else goto <D.32435>;
      <D.32434>:
      D.32433 = m->data.exc_class;
      D.32436 = D.32433->image;
      D.32437 = D.32436->assembly;
      if (D.32437 == assembly) goto <D.32438>; else goto <D.32439>;
      <D.32438>:
      D.32428 = 1;
      return D.32428;
      <D.32439>:
      <D.32435>:
      <D.32432>:
      D.32430 = m->kind;
      if (D.32430 == 11) goto <D.32440>; else goto <D.32441>;
      <D.32440>:
      D.32442 = m->data.assemblies;
      if (D.32442 != 0B) goto <D.32443>; else goto <D.32444>;
      <D.32443>:
      j = 0;
      goto <D.26458>;
      <D.26457>:
      D.32442 = m->data.assemblies;
      j.470 = (unsigned int) j;
      D.32446 = j.470 * 4;
      D.32447 = D.32442 + D.32446;
      D.32448 = *D.32447;
      if (D.32448 == assembly) goto <D.32449>; else goto <D.32450>;
      <D.32449>:
      D.32428 = 1;
      return D.32428;
      <D.32450>:
      j = j + 1;
      <D.26458>:
      D.32442 = m->data.assemblies;
      j.470 = (unsigned int) j;
      D.32446 = j.470 * 4;
      D.32447 = D.32442 + D.32446;
      D.32448 = *D.32447;
      if (D.32448 != 0B) goto <D.26457>; else goto <D.26459>;
      <D.26459>:
      <D.32444>:
      <D.32441>:
    }
    i = i + 1;
    <D.26461>:
    D.32451 = req->nmodifiers;
    if (D.32451 > i) goto <D.26460>; else goto <D.26462>;
    <D.26462>:
  }
  D.32428 = 0;
  return D.32428;
}


breakpoint_matches_assembly (struct MonoBreakpoint * bp, struct MonoAssembly * assembly)
{
  gboolean D.32453;
  int iftmp.471;
  struct MonoMethod * D.32457;
  struct MonoClass * D.32459;
  struct MonoImage * D.32460;
  struct MonoAssembly * D.32461;

  D.32457 = bp->method;
  if (D.32457 != 0B) goto <D.32458>; else goto <D.32455>;
  <D.32458>:
  D.32457 = bp->method;
  D.32459 = D.32457->klass;
  D.32460 = D.32459->image;
  D.32461 = D.32460->assembly;
  if (D.32461 == assembly) goto <D.32462>; else goto <D.32455>;
  <D.32462>:
  iftmp.471 = 1;
  goto <D.32456>;
  <D.32455>:
  iftmp.471 = 0;
  <D.32456>:
  D.32453 = iftmp.471;
  return D.32453;
}


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

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


type_comes_from_assembly (void * klass, void * also_klass, void * assembly)
{
  gboolean D.32465;
  struct MonoImage * D.32466;
  struct MonoImage * D.32467;
  _Bool D.32468;

  D.32466 = mono_class_get_image (klass);
  D.32467 = mono_assembly_get_image (assembly);
  D.32468 = D.32466 == D.32467;
  D.32465 = (gboolean) D.32468;
  return D.32465;
}


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

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


thread_end (struct MonoProfiler * prof, uintptr_t tid)
{
  const void * tid.473;
  struct MonoGHashTable * tid_to_thread.474;
  struct MonoGHashTable * tid_to_thread_obj.475;
  struct MonoGHashTable * thread_to_tls.476;
  struct MonoInternalThread * * D.32479;
  int log_level.477;
  _Bool D.32483;
  long int D.32484;
  long int D.32485;
  void * tid.478;
  struct FILE * log_file.479;
  struct MonoInternalThread * thread;
  struct DebuggerTlsData * tls;

  tls = 0B;
  mono_loader_lock ();
  tid.473 = (const void *) tid;
  tid_to_thread.474 = tid_to_thread;
  thread = mono_g_hash_table_lookup (tid_to_thread.474, tid.473);
  if (thread != 0B) goto <D.32473>; else goto <D.32474>;
  <D.32473>:
  tid.473 = (const void *) tid;
  tid_to_thread_obj.475 = tid_to_thread_obj;
  mono_g_hash_table_remove (tid_to_thread_obj.475, tid.473);
  thread_to_tls.476 = thread_to_tls;
  tls = mono_g_hash_table_lookup (thread_to_tls.476, thread);
  if (tls != 0B) goto <D.32477>; else goto <D.32478>;
  <D.32477>:
  tls->terminated = 1;
  D.32479 = &tls->thread;
  mono_gc_deregister_root (D.32479);
  tls->thread = 0B;
  <D.32478>:
  <D.32474>:
  mono_loader_unlock ();
  if (thread != 0B) goto <D.32480>; else goto <D.32481>;
  <D.32480>:
  log_level.477 = log_level;
  D.32483 = log_level.477 > 0;
  D.32484 = (long int) D.32483;
  D.32485 = __builtin_expect (D.32484, 0);
  if (D.32485 != 0) goto <D.32486>; else goto <D.32487>;
  <D.32486>:
  tid.478 = (void *) tid;
  log_file.479 = log_file;
  fprintf (log_file.479, "[%p] Thread terminated, obj=%p, tls=%p.\n", tid.478, thread, tls);
  log_file.479 = log_file;
  fflush (log_file.479);
  <D.32487>:
  process_profiler_event (3, thread);
  <D.32481>:
}


thread_startup (struct MonoProfiler * prof, uintptr_t tid)
{
  unsigned int debugger_thread_id.480;
  long long unsigned int D.32493;
  long long unsigned int D.32494;
  _Bool D.32495;
  long int D.32496;
  long int D.32497;
  const void * tid.481;
  struct MonoGHashTable * tid_to_thread.482;
  int log_level.483;
  _Bool D.32507;
  long int D.32508;
  long int D.32509;
  void * tid.484;
  struct FILE * log_file.485;
  struct MonoGHashTable * thread_to_tls.486;
  struct MonoGHashTable * tid_to_thread_obj.487;
  unsigned int debugger_tls_id.488;
  _Bool D.32519;
  long int D.32520;
  long int D.32521;
  void * D.32526;
  struct MonoInternalThread * * D.32527;
  struct MonoThread * D.32530;
  struct MonoInternalThread * thread;
  struct MonoInternalThread * old_thread;
  struct DebuggerTlsData * tls;

  thread = mono_thread_internal_current ();
  debugger_thread_id.480 = debugger_thread_id;
  if (tid == debugger_thread_id.480) goto <D.32491>; else goto <D.32492>;
  <D.32491>:
  return;
  <D.32492>:
  D.32493 = thread->tid;
  D.32494 = (long long unsigned int) tid;
  D.32495 = D.32493 != D.32494;
  D.32496 = (long int) D.32495;
  D.32497 = __builtin_expect (D.32496, 0);
  if (D.32497 != 0) goto <D.32498>; else goto <D.32499>;
  <D.32498>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 3789, "thread->tid == tid");
  <D.32499>:
  mono_loader_lock ();
  tid.481 = (const void *) tid;
  tid_to_thread.482 = tid_to_thread;
  old_thread = mono_g_hash_table_lookup (tid_to_thread.482, tid.481);
  mono_loader_unlock ();
  if (old_thread != 0B) goto <D.32502>; else goto <D.32503>;
  <D.32502>:
  if (thread == old_thread) goto <D.32504>; else goto <D.32505>;
  <D.32504>:
  log_level.483 = log_level;
  D.32507 = log_level.483 > 0;
  D.32508 = (long int) D.32507;
  D.32509 = __builtin_expect (D.32508, 0);
  if (D.32509 != 0) goto <D.32510>; else goto <D.32511>;
  <D.32510>:
  tid.484 = (void *) tid;
  tid.484 = (void *) tid;
  log_file.485 = log_file;
  fprintf (log_file.485, "[%p] thread_start () called multiple times for %p, ignored.\n", tid.484, tid.484);
  log_file.485 = log_file;
  fflush (log_file.485);
  <D.32511>:
  return;
  <D.32505>:
  log_level.483 = log_level;
  D.32507 = log_level.483 > 0;
  D.32508 = (long int) D.32507;
  D.32509 = __builtin_expect (D.32508, 0);
  if (D.32509 != 0) goto <D.32514>; else goto <D.32515>;
  <D.32514>:
  tid.484 = (void *) tid;
  tid.484 = (void *) tid;
  log_file.485 = log_file;
  fprintf (log_file.485, "[%p] Removing stale data for tid %p.\n", tid.484, tid.484);
  log_file.485 = log_file;
  fflush (log_file.485);
  <D.32515>:
  mono_loader_lock ();
  thread_to_tls.486 = thread_to_tls;
  mono_g_hash_table_remove (thread_to_tls.486, old_thread);
  tid.481 = (const void *) tid;
  tid_to_thread.482 = tid_to_thread;
  mono_g_hash_table_remove (tid_to_thread.482, tid.481);
  tid.481 = (const void *) tid;
  tid_to_thread_obj.487 = tid_to_thread_obj;
  mono_g_hash_table_remove (tid_to_thread_obj.487, tid.481);
  mono_loader_unlock ();
  <D.32503>:
  debugger_tls_id.488 = debugger_tls_id;
  tls = pthread_getspecific (debugger_tls_id.488);
  D.32519 = tls != 0B;
  D.32520 = (long int) D.32519;
  D.32521 = __builtin_expect (D.32520, 0);
  if (D.32521 != 0) goto <D.32522>; else goto <D.32523>;
  <D.32522>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 3817, "!tls");
  <D.32523>:
  tls = monoeg_malloc0 (392);
  if (0 != 0) goto <D.32524>; else goto <D.32525>;
  <D.32524>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 3820, "sizeof (tls->thread) == sizeof (MonoObject*)");
  <D.32525>:
  D.32526 = mono_gc_make_root_descr_all_refs (1);
  D.32527 = &tls->thread;
  mono_gc_register_root (D.32527, 4, D.32526);
  tls->thread = thread;
  debugger_tls_id.488 = debugger_tls_id;
  mono_native_tls_set_value (debugger_tls_id.488, tls);
  log_level.483 = log_level;
  D.32507 = log_level.483 > 0;
  D.32508 = (long int) D.32507;
  D.32509 = __builtin_expect (D.32508, 0);
  if (D.32509 != 0) goto <D.32528>; else goto <D.32529>;
  <D.32528>:
  tid.484 = (void *) tid;
  log_file.485 = log_file;
  fprintf (log_file.485, "[%p] Thread started, obj=%p, tls=%p.\n", tid.484, thread, tls);
  log_file.485 = log_file;
  fflush (log_file.485);
  <D.32529>:
  mono_loader_lock ();
  thread_to_tls.486 = thread_to_tls;
  mono_g_hash_table_insert (thread_to_tls.486, thread, tls);
  tid.484 = (void *) tid;
  tid_to_thread.482 = tid_to_thread;
  mono_g_hash_table_insert (tid_to_thread.482, tid.484, thread);
  D.32530 = mono_thread_current ();
  tid.484 = (void *) tid;
  tid_to_thread_obj.487 = tid_to_thread_obj;
  mono_g_hash_table_insert (tid_to_thread_obj.487, tid.484, D.32530);
  mono_loader_unlock ();
  process_profiler_event (2, thread);
  suspend_current ();
}


mono_native_tls_set_value (pthread_key_t key, void * value)
{
  int D.32532;
  int D.32533;
  _Bool D.32534;

  D.32533 = pthread_setspecific (key, value);
  D.32534 = D.32533 == 0;
  D.32532 = (int) D.32534;
  return D.32532;
}


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

  clear_breakpoints_for_domain (domain);
  mono_loader_lock ();
  thread_to_tls.489 = thread_to_tls;
  mono_g_hash_table_foreach (thread_to_tls.489, 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.490;
  void * * D.32540;
  unsigned int i.491;
  unsigned int D.32542;
  void * * D.32543;
  struct GPtrArray * D.32544;
  void * * D.32545;
  unsigned int j.492;
  unsigned int D.32547;
  void * * D.32548;
  struct MonoDomain * D.32549;
  unsigned int j.493;
  unsigned int D.32554;
  unsigned int i.494;
  unsigned int D.32556;
  int i;
  int j;

  breakpoints.490 = breakpoints;
  if (breakpoints.490 == 0B) goto <D.32538>; else goto <D.32539>;
  <D.32538>:
  return;
  <D.32539>:
  mono_loader_lock ();
  i = 0;
  goto <D.25915>;
  <D.25914>:
  {
    struct MonoBreakpoint * bp;

    breakpoints.490 = breakpoints;
    D.32540 = breakpoints.490->pdata;
    i.491 = (unsigned int) i;
    D.32542 = i.491 * 4;
    D.32543 = D.32540 + D.32542;
    bp = *D.32543;
    j = 0;
    goto <D.25912>;
    <D.25911>:
    {
      struct BreakpointInstance * inst;

      D.32544 = bp->children;
      D.32545 = D.32544->pdata;
      j.492 = (unsigned int) j;
      D.32547 = j.492 * 4;
      D.32548 = D.32545 + D.32547;
      inst = *D.32548;
      D.32549 = inst->domain;
      if (D.32549 == domain) goto <D.32550>; else goto <D.32551>;
      <D.32550>:
      remove_breakpoint (inst);
      monoeg_g_free (inst);
      j.493 = (unsigned int) j;
      D.32544 = bp->children;
      monoeg_g_ptr_array_remove_index_fast (D.32544, j.493);
      goto <D.32553>;
      <D.32551>:
      j = j + 1;
      <D.32553>:
    }
    <D.25912>:
    j.493 = (unsigned int) j;
    D.32544 = bp->children;
    D.32554 = D.32544->len;
    if (j.493 < D.32554) goto <D.25911>; else goto <D.25913>;
    <D.25913>:
  }
  i = i + 1;
  <D.25915>:
  i.494 = (unsigned int) i;
  breakpoints.490 = breakpoints;
  D.32556 = breakpoints.490->len;
  if (i.494 < D.32556) goto <D.25914>; else goto <D.25916>;
  <D.25916>:
  mono_loader_unlock ();
}


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

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


runtime_initialized (struct MonoProfiler * prof)
{
  struct MonoThread * D.32559;
  int D.32560;

  D.32559 = mono_thread_current ();
  process_profiler_event (0, D.32559);
  D.32560 = agent_config.defer;
  if (D.32560 != 0) goto <D.32561>; else goto <D.32562>;
  <D.32561>:
  start_debugger_thread ();
  <D.32562>:
}


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

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


mono_debugger_agent_cleanup ()
{
  int inited.496;

  inited.496 = inited;
  if (inited.496 == 0) goto <D.32565>; else goto <D.32566>;
  <D.32565>:
  return;
  <D.32566>:
  stop_debugger_thread ();
  breakpoints_cleanup ();
  objrefs_cleanup ();
  ids_cleanup ();
  pthread_mutex_destroy (&debugger_thread_exited_mutex);
}


stop_debugger_thread ()
{
  int inited.497;
  unsigned int D.32571;
  unsigned int debugger_thread_id.498;
  int debugger_thread_exited.499;

  inited.497 = inited;
  if (inited.497 == 0) goto <D.32569>; else goto <D.32570>;
  <D.32569>:
  return;
  <D.32570>:
  transport_close1 ();
  D.32571 = GetCurrentThreadId ();
  debugger_thread_id.498 = debugger_thread_id;
  if (D.32571 != debugger_thread_id.498) goto <D.32573>; else goto <D.32574>;
  <D.32573>:
  <D.24968>:
  pthread_mutex_lock (&debugger_thread_exited_mutex);
  debugger_thread_exited.499 = debugger_thread_exited;
  if (debugger_thread_exited.499 == 0) goto <D.32576>; else goto <D.32577>;
  <D.32576>:
  pthread_cond_wait (&debugger_thread_exited_cond, &debugger_thread_exited_mutex);
  <D.32577>:
  pthread_mutex_unlock (&debugger_thread_exited_mutex);
  debugger_thread_exited.499 = debugger_thread_exited;
  if (debugger_thread_exited.499 == 0) goto <D.24968>; else goto <D.24969>;
  <D.24969>:
  <D.32574>:
  transport_close2 ();
}


transport_close1 ()
{
  struct DebuggerTransport * transport.500;
  void (*<T7b9>) (void) D.32580;

  transport.500 = transport;
  D.32580 = transport.500->close1;
  D.32580 ();
}


breakpoints_cleanup ()
{
  struct GPtrArray * event_requests.501;
  void * * D.32582;
  unsigned int i.502;
  unsigned int D.32584;
  void * * D.32585;
  int D.32586;
  void * D.32589;
  unsigned int i.503;
  unsigned int D.32592;
  struct GPtrArray * breakpoints.504;
  void * * D.32594;
  void * * D.32595;
  void * D.32596;
  unsigned int D.32597;
  struct GHashTable * bp_locs.505;
  int i;

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

    event_requests.501 = event_requests;
    D.32582 = event_requests.501->pdata;
    i.502 = (unsigned int) i;
    D.32584 = i.502 * 4;
    D.32585 = D.32582 + D.32584;
    req = *D.32585;
    D.32586 = req->event_kind;
    if (D.32586 == 10) goto <D.32587>; else goto <D.32588>;
    <D.32587>:
    D.32589 = req->info;
    clear_breakpoint (D.32589);
    i.503 = (unsigned int) i;
    event_requests.501 = event_requests;
    monoeg_g_ptr_array_remove_index_fast (event_requests.501, i.503);
    monoeg_g_free (req);
    goto <D.32591>;
    <D.32588>:
    i = i + 1;
    <D.32591>:
  }
  <D.25899>:
  i.503 = (unsigned int) i;
  event_requests.501 = event_requests;
  D.32592 = event_requests.501->len;
  if (i.503 < D.32592) goto <D.25898>; else goto <D.25900>;
  <D.25900>:
  i = 0;
  goto <D.25902>;
  <D.25901>:
  breakpoints.504 = breakpoints;
  D.32594 = breakpoints.504->pdata;
  i.502 = (unsigned int) i;
  D.32584 = i.502 * 4;
  D.32595 = D.32594 + D.32584;
  D.32596 = *D.32595;
  monoeg_g_free (D.32596);
  i = i + 1;
  <D.25902>:
  i.503 = (unsigned int) i;
  breakpoints.504 = breakpoints;
  D.32597 = breakpoints.504->len;
  if (i.503 < D.32597) goto <D.25901>; else goto <D.25903>;
  <D.25903>:
  breakpoints.504 = breakpoints;
  monoeg_g_ptr_array_free (breakpoints.504, 1);
  bp_locs.505 = bp_locs;
  monoeg_g_hash_table_destroy (bp_locs.505);
  breakpoints = 0B;
  bp_locs = 0B;
  mono_loader_unlock ();
}


objrefs_cleanup ()
{
  struct GHashTable * objrefs.506;

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


ids_cleanup ()
{
  struct GPtrArray * D.32600;
  void * * D.32603;
  unsigned int j.507;
  unsigned int D.32605;
  void * * D.32606;
  void * D.32607;
  unsigned int j.508;
  unsigned int D.32609;
  int i;
  int j;

  i = 0;
  goto <D.25172>;
  <D.25171>:
  D.32600 = ids[i];
  if (D.32600 != 0B) goto <D.32601>; else goto <D.32602>;
  <D.32601>:
  j = 0;
  goto <D.25169>;
  <D.25168>:
  D.32600 = ids[i];
  D.32603 = D.32600->pdata;
  j.507 = (unsigned int) j;
  D.32605 = j.507 * 4;
  D.32606 = D.32603 + D.32605;
  D.32607 = *D.32606;
  monoeg_g_free (D.32607);
  j = j + 1;
  <D.25169>:
  j.508 = (unsigned int) j;
  D.32600 = ids[i];
  D.32609 = D.32600->len;
  if (j.508 < D.32609) goto <D.25168>; else goto <D.25170>;
  <D.25170>:
  D.32600 = ids[i];
  monoeg_g_ptr_array_free (D.32600, 1);
  <D.32602>:
  ids[i] = 0B;
  i = i + 1;
  <D.25172>:
  if (i <= 6) goto <D.25171>; else goto <D.25173>;
  <D.25173>:
}


transport_init ()
{
  int D.24928;
  const char * D.32610;
  char * D.32611;
  int ntransports.509;
  struct _IO_FILE * stderr.510;
  const char * iftmp.511;
  struct DebuggerTransport * transport.512;
  int i;

  register_socket_transport ();
  i = 0;
  goto <D.24931>;
  <D.24930>:
  {
    size_t __s1_len;
    size_t __s2_len;

    D.32610 = transports[i].name;
    D.32611 = agent_config.transport;
    D.24928 = __builtin_strcmp (D.32611, D.32610);
  }
  if (D.24928 == 0) goto <D.24929>; else goto <D.32612>;
  <D.32612>:
  i = i + 1;
  <D.24931>:
  ntransports.509 = ntransports;
  if (i < ntransports.509) goto <D.24930>; else goto <D.24929>;
  <D.24929>:
  ntransports.509 = ntransports;
  if (i == ntransports.509) goto <D.32614>; else goto <D.32615>;
  <D.32614>:
  stderr.510 = stderr;
  fprintf (stderr.510, "debugger-agent: The supported values for the \'transport\' option are: ");
  i = 0;
  goto <D.24933>;
  <D.24932>:
  D.32610 = transports[i].name;
  if (i > 0) goto <D.32618>; else goto <D.32619>;
  <D.32618>:
  iftmp.511 = ", ";
  goto <D.32620>;
  <D.32619>:
  iftmp.511 = "";
  <D.32620>:
  stderr.510 = stderr;
  fprintf (stderr.510, "%s\'%s\'", iftmp.511, D.32610);
  i = i + 1;
  <D.24933>:
  ntransports.509 = ntransports;
  if (i < ntransports.509) goto <D.24932>; else goto <D.24934>;
  <D.24934>:
  stderr.510 = stderr;
  fprintf (stderr.510, "\n");
  exit (1);
  <D.32615>:
  transport.512 = &transports[i];
  transport = transport.512;
}


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)
{
  int D.32622;
  unsigned int D.32623;
  sizetype total.513;
  void * D.32625;
  int D.32628;
  int * D.32634;
  int D.32635;
  unsigned int D.32639;
  int last_keepalive.514;
  int D.32641;
  _Bool D.32646;
  _Bool D.32647;
  _Bool D.32648;
  int D.32651;
  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.24846>:
  again:
  D.32622 = len - total;
  D.32623 = (unsigned int) D.32622;
  total.513 = (sizetype) total;
  D.32625 = buf + total.513;
  res = recv (fd, D.32625, D.32623, flags);
  if (res > 0) goto <D.32626>; else goto <D.32627>;
  <D.32626>:
  total = total + res;
  <D.32627>:
  D.32628 = agent_config.keepalive;
  if (D.32628 != 0) goto <D.32629>; else goto <D.32630>;
  <D.32629>:
  {
    gboolean need_keepalive;

    need_keepalive = 0;
    if (res == -1) goto <D.32633>; else goto <D.32631>;
    <D.32633>:
    D.32634 = __errno_location ();
    D.32635 = *D.32634;
    if (D.32635 == 11) goto <D.32636>; else goto <D.32631>;
    <D.32636>:
    need_keepalive = 1;
    goto <D.32632>;
    <D.32631>:
    if (res == -1) goto <D.32637>; else goto <D.32638>;
    <D.32637>:
    D.32639 = mono_msec_ticks ();
    msecs = (gint32) D.32639;
    last_keepalive.514 = last_keepalive;
    D.32641 = msecs - last_keepalive.514;
    D.32628 = agent_config.keepalive;
    if (D.32641 >= D.32628) goto <D.32642>; else goto <D.32643>;
    <D.32642>:
    need_keepalive = 1;
    last_keepalive = msecs;
    <D.32643>:
    <D.32638>:
    <D.32632>:
    if (need_keepalive != 0) goto <D.32644>; else goto <D.32645>;
    <D.32644>:
    process_profiler_event (14, 0B);
    goto again;
    <D.32645>:
  }
  <D.32630>:
  D.32646 = res > 0;
  D.32647 = total < len;
  D.32648 = D.32646 & D.32647;
  if (D.32648 != 0) goto <D.24846>; else goto <D.32649>;
  <D.32649>:
  if (res == -1) goto <D.32650>; else goto <D.24847>;
  <D.32650>:
  D.32634 = __errno_location ();
  D.32635 = *D.32634;
  if (D.32635 == 4) goto <D.24846>; else goto <D.24847>;
  <D.24847>:
  D.32651 = total;
  return D.32651;
}


recv (int __fd, void * __buf, size_t __n, int __flags)
{
  unsigned int D.32653;
  int D.32656;
  ssize_t D.32659;
  unsigned int D.32660;
  unsigned int D.32661;
  unsigned int D.32664;

  D.32653 = __builtin_object_size (__buf, 0);
  if (D.32653 != 4294967295) goto <D.32654>; else goto <D.32655>;
  <D.32654>:
  D.32656 = __builtin_constant_p (__n);
  if (D.32656 == 0) goto <D.32657>; else goto <D.32658>;
  <D.32657>:
  D.32660 = __builtin_object_size (__buf, 0);
  D.32659 = __recv_chk (__fd, __buf, __n, D.32660, __flags);
  return D.32659;
  <D.32658>:
  D.32661 = __builtin_object_size (__buf, 0);
  if (D.32661 < __n) goto <D.32662>; else goto <D.32663>;
  <D.32662>:
  D.32664 = __builtin_object_size (__buf, 0);
  D.32659 = __recv_chk_warn (__fd, __buf, __n, D.32664, __flags);
  return D.32659;
  <D.32663>:
  <D.32655>:
  D.32659 = __recv_alias (__fd, __buf, __n, __flags);
  return D.32659;
}


socket_transport_send (void * data, int len)
{
  unsigned int len.515;
  int conn_fd.516;
  int * D.32669;
  int D.32670;
  gboolean D.32673;
  int res;

  <D.24861>:
  len.515 = (unsigned int) len;
  conn_fd.516 = conn_fd;
  res = send (conn_fd.516, data, len.515, 0);
  if (res == -1) goto <D.32668>; else goto <D.24862>;
  <D.32668>:
  D.32669 = __errno_location ();
  D.32670 = *D.32669;
  if (D.32670 == 4) goto <D.24861>; else goto <D.24862>;
  <D.24862>:
  if (res != len) goto <D.32671>; else goto <D.32672>;
  <D.32671>:
  D.32673 = 0;
  return D.32673;
  <D.32672>:
  D.32673 = 1;
  return D.32673;
}


socket_transport_close2 ()
{
  int conn_fd.517;

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


socket_transport_close1 ()
{
  int conn_fd.518;
  int listen_fd.519;

  conn_fd.518 = conn_fd;
  shutdown (conn_fd.518, 0);
  listen_fd.519 = listen_fd;
  shutdown (listen_fd.519, 2);
  listen_fd.519 = listen_fd;
  close (listen_fd.519);
}


socket_transport_connect (const char * address)
{
  char * D.32678;
  _Bool D.32681;
  long int D.32682;
  long int D.32683;
  char * host.520;
  int port.521;
  const char * D.32693;
  struct _IO_FILE * stderr.522;
  int D.32695;
  _Bool D.32700;
  long int D.32701;
  long int D.32702;
  int * D.32707;
  int D.32708;
  char * D.32709;
  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.32710;
  short unsigned int D.24879;
  int D.32713;
  int D.32714;
  short unsigned int D.32717;
  signed short D.32718;
  int D.32719;
  signed short D.32720;
  signed short D.32721;
  int port.523;
  int D.32725;
  int D.32726;
  int D.32727;
  int D.32730;
  unsigned int D.32733;
  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.32734;
  struct sockaddr * D.32735;
  struct addrinfo * result.524;
  int D.32741;
  int log_level.525;
  _Bool D.32745;
  long int D.32746;
  long int D.32747;
  int D.32750;
  struct FILE * log_file.526;
  int D.32754;
  long int D.24890;
  long int iftmp.527;
  int D.32756;
  long int iftmp.528;
  unsigned int __d.529;
  long int D.32765;
  long int D.32766;
  int D.32767;
  long int D.32768;
  long int D.32769;
  int D.32770;
  int conn_fd.530;
  int conn_fd.531;
  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.32782;
  int D.32783;
  int D.32787;
  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.32678 = agent_config.address;
      if (D.32678 != 0B) goto <D.32679>; else goto <D.32680>;
      <D.32679>:
      D.32678 = agent_config.address;
      res = parse_address (D.32678, &host, &port);
      D.32681 = res != 0;
      D.32682 = (long int) D.32681;
      D.32683 = __builtin_expect (D.32682, 0);
      if (D.32683 != 0) goto <D.32684>; else goto <D.32685>;
      <D.32684>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 1177, "res == 0");
      <D.32685>:
      goto <D.32686>;
      <D.32680>:
      host = 0B;
      port = 0;
      <D.32686>:
      conn_fd = -1;
      listen_fd = -1;
      host.520 = host;
      if (host.520 != 0B) goto <D.32688>; else goto <D.32689>;
      <D.32688>:
      port.521 = port;
      sprintf (&port_string, "%d", port.521);
      mono_network_init ();
      memset (&hints, 0, 32);
      hints.ai_family = 0;
      hints.ai_socktype = 1;
      hints.ai_flags = 0;
      hints.ai_protocol = 0;
      host.520 = host;
      s = getaddrinfo (host.520, &port_string, &hints, &result);
      if (s != 0) goto <D.32691>; else goto <D.32692>;
      <D.32691>:
      D.32693 = gai_strerror (s);
      port.521 = port;
      host.520 = host;
      stderr.522 = stderr;
      fprintf (stderr.522, "debugger-agent: Unable to resolve %s:%d: %s\n", host.520, port.521, D.32693);
      exit (1);
      <D.32692>:
      <D.32689>:
      D.32695 = agent_config.server;
      if (D.32695 != 0) goto <D.32696>; else goto <D.32697>;
      <D.32696>:
      host.520 = host;
      if (host.520 == 0B) goto <D.32698>; else goto <D.32699>;
      <D.32698>:
      {
        struct sockaddr_in addr;
        socklen_t addrlen;

        try
          {
            sfd = socket (2, 1, 0);
            D.32700 = sfd == 0;
            D.32701 = (long int) D.32700;
            D.32702 = __builtin_expect (D.32701, 0);
            if (D.32702 != 0) goto <D.32703>; else goto <D.32704>;
            <D.32703>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 1222, "sfd");
            <D.32704>:
            res = listen (sfd, 16);
            if (res == -1) goto <D.32705>; else goto <D.32706>;
            <D.32705>:
            D.32707 = __errno_location ();
            D.32708 = *D.32707;
            D.32709 = strerror (D.32708);
            stderr.522 = stderr;
            fprintf (stderr.522, "debugger-agent: Unable to setup listening socket: %s\n", D.32709);
            exit (1);
            <D.32706>:
            listen_fd = sfd;
            addrlen = 16;
            memset (&addr, 0, 16);
            D.32710.__sockaddr__ = &addr;
            res = getsockname (sfd, D.32710, &addrlen);
            D.32681 = res != 0;
            D.32682 = (long int) D.32681;
            D.32683 = __builtin_expect (D.32682, 0);
            if (D.32683 != 0) goto <D.32711>; else goto <D.32712>;
            <D.32711>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 1235, "res == 0");
            <D.32712>:
            host = "127.0.0.1";
            {
              short unsigned int __v;
              short unsigned int __x;

              __x = addr.sin_port;
              {
                D.32713 = (int) __x;
                D.32714 = __builtin_constant_p (D.32713);
                if (D.32714 != 0) goto <D.32715>; else goto <D.32716>;
                <D.32715>:
                D.32717 = __x >> 8;
                D.32718 = (signed short) D.32717;
                D.32713 = (int) __x;
                D.32719 = D.32713 << 8;
                D.32720 = (signed short) D.32719;
                D.32721 = D.32718 | D.32720;
                __v = (short unsigned int) D.32721;
                goto <D.32722>;
                <D.32716>:
                __asm__("rorw $8, %w0" : "=r" __v : "0" __x : "cc");
                <D.32722>:
              }
              D.24879 = __v;
            }
            port.523 = (int) D.24879;
            port = port.523;
            port.521 = port;
            host.520 = host;
            printf ("%s:%d\n", host.520, port.521);
          }
        finally
          {
            addr = {CLOBBER};
            addrlen = {CLOBBER};
          }
      }
      goto <D.32724>;
      <D.32699>:
      rp = result;
      goto <D.24884>;
      <D.24883>:
      {
        int n;

        try
          {
            n = 1;
            D.32725 = rp->ai_protocol;
            D.32726 = rp->ai_socktype;
            D.32727 = rp->ai_family;
            sfd = socket (D.32727, D.32726, D.32725);
            if (sfd == -1) goto <D.32728>; else goto <D.32729>;
            <D.32728>:
            // predicted unlikely by continue predictor.
            goto <D.24881>;
            <D.32729>:
            D.32730 = setsockopt (sfd, 1, 2, &n, 4);
            if (D.32730 == -1) goto <D.32731>; else goto <D.32732>;
            <D.32731>:
            // predicted unlikely by continue predictor.
            goto <D.24881>;
            <D.32732>:
            D.32733 = rp->ai_addrlen;
            D.32735 = rp->ai_addr;
            D.32734.__sockaddr__ = D.32735;
            res = bind (sfd, D.32734, D.32733);
            if (res == -1) goto <D.32736>; else goto <D.32737>;
            <D.32736>:
            // predicted unlikely by continue predictor.
            goto <D.24881>;
            <D.32737>:
            res = listen (sfd, 16);
            if (res == -1) goto <D.32738>; else goto <D.32739>;
            <D.32738>:
            // predicted unlikely by continue predictor.
            goto <D.24881>;
            <D.32739>:
            listen_fd = sfd;
            goto <D.24882>;
          }
        finally
          {
            n = {CLOBBER};
          }
      }
      <D.24881>:
      rp = rp->ai_next;
      <D.24884>:
      if (rp != 0B) goto <D.24883>; else goto <D.24882>;
      <D.24882>:
      result.524 = result;
      freeaddrinfo (result.524);
      <D.32724>:
      D.32741 = agent_config.defer;
      if (D.32741 != 0) goto <D.32742>; else goto <D.32743>;
      <D.32742>:
      return;
      <D.32743>:
      log_level.525 = log_level;
      D.32745 = log_level.525 > 0;
      D.32746 = (long int) D.32745;
      D.32747 = __builtin_expect (D.32746, 0);
      if (D.32747 != 0) goto <D.32748>; else goto <D.32749>;
      <D.32748>:
      D.32750 = agent_config.timeout;
      port.521 = port;
      host.520 = host;
      log_file.526 = log_file;
      fprintf (log_file.526, "Listening on %s:%d (timeout=%d ms)...\n", host.520, port.521, D.32750);
      log_file.526 = log_file;
      fflush (log_file.526);
      <D.32749>:
      D.32750 = agent_config.timeout;
      if (D.32750 != 0) goto <D.32752>; else goto <D.32753>;
      <D.32752>:
      {
        struct fd_set readfds;
        struct timeval tv;

        try
          {
            tv.tv_sec = 0;
            D.32750 = agent_config.timeout;
            D.32754 = D.32750 * 1000;
            tv.tv_usec = D.32754;
            {
              int __d0;
              int __d1;

              __asm__ __volatile__("cld; rep; stosl" : "=c" __d0, "=D" __d1 : "a" 0, "0" 32, "1" &readfds.fds_bits[0] : "memory");
            }
            {
              long int __d;

              __d = sfd;
              D.32756 = __builtin_constant_p (__d);
              if (D.32756 != 0) goto <D.32757>; else goto <D.32758>;
              <D.32757>:
              __d.529 = (unsigned int) __d;
              if (__d.529 <= 1023) goto <D.32761>; else goto <D.32762>;
              <D.32761>:
              iftmp.528 = __d / 32;
              goto <D.32763>;
              <D.32762>:
              iftmp.528 = __fdelt_warn (__d);
              <D.32763>:
              iftmp.527 = iftmp.528;
              goto <D.32764>;
              <D.32758>:
              iftmp.527 = __fdelt_chk (__d);
              <D.32764>:
              D.24890 = iftmp.527;
            }
            D.32765 = D.24890;
            D.32766 = readfds.fds_bits[D.32765];
            D.32767 = sfd % 32;
            D.32768 = 1 << D.32767;
            D.32769 = D.32766 | D.32768;
            readfds.fds_bits[D.32765] = D.32769;
            D.32770 = sfd + 1;
            res = select (D.32770, &readfds, 0B, 0B, &tv);
            if (res == 0) goto <D.32771>; else goto <D.32772>;
            <D.32771>:
            stderr.522 = stderr;
            fprintf (stderr.522, "debugger-agent: Timed out waiting to connect.\n");
            exit (1);
            <D.32772>:
          }
        finally
          {
            readfds = {CLOBBER};
            tv = {CLOBBER};
          }
      }
      <D.32753>:
      conn_fd.530 = socket_transport_accept (sfd);
      conn_fd = conn_fd.530;
      conn_fd.531 = conn_fd;
      if (conn_fd.531 == -1) goto <D.32775>; else goto <D.32776>;
      <D.32775>:
      exit (1);
      <D.32776>:
      log_level.525 = log_level;
      D.32745 = log_level.525 > 0;
      D.32746 = (long int) D.32745;
      D.32747 = __builtin_expect (D.32746, 0);
      if (D.32747 != 0) goto <D.32777>; else goto <D.32778>;
      <D.32777>:
      conn_fd.531 = conn_fd;
      log_file.526 = log_file;
      fprintf (log_file.526, "Accepted connection from client, socket fd=%d.\n", conn_fd.531);
      log_file.526 = log_file;
      fflush (log_file.526);
      <D.32778>:
      goto <D.32779>;
      <D.32697>:
      rp = result;
      goto <D.24894>;
      <D.24893>:
      D.32725 = rp->ai_protocol;
      D.32726 = rp->ai_socktype;
      D.32727 = rp->ai_family;
      sfd = socket (D.32727, D.32726, D.32725);
      if (sfd == -1) goto <D.32780>; else goto <D.32781>;
      <D.32780>:
      // predicted unlikely by continue predictor.
      goto <D.24891>;
      <D.32781>:
      D.32733 = rp->ai_addrlen;
      D.32735 = rp->ai_addr;
      D.32782.__sockaddr__ = D.32735;
      D.32783 = connect (sfd, D.32782, D.32733);
      if (D.32783 != -1) goto <D.24892>; else goto <D.32784>;
      <D.32784>:
      close (sfd);
      <D.24891>:
      rp = rp->ai_next;
      <D.24894>:
      if (rp != 0B) goto <D.24893>; else goto <D.24892>;
      <D.24892>:
      if (rp == 0B) goto <D.32785>; else goto <D.32786>;
      <D.32785>:
      port.521 = port;
      host.520 = host;
      stderr.522 = stderr;
      fprintf (stderr.522, "debugger-agent: Unable to connect to %s:%d\n", host.520, port.521);
      exit (1);
      <D.32786>:
      conn_fd = sfd;
      result.524 = result;
      freeaddrinfo (result.524);
      <D.32779>:
      D.32787 = transport_handshake ();
      if (D.32787 == 0) goto <D.32788>; else goto <D.32789>;
      <D.32788>:
      exit (1);
      <D.32789>:
    }
  finally
    {
      hints = {CLOBBER};
      result = {CLOBBER};
      port_string = {CLOBBER};
      host = {CLOBBER};
      port = {CLOBBER};
    }
}


register_transport (struct DebuggerTransport * trans)
{
  int ntransports.532;
  _Bool D.32796;
  long int D.32797;
  long int D.32798;
  struct DebuggerTransport * D.32801;
  int ntransports.533;

  ntransports.532 = ntransports;
  D.32796 = ntransports.532 > 15;
  D.32797 = (long int) D.32796;
  D.32798 = __builtin_expect (D.32797, 0);
  if (D.32798 != 0) goto <D.32799>; else goto <D.32800>;
  <D.32799>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 1419, "ntransports < MAX_TRANSPORTS");
  <D.32800>:
  ntransports.532 = ntransports;
  D.32801 = &transports[ntransports.532];
  memcpy (D.32801, trans, 24);
  ntransports.532 = ntransports;
  ntransports.533 = ntransports.532 + 1;
  ntransports = ntransports.533;
}


mono_native_tls_alloc (pthread_key_t * key, void * destructor)
{
  int D.32803;
  void (*<Tbf>) (void *) destructor.534;
  int D.32805;
  _Bool D.32806;

  destructor.534 = (void (*<Tbf>) (void *)) destructor;
  D.32805 = pthread_key_create (key, destructor.534);
  D.32806 = D.32805 == 0;
  D.32803 = (int) D.32806;
  return D.32803;
}


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

  i = 0;
  goto <D.25161>;
  <D.25160>:
  D.32808 = monoeg_g_ptr_array_new ();
  ids[i] = D.32808;
  i = i + 1;
  <D.25161>:
  if (i <= 6) goto <D.25160>; else goto <D.25162>;
  <D.25162>:
}


objrefs_init ()
{
  struct GHashTable * objrefs.535;

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


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

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


breakpoints_init ()
{
  struct GPtrArray * breakpoints.536;
  struct GHashTable * bp_locs.537;

  breakpoints.536 = monoeg_g_ptr_array_new ();
  breakpoints = breakpoints.536;
  bp_locs.537 = monoeg_g_hash_table_new (0B, 0B);
  bp_locs = bp_locs.537;
}


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.32813;
  char * D.32816;
  char * D.32819;
  char * D.32820;
  struct _IO_FILE * stderr.538;
  int res;

  D.32813 = InterlockedCompareExchange (&inited, 1, 0);
  if (D.32813 == 1) goto <D.32814>; else goto <D.32815>;
  <D.32814>:
  return;
  <D.32815>:
  D.32816 = agent_config.launch;
  if (D.32816 != 0B) goto <D.32817>; else goto <D.32818>;
  <D.32817>:
  {
    char * argv[16];

    try
      {
        D.32816 = agent_config.launch;
        argv[0] = D.32816;
        D.32819 = agent_config.transport;
        argv[1] = D.32819;
        D.32820 = agent_config.address;
        argv[2] = D.32820;
        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.32821>; else goto <D.32822>;
        <D.32821>:
        D.32816 = agent_config.launch;
        stderr.538 = stderr;
        fprintf (stderr.538, "Failed to execute \'%s\'.\n", D.32816);
        exit (1);
        <D.32822>:
      }
    finally
      {
        argv = {CLOBBER};
      }
  }
  <D.32818>:
  D.32820 = agent_config.address;
  transport_connect (D.32820);
  if (on_startup == 0) goto <D.32824>; else goto <D.32825>;
  <D.32824>:
  vm_start_event_sent = 1;
  start_debugger_thread ();
  <D.32825>:
}


InterlockedCompareExchange (volatile gint32 * dest, gint32 exch, gint32 comp)
{
  gint32 D.32827;
  unsigned int exch.539;
  unsigned int comp.540;
  unsigned int D.32830;

  exch.539 = (unsigned int) exch;
  comp.540 = (unsigned int) comp;
  D.32830 = __sync_val_compare_and_swap_4 (dest, comp.540, exch.539);
  D.32827 = (gint32) D.32830;
  return D.32827;
}


transport_connect (const char * address)
{
  struct DebuggerTransport * transport.541;
  void (*<T3eac>) (const char *) D.32833;

  transport.541 = transport;
  D.32833 = transport.541->connect;
  D.32833 (address);
}


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


mono_debugger_agent_transport_handshake ()
{
  gboolean D.32834;

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


mono_debugger_agent_free_domain_info (struct MonoDomain * domain)
{
  void * D.32836;
  struct GHashTable * D.32839;
  struct GHashTable * D.32842;
  struct GHashTable * D.32843;
  struct GPtrArray * file_names.542;
  void * * D.32845;
  unsigned int i.543;
  unsigned int D.32847;
  void * * D.32848;
  void * D.32849;
  unsigned int i.544;
  unsigned int D.32851;
  int D.32852;
  struct GHashTable * D.32853;
  char * basename.545;
  struct GSList * l.546;
  int D.32856;
  struct GHashTable * D.32857;
  int D.32858;
  struct GPtrArray * D.32859;
  void * * D.32862;
  unsigned int j.547;
  unsigned int D.32864;
  void * * D.32865;
  struct MonoDomain * D.32866;
  unsigned int j.548;
  unsigned int D.32870;
  struct GHashTable * domains.549;
  struct AgentDomainInfo * info;
  int i;
  int j;
  struct GHashTableIter iter;
  struct GPtrArray * file_names;
  char * basename;
  struct GSList * l;

  try
    {
      D.32836 = domain->runtime_info;
      info = MEM[(struct MonoJitDomainInfo *)D.32836].agent_info;
      if (info != 0B) goto <D.32837>; else goto <D.32838>;
      <D.32837>:
      i = 0;
      goto <D.25185>;
      <D.25184>:
      D.32839 = info->val_to_id[i];
      if (D.32839 != 0B) goto <D.32840>; else goto <D.32841>;
      <D.32840>:
      D.32839 = info->val_to_id[i];
      monoeg_g_hash_table_destroy (D.32839);
      <D.32841>:
      i = i + 1;
      <D.25185>:
      if (i <= 6) goto <D.25184>; else goto <D.25186>;
      <D.25186>:
      D.32842 = info->loaded_classes;
      monoeg_g_hash_table_destroy (D.32842);
      D.32843 = info->source_files;
      monoeg_g_hash_table_iter_init (&iter, D.32843);
      goto <D.25191>;
      <D.25190>:
      i = 0;
      goto <D.25188>;
      <D.25187>:
      file_names.542 = file_names;
      D.32845 = file_names.542->pdata;
      i.543 = (unsigned int) i;
      D.32847 = i.543 * 4;
      D.32848 = D.32845 + D.32847;
      D.32849 = *D.32848;
      monoeg_g_free (D.32849);
      i = i + 1;
      <D.25188>:
      i.544 = (unsigned int) i;
      file_names.542 = file_names;
      D.32851 = file_names.542->len;
      if (i.544 < D.32851) goto <D.25187>; else goto <D.25189>;
      <D.25189>:
      file_names.542 = file_names;
      monoeg_g_ptr_array_free (file_names.542, 1);
      <D.25191>:
      D.32852 = monoeg_g_hash_table_iter_next (&iter, 0B, &file_names);
      if (D.32852 != 0) goto <D.25190>; else goto <D.25192>;
      <D.25192>:
      D.32853 = info->source_file_to_class;
      monoeg_g_hash_table_iter_init (&iter, D.32853);
      goto <D.25194>;
      <D.25193>:
      basename.545 = basename;
      monoeg_g_free (basename.545);
      l.546 = l;
      monoeg_g_slist_free (l.546);
      <D.25194>:
      D.32856 = monoeg_g_hash_table_iter_next (&iter, &basename, &l);
      if (D.32856 != 0) goto <D.25193>; else goto <D.25195>;
      <D.25195>:
      D.32857 = info->source_file_to_class_ignorecase;
      monoeg_g_hash_table_iter_init (&iter, D.32857);
      goto <D.25197>;
      <D.25196>:
      basename.545 = basename;
      monoeg_g_free (basename.545);
      l.546 = l;
      monoeg_g_slist_free (l.546);
      <D.25197>:
      D.32858 = monoeg_g_hash_table_iter_next (&iter, &basename, &l);
      if (D.32858 != 0) goto <D.25196>; else goto <D.25198>;
      <D.25198>:
      monoeg_g_free (info);
      <D.32838>:
      D.32836 = domain->runtime_info;
      MEM[(struct MonoJitDomainInfo *)D.32836].agent_info = 0B;
      i = 0;
      goto <D.25204>;
      <D.25203>:
      D.32859 = ids[i];
      if (D.32859 != 0B) goto <D.32860>; else goto <D.32861>;
      <D.32860>:
      j = 0;
      goto <D.25201>;
      <D.25200>:
      {
        struct Id * id;

        D.32859 = ids[i];
        D.32862 = D.32859->pdata;
        j.547 = (unsigned int) j;
        D.32864 = j.547 * 4;
        D.32865 = D.32862 + D.32864;
        id = *D.32865;
        D.32866 = id->domain;
        if (D.32866 == domain) goto <D.32867>; else goto <D.32868>;
        <D.32867>:
        id->domain = 0B;
        <D.32868>:
      }
      j = j + 1;
      <D.25201>:
      j.548 = (unsigned int) j;
      D.32859 = ids[i];
      D.32870 = D.32859->len;
      if (j.548 < D.32870) goto <D.25200>; else goto <D.25202>;
      <D.25202>:
      <D.32861>:
      i = i + 1;
      <D.25204>:
      if (i <= 6) goto <D.25203>; else goto <D.25205>;
      <D.25205>:
      mono_loader_lock ();
      domains.549 = domains;
      monoeg_g_hash_table_remove (domains.549, domain);
      mono_loader_unlock ();
    }
  finally
    {
      iter = {CLOBBER};
      file_names = {CLOBBER};
      basename = {CLOBBER};
      l = {CLOBBER};
    }
}


mono_debugger_agent_thread_interrupt (void * sigctx, struct MonoJitInfo * ji)
{
  int inited.550;
  gboolean D.32875;
  unsigned int debugger_tls_id.551;
  int log_level.552;
  _Bool D.32880;
  long int D.32881;
  long int D.32882;
  unsigned int D.32885;
  void * D.32886;
  struct FILE * log_file.553;
  struct DebuggerTlsData * tls;

  inited.550 = inited;
  if (inited.550 == 0) goto <D.32873>; else goto <D.32874>;
  <D.32873>:
  D.32875 = 0;
  return D.32875;
  <D.32874>:
  debugger_tls_id.551 = debugger_tls_id;
  tls = pthread_getspecific (debugger_tls_id.551);
  if (tls == 0B) goto <D.32877>; else goto <D.32878>;
  <D.32877>:
  log_level.552 = log_level;
  D.32880 = log_level.552 > 0;
  D.32881 = (long int) D.32880;
  D.32882 = __builtin_expect (D.32881, 0);
  if (D.32882 != 0) goto <D.32883>; else goto <D.32884>;
  <D.32883>:
  D.32885 = GetCurrentThreadId ();
  D.32886 = (void *) D.32885;
  log_file.553 = log_file;
  fprintf (log_file.553, "[%p] Received interrupt with no TLS, continuing.\n", D.32886);
  log_file.553 = log_file;
  fflush (log_file.553);
  <D.32884>:
  D.32875 = 0;
  return D.32875;
  <D.32878>:
  D.32875 = thread_interrupt (tls, 0B, sigctx, ji);
  return D.32875;
}


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)
{
  int D.32889;
  struct MonoDomain * D.32890;
  _Bool D.32891;
  long int D.32892;
  long int D.32893;
  int ip.554;
  void * D.32897;
  int D.32898;
  int D.32899;
  unsigned char D.32902;
  unsigned char D.32903;
  int D.32905;
  int native_offset.555;
  struct MonoDomain * D.32907;
  _Bool D.32910;
  long int D.32911;
  long int D.32912;
  int log_level.556;
  _Bool D.32916;
  long int D.32917;
  long int D.32918;
  int iftmp.557;
  const char * D.32925;
  unsigned int D.32926;
  void * D.32927;
  struct FILE * log_file.558;
  struct GPtrArray * breakpoints.559;
  void * * D.32930;
  unsigned int i.560;
  unsigned int D.32932;
  void * * D.32933;
  struct MonoMethod * D.32934;
  struct GPtrArray * D.32937;
  void * * D.32938;
  unsigned int j.561;
  unsigned int D.32940;
  void * * D.32941;
  struct MonoJitInfo * D.32942;
  struct SeqPoint * D.32945;
  struct EventRequest * D.32948;
  int D.32949;
  unsigned int j.562;
  unsigned int D.32954;
  unsigned int i.563;
  unsigned int D.32956;
  unsigned int D.32957;
  unsigned int D.32960;
  int D.32963;
  void * * D.32969;
  void * * D.32970;
  struct MonoInternalThread * D.32971;
  struct MonoInternalThread * D.32972;
  struct MonoSeqPointInfo * info.564;
  unsigned int D.32978;
  int suspend_policy.565;
  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.32889 = ctx->eip;
      ip = (guint8 *) D.32889;
      D.32890 = mono_domain_get ();
      ji = mini_jit_info_table_find (D.32890, ip, 0B);
      D.32891 = ji == 0B;
      D.32892 = (long int) D.32891;
      D.32893 = __builtin_expect (D.32892, 0);
      if (D.32893 != 0) goto <D.32894>; else goto <D.32895>;
      <D.32894>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 4554, "ji");
      <D.32895>:
      method = jinfo_get_method (ji);
      ip.554 = (int) ip;
      D.32897 = ji->code_start;
      D.32898 = (int) D.32897;
      D.32899 = ip.554 - D.32898;
      native_offset = (guint32) D.32899;
      mono_arch_skip_breakpoint (ctx, ji);
      D.32902 = BIT_FIELD_REF <*method, 8, 160>;
      D.32903 = D.32902 & 124;
      if (D.32903 != 0) goto <D.32900>; else goto <D.32904>;
      <D.32904>:
      D.32905 = tls->disable_breakpoints;
      if (D.32905 != 0) goto <D.32900>; else goto <D.32901>;
      <D.32900>:
      return;
      <D.32901>:
      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 ();
      native_offset.555 = (int) native_offset;
      D.32907 = mono_domain_get ();
      sp = find_prev_seq_point_for_native_offset (D.32907, method, native_offset.555, &info);
      if (sp == 0B) goto <D.32908>; else goto <D.32909>;
      <D.32908>:
      no_seq_points_found (method);
      <D.32909>:
      D.32910 = sp == 0B;
      D.32911 = (long int) D.32910;
      D.32912 = __builtin_expect (D.32911, 0);
      if (D.32912 != 0) goto <D.32913>; else goto <D.32914>;
      <D.32913>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 4581, "sp");
      <D.32914>:
      log_level.556 = log_level;
      D.32916 = log_level.556 > 0;
      D.32917 = (long int) D.32916;
      D.32918 = __builtin_expect (D.32917, 0);
      if (D.32918 != 0) goto <D.32919>; else goto <D.32920>;
      <D.32919>:
      if (sp != 0B) goto <D.32922>; else goto <D.32923>;
      <D.32922>:
      iftmp.557 = sp->il_offset;
      goto <D.32924>;
      <D.32923>:
      iftmp.557 = -1;
      <D.32924>:
      D.32925 = method->name;
      D.32926 = GetCurrentThreadId ();
      D.32927 = (void *) D.32926;
      log_file.558 = log_file;
      fprintf (log_file.558, "[%p] Breakpoint hit, method=%s, ip=%p, offset=0x%x, sp il offset=0x%x.\n", D.32927, D.32925, ip, native_offset, iftmp.557);
      log_file.558 = log_file;
      fflush (log_file.558);
      <D.32920>:
      bp = 0B;
      i = 0;
      goto <D.25959>;
      <D.25958>:
      breakpoints.559 = breakpoints;
      D.32930 = breakpoints.559->pdata;
      i.560 = (unsigned int) i;
      D.32932 = i.560 * 4;
      D.32933 = D.32930 + D.32932;
      bp = *D.32933;
      D.32934 = bp->method;
      if (D.32934 == 0B) goto <D.32935>; else goto <D.32936>;
      <D.32935>:
      // predicted unlikely by continue predictor.
      goto <D.25954>;
      <D.32936>:
      j = 0;
      goto <D.25956>;
      <D.25955>:
      D.32937 = bp->children;
      D.32938 = D.32937->pdata;
      j.561 = (unsigned int) j;
      D.32940 = j.561 * 4;
      D.32941 = D.32938 + D.32940;
      inst = *D.32941;
      D.32942 = inst->ji;
      if (D.32942 == ji) goto <D.32943>; else goto <D.32944>;
      <D.32943>:
      D.32945 = inst->sp;
      if (D.32945 == sp) goto <D.32946>; else goto <D.32947>;
      <D.32946>:
      D.32948 = bp->req;
      D.32949 = D.32948->event_kind;
      if (D.32949 == 11) goto <D.32950>; else goto <D.32951>;
      <D.32950>:
      D.32948 = bp->req;
      monoeg_g_ptr_array_add (ss_reqs_orig, D.32948);
      goto <D.32952>;
      <D.32951>:
      D.32948 = bp->req;
      monoeg_g_ptr_array_add (bp_reqs, D.32948);
      <D.32952>:
      <D.32947>:
      <D.32944>:
      j = j + 1;
      <D.25956>:
      j.562 = (unsigned int) j;
      D.32937 = bp->children;
      D.32954 = D.32937->len;
      if (j.562 < D.32954) goto <D.25955>; else goto <D.25957>;
      <D.25957>:
      <D.25954>:
      i = i + 1;
      <D.25959>:
      i.563 = (unsigned int) i;
      breakpoints.559 = breakpoints;
      D.32956 = breakpoints.559->len;
      if (i.563 < D.32956) goto <D.25958>; else goto <D.25960>;
      <D.25960>:
      D.32957 = bp_reqs->len;
      if (D.32957 == 0) goto <D.32958>; else goto <D.32959>;
      <D.32958>:
      D.32960 = ss_reqs_orig->len;
      if (D.32960 == 0) goto <D.32961>; else goto <D.32962>;
      <D.32961>:
      D.32963 = sp->il_offset;
      if (D.32963 == -1) goto <D.32964>; else goto <D.32965>;
      <D.32964>:
      kind = 6;
      goto <D.32966>;
      <D.32965>:
      D.32963 = sp->il_offset;
      if (D.32963 == 16777215) goto <D.32967>; else goto <D.32968>;
      <D.32967>:
      kind = 7;
      <D.32968>:
      <D.32966>:
      <D.32962>:
      <D.32959>:
      i = 0;
      goto <D.25966>;
      <D.25965>:
      {
        struct EventRequest * req;
        struct SingleStepReq * ss_req;
        gboolean hit;

        D.32969 = ss_reqs_orig->pdata;
        i.560 = (unsigned int) i;
        D.32932 = i.560 * 4;
        D.32970 = D.32969 + D.32932;
        req = *D.32970;
        ss_req = req->info;
        D.32971 = mono_thread_internal_current ();
        D.32972 = ss_req->thread;
        if (D.32971 != D.32972) goto <D.32973>; else goto <D.32974>;
        <D.32973>:
        // predicted unlikely by continue predictor.
        goto <D.25964>;
        <D.32974>:
        hit = ss_update (ss_req, ji, sp, tls, ctx);
        if (hit != 0) goto <D.32975>; else goto <D.32976>;
        <D.32975>:
        monoeg_g_ptr_array_add (ss_reqs, req);
        <D.32976>:
        info.564 = info;
        ss_start (ss_req, method, sp, info.564, ctx, tls, 0);
      }
      <D.25964>:
      i = i + 1;
      <D.25966>:
      i.563 = (unsigned int) i;
      D.32960 = ss_reqs_orig->len;
      if (i.563 < D.32960) goto <D.25965>; else goto <D.25967>;
      <D.25967>:
      D.32978 = ss_reqs->len;
      if (D.32978 != 0) goto <D.32979>; else goto <D.32980>;
      <D.32979>:
      ss_events = create_event_list (11, ss_reqs, ji, 0B, &suspend_policy);
      <D.32980>:
      D.32957 = bp_reqs->len;
      if (D.32957 != 0) goto <D.32981>; else goto <D.32982>;
      <D.32981>:
      bp_events = create_event_list (10, bp_reqs, ji, 0B, &suspend_policy);
      <D.32982>:
      if (kind != 10) goto <D.32983>; else goto <D.32984>;
      <D.32983>:
      enter_leave_events = create_event_list (kind, 0B, ji, 0B, &suspend_policy);
      <D.32984>:
      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.32985>; else goto <D.32986>;
      <D.32985>:
      suspend_policy.565 = suspend_policy;
      process_event (11, method, 0, ctx, ss_events, suspend_policy.565);
      <D.32986>:
      if (bp_events != 0B) goto <D.32988>; else goto <D.32989>;
      <D.32988>:
      suspend_policy.565 = suspend_policy;
      process_event (kind, method, 0, ctx, bp_events, suspend_policy.565);
      <D.32989>:
      if (enter_leave_events != 0B) goto <D.32990>; else goto <D.32991>;
      <D.32990>:
      suspend_policy.565 = suspend_policy;
      process_event (kind, method, 0, ctx, enter_leave_events, suspend_policy.565);
      <D.32991>:
    }
  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.32995;
  int D.32998;
  int D.32999;
  int log_level.566;
  _Bool D.33003;
  long int D.33004;
  long int D.33005;
  int D.33008;
  unsigned int D.33009;
  void * D.33010;
  struct FILE * log_file.567;
  gboolean D.33012;
  int D.33017;
  struct MonoThreadUnwindState * D.33020;
  struct MonoInternalThread * D.33021;
  int D.33022;
  int D.33025;
  unsigned int D.33032;
  void * D.33033;
  <unnamed type> D.33034;
  unsigned int D.33039;
  struct SingleStepReq * ss_req.568;
  struct MonoMethod * D.33044;
  unsigned int D.33046;
  int D.33047;
  unsigned int D.33048;
  unsigned int D.33053;
  void * D.33054;
  unsigned int D.33058;
  void * D.33059;
  int D.33062;
  struct MonoDebugMethodInfo * minfo;
  struct MonoDebugSourceLocation * loc;
  gboolean hit;
  struct MonoMethod * method;

  loc = 0B;
  hit = 1;
  D.32995 = req->depth;
  if (D.32995 == 1) goto <D.32996>; else goto <D.32997>;
  <D.32996>:
  D.32998 = sp->flags;
  D.32999 = D.32998 & 1;
  if (D.32999 != 0) goto <D.33000>; else goto <D.33001>;
  <D.33000>:
  log_level.566 = log_level;
  D.33003 = log_level.566 > 0;
  D.33004 = (long int) D.33003;
  D.33005 = __builtin_expect (D.33004, 0);
  if (D.33005 != 0) goto <D.33006>; else goto <D.33007>;
  <D.33006>:
  D.33008 = sp->il_offset;
  D.33009 = GetCurrentThreadId ();
  D.33010 = (void *) D.33009;
  log_file.567 = log_file;
  fprintf (log_file.567, "[%p] Seq point at nonempty stack %x while stepping over, continuing single stepping.\n", D.33010, D.33008);
  log_file.567 = log_file;
  fflush (log_file.567);
  <D.33007>:
  D.33012 = 0;
  return D.33012;
  <D.33001>:
  <D.32997>:
  D.32995 = req->depth;
  if (D.32995 == 1) goto <D.33013>; else goto <D.33014>;
  <D.33013>:
  if (hit != 0) goto <D.33015>; else goto <D.33016>;
  <D.33015>:
  D.33017 = tls->context.valid;
  if (D.33017 == 0) goto <D.33018>; else goto <D.33019>;
  <D.33018>:
  D.33020 = &tls->context;
  mono_thread_state_init_from_monoctx (D.33020, ctx);
  <D.33019>:
  D.33021 = tls->thread;
  compute_frame_info (D.33021, tls);
  D.33022 = req->nframes;
  if (D.33022 != 0) goto <D.33023>; else goto <D.33024>;
  <D.33023>:
  D.33025 = tls->frame_count;
  if (D.33025 != 0) goto <D.33026>; else goto <D.33027>;
  <D.33026>:
  D.33025 = tls->frame_count;
  D.33022 = req->nframes;
  if (D.33025 > D.33022) goto <D.33028>; else goto <D.33029>;
  <D.33028>:
  log_level.566 = log_level;
  D.33003 = log_level.566 > 0;
  D.33004 = (long int) D.33003;
  D.33005 = __builtin_expect (D.33004, 0);
  if (D.33005 != 0) goto <D.33030>; else goto <D.33031>;
  <D.33030>:
  D.33032 = GetCurrentThreadId ();
  D.33033 = (void *) D.33032;
  log_file.567 = log_file;
  fprintf (log_file.567, "[%p] Breakpoint at lower frame while stepping over, continuing single stepping.\n", D.33033);
  log_file.567 = log_file;
  fflush (log_file.567);
  <D.33031>:
  D.33012 = 0;
  return D.33012;
  <D.33029>:
  <D.33027>:
  <D.33024>:
  <D.33016>:
  <D.33014>:
  D.33034 = req->size;
  if (D.33034 != 1) goto <D.33035>; else goto <D.33036>;
  <D.33035>:
  D.33012 = 1;
  return D.33012;
  <D.33036>:
  method = jinfo_get_method (ji);
  minfo = mono_debug_lookup_method (method);
  if (minfo != 0B) goto <D.33037>; else goto <D.33038>;
  <D.33037>:
  D.33008 = sp->il_offset;
  D.33039 = (unsigned int) D.33008;
  loc = mono_debug_symfile_lookup_location (minfo, D.33039);
  <D.33038>:
  if (loc == 0B) goto <D.33040>; else goto <D.33042>;
  <D.33042>:
  ss_req.568 = ss_req;
  D.33044 = ss_req.568->last_method;
  if (D.33044 == method) goto <D.33045>; else goto <D.33041>;
  <D.33045>:
  D.33046 = loc->row;
  ss_req.568 = ss_req;
  D.33047 = ss_req.568->last_line;
  D.33048 = (unsigned int) D.33047;
  if (D.33046 == D.33048) goto <D.33040>; else goto <D.33041>;
  <D.33040>:
  if (loc == 0B) goto <D.33049>; else goto <D.33050>;
  <D.33049>:
  log_level.566 = log_level;
  D.33003 = log_level.566 > 0;
  D.33004 = (long int) D.33003;
  D.33005 = __builtin_expect (D.33004, 0);
  if (D.33005 != 0) goto <D.33051>; else goto <D.33052>;
  <D.33051>:
  D.33008 = sp->il_offset;
  D.33053 = GetCurrentThreadId ();
  D.33054 = (void *) D.33053;
  log_file.567 = log_file;
  fprintf (log_file.567, "[%p] No line number info for il offset %x, continuing single stepping.\n", D.33054, D.33008);
  log_file.567 = log_file;
  fflush (log_file.567);
  <D.33052>:
  goto <D.33055>;
  <D.33050>:
  log_level.566 = log_level;
  D.33003 = log_level.566 > 0;
  D.33004 = (long int) D.33003;
  D.33005 = __builtin_expect (D.33004, 0);
  if (D.33005 != 0) goto <D.33056>; else goto <D.33057>;
  <D.33056>:
  D.33046 = loc->row;
  D.33058 = GetCurrentThreadId ();
  D.33059 = (void *) D.33058;
  log_file.567 = log_file;
  fprintf (log_file.567, "[%p] Same source line (%d), continuing single stepping.\n", D.33059, D.33046);
  log_file.567 = log_file;
  fflush (log_file.567);
  <D.33057>:
  <D.33055>:
  hit = 0;
  <D.33041>:
  if (loc != 0B) goto <D.33060>; else goto <D.33061>;
  <D.33060>:
  ss_req.568 = ss_req;
  ss_req.568->last_method = method;
  ss_req.568 = ss_req;
  D.33046 = loc->row;
  D.33062 = (int) D.33046;
  ss_req.568->last_line = D.33062;
  mono_debug_free_source_location (loc);
  <D.33061>:
  D.33012 = hit;
  return D.33012;
}


process_signal_event (void (*<T453a>) (struct DebuggerTlsData *) func)
{
  unsigned int debugger_tls_id.569;
  struct MonoContext * D.33065;
  struct MonoContext * D.33066;
  struct DebuggerTlsData * tls;
  struct MonoContext orig_restore_ctx;
  struct MonoContext ctx;

  try
    {
      debugger_tls_id.569 = debugger_tls_id;
      tls = pthread_getspecific (debugger_tls_id.569);
      D.33065 = &tls->restore_ctx;
      memcpy (&orig_restore_ctx, D.33065, 36);
      D.33066 = &tls->handler_ctx;
      D.33065 = &tls->restore_ctx;
      memcpy (D.33065, D.33066, 36);
      func (tls);
      D.33065 = &tls->restore_ctx;
      memcpy (&ctx, D.33065, 36);
      D.33065 = &tls->restore_ctx;
      memcpy (D.33065, &orig_restore_ctx, 36);
      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.570;
  unsigned int D.33070;
  void * D.33071;
  struct _IO_FILE * stderr.571;
  _Bool D.33073;
  long int D.33074;
  long int D.33075;
  struct MonoContext * D.33078;
  struct DebuggerTlsData * tls;
  struct MonoContext ctx;

  try
    {
      debugger_tls_id.570 = debugger_tls_id;
      tls = pthread_getspecific (debugger_tls_id.570);
      if (tls == 0B) goto <D.33068>; else goto <D.33069>;
      <D.33068>:
      D.33070 = GetCurrentThreadId ();
      D.33071 = (void *) D.33070;
      stderr.571 = stderr;
      fprintf (stderr.571, "Thread %p is not attached to the JIT.\n", D.33071);
      <D.33069>:
      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", 4690, "tls");
      <D.33077>:
      mono_arch_sigctx_to_monoctx (sigctx, &ctx);
      D.33078 = &tls->handler_ctx;
      memcpy (D.33078, &ctx, 36);
      mono_arch_setup_resume_sighandler_ctx (&ctx, func);
      mono_arch_monoctx_to_sigctx (&ctx, sigctx);
    }
  finally
    {
      ctx = {CLOBBER};
    }
}


mono_debugger_agent_user_break ()
{
  int D.33079;
  int D.33082;
  void * D.33083;
  _Bool D.33084;
  long int D.33085;
  long int D.33086;
  int suspend_policy.572;

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

    try
      {
        ctx.eip = 0;
        mono_walk_stack_with_ctx (user_break_cb, 0B, 0, &ctx);
        D.33082 = ctx.eip;
        D.33083 = (void *) D.33082;
        D.33084 = D.33083 == 0B;
        D.33085 = (long int) D.33084;
        D.33086 = __builtin_expect (D.33085, 0);
        if (D.33086 != 0) goto <D.33087>; else goto <D.33088>;
        <D.33087>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 4747, "MONO_CONTEXT_GET_IP (&ctx) != NULL");
        <D.33088>:
        mono_loader_lock ();
        events = create_event_list (15, 0B, 0B, 0B, &suspend_policy);
        mono_loader_unlock ();
        suspend_policy.572 = suspend_policy;
        process_event (15, 0B, 0, &ctx, events, suspend_policy.572);
      }
    finally
      {
        ctx = {CLOBBER};
        suspend_policy = {CLOBBER};
      }
  }
  goto <D.33090>;
  <D.33081>:
  __asm__ __volatile__("int $03");
  <D.33090>:
}


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

  D.33091 = frame->managed;
  if (D.33091 != 0) goto <D.33092>; else goto <D.33093>;
  <D.33092>:
  MEM[(struct MonoContext *)data] = *ctx;
  D.33094 = 1;
  return D.33094;
  <D.33093>:
  D.33094 = 0;
  return D.33094;
}


mono_debugger_agent_single_step_event (void * sigctx)
{
  unsigned int D.33096;
  unsigned int debugger_thread_id.573;

  D.33096 = GetCurrentThreadId ();
  debugger_thread_id.573 = debugger_thread_id;
  if (D.33096 == debugger_thread_id.573) goto <D.33098>; else goto <D.33099>;
  <D.33098>:
  {
    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.33099>:
  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)
{
  int D.33102;
  int suspend_count.574;
  struct SingleStepReq * ss_req.575;
  struct MonoInternalThread * D.33109;
  struct MonoInternalThread * D.33110;
  int log_level.576;
  struct MonoDomain * D.33116;
  _Bool D.33117;
  long int D.33118;
  long int D.33119;
  void * D.33122;
  int D.33123;
  void * D.33124;
  void * D.33125;
  struct MonoMethod * D.33126;
  char * D.33127;
  <unnamed type> D.33128;
  const char * D.33129;
  unsigned int D.33130;
  void * D.33131;
  struct FILE * log_file.577;
  struct MonoDomain * D.33133;
  _Bool D.33134;
  long int D.33135;
  long int D.33136;
  _Bool D.33139;
  long int D.33140;
  long int D.33141;
  unsigned char D.33144;
  unsigned char D.33145;
  _Bool D.33146;
  _Bool D.33147;
  _Bool D.33148;
  struct MonoClass * D.33153;
  struct MonoClass * D.33154;
  int D.26027;
  int iftmp.578;
  int D.26026;
  const char[7] * D.33160;
  unsigned char D.33161;
  int D.33162;
  unsigned char D.33163;
  int D.33164;
  _Bool D.33165;
  _Bool D.33166;
  _Bool D.33167;
  const unsigned char * D.33170;
  unsigned char D.33171;
  int D.33172;
  const unsigned char * D.33173;
  unsigned char D.33174;
  int D.33175;
  _Bool D.33176;
  _Bool D.33177;
  const unsigned char * D.33180;
  unsigned char D.33181;
  int D.33182;
  const unsigned char * D.33183;
  unsigned char D.33184;
  int D.33185;
  _Bool D.33186;
  _Bool D.33187;
  const unsigned char * D.33190;
  unsigned char D.33191;
  int D.33192;
  const unsigned char * D.33193;
  unsigned char D.33194;
  int D.33195;
  const char * D.33197;
  char * D.33199;
  int ip.579;
  void * D.33201;
  int D.33202;
  int D.33203;
  struct MonoDomain * domain.580;
  int D.33207;
  struct MonoSeqPointInfo * info.581;
  <unnamed type> D.33211;
  unsigned int D.33212;
  short unsigned int D.33215;
  int D.33216;
  int D.33217;
  int D.26036;
  int iftmp.582;
  int D.26035;
  const char[7] * D.33223;
  unsigned char D.33224;
  int D.33225;
  unsigned char D.33226;
  int D.33227;
  _Bool D.33228;
  _Bool D.33229;
  _Bool D.33230;
  const unsigned char * D.33233;
  unsigned char D.33234;
  int D.33235;
  const unsigned char * D.33236;
  unsigned char D.33237;
  int D.33238;
  _Bool D.33239;
  _Bool D.33240;
  const unsigned char * D.33243;
  unsigned char D.33244;
  int D.33245;
  const unsigned char * D.33246;
  unsigned char D.33247;
  int D.33248;
  _Bool D.33249;
  _Bool D.33250;
  const unsigned char * D.33253;
  unsigned char D.33254;
  int D.33255;
  const unsigned char * D.33256;
  unsigned char D.33257;
  int D.33258;
  struct EventRequest * D.33262;
  int suspend_policy.583;
  struct MonoMethod * D.33264;
  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.33102 = ctx->eip;
      ip = (guint8 *) D.33102;
      mono_arch_skip_single_step (ctx);
      suspend_count.574 = suspend_count;
      if (suspend_count.574 > 0) goto <D.33104>; else goto <D.33105>;
      <D.33104>:
      process_suspend (tls, ctx);
      return;
      <D.33105>:
      ss_req.575 = ss_req;
      if (ss_req.575 == 0B) goto <D.33107>; else goto <D.33108>;
      <D.33107>:
      return;
      <D.33108>:
      D.33109 = mono_thread_internal_current ();
      ss_req.575 = ss_req;
      D.33110 = ss_req.575->thread;
      if (D.33109 != D.33110) goto <D.33111>; else goto <D.33112>;
      <D.33111>:
      return;
      <D.33112>:
      log_level.576 = log_level;
      if (log_level.576 > 0) goto <D.33114>; else goto <D.33115>;
      <D.33114>:
      D.33116 = mono_domain_get ();
      ji = mini_jit_info_table_find (D.33116, ip, &domain);
      log_level.576 = log_level;
      D.33117 = log_level.576 > 0;
      D.33118 = (long int) D.33117;
      D.33119 = __builtin_expect (D.33118, 0);
      if (D.33119 != 0) goto <D.33120>; else goto <D.33121>;
      <D.33120>:
      ss_req.575 = ss_req;
      D.33122 = ss_req.575->last_sp;
      D.33123 = ctx->esp;
      D.33124 = (void *) D.33123;
      D.33102 = ctx->eip;
      D.33125 = (void *) D.33102;
      D.33126 = jinfo_get_method (ji);
      D.33127 = mono_method_full_name (D.33126, 1);
      ss_req.575 = ss_req;
      D.33128 = ss_req.575->depth;
      D.33129 = ss_depth_to_string (D.33128);
      D.33130 = GetCurrentThreadId ();
      D.33131 = (void *) D.33130;
      log_file.577 = log_file;
      fprintf (log_file.577, "[%p] Single step event (depth=%s) at %s (%p), sp %p, last sp %p\n", D.33131, D.33129, D.33127, D.33125, D.33124, D.33122);
      log_file.577 = log_file;
      fflush (log_file.577);
      <D.33121>:
      <D.33115>:
      D.33133 = mono_domain_get ();
      ji = mini_jit_info_table_find (D.33133, ip, &domain);
      D.33134 = ji == 0B;
      D.33135 = (long int) D.33134;
      D.33136 = __builtin_expect (D.33135, 0);
      if (D.33136 != 0) goto <D.33137>; else goto <D.33138>;
      <D.33137>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 4813, "ji");
      <D.33138>:
      method = jinfo_get_method (ji);
      D.33139 = method == 0B;
      D.33140 = (long int) D.33139;
      D.33141 = __builtin_expect (D.33140, 0);
      if (D.33141 != 0) goto <D.33142>; else goto <D.33143>;
      <D.33142>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 4815, "method");
      <D.33143>:
      D.33144 = BIT_FIELD_REF <*method, 8, 160>;
      D.33145 = D.33144 & 124;
      D.33146 = D.33145 != 0;
      D.33147 = D.33145 != 68;
      D.33148 = D.33146 & D.33147;
      if (D.33148 != 0) goto <D.33149>; else goto <D.33150>;
      <D.33149>:
      return;
      <D.33150>:
      D.33153 = method->klass;
      D.33154 = mono_defaults.string_class;
      if (D.33153 == D.33154) goto <D.33155>; else goto <D.33156>;
      <D.33155>:
      {
        size_t __s1_len;
        size_t __s2_len;

        __s2_len = 6;
        if (__s2_len <= 3) goto <D.33158>; else goto <D.33159>;
        <D.33158>:
        {
          const unsigned char * __s2;
          int __result;

          __s2 = method->name;
          D.33160 = "memset";
          D.33161 = MEM[(const unsigned char *)D.33160];
          D.33162 = (int) D.33161;
          D.33163 = *__s2;
          D.33164 = (int) D.33163;
          __result = D.33162 - D.33164;
          {
            D.33165 = __s2_len != 0;
            D.33166 = __result == 0;
            D.33167 = D.33165 & D.33166;
            if (D.33167 != 0) goto <D.33168>; else goto <D.33169>;
            <D.33168>:
            D.33170 = &MEM[(void *)"memset" + 1B];
            D.33171 = *D.33170;
            D.33172 = (int) D.33171;
            D.33173 = __s2 + 1;
            D.33174 = *D.33173;
            D.33175 = (int) D.33174;
            __result = D.33172 - D.33175;
            D.33176 = __s2_len > 1;
            D.33166 = __result == 0;
            D.33177 = D.33176 & D.33166;
            if (D.33177 != 0) goto <D.33178>; else goto <D.33179>;
            <D.33178>:
            D.33180 = &MEM[(void *)"memset" + 2B];
            D.33181 = *D.33180;
            D.33182 = (int) D.33181;
            D.33183 = __s2 + 2;
            D.33184 = *D.33183;
            D.33185 = (int) D.33184;
            __result = D.33182 - D.33185;
            D.33186 = __s2_len > 2;
            D.33166 = __result == 0;
            D.33187 = D.33186 & D.33166;
            if (D.33187 != 0) goto <D.33188>; else goto <D.33189>;
            <D.33188>:
            D.33190 = &MEM[(void *)"memset" + 3B];
            D.33191 = *D.33190;
            D.33192 = (int) D.33191;
            D.33193 = __s2 + 3;
            D.33194 = *D.33193;
            D.33195 = (int) D.33194;
            __result = D.33192 - D.33195;
            <D.33189>:
            <D.33179>:
            <D.33169>:
          }
          D.26026 = __result;
        }
        iftmp.578 = -D.26026;
        goto <D.33196>;
        <D.33159>:
        D.33197 = method->name;
        iftmp.578 = __builtin_strcmp (D.33197, "memset");
        <D.33196>:
        D.26027 = iftmp.578;
      }
      if (D.26027 == 0) goto <D.33151>; else goto <D.33198>;
      <D.33198>:
      D.33197 = method->name;
      D.33199 = strstr (D.33197, "memcpy");
      if (D.33199 != 0B) goto <D.33151>; else goto <D.33152>;
      <D.33151>:
      return;
      <D.33152>:
      <D.33156>:
      ip.579 = (int) ip;
      D.33201 = ji->code_start;
      D.33202 = (int) D.33201;
      D.33203 = ip.579 - D.33202;
      domain.580 = domain;
      sp = find_next_seq_point_for_native_offset (domain.580, method, D.33203, &info);
      if (sp == 0B) goto <D.33205>; else goto <D.33206>;
      <D.33205>:
      return;
      <D.33206>:
      il_offset = sp->il_offset;
      ss_req.575 = ss_req;
      D.33207 = ss_update (ss_req.575, ji, sp, tls, ctx);
      if (D.33207 == 0) goto <D.33208>; else goto <D.33209>;
      <D.33208>:
      return;
      <D.33209>:
      info.581 = info;
      ss_req.575 = ss_req;
      ss_start (ss_req.575, method, sp, info.581, ctx, tls, 0);
      ss_req.575 = ss_req;
      D.33211 = ss_req.575->filter;
      D.33212 = D.33211 & 1;
      if (D.33212 != 0) goto <D.33213>; else goto <D.33214>;
      <D.33213>:
      D.33215 = method->flags;
      D.33216 = (int) D.33215;
      D.33217 = D.33216 & 2048;
      if (D.33217 != 0) goto <D.33218>; else goto <D.33219>;
      <D.33218>:
      {
        size_t __s1_len;
        size_t __s2_len;

        __s2_len = 6;
        if (__s2_len <= 3) goto <D.33221>; else goto <D.33222>;
        <D.33221>:
        {
          const unsigned char * __s2;
          int __result;

          __s2 = method->name;
          D.33223 = ".cctor";
          D.33224 = MEM[(const unsigned char *)D.33223];
          D.33225 = (int) D.33224;
          D.33226 = *__s2;
          D.33227 = (int) D.33226;
          __result = D.33225 - D.33227;
          {
            D.33228 = __s2_len != 0;
            D.33229 = __result == 0;
            D.33230 = D.33228 & D.33229;
            if (D.33230 != 0) goto <D.33231>; else goto <D.33232>;
            <D.33231>:
            D.33233 = &MEM[(void *)".cctor" + 1B];
            D.33234 = *D.33233;
            D.33235 = (int) D.33234;
            D.33236 = __s2 + 1;
            D.33237 = *D.33236;
            D.33238 = (int) D.33237;
            __result = D.33235 - D.33238;
            D.33239 = __s2_len > 1;
            D.33229 = __result == 0;
            D.33240 = D.33239 & D.33229;
            if (D.33240 != 0) goto <D.33241>; else goto <D.33242>;
            <D.33241>:
            D.33243 = &MEM[(void *)".cctor" + 2B];
            D.33244 = *D.33243;
            D.33245 = (int) D.33244;
            D.33246 = __s2 + 2;
            D.33247 = *D.33246;
            D.33248 = (int) D.33247;
            __result = D.33245 - D.33248;
            D.33249 = __s2_len > 2;
            D.33229 = __result == 0;
            D.33250 = D.33249 & D.33229;
            if (D.33250 != 0) goto <D.33251>; else goto <D.33252>;
            <D.33251>:
            D.33253 = &MEM[(void *)".cctor" + 3B];
            D.33254 = *D.33253;
            D.33255 = (int) D.33254;
            D.33256 = __s2 + 3;
            D.33257 = *D.33256;
            D.33258 = (int) D.33257;
            __result = D.33255 - D.33258;
            <D.33252>:
            <D.33242>:
            <D.33232>:
          }
          D.26035 = __result;
        }
        iftmp.582 = -D.26035;
        goto <D.33259>;
        <D.33222>:
        D.33197 = method->name;
        iftmp.582 = __builtin_strcmp (D.33197, ".cctor");
        <D.33259>:
        D.26036 = iftmp.582;
      }
      if (D.26036 == 0) goto <D.33260>; else goto <D.33261>;
      <D.33260>:
      return;
      <D.33261>:
      <D.33219>:
      <D.33214>:
      reqs = monoeg_g_ptr_array_new ();
      mono_loader_lock ();
      ss_req.575 = ss_req;
      D.33262 = ss_req.575->req;
      monoeg_g_ptr_array_add (reqs, D.33262);
      events = create_event_list (11, reqs, ji, 0B, &suspend_policy);
      monoeg_g_ptr_array_free (reqs, 1);
      mono_loader_unlock ();
      suspend_policy.583 = suspend_policy;
      D.33264 = jinfo_get_method (ji);
      process_event (11, D.33264, il_offset, ctx, events, suspend_policy.583);
    }
  finally
    {
      suspend_policy = {CLOBBER};
      domain = {CLOBBER};
      info = {CLOBBER};
    }
}


process_suspend (struct DebuggerTlsData * tls, struct MonoContext * ctx)
{
  int D.33268;
  int D.33269;
  unsigned int D.33272;
  unsigned int debugger_thread_id.584;
  int suspend_count.585;
  unsigned int suspend_count.586;
  unsigned int D.33278;
  int log_level.587;
  _Bool D.33282;
  long int D.33283;
  long int D.33284;
  unsigned int D.33287;
  void * D.33288;
  struct FILE * log_file.588;
  unsigned int D.33294;
  void * D.33295;
  struct MonoDomain * D.33296;
  struct MonoClass * D.33299;
  struct MonoClass * D.33300;
  int D.25400;
  int iftmp.589;
  int D.25399;
  const char[7] * D.33306;
  unsigned char D.33307;
  int D.33308;
  unsigned char D.33309;
  int D.33310;
  _Bool D.33311;
  _Bool D.33312;
  _Bool D.33313;
  const unsigned char * D.33316;
  unsigned char D.33317;
  int D.33318;
  const unsigned char * D.33319;
  unsigned char D.33320;
  int D.33321;
  _Bool D.33322;
  _Bool D.33323;
  const unsigned char * D.33326;
  unsigned char D.33327;
  int D.33328;
  const unsigned char * D.33329;
  unsigned char D.33330;
  int D.33331;
  _Bool D.33332;
  _Bool D.33333;
  const unsigned char * D.33336;
  unsigned char D.33337;
  int D.33338;
  const unsigned char * D.33339;
  unsigned char D.33340;
  int D.33341;
  const char * D.33343;
  char * D.33345;
  guint8 * ip;
  struct MonoJitInfo * ji;
  struct MonoMethod * method;

  D.33268 = ctx->eip;
  ip = (guint8 *) D.33268;
  D.33269 = mono_loader_lock_is_owned_by_self ();
  if (D.33269 != 0) goto <D.33270>; else goto <D.33271>;
  <D.33270>:
  return;
  <D.33271>:
  D.33272 = GetCurrentThreadId ();
  debugger_thread_id.584 = debugger_thread_id;
  if (D.33272 == debugger_thread_id.584) goto <D.33274>; else goto <D.33275>;
  <D.33274>:
  return;
  <D.33275>:
  suspend_count.585 = suspend_count;
  suspend_count.586 = (unsigned int) suspend_count.585;
  D.33278 = tls->resume_count;
  if (suspend_count.586 != D.33278) goto <D.33279>; else goto <D.33280>;
  <D.33279>:
  tls->suspending = 1;
  <D.33280>:
  log_level.587 = log_level;
  D.33282 = log_level.587 > 0;
  D.33283 = (long int) D.33282;
  D.33284 = __builtin_expect (D.33283, 0);
  if (D.33284 != 0) goto <D.33285>; else goto <D.33286>;
  <D.33285>:
  D.33287 = GetCurrentThreadId ();
  D.33288 = (void *) D.33287;
  log_file.588 = log_file;
  fprintf (log_file.588, "[%p] Received single step event for suspending.\n", D.33288);
  log_file.588 = log_file;
  fflush (log_file.588);
  <D.33286>:
  suspend_count.585 = suspend_count;
  suspend_count.586 = (unsigned int) suspend_count.585;
  D.33278 = tls->resume_count;
  if (suspend_count.586 == D.33278) goto <D.33290>; else goto <D.33291>;
  <D.33290>:
  log_level.587 = log_level;
  D.33282 = log_level.587 > 0;
  D.33283 = (long int) D.33282;
  D.33284 = __builtin_expect (D.33283, 0);
  if (D.33284 != 0) goto <D.33292>; else goto <D.33293>;
  <D.33292>:
  D.33294 = GetCurrentThreadId ();
  D.33295 = (void *) D.33294;
  log_file.588 = log_file;
  fprintf (log_file.588, "[%p] Ignored during single threaded invoke.\n", D.33295);
  log_file.588 = log_file;
  fflush (log_file.588);
  <D.33293>:
  return;
  <D.33291>:
  D.33296 = mono_domain_get ();
  ji = mini_jit_info_table_find (D.33296, ip, 0B);
  method = jinfo_get_method (ji);
  D.33299 = method->klass;
  D.33300 = mono_defaults.string_class;
  if (D.33299 == D.33300) goto <D.33301>; else goto <D.33302>;
  <D.33301>:
  {
    size_t __s1_len;
    size_t __s2_len;

    __s2_len = 6;
    if (__s2_len <= 3) goto <D.33304>; else goto <D.33305>;
    <D.33304>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = method->name;
      D.33306 = "memset";
      D.33307 = MEM[(const unsigned char *)D.33306];
      D.33308 = (int) D.33307;
      D.33309 = *__s2;
      D.33310 = (int) D.33309;
      __result = D.33308 - D.33310;
      {
        D.33311 = __s2_len != 0;
        D.33312 = __result == 0;
        D.33313 = D.33311 & D.33312;
        if (D.33313 != 0) goto <D.33314>; else goto <D.33315>;
        <D.33314>:
        D.33316 = &MEM[(void *)"memset" + 1B];
        D.33317 = *D.33316;
        D.33318 = (int) D.33317;
        D.33319 = __s2 + 1;
        D.33320 = *D.33319;
        D.33321 = (int) D.33320;
        __result = D.33318 - D.33321;
        D.33322 = __s2_len > 1;
        D.33312 = __result == 0;
        D.33323 = D.33322 & D.33312;
        if (D.33323 != 0) goto <D.33324>; else goto <D.33325>;
        <D.33324>:
        D.33326 = &MEM[(void *)"memset" + 2B];
        D.33327 = *D.33326;
        D.33328 = (int) D.33327;
        D.33329 = __s2 + 2;
        D.33330 = *D.33329;
        D.33331 = (int) D.33330;
        __result = D.33328 - D.33331;
        D.33332 = __s2_len > 2;
        D.33312 = __result == 0;
        D.33333 = D.33332 & D.33312;
        if (D.33333 != 0) goto <D.33334>; else goto <D.33335>;
        <D.33334>:
        D.33336 = &MEM[(void *)"memset" + 3B];
        D.33337 = *D.33336;
        D.33338 = (int) D.33337;
        D.33339 = __s2 + 3;
        D.33340 = *D.33339;
        D.33341 = (int) D.33340;
        __result = D.33338 - D.33341;
        <D.33335>:
        <D.33325>:
        <D.33315>:
      }
      D.25399 = __result;
    }
    iftmp.589 = -D.25399;
    goto <D.33342>;
    <D.33305>:
    D.33343 = method->name;
    iftmp.589 = __builtin_strcmp (D.33343, "memset");
    <D.33342>:
    D.25400 = iftmp.589;
  }
  if (D.25400 == 0) goto <D.33297>; else goto <D.33344>;
  <D.33344>:
  D.33343 = method->name;
  D.33345 = strstr (D.33343, "memcpy");
  if (D.33345 != 0B) goto <D.33297>; else goto <D.33298>;
  <D.33297>:
  return;
  <D.33298>:
  <D.33302>:
  save_thread_context (ctx);
  suspend_current ();
}


debugger_agent_single_step_from_context (struct MonoContext * ctx)
{
  unsigned int debugger_tls_id.590;
  _Bool D.33348;
  long int D.33349;
  long int D.33350;
  struct MonoContext * D.33353;
  struct DebuggerTlsData * tls;
  struct MonoContext orig_restore_ctx;

  try
    {
      debugger_tls_id.590 = debugger_tls_id;
      tls = pthread_getspecific (debugger_tls_id.590);
      D.33348 = tls == 0B;
      D.33349 = (long int) D.33348;
      D.33350 = __builtin_expect (D.33349, 0);
      if (D.33350 != 0) goto <D.33351>; else goto <D.33352>;
      <D.33351>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 4909, "tls");
      <D.33352>:
      D.33353 = &tls->restore_ctx;
      memcpy (&orig_restore_ctx, D.33353, 36);
      D.33353 = &tls->restore_ctx;
      memcpy (D.33353, ctx, 36);
      process_single_step_inner (tls);
      D.33353 = &tls->restore_ctx;
      memcpy (ctx, D.33353, 36);
      D.33353 = &tls->restore_ctx;
      memcpy (D.33353, &orig_restore_ctx, 36);
    }
  finally
    {
      orig_restore_ctx = {CLOBBER};
    }
}


debugger_agent_breakpoint_from_context (struct MonoContext * ctx)
{
  unsigned int debugger_tls_id.591;
  _Bool D.33355;
  long int D.33356;
  long int D.33357;
  struct MonoContext * D.33360;
  struct DebuggerTlsData * tls;
  struct MonoContext orig_restore_ctx;

  try
    {
      debugger_tls_id.591 = debugger_tls_id;
      tls = pthread_getspecific (debugger_tls_id.591);
      D.33355 = tls == 0B;
      D.33356 = (long int) D.33355;
      D.33357 = __builtin_expect (D.33356, 0);
      if (D.33357 != 0) goto <D.33358>; else goto <D.33359>;
      <D.33358>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 4928, "tls");
      <D.33359>:
      D.33360 = &tls->restore_ctx;
      memcpy (&orig_restore_ctx, D.33360, 36);
      D.33360 = &tls->restore_ctx;
      memcpy (D.33360, ctx, 36);
      process_breakpoint_inner (tls);
      D.33360 = &tls->restore_ctx;
      memcpy (ctx, D.33360, 36);
      D.33360 = &tls->restore_ctx;
      memcpy (D.33360, &orig_restore_ctx, 36);
    }
  finally
    {
      orig_restore_ctx = {CLOBBER};
    }
}


mono_debugger_agent_debug_log (int level, struct MonoString * category, struct MonoString * message)
{
  int D.33361;
  char * iftmp.592;
  char * iftmp.593;
  int suspend_policy.594;
  char * D.33373;
  char * D.33374;
  int suspend_policy;
  struct GSList * events;
  struct EventInfo ei;

  try
    {
      D.33361 = agent_config.enabled;
      if (D.33361 == 0) goto <D.33362>; else goto <D.33363>;
      <D.33362>:
      return;
      <D.33363>:
      mono_loader_lock ();
      events = create_event_list (16, 0B, 0B, 0B, &suspend_policy);
      mono_loader_unlock ();
      ei.level = level;
      if (category != 0B) goto <D.33365>; else goto <D.33366>;
      <D.33365>:
      iftmp.592 = mono_string_to_utf8 (category);
      goto <D.33367>;
      <D.33366>:
      iftmp.592 = 0B;
      <D.33367>:
      ei.category = iftmp.592;
      if (message != 0B) goto <D.33369>; else goto <D.33370>;
      <D.33369>:
      iftmp.593 = mono_string_to_utf8 (message);
      goto <D.33371>;
      <D.33370>:
      iftmp.593 = 0B;
      <D.33371>:
      ei.message = iftmp.593;
      suspend_policy.594 = suspend_policy;
      process_event (16, &ei, 0, 0B, events, suspend_policy.594);
      D.33373 = ei.category;
      monoeg_g_free (D.33373);
      D.33374 = ei.message;
      monoeg_g_free (D.33374);
    }
  finally
    {
      suspend_policy = {CLOBBER};
      ei = {CLOBBER};
    }
}


mono_debugger_agent_debug_log_is_enabled ()
{
  gboolean D.33378;

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


mono_debugger_agent_handle_exception (struct MonoException * exc, struct MonoContext * throw_ctx, struct MonoContext * catch_ctx)
{
  struct MonoGHashTable * thread_to_tls.595;
  int D.33385;
  int D.33390;
  int D.33395;
  int inited.596;
  struct GSList * D.33402;
  struct MonoVTable * D.33407;
  struct MonoClass * D.33408;
  struct MonoType * D.33409;
  int D.26164;
  int iftmp.597;
  int D.26163;
  const char[1] * D.33415;
  unsigned char D.33416;
  int D.33417;
  unsigned char D.33418;
  int D.33419;
  _Bool D.33420;
  _Bool D.33421;
  _Bool D.33422;
  const unsigned char * D.33425;
  unsigned char D.33426;
  int D.33427;
  const unsigned char * D.33428;
  unsigned char D.33429;
  int D.33430;
  _Bool D.33431;
  _Bool D.33432;
  const unsigned char * D.33435;
  unsigned char D.33436;
  int D.33437;
  const unsigned char * D.33438;
  unsigned char D.33439;
  int D.33440;
  _Bool D.33441;
  _Bool D.33442;
  const unsigned char * D.33445;
  unsigned char D.33446;
  int D.33447;
  const unsigned char * D.33448;
  unsigned char D.33449;
  int D.33450;
  unsigned char D.33452;
  int D.26173;
  int D.33458;
  char * D.33459;
  struct MonoDomain * D.33460;
  int D.33463;
  char * D.33464;
  struct MonoDomain * D.33465;
  _Bool D.33467;
  int D.33468;
  struct GPtrArray * event_requests.598;
  void * * D.33470;
  unsigned int i.599;
  unsigned int D.33472;
  void * * D.33473;
  int D.33474;
  <unnamed type> D.33477;
  unsigned int k.600;
  unsigned int D.33485;
  struct MonoAssembly * * D.33486;
  struct MonoAssembly * D.33487;
  struct MonoMethod * D.33488;
  struct MonoClass * D.33489;
  struct MonoImage * D.33490;
  struct MonoAssembly * D.33491;
  int D.33496;
  unsigned int i.601;
  unsigned int D.33498;
  int D.33501;
  struct MonoThreadUnwindState * D.33506;
  struct MonoDomain * D.33507;
  int suspend_policy.602;
  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.595 = thread_to_tls;
      if (thread_to_tls.595 != 0B) goto <D.33381>; else goto <D.33382>;
      <D.33381>:
      {
        struct MonoInternalThread * thread;

        thread = mono_thread_internal_current ();
        mono_loader_lock ();
        thread_to_tls.595 = thread_to_tls;
        tls = mono_g_hash_table_lookup (thread_to_tls.595, thread);
        mono_loader_unlock ();
        if (tls != 0B) goto <D.33383>; else goto <D.33384>;
        <D.33383>:
        D.33385 = tls->abort_requested;
        if (D.33385 != 0) goto <D.33386>; else goto <D.33387>;
        <D.33386>:
        return;
        <D.33387>:
        <D.33384>:
        if (tls != 0B) goto <D.33388>; else goto <D.33389>;
        <D.33388>:
        D.33390 = tls->disable_breakpoints;
        if (D.33390 != 0) goto <D.33391>; else goto <D.33392>;
        <D.33391>:
        return;
        <D.33392>:
        <D.33389>:
      }
      <D.33382>:
      memset (&ei, 0, 60);
      if (catch_ctx == 0B) goto <D.33393>; else goto <D.33394>;
      <D.33393>:
      D.33395 = agent_config.onuncaught;
      if (D.33395 != 0) goto <D.33396>; else goto <D.33397>;
      <D.33396>:
      inited.596 = inited;
      if (inited.596 == 0) goto <D.33399>; else goto <D.33400>;
      <D.33399>:
      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.33400>:
      <D.33397>:
      goto <D.33401>;
      <D.33394>:
      D.33402 = agent_config.onthrow;
      if (D.33402 != 0B) goto <D.33403>; else goto <D.33404>;
      <D.33403>:
      inited.596 = inited;
      if (inited.596 == 0) goto <D.33405>; else goto <D.33406>;
      <D.33405>:
      {
        struct GSList * l;
        gboolean found;

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

          ex_type = l->data;
          D.33407 = exc->object.vtable;
          D.33408 = D.33407->klass;
          D.33409 = &D.33408->byval_arg;
          f = mono_type_full_name (D.33409);
          {
            size_t __s1_len;
            size_t __s2_len;

            __s2_len = 0;
            if (__s2_len <= 3) goto <D.33413>; else goto <D.33414>;
            <D.33413>:
            {
              const unsigned char * __s2;
              int __result;

              __s2 = ex_type;
              D.33415 = "";
              D.33416 = MEM[(const unsigned char *)D.33415];
              D.33417 = (int) D.33416;
              D.33418 = *__s2;
              D.33419 = (int) D.33418;
              __result = D.33417 - D.33419;
              {
                D.33420 = __s2_len != 0;
                D.33421 = __result == 0;
                D.33422 = D.33420 & D.33421;
                if (D.33422 != 0) goto <D.33423>; else goto <D.33424>;
                <D.33423>:
                D.33425 = &MEM[(void *)"" + 1B];
                D.33426 = *D.33425;
                D.33427 = (int) D.33426;
                D.33428 = __s2 + 1;
                D.33429 = *D.33428;
                D.33430 = (int) D.33429;
                __result = D.33427 - D.33430;
                D.33431 = __s2_len > 1;
                D.33421 = __result == 0;
                D.33432 = D.33431 & D.33421;
                if (D.33432 != 0) goto <D.33433>; else goto <D.33434>;
                <D.33433>:
                D.33435 = &MEM[(void *)"" + 2B];
                D.33436 = *D.33435;
                D.33437 = (int) D.33436;
                D.33438 = __s2 + 2;
                D.33439 = *D.33438;
                D.33440 = (int) D.33439;
                __result = D.33437 - D.33440;
                D.33441 = __s2_len > 2;
                D.33421 = __result == 0;
                D.33442 = D.33441 & D.33421;
                if (D.33442 != 0) goto <D.33443>; else goto <D.33444>;
                <D.33443>:
                D.33445 = &MEM[(void *)"" + 3B];
                D.33446 = *D.33445;
                D.33447 = (int) D.33446;
                D.33448 = __s2 + 3;
                D.33449 = *D.33448;
                D.33450 = (int) D.33449;
                __result = D.33447 - D.33450;
                <D.33444>:
                <D.33434>:
                <D.33424>:
              }
              D.26163 = __result;
            }
            iftmp.597 = -D.26163;
            goto <D.33451>;
            <D.33414>:
            D.33452 = MEM[(const unsigned char * {ref-all})ex_type];
            iftmp.597 = (int) D.33452;
            <D.33451>:
            D.26164 = iftmp.597;
          }
          if (D.26164 == 0) goto <D.33410>; else goto <D.33453>;
          <D.33453>:
          {
            size_t __s1_len;
            size_t __s2_len;

            D.26173 = __builtin_strcmp (ex_type, f);
          }
          if (D.26173 == 0) goto <D.33410>; else goto <D.33411>;
          <D.33410>:
          found = 1;
          <D.33411>:
          monoeg_g_free (f);
        }
        l = l->next;
        <D.26175>:
        if (l != 0B) goto <D.26174>; else goto <D.26176>;
        <D.26176>:
        if (found != 0) goto <D.33454>; else goto <D.33455>;
        <D.33454>:
        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.33455>:
      }
      <D.33406>:
      <D.33404>:
      <D.33401>:
      inited.596 = inited;
      if (inited.596 == 0) goto <D.33456>; else goto <D.33457>;
      <D.33456>:
      return;
      <D.33457>:
      D.33458 = throw_ctx->eip;
      D.33459 = (char *) D.33458;
      D.33460 = mono_domain_get ();
      ji = mini_jit_info_table_find (D.33460, D.33459, 0B);
      if (catch_ctx != 0B) goto <D.33461>; else goto <D.33462>;
      <D.33461>:
      D.33463 = catch_ctx->eip;
      D.33464 = (char *) D.33463;
      D.33465 = mono_domain_get ();
      catch_ji = mini_jit_info_table_find (D.33465, D.33464, 0B);
      goto <D.33466>;
      <D.33462>:
      catch_ji = 0B;
      <D.33466>:
      ei.exc = exc;
      D.33467 = catch_ctx != 0B;
      D.33468 = (int) D.33467;
      ei.caught = D.33468;
      mono_loader_lock ();
      i = 0;
      goto <D.26190>;
      <D.26189>:
      {
        struct EventRequest * req;

        event_requests.598 = event_requests;
        D.33470 = event_requests.598->pdata;
        i.599 = (unsigned int) i;
        D.33472 = i.599 * 4;
        D.33473 = D.33470 + D.33472;
        req = *D.33473;
        D.33474 = req->event_kind;
        if (D.33474 != 13) goto <D.33475>; else goto <D.33476>;
        <D.33475>:
        // predicted unlikely by continue predictor.
        goto <D.26178>;
        <D.33476>:
        j = 0;
        goto <D.26187>;
        <D.26186>:
        {
          struct Modifier * mod;

          mod = &req->modifiers[j];
          D.33477 = mod->kind;
          if (D.33477 == 11) goto <D.33478>; else goto <D.33479>;
          <D.33478>:
          if (catch_ji != 0B) goto <D.33480>; else goto <D.33481>;
          <D.33480>:
          {
            int k;
            gboolean found;
            struct MonoAssembly * * assemblies;

            found = 0;
            assemblies = mod->data.assemblies;
            if (assemblies != 0B) goto <D.33482>; else goto <D.33483>;
            <D.33482>:
            k = 0;
            goto <D.26184>;
            <D.26183>:
            k.600 = (unsigned int) k;
            D.33485 = k.600 * 4;
            D.33486 = assemblies + D.33485;
            D.33487 = *D.33486;
            D.33488 = jinfo_get_method (catch_ji);
            D.33489 = D.33488->klass;
            D.33490 = D.33489->image;
            D.33491 = D.33490->assembly;
            if (D.33487 == D.33491) goto <D.33492>; else goto <D.33493>;
            <D.33492>:
            found = 1;
            <D.33493>:
            k = k + 1;
            <D.26184>:
            k.600 = (unsigned int) k;
            D.33485 = k.600 * 4;
            D.33486 = assemblies + D.33485;
            D.33487 = *D.33486;
            if (D.33487 != 0B) goto <D.26183>; else goto <D.26185>;
            <D.26185>:
            <D.33483>:
            if (found == 0) goto <D.33494>; else goto <D.33495>;
            <D.33494>:
            ei.caught = 0;
            <D.33495>:
          }
          <D.33481>:
          <D.33479>:
        }
        j = j + 1;
        <D.26187>:
        D.33496 = req->nmodifiers;
        if (D.33496 > j) goto <D.26186>; else goto <D.26188>;
        <D.26188>:
      }
      <D.26178>:
      i = i + 1;
      <D.26190>:
      i.601 = (unsigned int) i;
      event_requests.598 = event_requests;
      D.33498 = event_requests.598->len;
      if (i.601 < D.33498) goto <D.26189>; else goto <D.26191>;
      <D.26191>:
      events = create_event_list (13, 0B, ji, &ei, &suspend_policy);
      mono_loader_unlock ();
      if (tls != 0B) goto <D.33499>; else goto <D.33500>;
      <D.33499>:
      D.33501 = ei.caught;
      if (D.33501 != 0) goto <D.33502>; else goto <D.33503>;
      <D.33502>:
      if (catch_ctx != 0B) goto <D.33504>; else goto <D.33505>;
      <D.33504>:
      D.33506 = &tls->catch_state;
      memset (D.33506, 0, 52);
      tls->catch_state.ctx = *catch_ctx;
      D.33507 = mono_domain_get ();
      tls->catch_state.unwind_data[0] = D.33507;
      tls->catch_state.valid = 1;
      <D.33505>:
      <D.33503>:
      <D.33500>:
      suspend_policy.602 = suspend_policy;
      process_event (13, &ei, 0, throw_ctx, events, suspend_policy.602);
      if (tls != 0B) goto <D.33509>; else goto <D.33510>;
      <D.33509>:
      tls->catch_state.valid = 0;
      <D.33510>:
    }
  finally
    {
      suspend_policy = {CLOBBER};
      ei = {CLOBBER};
    }
}


mono_debugger_agent_begin_exception_filter (struct MonoException * exc, struct MonoContext * ctx, struct MonoContext * orig_ctx)
{
  int inited.603;
  unsigned int debugger_tls_id.604;
  struct MonoThreadUnwindState * D.33520;
  int D.33521;
  _Bool D.33522;
  long int D.33523;
  long int D.33524;
  struct DebuggerTlsData * tls;

  inited.603 = inited;
  if (inited.603 == 0) goto <D.33515>; else goto <D.33516>;
  <D.33515>:
  return;
  <D.33516>:
  debugger_tls_id.604 = debugger_tls_id;
  tls = pthread_getspecific (debugger_tls_id.604);
  if (tls == 0B) goto <D.33518>; else goto <D.33519>;
  <D.33518>:
  return;
  <D.33519>:
  D.33520 = &tls->filter_state;
  D.33521 = mono_thread_state_init_from_monoctx (D.33520, orig_ctx);
  D.33522 = D.33521 == 0;
  D.33523 = (long int) D.33522;
  D.33524 = __builtin_expect (D.33523, 0);
  if (D.33524 != 0) goto <D.33525>; else goto <D.33526>;
  <D.33525>:
  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.33526>:
}


mono_debugger_agent_end_exception_filter (struct MonoException * exc, struct MonoContext * ctx, struct MonoContext * orig_ctx)
{
  int inited.605;
  unsigned int debugger_tls_id.606;
  struct DebuggerTlsData * tls;

  inited.605 = inited;
  if (inited.605 == 0) goto <D.33529>; else goto <D.33530>;
  <D.33529>:
  return;
  <D.33530>:
  debugger_tls_id.606 = debugger_tls_id;
  tls = pthread_getspecific (debugger_tls_id.606);
  if (tls == 0B) goto <D.33532>; else goto <D.33533>;
  <D.33532>:
  return;
  <D.33533>:
  tls->filter_state.valid = 0;
}