mono_debugger_agent_parse_options (char * options)
{
  int D.29974;
  const gchar * D.29977;
  gchar * D.29978;
  int D.29980;
  const gchar * D.29983;
  gchar * D.29984;
  int D.29986;
  const char * D.29989;
  int D.29990;
  int D.29992;
  gchar * D.29995;
  int D.29997;
  char * D.30000;
  int D.30001;
  int D.30003;
  char * D.30006;
  int D.30007;
  int D.30009;
  char * D.30012;
  int D.30013;
  int D.30015;
  struct GSList * D.30018;
  gchar * D.30019;
  struct GSList * D.30020;
  int D.30022;
  gchar * D.30025;
  struct GSList * D.30026;
  int D.30028;
  int D.30031;
  const char * D.30034;
  int D.30035;
  int D.30037;
  const gchar * D.30040;
  gchar * D.30041;
  int D.30043;
  const char * D.30046;
  int D.30047;
  _Bool D.30048;
  int D.30049;
  int D.30051;
  int D.30054;
  int D.30056;
  int D.30059;
  char * D.30062;
  int D.30063;
  int D.30066;
  char * D.30069;
  unsigned int D.30072;
  unsigned int D.30073;
  unsigned int D.30074;
  gchar * D.30075;
  char * D.30076;
  struct _IO_FILE * stderr.0;
  int D.27342;
  int iftmp.1;
  int D.27341;
  const char[10] * D.30087;
  unsigned char D.30088;
  int D.30089;
  unsigned char D.30090;
  int D.30091;
  _Bool D.30092;
  _Bool D.30093;
  _Bool D.30094;
  const unsigned char * D.30097;
  unsigned char D.30098;
  int D.30099;
  const unsigned char * D.30100;
  unsigned char D.30101;
  int D.30102;
  _Bool D.30103;
  _Bool D.30104;
  const unsigned char * D.30107;
  unsigned char D.30108;
  int D.30109;
  const unsigned char * D.30110;
  unsigned char D.30111;
  int D.30112;
  _Bool D.30113;
  _Bool D.30114;
  const unsigned char * D.30117;
  unsigned char D.30118;
  int D.30119;
  const unsigned char * D.30120;
  unsigned char D.30121;
  int D.30122;
  int D.30128;
  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.29972>; else goto <D.29973>;
      <D.29972>:
      options = monoeg_g_strdup_printf ("%s,%s", options, extra);
      <D.29973>:
      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.27332>;
      <D.27331>:
      {
        char * arg;

        arg = *ptr;
        D.29974 = strncmp (arg, "transport=", 10);
        if (D.29974 == 0) goto <D.29975>; else goto <D.29976>;
        <D.29975>:
        D.29977 = arg + 10;
        D.29978 = monoeg_strdup (D.29977);
        agent_config.transport = D.29978;
        goto <D.29979>;
        <D.29976>:
        D.29980 = strncmp (arg, "address=", 8);
        if (D.29980 == 0) goto <D.29981>; else goto <D.29982>;
        <D.29981>:
        D.29983 = arg + 8;
        D.29984 = monoeg_strdup (D.29983);
        agent_config.address = D.29984;
        goto <D.29985>;
        <D.29982>:
        D.29986 = strncmp (arg, "loglevel=", 9);
        if (D.29986 == 0) goto <D.29987>; else goto <D.29988>;
        <D.29987>:
        D.29989 = arg + 9;
        D.29990 = atoi (D.29989);
        agent_config.log_level = D.29990;
        goto <D.29991>;
        <D.29988>:
        D.29992 = strncmp (arg, "logfile=", 8);
        if (D.29992 == 0) goto <D.29993>; else goto <D.29994>;
        <D.29993>:
        D.29983 = arg + 8;
        D.29995 = monoeg_strdup (D.29983);
        agent_config.log_file = D.29995;
        goto <D.29996>;
        <D.29994>:
        D.29997 = strncmp (arg, "suspend=", 8);
        if (D.29997 == 0) goto <D.29998>; else goto <D.29999>;
        <D.29998>:
        D.30000 = arg + 8;
        D.30001 = parse_flag ("suspend", D.30000);
        agent_config.suspend = D.30001;
        goto <D.30002>;
        <D.29999>:
        D.30003 = strncmp (arg, "server=", 7);
        if (D.30003 == 0) goto <D.30004>; else goto <D.30005>;
        <D.30004>:
        D.30006 = arg + 7;
        D.30007 = parse_flag ("server", D.30006);
        agent_config.server = D.30007;
        goto <D.30008>;
        <D.30005>:
        D.30009 = strncmp (arg, "onuncaught=", 11);
        if (D.30009 == 0) goto <D.30010>; else goto <D.30011>;
        <D.30010>:
        D.30012 = arg + 11;
        D.30013 = parse_flag ("onuncaught", D.30012);
        agent_config.onuncaught = D.30013;
        goto <D.30014>;
        <D.30011>:
        D.30015 = strncmp (arg, "onthrow=", 8);
        if (D.30015 == 0) goto <D.30016>; else goto <D.30017>;
        <D.30016>:
        D.30018 = agent_config.onthrow;
        D.29983 = arg + 8;
        D.30019 = monoeg_strdup (D.29983);
        D.30020 = monoeg_g_slist_append (D.30018, D.30019);
        agent_config.onthrow = D.30020;
        goto <D.30021>;
        <D.30017>:
        D.30022 = strncmp (arg, "onthrow", 7);
        if (D.30022 == 0) goto <D.30023>; else goto <D.30024>;
        <D.30023>:
        D.30018 = agent_config.onthrow;
        D.30025 = monoeg_strdup ("");
        D.30026 = monoeg_g_slist_append (D.30018, D.30025);
        agent_config.onthrow = D.30026;
        goto <D.30027>;
        <D.30024>:
        D.30028 = strncmp (arg, "help", 4);
        if (D.30028 == 0) goto <D.30029>; else goto <D.30030>;
        <D.30029>:
        print_usage ();
        exit (0);
        <D.30030>:
        D.30031 = strncmp (arg, "timeout=", 8);
        if (D.30031 == 0) goto <D.30032>; else goto <D.30033>;
        <D.30032>:
        D.30034 = arg + 8;
        D.30035 = atoi (D.30034);
        agent_config.timeout = D.30035;
        goto <D.30036>;
        <D.30033>:
        D.30037 = strncmp (arg, "launch=", 7);
        if (D.30037 == 0) goto <D.30038>; else goto <D.30039>;
        <D.30038>:
        D.30040 = arg + 7;
        D.30041 = monoeg_strdup (D.30040);
        agent_config.launch = D.30041;
        goto <D.30042>;
        <D.30039>:
        D.30043 = strncmp (arg, "embedding=", 10);
        if (D.30043 == 0) goto <D.30044>; else goto <D.30045>;
        <D.30044>:
        D.30046 = arg + 10;
        D.30047 = atoi (D.30046);
        D.30048 = D.30047 == 1;
        D.30049 = (int) D.30048;
        agent_config.embedding = D.30049;
        goto <D.30050>;
        <D.30045>:
        D.30051 = strncmp (arg, "keepalive=", 10);
        if (D.30051 == 0) goto <D.30052>; else goto <D.30053>;
        <D.30052>:
        D.30046 = arg + 10;
        D.30054 = atoi (D.30046);
        agent_config.keepalive = D.30054;
        goto <D.30055>;
        <D.30053>:
        D.30056 = strncmp (arg, "setpgid=", 8);
        if (D.30056 == 0) goto <D.30057>; else goto <D.30058>;
        <D.30057>:
        D.30000 = arg + 8;
        D.30059 = parse_flag ("setpgid", D.30000);
        agent_config.setpgid = D.30059;
        goto <D.30060>;
        <D.30058>:
        print_usage ();
        exit (1);
        <D.30060>:
        <D.30055>:
        <D.30050>:
        <D.30042>:
        <D.30036>:
        <D.30027>:
        <D.30021>:
        <D.30014>:
        <D.30008>:
        <D.30002>:
        <D.29996>:
        <D.29991>:
        <D.29985>:
        <D.29979>:
      }
      ptr = ptr + 4;
      <D.27332>:
      if (ptr != 0B) goto <D.30061>; else goto <D.27333>;
      <D.30061>:
      D.30062 = *ptr;
      if (D.30062 != 0B) goto <D.27331>; else goto <D.27333>;
      <D.27333>:
      D.30063 = agent_config.server;
      if (D.30063 != 0) goto <D.30064>; else goto <D.30065>;
      <D.30064>:
      D.30066 = agent_config.suspend;
      if (D.30066 == 0) goto <D.30067>; else goto <D.30068>;
      <D.30067>:
      agent_config.defer = 1;
      D.30069 = agent_config.address;
      if (D.30069 == 0B) goto <D.30070>; else goto <D.30071>;
      <D.30070>:
      D.30072 = GetCurrentProcessId ();
      D.30073 = D.30072 % 1000;
      D.30074 = D.30073 + 56000;
      D.30075 = monoeg_g_strdup_printf ("0.0.0.0:%u", D.30074);
      agent_config.address = D.30075;
      <D.30071>:
      <D.30068>:
      <D.30065>:
      D.30076 = agent_config.transport;
      if (D.30076 == 0B) goto <D.30077>; else goto <D.30078>;
      <D.30077>:
      stderr.0 = stderr;
      fprintf (stderr.0, "debugger-agent: The \'transport\' option is mandatory.\n");
      exit (1);
      <D.30078>:
      D.30069 = agent_config.address;
      if (D.30069 == 0B) goto <D.30080>; else goto <D.30081>;
      <D.30080>:
      D.30063 = agent_config.server;
      if (D.30063 == 0) goto <D.30082>; else goto <D.30083>;
      <D.30082>:
      stderr.0 = stderr;
      fprintf (stderr.0, "debugger-agent: The \'address\' option is mandatory.\n");
      exit (1);
      <D.30083>:
      <D.30081>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          __s2 = agent_config.transport;
          D.30087 = "dt_socket";
          D.30088 = MEM[(const unsigned char *)D.30087];
          D.30089 = (int) D.30088;
          D.30090 = *__s2;
          D.30091 = (int) D.30090;
          __result = D.30089 - D.30091;
          {
            D.30092 = __s2_len != 0;
            D.30093 = __result == 0;
            D.30094 = D.30092 & D.30093;
            if (D.30094 != 0) goto <D.30095>; else goto <D.30096>;
            <D.30095>:
            D.30097 = &MEM[(void *)"dt_socket" + 1B];
            D.30098 = *D.30097;
            D.30099 = (int) D.30098;
            D.30100 = __s2 + 1;
            D.30101 = *D.30100;
            D.30102 = (int) D.30101;
            __result = D.30099 - D.30102;
            D.30103 = __s2_len > 1;
            D.30093 = __result == 0;
            D.30104 = D.30103 & D.30093;
            if (D.30104 != 0) goto <D.30105>; else goto <D.30106>;
            <D.30105>:
            D.30107 = &MEM[(void *)"dt_socket" + 2B];
            D.30108 = *D.30107;
            D.30109 = (int) D.30108;
            D.30110 = __s2 + 2;
            D.30111 = *D.30110;
            D.30112 = (int) D.30111;
            __result = D.30109 - D.30112;
            D.30113 = __s2_len > 2;
            D.30093 = __result == 0;
            D.30114 = D.30113 & D.30093;
            if (D.30114 != 0) goto <D.30115>; else goto <D.30116>;
            <D.30115>:
            D.30117 = &MEM[(void *)"dt_socket" + 3B];
            D.30118 = *D.30117;
            D.30119 = (int) D.30118;
            D.30120 = __s2 + 3;
            D.30121 = *D.30120;
            D.30122 = (int) D.30121;
            __result = D.30119 - D.30122;
            <D.30116>:
            <D.30106>:
            <D.30096>:
          }
          D.27341 = __result;
        }
        iftmp.1 = -D.27341;
        goto <D.30123>;
        <D.30086>:
        D.30076 = agent_config.transport;
        iftmp.1 = __builtin_strcmp (D.30076, "dt_socket");
        <D.30123>:
        D.27342 = iftmp.1;
      }
      if (D.27342 == 0) goto <D.30124>; else goto <D.30125>;
      <D.30124>:
      D.30069 = agent_config.address;
      if (D.30069 != 0B) goto <D.30126>; else goto <D.30127>;
      <D.30126>:
      D.30069 = agent_config.address;
      D.30128 = parse_address (D.30069, &host, &port);
      if (D.30128 != 0) goto <D.30129>; else goto <D.30130>;
      <D.30129>:
      stderr.0 = stderr;
      fprintf (stderr.0, "debugger-agent: The format of the \'address\' options is \'<host>:<port>\'\n");
      exit (1);
      <D.30130>:
      <D.30127>:
      <D.30125>:
    }
  finally
    {
      host = {CLOBBER};
      port = {CLOBBER};
    }
}


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

  if (str != 0B) goto <D.30131>; else goto <D.30132>;
  <D.30131>:
  D.30133 = __strdup (str);
  return D.30133;
  <D.30132>:
  D.30133 = 0B;
  return D.30133;
}


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

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


parse_flag (const char * option, char * flag)
{
  int D.27177;
  int iftmp.2;
  int D.27176;
  const char[2] * D.30140;
  unsigned char D.30141;
  int D.30142;
  unsigned char D.30143;
  int D.30144;
  _Bool D.30145;
  _Bool D.30146;
  _Bool D.30147;
  const unsigned char * D.30150;
  unsigned char D.30151;
  int D.30152;
  const unsigned char * D.30153;
  unsigned char D.30154;
  int D.30155;
  _Bool D.30156;
  _Bool D.30157;
  const unsigned char * D.30160;
  unsigned char D.30161;
  int D.30162;
  const unsigned char * D.30163;
  unsigned char D.30164;
  int D.30165;
  _Bool D.30166;
  _Bool D.30167;
  const unsigned char * D.30170;
  unsigned char D.30171;
  int D.30172;
  const unsigned char * D.30173;
  unsigned char D.30174;
  int D.30175;
  gboolean D.30179;
  int D.27186;
  int iftmp.3;
  int D.27185;
  const char[2] * D.30183;
  unsigned char D.30184;
  int D.30185;
  unsigned char D.30186;
  int D.30187;
  _Bool D.30188;
  _Bool D.30189;
  _Bool D.30190;
  const unsigned char * D.30193;
  unsigned char D.30194;
  int D.30195;
  const unsigned char * D.30196;
  unsigned char D.30197;
  int D.30198;
  _Bool D.30199;
  _Bool D.30200;
  const unsigned char * D.30203;
  unsigned char D.30204;
  int D.30205;
  const unsigned char * D.30206;
  unsigned char D.30207;
  int D.30208;
  _Bool D.30209;
  _Bool D.30210;
  const unsigned char * D.30213;
  unsigned char D.30214;
  int D.30215;
  const unsigned char * D.30216;
  unsigned char D.30217;
  int D.30218;
  struct _IO_FILE * stderr.4;

  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = flag;
      D.30140 = "y";
      D.30141 = MEM[(const unsigned char *)D.30140];
      D.30142 = (int) D.30141;
      D.30143 = *__s2;
      D.30144 = (int) D.30143;
      __result = D.30142 - D.30144;
      {
        D.30145 = __s2_len != 0;
        D.30146 = __result == 0;
        D.30147 = D.30145 & D.30146;
        if (D.30147 != 0) goto <D.30148>; else goto <D.30149>;
        <D.30148>:
        D.30150 = &MEM[(void *)"y" + 1B];
        D.30151 = *D.30150;
        D.30152 = (int) D.30151;
        D.30153 = __s2 + 1;
        D.30154 = *D.30153;
        D.30155 = (int) D.30154;
        __result = D.30152 - D.30155;
        D.30156 = __s2_len > 1;
        D.30146 = __result == 0;
        D.30157 = D.30156 & D.30146;
        if (D.30157 != 0) goto <D.30158>; else goto <D.30159>;
        <D.30158>:
        D.30160 = &MEM[(void *)"y" + 2B];
        D.30161 = *D.30160;
        D.30162 = (int) D.30161;
        D.30163 = __s2 + 2;
        D.30164 = *D.30163;
        D.30165 = (int) D.30164;
        __result = D.30162 - D.30165;
        D.30166 = __s2_len > 2;
        D.30146 = __result == 0;
        D.30167 = D.30166 & D.30146;
        if (D.30167 != 0) goto <D.30168>; else goto <D.30169>;
        <D.30168>:
        D.30170 = &MEM[(void *)"y" + 3B];
        D.30171 = *D.30170;
        D.30172 = (int) D.30171;
        D.30173 = __s2 + 3;
        D.30174 = *D.30173;
        D.30175 = (int) D.30174;
        __result = D.30172 - D.30175;
        <D.30169>:
        <D.30159>:
        <D.30149>:
      }
      D.27176 = __result;
    }
    iftmp.2 = -D.27176;
    goto <D.30176>;
    <D.30139>:
    iftmp.2 = __builtin_strcmp (flag, "y");
    <D.30176>:
    D.27177 = iftmp.2;
  }
  if (D.27177 == 0) goto <D.30177>; else goto <D.30178>;
  <D.30177>:
  D.30179 = 1;
  return D.30179;
  <D.30178>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = flag;
      D.30183 = "n";
      D.30184 = MEM[(const unsigned char *)D.30183];
      D.30185 = (int) D.30184;
      D.30186 = *__s2;
      D.30187 = (int) D.30186;
      __result = D.30185 - D.30187;
      {
        D.30188 = __s2_len != 0;
        D.30189 = __result == 0;
        D.30190 = D.30188 & D.30189;
        if (D.30190 != 0) goto <D.30191>; else goto <D.30192>;
        <D.30191>:
        D.30193 = &MEM[(void *)"n" + 1B];
        D.30194 = *D.30193;
        D.30195 = (int) D.30194;
        D.30196 = __s2 + 1;
        D.30197 = *D.30196;
        D.30198 = (int) D.30197;
        __result = D.30195 - D.30198;
        D.30199 = __s2_len > 1;
        D.30189 = __result == 0;
        D.30200 = D.30199 & D.30189;
        if (D.30200 != 0) goto <D.30201>; else goto <D.30202>;
        <D.30201>:
        D.30203 = &MEM[(void *)"n" + 2B];
        D.30204 = *D.30203;
        D.30205 = (int) D.30204;
        D.30206 = __s2 + 2;
        D.30207 = *D.30206;
        D.30208 = (int) D.30207;
        __result = D.30205 - D.30208;
        D.30209 = __s2_len > 2;
        D.30189 = __result == 0;
        D.30210 = D.30209 & D.30189;
        if (D.30210 != 0) goto <D.30211>; else goto <D.30212>;
        <D.30211>:
        D.30213 = &MEM[(void *)"n" + 3B];
        D.30214 = *D.30213;
        D.30215 = (int) D.30214;
        D.30216 = __s2 + 3;
        D.30217 = *D.30216;
        D.30218 = (int) D.30217;
        __result = D.30215 - D.30218;
        <D.30212>:
        <D.30202>:
        <D.30192>:
      }
      D.27185 = __result;
    }
    iftmp.3 = -D.27185;
    goto <D.30219>;
    <D.30182>:
    iftmp.3 = __builtin_strcmp (flag, "n");
    <D.30219>:
    D.27186 = iftmp.3;
  }
  if (D.27186 == 0) goto <D.30220>; else goto <D.30221>;
  <D.30220>:
  D.30179 = 0;
  return D.30179;
  <D.30221>:
  stderr.4 = stderr;
  fprintf (stderr.4, "debugger-agent: The valid values for the \'%s\' option are \'y\' and \'n\'.\n", option);
  exit (1);
  D.30179 = 0;
  return D.30179;
}


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.30225;
  _Bool D.30226;
  _Bool D.30227;
  int D.30230;
  int pos.6;
  int address.7;
  int D.30233;
  int D.30234;
  unsigned int D.30235;
  void * D.30236;
  char * D.30237;
  unsigned int D.30238;
  sizetype D.30239;
  char * D.30240;
  const char * D.30241;
  int D.30242;
  char * pos;

  pos = __builtin_strchr (address, 58);
  D.30225 = pos == 0B;
  D.30226 = pos == address;
  D.30227 = D.30225 | D.30226;
  if (D.30227 != 0) goto <D.30228>; else goto <D.30229>;
  <D.30228>:
  D.30230 = 1;
  return D.30230;
  <D.30229>:
  pos.6 = (int) pos;
  address.7 = (int) address;
  D.30233 = pos.6 - address.7;
  D.30234 = D.30233 + 1;
  D.30235 = (unsigned int) D.30234;
  D.30236 = monoeg_malloc (D.30235);
  *host = D.30236;
  D.30237 = *host;
  pos.6 = (int) pos;
  address.7 = (int) address;
  D.30233 = pos.6 - address.7;
  D.30238 = (unsigned int) D.30233;
  strncpy (D.30237, address, D.30238);
  D.30237 = *host;
  pos.6 = (int) pos;
  address.7 = (int) address;
  D.30233 = pos.6 - address.7;
  D.30239 = (sizetype) D.30233;
  D.30240 = D.30237 + D.30239;
  *D.30240 = 0;
  D.30241 = pos + 1;
  D.30242 = atoi (D.30241);
  *port = D.30242;
  D.30230 = 0;
  return D.30230;
}


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

  D.30245 = __builtin_object_size (__dest, 1);
  D.30244 = __builtin___strncpy_chk (__dest, __src, __len, D.30245);
  return D.30244;
}


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

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


mono_debugger_agent_init ()
{
  int D.30249;
  struct GPtrArray * event_requests.8;
  struct MonoGHashTable * thread_to_tls.9;
  int D.30254;
  struct MonoGHashTable * tid_to_thread.10;
  int D.30258;
  struct MonoGHashTable * tid_to_thread_obj.11;
  int D.30262;
  struct GPtrArray * pending_assembly_loads.12;
  struct GHashTable * domains.13;
  int log_level.14;
  int embedding.15;
  char * D.30269;
  struct FILE * log_file.16;
  struct FILE * log_file.17;
  struct _IO_FILE * stderr.18;
  int * D.30277;
  int D.30278;
  char * D.30279;
  struct _IO_FILE * stdout.19;
  struct MonoDebugOptions * D.30282;
  struct MonoDebugOptions * D.30283;
  struct MonoDebugOptions * D.30284;
  int D.30285;
  int D.30288;
  struct GSList * D.30291;

  D.30249 = agent_config.enabled;
  if (D.30249 == 0) goto <D.30250>; else goto <D.30251>;
  <D.30250>:
  return;
  <D.30251>:
  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.30254 = mono_gc_is_moving ();
  if (D.30254 == 0) goto <D.30255>; else goto <D.30256>;
  <D.30255>:
  mono_gc_register_root (&thread_to_tls, 4, 0B);
  <D.30256>:
  tid_to_thread.10 = mono_g_hash_table_new_type (0B, 0B, 2);
  tid_to_thread = tid_to_thread.10;
  D.30258 = mono_gc_is_moving ();
  if (D.30258 == 0) goto <D.30259>; else goto <D.30260>;
  <D.30259>:
  mono_gc_register_root (&tid_to_thread, 4, 0B);
  <D.30260>:
  tid_to_thread_obj.11 = mono_g_hash_table_new_type (0B, 0B, 2);
  tid_to_thread_obj = tid_to_thread_obj.11;
  D.30262 = mono_gc_is_moving ();
  if (D.30262 == 0) goto <D.30263>; else goto <D.30264>;
  <D.30263>:
  mono_gc_register_root (&tid_to_thread_obj, 4, 0B);
  <D.30264>:
  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.30269 = agent_config.log_file;
  if (D.30269 != 0B) goto <D.30270>; else goto <D.30271>;
  <D.30270>:
  D.30269 = agent_config.log_file;
  log_file.16 = fopen (D.30269, "w+");
  log_file = log_file.16;
  log_file.17 = log_file;
  if (log_file.17 == 0B) goto <D.30274>; else goto <D.30275>;
  <D.30274>:
  stderr.18 = stderr;
  D.30269 = agent_config.log_file;
  D.30277 = __errno_location ();
  D.30278 = *D.30277;
  D.30279 = strerror (D.30278);
  fprintf (stderr.18, "Unable to create log file \'%s\': %s.\n", D.30269, D.30279);
  exit (1);
  <D.30275>:
  goto <D.30280>;
  <D.30271>:
  stdout.19 = stdout;
  log_file = stdout.19;
  <D.30280>:
  ids_init ();
  objrefs_init ();
  breakpoints_init ();
  suspend_init ();
  D.30282 = mini_get_debug_options ();
  D.30282->gen_seq_points = 1;
  D.30283 = mini_get_debug_options ();
  D.30283->mdb_optimizations = 1;
  D.30284 = mini_get_debug_options ();
  D.30284->load_aot_jit_info_eagerly = 1;
  D.30285 = agent_config.setpgid;
  if (D.30285 != 0) goto <D.30286>; else goto <D.30287>;
  <D.30286>:
  setpgid (0, 0);
  <D.30287>:
  D.30288 = agent_config.onuncaught;
  if (D.30288 == 0) goto <D.30289>; else goto <D.30290>;
  <D.30289>:
  D.30291 = agent_config.onthrow;
  if (D.30291 == 0B) goto <D.30292>; else goto <D.30293>;
  <D.30292>:
  finish_agent_init (1);
  <D.30293>:
  <D.30290>:
}


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.30303;
  struct MonoInternalThread * D.30304;
  struct GPtrArray * event_requests.23;
  void * * D.30306;
  unsigned int i.24;
  unsigned int D.30308;
  void * * D.30309;
  int D.30310;
  void * D.30313;
  unsigned int i.25;
  unsigned int D.30315;
  int i;
  void * stackptr;

  stackptr = __builtin_frame_address (1);
  embedding.20 = embedding;
  if (embedding.20 == 0) goto <D.30295>; else goto <D.30298>;
  <D.30298>:
  ss_req.21 = ss_req;
  if (ss_req.21 == 0B) goto <D.30295>; else goto <D.30300>;
  <D.30300>:
  ss_invoke_addr.22 = ss_invoke_addr;
  if (stackptr != ss_invoke_addr.22) goto <D.30295>; else goto <D.30302>;
  <D.30302>:
  ss_req.21 = ss_req;
  D.30303 = ss_req.21->thread;
  D.30304 = mono_thread_internal_current ();
  if (D.30303 != D.30304) goto <D.30295>; else goto <D.30296>;
  <D.30295>:
  return;
  <D.30296>:
  mono_loader_lock ();
  ss_invoke_addr = 0B;
  i = 0;
  goto <D.28273>;
  <D.28272>:
  {
    struct EventRequest * req;

    event_requests.23 = event_requests;
    D.30306 = event_requests.23->pdata;
    i.24 = (unsigned int) i;
    D.30308 = i.24 * 4;
    D.30309 = D.30306 + D.30308;
    req = *D.30309;
    D.30310 = req->event_kind;
    if (D.30310 == 11) goto <D.30311>; else goto <D.30312>;
    <D.30311>:
    D.30313 = req->info;
    ss_destroy (D.30313);
    event_requests.23 = event_requests;
    i.25 = (unsigned int) i;
    monoeg_g_ptr_array_remove_index_fast (event_requests.23, i.25);
    monoeg_g_free (req);
    goto <D.28271>;
    <D.30312>:
  }
  i = i + 1;
  <D.28273>:
  i.25 = (unsigned int) i;
  event_requests.23 = event_requests;
  D.30315 = event_requests.23->len;
  if (i.25 < D.30315) goto <D.28272>; else goto <D.28271>;
  <D.28271>:
  mono_loader_unlock ();
}


ss_destroy (struct SingleStepReq * req)
{
  struct SingleStepReq * ss_req.26;
  _Bool D.30318;
  long int D.30319;
  long int D.30320;

  ss_req.26 = ss_req;
  D.30318 = ss_req.26 != req;
  D.30319 = (long int) D.30318;
  D.30320 = __builtin_expect (D.30319, 0);
  if (D.30320 != 0) goto <D.30321>; else goto <D.30322>;
  <D.30321>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 5255, "ss_req == req");
  <D.30322>:
  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.30323;
  void * D.30326;
  int D.30327;

  D.30323 = ss_req->bps;
  if (D.30323 != 0B) goto <D.30324>; else goto <D.30325>;
  <D.30324>:
  {
    struct GSList * l;

    l = ss_req->bps;
    goto <D.28590>;
    <D.28589>:
    D.30326 = l->data;
    clear_breakpoint (D.30326);
    l = l->next;
    <D.28590>:
    if (l != 0B) goto <D.28589>; else goto <D.28591>;
    <D.28591>:
    D.30323 = ss_req->bps;
    monoeg_g_slist_free (D.30323);
    ss_req->bps = 0B;
  }
  <D.30325>:
  D.30327 = ss_req->global;
  if (D.30327 != 0) goto <D.30328>; else goto <D.30329>;
  <D.30328>:
  stop_single_stepping ();
  ss_req->global = 0;
  <D.30329>:
}


clear_breakpoint (struct MonoBreakpoint * bp)
{
  struct GPtrArray * D.30330;
  void * * D.30331;
  unsigned int i.27;
  unsigned int D.30333;
  void * * D.30334;
  unsigned int i.28;
  unsigned int D.30336;
  struct GPtrArray * breakpoints.29;
  int i;

  i = 0;
  goto <D.28413>;
  <D.28412>:
  {
    struct BreakpointInstance * inst;

    D.30330 = bp->children;
    D.30331 = D.30330->pdata;
    i.27 = (unsigned int) i;
    D.30333 = i.27 * 4;
    D.30334 = D.30331 + D.30333;
    inst = *D.30334;
    remove_breakpoint (inst);
    monoeg_g_free (inst);
  }
  i = i + 1;
  <D.28413>:
  i.28 = (unsigned int) i;
  D.30330 = bp->children;
  D.30336 = D.30330->len;
  if (i.28 < D.30336) goto <D.28412>; else goto <D.28414>;
  <D.28414>:
  mono_loader_lock ();
  breakpoints.29 = breakpoints;
  monoeg_g_ptr_array_remove (breakpoints.29, bp);
  mono_loader_unlock ();
  D.30330 = bp->children;
  monoeg_g_ptr_array_free (D.30330, 1);
  monoeg_g_free (bp);
}


remove_breakpoint (struct BreakpointInstance * inst)
{
  struct GHashTable * bp_locs.30;
  void * D.30339;
  int D.30340;
  void * D.30341;
  _Bool D.30342;
  long int D.30343;
  long int D.30344;
  long int D.30349;
  int count;
  struct MonoJitInfo * ji;
  guint8 * ip;

  ji = inst->ji;
  ip = inst->ip;
  mono_loader_lock ();
  bp_locs.30 = bp_locs;
  D.30339 = monoeg_g_hash_table_lookup (bp_locs.30, ip);
  count = (int) D.30339;
  bp_locs.30 = bp_locs;
  D.30340 = count + -1;
  D.30341 = (void *) D.30340;
  monoeg_g_hash_table_insert_replace (bp_locs.30, ip, D.30341, 0);
  mono_loader_unlock ();
  D.30342 = count <= 0;
  D.30343 = (long int) D.30342;
  D.30344 = __builtin_expect (D.30343, 0);
  if (D.30344 != 0) goto <D.30345>; else goto <D.30346>;
  <D.30345>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 4193, "count > 0");
  <D.30346>:
  if (count == 1) goto <D.30347>; else goto <D.30348>;
  <D.30347>:
  D.30349 = inst->native_offset;
  if (D.30349 != -1) goto <D.30350>; else goto <D.30351>;
  <D.30350>:
  mono_arch_clear_breakpoint (ji, ip);
  <D.30351>:
  <D.30348>:
}


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

  val = InterlockedDecrement (&ss_count);
  if (val == 0) goto <D.30352>; else goto <D.30353>;
  <D.30352>:
  mono_arch_stop_single_stepping ();
  <D.30353>:
  ss_req.31 = ss_req;
  if (ss_req.31 != 0B) goto <D.30355>; else goto <D.30356>;
  <D.30355>:
  ss_invoke_addr = 0B;
  <D.30356>:
}


InterlockedDecrement (volatile gint32 * val)
{
  gint32 D.30357;
  unsigned int D.30358;

  D.30358 = __sync_sub_and_fetch_4 (val, 1);
  D.30357 = (gint32) D.30358;
  return D.30357;
}


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.30361>; else goto <D.30362>;
  <D.30361>:
  tls->invoke_addr = stackptr;
  <D.30362>:
  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.30364;
  void * * D.30367;
  struct MonoClass * D.30369;

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

    assembly = 0B;
    mono_loader_lock ();
    pending_assembly_loads.33 = pending_assembly_loads;
    D.30364 = pending_assembly_loads.33->len;
    if (D.30364 != 0) goto <D.30365>; else goto <D.30366>;
    <D.30365>:
    pending_assembly_loads.33 = pending_assembly_loads;
    D.30367 = pending_assembly_loads.33->pdata;
    assembly = *D.30367;
    pending_assembly_loads.33 = pending_assembly_loads;
    monoeg_g_ptr_array_remove_index (pending_assembly_loads.33, 0);
    <D.30366>:
    mono_loader_unlock ();
    if (assembly != 0B) goto <D.30368>; else goto <D.28296>;
    <D.30368>:
    process_profiler_event (8, assembly);
  }
  goto <D.28297>;
  <D.28296>:
  D.30369 = method->klass;
  send_type_load (D.30369);
  if (result == 0) goto <D.30370>; else goto <D.30371>;
  <D.30370>:
  add_pending_breakpoints (method, jinfo);
  <D.30371>:
}


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.30372>; else goto <D.30373>;
      <D.30372>:
      ei.klass = arg;
      ei_arg = &ei;
      <D.30373>:
      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.30379;
  void * * D.30380;
  unsigned int i.35;
  unsigned int D.30382;
  void * * D.30383;
  int D.30384;
  unsigned int D.30385;
  <unnamed type> D.30388;
  int D.30391;
  int D.30396;
  struct MonoInternalThread * D.30402;
  struct MonoInternalThread * D.30403;
  struct MonoClass * D.30411;
  int D.30414;
  struct MonoObject * D.30417;
  struct MonoVTable * D.30418;
  struct MonoClass * D.30419;
  int D.30420;
  int D.30429;
  int D.30432;
  int D.30437;
  unsigned int k.36;
  unsigned int D.30447;
  struct MonoAssembly * * D.30448;
  struct MonoAssembly * D.30449;
  struct MonoMethod * D.30450;
  struct MonoClass * D.30451;
  struct MonoImage * D.30452;
  struct MonoAssembly * D.30453;
  struct MonoClass * D.30462;
  struct GPtrArray * source_file_list.37;
  void * * D.30467;
  unsigned int i.38;
  unsigned int D.30469;
  void * * D.30470;
  char * D.30471;
  struct GHashTable * D.30472;
  void * D.30473;
  void * D.30477;
  unsigned int i.39;
  unsigned int D.30481;
  struct MonoType * D.30489;
  struct GHashTable * D.30490;
  void * D.30491;
  <unnamed type> D.30496;
  unsigned int D.30497;
  struct MonoMethod * D.30502;
  short unsigned int D.30503;
  int D.30504;
  int D.30505;
  int D.28130;
  int iftmp.40;
  int D.28129;
  struct MonoMethod * D.30511;
  const char[7] * D.30512;
  unsigned char D.30513;
  int D.30514;
  unsigned char D.30515;
  int D.30516;
  _Bool D.30517;
  _Bool D.30518;
  _Bool D.30519;
  const unsigned char * D.30522;
  unsigned char D.30523;
  int D.30524;
  const unsigned char * D.30525;
  unsigned char D.30526;
  int D.30527;
  _Bool D.30528;
  _Bool D.30529;
  const unsigned char * D.30532;
  unsigned char D.30533;
  int D.30534;
  const unsigned char * D.30535;
  unsigned char D.30536;
  int D.30537;
  _Bool D.30538;
  _Bool D.30539;
  const unsigned char * D.30542;
  unsigned char D.30543;
  int D.30544;
  const unsigned char * D.30545;
  unsigned char D.30546;
  int D.30547;
  struct MonoMethod * D.30549;
  const char * D.30550;
  unsigned int D.30553;
  struct MonoClass * klass.41;
  struct MonoImage * D.30561;
  struct MonoClass * klass.42;
  _Bool D.30563;
  long int D.30564;
  long int D.30565;
  unsigned char D.30568;
  unsigned char D.30569;
  struct MonoMethod * D.30572;
  int D.30575;
  unsigned char D.30578;
  unsigned int D.30581;
  struct MonoClass * klass.43;
  struct MonoClass * klass.44;
  _Bool D.30590;
  long int D.30591;
  long int D.30592;
  unsigned char D.30595;
  unsigned char D.30596;
  struct MonoMethod * D.30599;
  int D.30602;
  struct MonoMethod * D.30605;
  struct MonoClass * D.30606;
  int D.30609;
  unsigned char D.30612;
  int D.30615;
  int D.30618;
  int D.30619;
  int D.30620;
  int D.30621;
  void * D.30622;
  unsigned int i.45;
  unsigned int D.30624;
  int i;
  int j;
  struct GSList * events;

  events = 0B;
  *suspend_policy = 0;
  if (reqs == 0B) goto <D.30375>; else goto <D.30376>;
  <D.30375>:
  reqs = event_requests;
  <D.30376>:
  if (reqs == 0B) goto <D.30377>; else goto <D.30378>;
  <D.30377>:
  D.30379 = 0B;
  return D.30379;
  <D.30378>:
  i = 0;
  goto <D.28139>;
  <D.28138>:
  {
    struct EventRequest * req;

    D.30380 = reqs->pdata;
    i.35 = (unsigned int) i;
    D.30382 = i.35 * 4;
    D.30383 = D.30380 + D.30382;
    req = *D.30383;
    D.30384 = req->event_kind;
    D.30385 = (unsigned int) D.30384;
    if (D.30385 == event) goto <D.30386>; else goto <D.30387>;
    <D.30386>:
    {
      gboolean filtered;

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

        mod = &req->modifiers[j];
        D.30388 = mod->kind;
        if (D.30388 == 1) goto <D.30389>; else goto <D.30390>;
        <D.30389>:
        filtered = 1;
        D.30391 = mod->data.count;
        if (D.30391 > 0) goto <D.30392>; else goto <D.30393>;
        <D.30392>:
        D.30391 = mod->data.count;
        if (D.30391 > 0) goto <D.30394>; else goto <D.30395>;
        <D.30394>:
        D.30391 = mod->data.count;
        D.30396 = D.30391 + -1;
        mod->data.count = D.30396;
        D.30391 = mod->data.count;
        if (D.30391 == 0) goto <D.30397>; else goto <D.30398>;
        <D.30397>:
        filtered = 0;
        <D.30398>:
        <D.30395>:
        <D.30393>:
        goto <D.30399>;
        <D.30390>:
        D.30388 = mod->kind;
        if (D.30388 == 3) goto <D.30400>; else goto <D.30401>;
        <D.30400>:
        D.30402 = mod->data.thread;
        D.30403 = mono_thread_internal_current ();
        if (D.30402 != D.30403) goto <D.30404>; else goto <D.30405>;
        <D.30404>:
        filtered = 1;
        <D.30405>:
        goto <D.30406>;
        <D.30401>:
        D.30388 = mod->kind;
        if (D.30388 == 8) goto <D.30409>; else goto <D.30407>;
        <D.30409>:
        if (ei != 0B) goto <D.30410>; else goto <D.30407>;
        <D.30410>:
        D.30411 = mod->data.exc_class;
        if (D.30411 != 0B) goto <D.30412>; else goto <D.30413>;
        <D.30412>:
        D.30414 = mod->subclasses;
        if (D.30414 != 0) goto <D.30415>; else goto <D.30416>;
        <D.30415>:
        D.30411 = mod->data.exc_class;
        D.30417 = ei->exc;
        D.30418 = D.30417->vtable;
        D.30419 = D.30418->klass;
        D.30420 = mono_class_is_assignable_from (D.30411, D.30419);
        if (D.30420 == 0) goto <D.30421>; else goto <D.30422>;
        <D.30421>:
        filtered = 1;
        <D.30422>:
        <D.30416>:
        <D.30413>:
        D.30411 = mod->data.exc_class;
        if (D.30411 != 0B) goto <D.30423>; else goto <D.30424>;
        <D.30423>:
        D.30414 = mod->subclasses;
        if (D.30414 == 0) goto <D.30425>; else goto <D.30426>;
        <D.30425>:
        D.30411 = mod->data.exc_class;
        D.30417 = ei->exc;
        D.30418 = D.30417->vtable;
        D.30419 = D.30418->klass;
        if (D.30411 != D.30419) goto <D.30427>; else goto <D.30428>;
        <D.30427>:
        filtered = 1;
        <D.30428>:
        <D.30426>:
        <D.30424>:
        D.30429 = ei->caught;
        if (D.30429 != 0) goto <D.30430>; else goto <D.30431>;
        <D.30430>:
        D.30432 = mod->caught;
        if (D.30432 == 0) goto <D.30433>; else goto <D.30434>;
        <D.30433>:
        filtered = 1;
        <D.30434>:
        <D.30431>:
        D.30429 = ei->caught;
        if (D.30429 == 0) goto <D.30435>; else goto <D.30436>;
        <D.30435>:
        D.30437 = mod->uncaught;
        if (D.30437 == 0) goto <D.30438>; else goto <D.30439>;
        <D.30438>:
        filtered = 1;
        <D.30439>:
        <D.30436>:
        goto <D.30408>;
        <D.30407>:
        D.30388 = mod->kind;
        if (D.30388 == 11) goto <D.30442>; else goto <D.30440>;
        <D.30442>:
        if (ji != 0B) goto <D.30443>; else goto <D.30440>;
        <D.30443>:
        {
          int k;
          gboolean found;
          struct MonoAssembly * * assemblies;

          found = 0;
          assemblies = mod->data.assemblies;
          if (assemblies != 0B) goto <D.30444>; else goto <D.30445>;
          <D.30444>:
          k = 0;
          goto <D.28102>;
          <D.28101>:
          k.36 = (unsigned int) k;
          D.30447 = k.36 * 4;
          D.30448 = assemblies + D.30447;
          D.30449 = *D.30448;
          D.30450 = jinfo_get_method (ji);
          D.30451 = D.30450->klass;
          D.30452 = D.30451->image;
          D.30453 = D.30452->assembly;
          if (D.30449 == D.30453) goto <D.30454>; else goto <D.30455>;
          <D.30454>:
          found = 1;
          <D.30455>:
          k = k + 1;
          <D.28102>:
          k.36 = (unsigned int) k;
          D.30447 = k.36 * 4;
          D.30448 = assemblies + D.30447;
          D.30449 = *D.30448;
          if (D.30449 != 0B) goto <D.28101>; else goto <D.28103>;
          <D.28103>:
          <D.30445>:
          if (found == 0) goto <D.30456>; else goto <D.30457>;
          <D.30456>:
          filtered = 1;
          <D.30457>:
        }
        goto <D.30441>;
        <D.30440>:
        D.30388 = mod->kind;
        if (D.30388 == 12) goto <D.30460>; else goto <D.30458>;
        <D.30460>:
        if (ei != 0B) goto <D.30461>; else goto <D.30458>;
        <D.30461>:
        D.30462 = ei->klass;
        if (D.30462 != 0B) goto <D.30463>; else goto <D.30458>;
        <D.30463>:
        {
          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.28119>;
              <D.28118>:
              {
                struct MonoDebugMethodInfo * minfo;

                minfo = mono_debug_lookup_method (method);
                if (minfo != 0B) goto <D.30464>; else goto <D.30465>;
                <D.30464>:
                mono_debug_symfile_get_line_numbers_full (minfo, &source_file, &source_file_list, 0B, 0B, 0B, 0B, 0B);
                i = 0;
                goto <D.28116>;
                <D.28115>:
                source_file_list.37 = source_file_list;
                D.30467 = source_file_list.37->pdata;
                i.38 = (unsigned int) i;
                D.30469 = i.38 * 4;
                D.30470 = D.30467 + D.30469;
                sinfo = *D.30470;
                D.30471 = sinfo->source_file;
                s = strdup_tolower (D.30471);
                D.30472 = mod->data.source_files;
                D.30473 = monoeg_g_hash_table_lookup (D.30472, s);
                if (D.30473 != 0B) goto <D.30474>; else goto <D.30475>;
                <D.30474>:
                found = 1;
                goto <D.30476>;
                <D.30475>:
                {
                  char * s2;
                  char * s3;

                  D.30471 = sinfo->source_file;
                  s2 = monoeg_g_path_get_basename (D.30471);
                  s3 = strdup_tolower (s2);
                  D.30472 = mod->data.source_files;
                  D.30477 = monoeg_g_hash_table_lookup (D.30472, s3);
                  if (D.30477 != 0B) goto <D.30478>; else goto <D.30479>;
                  <D.30478>:
                  found = 1;
                  <D.30479>:
                  monoeg_g_free (s2);
                  monoeg_g_free (s3);
                }
                <D.30476>:
                monoeg_g_free (s);
                i = i + 1;
                <D.28116>:
                i.39 = (unsigned int) i;
                source_file_list.37 = source_file_list;
                D.30481 = source_file_list.37->len;
                if (i.39 < D.30481) goto <D.28115>; else goto <D.28117>;
                <D.28117>:
                source_file_list.37 = source_file_list;
                monoeg_g_ptr_array_free (source_file_list.37, 1);
                <D.30465>:
              }
              <D.28119>:
              D.30462 = ei->klass;
              method = mono_class_get_methods (D.30462, &iter);
              if (method != 0B) goto <D.28118>; else goto <D.28120>;
              <D.28120>:
              if (found == 0) goto <D.30482>; else goto <D.30483>;
              <D.30482>:
              filtered = 1;
              <D.30483>:
            }
          finally
            {
              iter = {CLOBBER};
              source_file = {CLOBBER};
              source_file_list = {CLOBBER};
            }
        }
        goto <D.30459>;
        <D.30458>:
        D.30388 = mod->kind;
        if (D.30388 == 13) goto <D.30486>; else goto <D.30484>;
        <D.30486>:
        if (ei != 0B) goto <D.30487>; else goto <D.30484>;
        <D.30487>:
        D.30462 = ei->klass;
        if (D.30462 != 0B) goto <D.30488>; else goto <D.30484>;
        <D.30488>:
        {
          char * s;

          D.30462 = ei->klass;
          D.30489 = &D.30462->byval_arg;
          s = mono_type_full_name (D.30489);
          D.30490 = mod->data.type_names;
          D.30491 = monoeg_g_hash_table_lookup (D.30490, s);
          if (D.30491 == 0B) goto <D.30492>; else goto <D.30493>;
          <D.30492>:
          filtered = 1;
          <D.30493>:
          monoeg_g_free (s);
        }
        goto <D.30485>;
        <D.30484>:
        D.30388 = mod->kind;
        if (D.30388 == 10) goto <D.30494>; else goto <D.30495>;
        <D.30494>:
        D.30496 = mod->data.filter;
        D.30497 = D.30496 & 1;
        if (D.30497 != 0) goto <D.30498>; else goto <D.30499>;
        <D.30498>:
        if (ji != 0B) goto <D.30500>; else goto <D.30501>;
        <D.30500>:
        D.30502 = jinfo_get_method (ji);
        D.30503 = D.30502->flags;
        D.30504 = (int) D.30503;
        D.30505 = D.30504 & 2048;
        if (D.30505 != 0) goto <D.30506>; else goto <D.30507>;
        <D.30506>:
        {
          size_t __s1_len;
          size_t __s2_len;

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

            D.30511 = jinfo_get_method (ji);
            __s2 = D.30511->name;
            D.30512 = ".cctor";
            D.30513 = MEM[(const unsigned char *)D.30512];
            D.30514 = (int) D.30513;
            D.30515 = *__s2;
            D.30516 = (int) D.30515;
            __result = D.30514 - D.30516;
            {
              D.30517 = __s2_len != 0;
              D.30518 = __result == 0;
              D.30519 = D.30517 & D.30518;
              if (D.30519 != 0) goto <D.30520>; else goto <D.30521>;
              <D.30520>:
              D.30522 = &MEM[(void *)".cctor" + 1B];
              D.30523 = *D.30522;
              D.30524 = (int) D.30523;
              D.30525 = __s2 + 1;
              D.30526 = *D.30525;
              D.30527 = (int) D.30526;
              __result = D.30524 - D.30527;
              D.30528 = __s2_len > 1;
              D.30518 = __result == 0;
              D.30529 = D.30528 & D.30518;
              if (D.30529 != 0) goto <D.30530>; else goto <D.30531>;
              <D.30530>:
              D.30532 = &MEM[(void *)".cctor" + 2B];
              D.30533 = *D.30532;
              D.30534 = (int) D.30533;
              D.30535 = __s2 + 2;
              D.30536 = *D.30535;
              D.30537 = (int) D.30536;
              __result = D.30534 - D.30537;
              D.30538 = __s2_len > 2;
              D.30518 = __result == 0;
              D.30539 = D.30538 & D.30518;
              if (D.30539 != 0) goto <D.30540>; else goto <D.30541>;
              <D.30540>:
              D.30542 = &MEM[(void *)".cctor" + 3B];
              D.30543 = *D.30542;
              D.30544 = (int) D.30543;
              D.30545 = __s2 + 3;
              D.30546 = *D.30545;
              D.30547 = (int) D.30546;
              __result = D.30544 - D.30547;
              <D.30541>:
              <D.30531>:
              <D.30521>:
            }
            D.28129 = __result;
          }
          iftmp.40 = -D.28129;
          goto <D.30548>;
          <D.30510>:
          D.30549 = jinfo_get_method (ji);
          D.30550 = D.30549->name;
          iftmp.40 = __builtin_strcmp (D.30550, ".cctor");
          <D.30548>:
          D.28130 = iftmp.40;
        }
        if (D.28130 == 0) goto <D.30551>; else goto <D.30552>;
        <D.30551>:
        filtered = 1;
        <D.30552>:
        <D.30507>:
        <D.30501>:
        <D.30499>:
        D.30496 = mod->data.filter;
        D.30553 = D.30496 & 2;
        if (D.30553 != 0) goto <D.30554>; else goto <D.30555>;
        <D.30554>:
        if (ji != 0B) goto <D.30556>; else goto <D.30557>;
        <D.30556>:
        {
          struct MonoCustomAttrInfo * ainfo;
          static struct MonoClass * klass;

          klass.41 = klass;
          if (klass.41 == 0B) goto <D.30559>; else goto <D.30560>;
          <D.30559>:
          D.30561 = mono_defaults.corlib;
          klass.42 = mono_class_from_name (D.30561, "System.Diagnostics", "DebuggerHiddenAttribute");
          klass = klass.42;
          klass.41 = klass;
          D.30563 = klass.41 == 0B;
          D.30564 = (long int) D.30563;
          D.30565 = __builtin_expect (D.30564, 0);
          if (D.30565 != 0) goto <D.30566>; else goto <D.30567>;
          <D.30566>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 3454, "klass");
          <D.30567>:
          <D.30560>:
          D.30568 = BIT_FIELD_REF <*ji, 8, 176>;
          D.30569 = D.30568 & 64;
          if (D.30569 == 0) goto <D.30570>; else goto <D.30571>;
          <D.30570>:
          D.30572 = jinfo_get_method (ji);
          ainfo = mono_custom_attrs_from_method (D.30572);
          if (ainfo != 0B) goto <D.30573>; else goto <D.30574>;
          <D.30573>:
          klass.41 = klass;
          D.30575 = mono_custom_attrs_has_attr (ainfo, klass.41);
          if (D.30575 != 0) goto <D.30576>; else goto <D.30577>;
          <D.30576>:
          ji->dbg_hidden = -1;
          <D.30577>:
          mono_custom_attrs_free (ainfo);
          <D.30574>:
          ji->dbg_hidden_inited = -1;
          <D.30571>:
          D.30568 = BIT_FIELD_REF <*ji, 8, 176>;
          D.30578 = D.30568 & 128;
          if (D.30578 != 0) goto <D.30579>; else goto <D.30580>;
          <D.30579>:
          filtered = 1;
          <D.30580>:
        }
        <D.30557>:
        <D.30555>:
        D.30496 = mod->data.filter;
        D.30581 = D.30496 & 4;
        if (D.30581 != 0) goto <D.30582>; else goto <D.30583>;
        <D.30582>:
        if (ji != 0B) goto <D.30584>; else goto <D.30585>;
        <D.30584>:
        {
          struct MonoCustomAttrInfo * ainfo;
          static struct MonoClass * klass;

          klass.43 = klass;
          if (klass.43 == 0B) goto <D.30587>; else goto <D.30588>;
          <D.30587>:
          D.30561 = mono_defaults.corlib;
          klass.44 = mono_class_from_name (D.30561, "System.Diagnostics", "DebuggerStepThroughAttribute");
          klass = klass.44;
          klass.43 = klass;
          D.30590 = klass.43 == 0B;
          D.30591 = (long int) D.30590;
          D.30592 = __builtin_expect (D.30591, 0);
          if (D.30592 != 0) goto <D.30593>; else goto <D.30594>;
          <D.30593>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 3474, "klass");
          <D.30594>:
          <D.30588>:
          D.30595 = BIT_FIELD_REF <*ji, 8, 184>;
          D.30596 = D.30595 & 2;
          if (D.30596 == 0) goto <D.30597>; else goto <D.30598>;
          <D.30597>:
          D.30599 = jinfo_get_method (ji);
          ainfo = mono_custom_attrs_from_method (D.30599);
          if (ainfo != 0B) goto <D.30600>; else goto <D.30601>;
          <D.30600>:
          klass.43 = klass;
          D.30602 = mono_custom_attrs_has_attr (ainfo, klass.43);
          if (D.30602 != 0) goto <D.30603>; else goto <D.30604>;
          <D.30603>:
          ji->dbg_step_through = -1;
          <D.30604>:
          mono_custom_attrs_free (ainfo);
          <D.30601>:
          D.30605 = jinfo_get_method (ji);
          D.30606 = D.30605->klass;
          ainfo = mono_custom_attrs_from_class (D.30606);
          if (ainfo != 0B) goto <D.30607>; else goto <D.30608>;
          <D.30607>:
          klass.43 = klass;
          D.30609 = mono_custom_attrs_has_attr (ainfo, klass.43);
          if (D.30609 != 0) goto <D.30610>; else goto <D.30611>;
          <D.30610>:
          ji->dbg_step_through = -1;
          <D.30611>:
          mono_custom_attrs_free (ainfo);
          <D.30608>:
          ji->dbg_step_through_inited = -1;
          <D.30598>:
          D.30595 = BIT_FIELD_REF <*ji, 8, 184>;
          D.30612 = D.30595 & 4;
          if (D.30612 != 0) goto <D.30613>; else goto <D.30614>;
          <D.30613>:
          filtered = 1;
          <D.30614>:
        }
        <D.30585>:
        <D.30583>:
        <D.30495>:
        <D.30485>:
        <D.30459>:
        <D.30441>:
        <D.30408>:
        <D.30406>:
        <D.30399>:
      }
      j = j + 1;
      <D.28136>:
      D.30615 = req->nmodifiers;
      if (D.30615 > j) goto <D.28135>; else goto <D.28137>;
      <D.28137>:
      if (filtered == 0) goto <D.30616>; else goto <D.30617>;
      <D.30616>:
      D.30618 = req->suspend_policy;
      D.30619 = *suspend_policy;
      D.30620 = MAX_EXPR <D.30618, D.30619>;
      *suspend_policy = D.30620;
      D.30621 = req->id;
      D.30622 = (void *) D.30621;
      events = monoeg_g_slist_append (events, D.30622);
      <D.30617>:
    }
    <D.30387>:
  }
  i = i + 1;
  <D.28139>:
  i.45 = (unsigned int) i;
  D.30624 = reqs->len;
  if (i.45 < D.30624) goto <D.28138>; else goto <D.28140>;
  <D.28140>:
  if (event == 0) goto <D.30625>; else goto <D.30626>;
  <D.30625>:
  events = monoeg_g_slist_append (events, 0B);
  <D.30626>:
  if (event == 1) goto <D.30627>; else goto <D.30628>;
  <D.30627>:
  events = monoeg_g_slist_append (events, 0B);
  <D.30628>:
  D.30379 = events;
  return D.30379;
}


strdup_tolower (char * s)
{
  int D.28081;
  char D.30632;
  int D.30633;
  int D.30634;
  const int iftmp.46;
  unsigned int __c.47;
  unsigned int D.30639;
  const __int32_t * * D.30642;
  const __int32_t * D.30643;
  unsigned int __c.48;
  unsigned int D.30645;
  const __int32_t * D.30646;
  unsigned int D.30650;
  unsigned int D.30651;
  const __int32_t * D.30652;
  char D.30653;
  char * D.30654;
  char * s2;
  char * p;

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

    {
      if (0 != 0) goto <D.30630>; else goto <D.30631>;
      <D.30630>:
      D.30632 = *p;
      D.30633 = (int) D.30632;
      D.30634 = __builtin_constant_p (D.30633);
      if (D.30634 != 0) goto <D.30635>; else goto <D.30636>;
      <D.30635>:
      {
        int __c;

        D.30632 = *p;
        __c = (int) D.30632;
        __c.47 = (unsigned int) __c;
        D.30639 = __c.47 + 128;
        if (D.30639 <= 383) goto <D.30640>; else goto <D.30641>;
        <D.30640>:
        D.30642 = __ctype_tolower_loc ();
        D.30643 = *D.30642;
        __c.48 = (unsigned int) __c;
        D.30645 = __c.48 * 4;
        D.30646 = D.30643 + D.30645;
        iftmp.46 = *D.30646;
        goto <D.30647>;
        <D.30641>:
        iftmp.46 = __c;
        <D.30647>:
        __res = iftmp.46;
      }
      goto <D.30648>;
      <D.30636>:
      D.30632 = *p;
      D.30633 = (int) D.30632;
      __res = tolower (D.30633);
      <D.30648>:
      goto <D.30649>;
      <D.30631>:
      D.30642 = __ctype_tolower_loc ();
      D.30643 = *D.30642;
      D.30632 = *p;
      D.30650 = (unsigned int) D.30632;
      D.30651 = D.30650 * 4;
      D.30652 = D.30643 + D.30651;
      __res = *D.30652;
      <D.30649>:
    }
    D.28081 = __res;
  }
  D.30653 = (char) D.28081;
  *p = D.30653;
  p = p + 1;
  <D.28083>:
  D.30632 = *p;
  if (D.30632 != 0) goto <D.28082>; else goto <D.28084>;
  <D.28084>:
  D.30654 = s2;
  return D.30654;
}


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

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


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.30662;
  long int D.30663;
  long int D.30664;
  struct FILE * log_file.51;
  const char * D.30668;
  int vm_start_event_sent.52;
  const char * D.30676;
  int vm_death_event_sent.53;
  const char * D.30682;
  int D.30683;
  const char * D.30690;
  int disconnected.54;
  const char * D.30696;
  int D.30702;
  unsigned int D.30705;
  unsigned int debugger_thread_id.55;
  unsigned int D.30711;
  unsigned int D.30716;
  unsigned char D.30717;
  unsigned int nevents.56;
  unsigned char D.30719;
  void * D.30720;
  unsigned int D.30721;
  int ecount.57;
  int ecount.58;
  _Bool D.30726;
  _Bool D.30727;
  _Bool D.30728;
  long long unsigned int D.30731;
  struct MonoDomain * D.30732;
  int protocol_version_set.59;
  int major_version.60;
  int minor_version.61;
  int D.30742;
  unsigned int D.30743;
  struct MonoObject * D.30744;
  int D.30745;
  unsigned int D.30746;
  const char * iftmp.62;
  char * D.30748;
  const char * iftmp.63;
  char * D.30753;
  int iftmp.64;
  int D.30760;
  int D.30768;
  const char * D.30779;
  _Bool D.30782;
  long int D.30783;
  long int D.30784;
  unsigned int D.30787;
  void * D.30788;
  const char * D.30789;
  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.30659>; else goto <D.30660>;
      <D.30659>:
      log_level.50 = log_level;
      D.30662 = log_level.50 > 1;
      D.30663 = (long int) D.30662;
      D.30664 = __builtin_expect (D.30663, 0);
      if (D.30664 != 0) goto <D.30665>; else goto <D.30666>;
      <D.30665>:
      log_file.51 = log_file;
      D.30668 = event_to_string (event);
      fprintf (log_file.51, "Debugger agent not initialized yet: dropping %s\n", D.30668);
      log_file.51 = log_file;
      fflush (log_file.51);
      <D.30666>:
      return;
      <D.30660>:
      vm_start_event_sent.52 = vm_start_event_sent;
      if (vm_start_event_sent.52 == 0) goto <D.30670>; else goto <D.30671>;
      <D.30670>:
      if (event != 0) goto <D.30672>; else goto <D.30673>;
      <D.30672>:
      log_level.50 = log_level;
      D.30662 = log_level.50 > 1;
      D.30663 = (long int) D.30662;
      D.30664 = __builtin_expect (D.30663, 0);
      if (D.30664 != 0) goto <D.30674>; else goto <D.30675>;
      <D.30674>:
      log_file.51 = log_file;
      D.30676 = event_to_string (event);
      fprintf (log_file.51, "VM start event not sent yet: dropping %s\n", D.30676);
      log_file.51 = log_file;
      fflush (log_file.51);
      <D.30675>:
      return;
      <D.30673>:
      <D.30671>:
      vm_death_event_sent.53 = vm_death_event_sent;
      if (vm_death_event_sent.53 != 0) goto <D.30678>; else goto <D.30679>;
      <D.30678>:
      log_level.50 = log_level;
      D.30662 = log_level.50 > 1;
      D.30663 = (long int) D.30662;
      D.30664 = __builtin_expect (D.30663, 0);
      if (D.30664 != 0) goto <D.30680>; else goto <D.30681>;
      <D.30680>:
      log_file.51 = log_file;
      D.30682 = event_to_string (event);
      fprintf (log_file.51, "VM death event has been sent: dropping %s\n", D.30682);
      log_file.51 = log_file;
      fflush (log_file.51);
      <D.30681>:
      return;
      <D.30679>:
      D.30683 = mono_runtime_is_shutting_down ();
      if (D.30683 != 0) goto <D.30684>; else goto <D.30685>;
      <D.30684>:
      if (event != 1) goto <D.30686>; else goto <D.30687>;
      <D.30686>:
      log_level.50 = log_level;
      D.30662 = log_level.50 > 1;
      D.30663 = (long int) D.30662;
      D.30664 = __builtin_expect (D.30663, 0);
      if (D.30664 != 0) goto <D.30688>; else goto <D.30689>;
      <D.30688>:
      log_file.51 = log_file;
      D.30690 = event_to_string (event);
      fprintf (log_file.51, "Mono runtime is shutting down: dropping %s\n", D.30690);
      log_file.51 = log_file;
      fflush (log_file.51);
      <D.30689>:
      return;
      <D.30687>:
      <D.30685>:
      disconnected.54 = disconnected;
      if (disconnected.54 != 0) goto <D.30692>; else goto <D.30693>;
      <D.30692>:
      log_level.50 = log_level;
      D.30662 = log_level.50 > 1;
      D.30663 = (long int) D.30662;
      D.30664 = __builtin_expect (D.30663, 0);
      if (D.30664 != 0) goto <D.30694>; else goto <D.30695>;
      <D.30694>:
      log_file.51 = log_file;
      D.30696 = event_to_string (event);
      fprintf (log_file.51, "Debugger client is not connected: dropping %s\n", D.30696);
      log_file.51 = log_file;
      fflush (log_file.51);
      <D.30695>:
      return;
      <D.30693>:
      if (event == 14) goto <D.30697>; else goto <D.30698>;
      <D.30697>:
      suspend_policy = 0;
      goto <D.30699>;
      <D.30698>:
      if (events == 0B) goto <D.30700>; else goto <D.30701>;
      <D.30700>:
      return;
      <D.30701>:
      D.30702 = agent_config.defer;
      if (D.30702 != 0) goto <D.30703>; else goto <D.30704>;
      <D.30703>:
      D.30705 = GetCurrentThreadId ();
      debugger_thread_id.55 = debugger_thread_id;
      if (D.30705 == debugger_thread_id.55) goto <D.30707>; else goto <D.30708>;
      <D.30707>:
      suspend_policy = 0;
      thread = mono_thread_get_main ();
      goto <D.30709>;
      <D.30708>:
      thread = mono_thread_current ();
      <D.30709>:
      goto <D.30710>;
      <D.30704>:
      D.30711 = GetCurrentThreadId ();
      debugger_thread_id.55 = debugger_thread_id;
      if (D.30711 == debugger_thread_id.55) goto <D.30712>; else goto <D.30713>;
      <D.30712>:
      if (event != 1) goto <D.30714>; else goto <D.30715>;
      <D.30714>:
      return;
      <D.30715>:
      <D.30713>:
      <D.30710>:
      <D.30699>:
      D.30716 = monoeg_g_slist_length (events);
      nevents = (int) D.30716;
      buffer_init (&buf, 128);
      D.30717 = (unsigned char) suspend_policy;
      buffer_add_byte (&buf, D.30717);
      nevents.56 = (unsigned int) nevents;
      buffer_add_int (&buf, nevents.56);
      l = events;
      goto <D.28200>;
      <D.28199>:
      D.30719 = (unsigned char) event;
      buffer_add_byte (&buf, D.30719);
      D.30720 = l->data;
      D.30721 = (unsigned int) D.30720;
      buffer_add_int (&buf, D.30721);
      ecount.57 = ecount;
      ecount.58 = ecount.57 + 1;
      ecount = ecount.58;
      if (thread == 0B) goto <D.30724>; else goto <D.30725>;
      <D.30724>:
      thread = mono_thread_current ();
      <D.30725>:
      D.30726 = event == 0;
      D.30727 = arg != 0B;
      D.30728 = D.30726 & D.30727;
      if (D.30728 != 0) goto <D.30729>; else goto <D.30730>;
      <D.30729>:
      thread = arg;
      <D.30730>:
      buffer_add_objid (&buf, thread);
      switch (event) <default: <D.28198>, case 0: <D.28190>, case 1: <D.28191>, case 2: <D.28178>, case 3: <D.28179>, case 4: <D.28181>, case 5: <D.28182>, case 6: <D.28183>, case 7: <D.28184>, case 8: <D.28185>, case 9: <D.28186>, case 10: <D.28188>, case 11: <D.28189>, case 12: <D.28187>, case 13: <D.28192>, case 14: <D.28197>, case 15: <D.28194>, case 16: <D.28195>>
      <D.28178>:
      <D.28179>:
      goto <D.28180>;
      <D.28181>:
      <D.28182>:
      buffer_add_domainid (&buf, arg);
      goto <D.28180>;
      <D.28183>:
      <D.28184>:
      buffer_add_methodid (&buf, domain, arg);
      goto <D.28180>;
      <D.28185>:
      <D.28186>:
      buffer_add_assemblyid (&buf, domain, arg);
      goto <D.28180>;
      <D.28187>:
      buffer_add_typeid (&buf, domain, arg);
      goto <D.28180>;
      <D.28188>:
      <D.28189>:
      buffer_add_methodid (&buf, domain, arg);
      D.30731 = (long long unsigned int) il_offset;
      buffer_add_long (&buf, D.30731);
      goto <D.28180>;
      <D.28190>:
      D.30732 = mono_get_root_domain ();
      buffer_add_domainid (&buf, D.30732);
      goto <D.28180>;
      <D.28191>:
      protocol_version_set.59 = protocol_version_set;
      if (protocol_version_set.59 != 0) goto <D.30736>; else goto <D.30737>;
      <D.30736>:
      major_version.60 = major_version;
      if (major_version.60 > 2) goto <D.30733>; else goto <D.30739>;
      <D.30739>:
      major_version.60 = major_version;
      if (major_version.60 == 2) goto <D.30740>; else goto <D.30734>;
      <D.30740>:
      minor_version.61 = minor_version;
      if (minor_version.61 > 26) goto <D.30733>; else goto <D.30734>;
      <D.30733>:
      D.30742 = mono_environment_exitcode_get ();
      D.30743 = (unsigned int) D.30742;
      buffer_add_int (&buf, D.30743);
      <D.30734>:
      <D.30737>:
      goto <D.28180>;
      <D.28192>:
      {
        struct EventInfo * ei;

        ei = arg;
        D.30744 = ei->exc;
        buffer_add_objid (&buf, D.30744);
        keepalive_obj = ei->exc;
        goto <D.28180>;
      }
      <D.28194>:
      goto <D.28180>;
      <D.28195>:
      {
        struct EventInfo * ei;

        ei = arg;
        D.30745 = ei->level;
        D.30746 = (unsigned int) D.30745;
        buffer_add_int (&buf, D.30746);
        D.30748 = ei->category;
        if (D.30748 != 0B) goto <D.30749>; else goto <D.30750>;
        <D.30749>:
        iftmp.62 = ei->category;
        goto <D.30751>;
        <D.30750>:
        iftmp.62 = "";
        <D.30751>:
        buffer_add_string (&buf, iftmp.62);
        D.30753 = ei->message;
        if (D.30753 != 0B) goto <D.30754>; else goto <D.30755>;
        <D.30754>:
        iftmp.63 = ei->message;
        goto <D.30756>;
        <D.30755>:
        iftmp.63 = "";
        <D.30756>:
        buffer_add_string (&buf, iftmp.63);
        goto <D.28180>;
      }
      <D.28197>:
      suspend_policy = 0;
      goto <D.28180>;
      <D.28198>:
      monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "debugger-agent.c", 3680);
      <D.28180>:
      l = l->next;
      <D.28200>:
      if (l != 0B) goto <D.28199>; else goto <D.28201>;
      <D.28201>:
      if (event == 0) goto <D.30757>; else goto <D.30758>;
      <D.30757>:
      D.30760 = agent_config.suspend;
      if (D.30760 != 0) goto <D.30761>; else goto <D.30762>;
      <D.30761>:
      iftmp.64 = 2;
      goto <D.30763>;
      <D.30762>:
      iftmp.64 = 0;
      <D.30763>:
      suspend_policy = iftmp.64;
      D.30702 = agent_config.defer;
      if (D.30702 == 0) goto <D.30764>; else goto <D.30765>;
      <D.30764>:
      start_debugger_thread ();
      <D.30765>:
      <D.30758>:
      if (event == 1) goto <D.30766>; else goto <D.30767>;
      <D.30766>:
      vm_death_event_sent = 1;
      suspend_policy = 0;
      <D.30767>:
      D.30768 = mono_runtime_is_shutting_down ();
      if (D.30768 != 0) goto <D.30769>; else goto <D.30770>;
      <D.30769>:
      suspend_policy = 0;
      <D.30770>:
      if (suspend_policy != 0) goto <D.30771>; else goto <D.30772>;
      <D.30771>:
      save_thread_context (ctx);
      suspend_vm ();
      if (keepalive_obj != 0B) goto <D.30773>; else goto <D.30774>;
      <D.30773>:
      get_objref (keepalive_obj);
      <D.30774>:
      <D.30772>:
      send_success = send_packet (64, 100, &buf);
      buffer_free (&buf);
      monoeg_g_slist_free (events);
      events = 0B;
      if (send_success == 0) goto <D.30775>; else goto <D.30776>;
      <D.30775>:
      log_level.50 = log_level;
      D.30662 = log_level.50 > 1;
      D.30663 = (long int) D.30662;
      D.30664 = __builtin_expect (D.30663, 0);
      if (D.30664 != 0) goto <D.30777>; else goto <D.30778>;
      <D.30777>:
      log_file.51 = log_file;
      D.30779 = event_to_string (event);
      fprintf (log_file.51, "Sending command %s failed.\n", D.30779);
      log_file.51 = log_file;
      fflush (log_file.51);
      <D.30778>:
      return;
      <D.30776>:
      if (event == 0) goto <D.30780>; else goto <D.30781>;
      <D.30780>:
      vm_start_event_sent = 1;
      <D.30781>:
      log_level.50 = log_level;
      D.30782 = log_level.50 > 0;
      D.30783 = (long int) D.30782;
      D.30784 = __builtin_expect (D.30783, 0);
      if (D.30784 != 0) goto <D.30785>; else goto <D.30786>;
      <D.30785>:
      log_file.51 = log_file;
      D.30787 = GetCurrentThreadId ();
      D.30788 = (void *) D.30787;
      D.30789 = event_to_string (event);
      ecount.57 = ecount;
      fprintf (log_file.51, "[%p] Sent %d events %s(%d), suspend=%d.\n", D.30788, nevents, D.30789, ecount.57, suspend_policy);
      log_file.51 = log_file;
      fflush (log_file.51);
      <D.30786>:
      switch (suspend_policy) <default: <D.28206>, case 0: <D.28202>, case 1: <D.28205>, case 2: <D.28204>>
      <D.28202>:
      goto <D.28203>;
      <D.28204>:
      suspend_current ();
      goto <D.28203>;
      <D.28205>:
      monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "debugger-agent.c", 3737);
      <D.28206>:
      monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "debugger-agent.c", 3740);
      <D.28203>:
    }
  finally
    {
      buf = {CLOBBER};
    }
}


buffer_init (struct Buffer * buf, int size)
{
  unsigned int size.65;
  void * D.30796;
  guint8 * D.30797;
  sizetype size.66;
  guint8 * D.30799;

  size.65 = (unsigned int) size;
  D.30796 = monoeg_malloc (size.65);
  buf->buf = D.30796;
  D.30797 = buf->buf;
  buf->p = D.30797;
  D.30797 = buf->buf;
  size.66 = (sizetype) size;
  D.30799 = D.30797 + size.66;
  buf->end = D.30799;
}


buffer_add_byte (struct Buffer * buf, guint8 val)
{
  guint8 * D.30800;
  guint8 * D.30801;

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


buffer_make_room (struct Buffer * buf, int size)
{
  guint8 * D.30802;
  int D.30803;
  guint8 * D.30804;
  int D.30805;
  int D.30806;
  guint8 * D.30809;
  int D.30810;
  int D.30811;
  int D.30812;
  unsigned int new_size.67;
  sizetype size.68;
  guint8 * D.30815;
  sizetype new_size.69;
  guint8 * D.30817;

  D.30802 = buf->end;
  D.30803 = (int) D.30802;
  D.30804 = buf->p;
  D.30805 = (int) D.30804;
  D.30806 = D.30803 - D.30805;
  if (D.30806 < size) goto <D.30807>; else goto <D.30808>;
  <D.30807>:
  {
    int new_size;
    guint8 * p;

    D.30802 = buf->end;
    D.30803 = (int) D.30802;
    D.30809 = buf->buf;
    D.30810 = (int) D.30809;
    D.30811 = D.30803 - D.30810;
    D.30812 = D.30811 + size;
    new_size = D.30812 + 32;
    D.30809 = buf->buf;
    new_size.67 = (unsigned int) new_size;
    p = monoeg_realloc (D.30809, new_size.67);
    D.30804 = buf->p;
    D.30805 = (int) D.30804;
    D.30809 = buf->buf;
    D.30810 = (int) D.30809;
    size = D.30805 - D.30810;
    buf->buf = p;
    size.68 = (sizetype) size;
    D.30815 = p + size.68;
    buf->p = D.30815;
    D.30809 = buf->buf;
    new_size.69 = (sizetype) new_size;
    D.30817 = D.30809 + new_size.69;
    buf->end = D.30817;
  }
  <D.30808>:
}


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

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


get_id (struct MonoDomain * domain, IdType type, void * val)
{
  int D.30821;
  union mono_mutex_t * D.30822;
  _Bool D.30825;
  long int D.30826;
  long int D.30827;
  struct GHashTable * D.30830;
  struct GHashTable * D.30833;
  _Bool D.30838;
  long int D.30839;
  long int D.30840;
  struct GPtrArray * D.30843;
  unsigned int D.30844;
  unsigned int D.30845;
  int D.30846;
  _Bool D.30849;
  long int D.30850;
  long int D.30851;
  struct Id * id;
  struct AgentDomainInfo * info;

  if (val == 0B) goto <D.30819>; else goto <D.30820>;
  <D.30819>:
  D.30821 = 0;
  return D.30821;
  <D.30820>:
  mono_loader_lock ();
  {
    int ret;

    D.30822 = &domain->lock.mutex;
    ret = pthread_mutex_lock (D.30822);
    if (ret != 0) goto <D.30823>; else goto <D.30824>;
    <D.30823>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.30824>:
    D.30825 = ret != 0;
    D.30826 = (long int) D.30825;
    D.30827 = __builtin_expect (D.30826, 0);
    if (D.30827 != 0) goto <D.30828>; else goto <D.30829>;
    <D.30828>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 2149, "ret == 0");
    <D.30829>:
  }
  info = get_agent_domain_info (domain);
  D.30830 = info->val_to_id[type];
  if (D.30830 == 0B) goto <D.30831>; else goto <D.30832>;
  <D.30831>:
  D.30833 = monoeg_g_hash_table_new (mono_aligned_addr_hash, 0B);
  info->val_to_id[type] = D.30833;
  <D.30832>:
  D.30830 = info->val_to_id[type];
  id = monoeg_g_hash_table_lookup (D.30830, val);
  if (id != 0B) goto <D.30834>; else goto <D.30835>;
  <D.30834>:
  {
    int ret;

    D.30822 = &domain->lock.mutex;
    ret = pthread_mutex_unlock (D.30822);
    if (ret != 0) goto <D.30836>; else goto <D.30837>;
    <D.30836>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.30837>:
    D.30838 = ret != 0;
    D.30839 = (long int) D.30838;
    D.30840 = __builtin_expect (D.30839, 0);
    if (D.30840 != 0) goto <D.30841>; else goto <D.30842>;
    <D.30841>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 2158, "ret == 0");
    <D.30842>:
  }
  mono_loader_unlock ();
  D.30821 = id->id;
  return D.30821;
  <D.30835>:
  id = monoeg_malloc0 (12);
  D.30843 = ids[type];
  D.30844 = D.30843->len;
  D.30845 = D.30844 + 1;
  D.30846 = (int) D.30845;
  id->id = D.30846;
  id->domain = domain;
  id->data.val = val;
  D.30830 = info->val_to_id[type];
  monoeg_g_hash_table_insert_replace (D.30830, val, id, 0);
  {
    int ret;

    D.30822 = &domain->lock.mutex;
    ret = pthread_mutex_unlock (D.30822);
    if (ret != 0) goto <D.30847>; else goto <D.30848>;
    <D.30847>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.30848>:
    D.30849 = ret != 0;
    D.30850 = (long int) D.30849;
    D.30851 = __builtin_expect (D.30850, 0);
    if (D.30851 != 0) goto <D.30852>; else goto <D.30853>;
    <D.30852>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 2171, "ret == 0");
    <D.30853>:
  }
  D.30843 = ids[type];
  monoeg_g_ptr_array_add (D.30843, id);
  mono_loader_unlock ();
  D.30821 = id->id;
  return D.30821;
}


get_agent_domain_info (struct MonoDomain * domain)
{
  union mono_mutex_t * D.30855;
  _Bool D.30858;
  long int D.30859;
  long int D.30860;
  void * D.30863;
  void * D.30866;
  struct GHashTable * D.30867;
  struct GHashTable * D.30868;
  struct GHashTable * D.30869;
  struct GHashTable * D.30870;
  _Bool D.30873;
  long int D.30874;
  long int D.30875;
  struct AgentDomainInfo * D.30878;
  struct AgentDomainInfo * info;

  info = 0B;
  {
    int ret;

    D.30855 = &domain->lock.mutex;
    ret = pthread_mutex_lock (D.30855);
    if (ret != 0) goto <D.30856>; else goto <D.30857>;
    <D.30856>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.30857>:
    D.30858 = ret != 0;
    D.30859 = (long int) D.30858;
    D.30860 = __builtin_expect (D.30859, 0);
    if (D.30860 != 0) goto <D.30861>; else goto <D.30862>;
    <D.30861>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 2122, "ret == 0");
    <D.30862>:
  }
  D.30863 = domain->runtime_info;
  info = MEM[(struct MonoJitDomainInfo *)D.30863].agent_info;
  if (info == 0B) goto <D.30864>; else goto <D.30865>;
  <D.30864>:
  D.30863 = domain->runtime_info;
  D.30866 = monoeg_malloc0 (44);
  MEM[(struct MonoJitDomainInfo *)D.30863].agent_info = D.30866;
  info = MEM[(struct MonoJitDomainInfo *)D.30863].agent_info;
  D.30867 = monoeg_g_hash_table_new (mono_aligned_addr_hash, 0B);
  info->loaded_classes = D.30867;
  D.30868 = monoeg_g_hash_table_new (mono_aligned_addr_hash, 0B);
  info->source_files = D.30868;
  D.30869 = monoeg_g_hash_table_new (monoeg_g_str_hash, monoeg_g_str_equal);
  info->source_file_to_class = D.30869;
  D.30870 = monoeg_g_hash_table_new (monoeg_g_str_hash, monoeg_g_str_equal);
  info->source_file_to_class_ignorecase = D.30870;
  <D.30865>:
  {
    int ret;

    D.30855 = &domain->lock.mutex;
    ret = pthread_mutex_unlock (D.30855);
    if (ret != 0) goto <D.30871>; else goto <D.30872>;
    <D.30871>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.30872>:
    D.30873 = ret != 0;
    D.30874 = (long int) D.30873;
    D.30875 = __builtin_expect (D.30874, 0);
    if (D.30875 != 0) goto <D.30876>; else goto <D.30877>;
    <D.30876>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 2133, "ret == 0");
    <D.30877>:
  }
  D.30878 = info;
  return D.30878;
}


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.30882;
  long int D.30883;
  long int D.30884;
  struct MonoType * D.30889;
  unsigned int D.30890;
  unsigned int debugger_thread_id.72;
  struct FILE * log_file.73;
  unsigned int D.30900;
  void * D.30901;

  buffer_add_ptr_id (buf, domain, 2, klass);
  log_level.71 = log_level;
  D.30882 = log_level.71 > 1;
  D.30883 = (long int) D.30882;
  D.30884 = __builtin_expect (D.30883, 0);
  if (D.30884 != 0) goto <D.30885>; else goto <D.30886>;
  <D.30885>:
  if (klass != 0B) goto <D.30887>; else goto <D.30888>;
  <D.30887>:
  {
    char * s;

    D.30889 = &klass->byval_arg;
    s = mono_type_full_name (D.30889);
    D.30890 = GetCurrentThreadId ();
    debugger_thread_id.72 = debugger_thread_id;
    if (D.30890 == debugger_thread_id.72) goto <D.30892>; else goto <D.30893>;
    <D.30892>:
    log_level.71 = log_level;
    D.30882 = log_level.71 > 1;
    D.30883 = (long int) D.30882;
    D.30884 = __builtin_expect (D.30883, 0);
    if (D.30884 != 0) goto <D.30894>; else goto <D.30895>;
    <D.30894>:
    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.30895>:
    goto <D.30897>;
    <D.30893>:
    log_level.71 = log_level;
    D.30882 = log_level.71 > 1;
    D.30883 = (long int) D.30882;
    D.30884 = __builtin_expect (D.30883, 0);
    if (D.30884 != 0) goto <D.30898>; else goto <D.30899>;
    <D.30898>:
    log_file.73 = log_file;
    D.30900 = GetCurrentThreadId ();
    D.30901 = (void *) D.30900;
    fprintf (log_file.73, "[%p]   send class [%s]\n", D.30901, s);
    log_file.73 = log_file;
    fflush (log_file.73);
    <D.30899>:
    <D.30897>:
    monoeg_g_free (s);
  }
  <D.30888>:
  <D.30886>:
}


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

  buffer_add_ptr_id (buf, domain, 3, method);
  log_level.74 = log_level;
  D.30903 = log_level.74 > 1;
  D.30904 = (long int) D.30903;
  D.30905 = __builtin_expect (D.30904, 0);
  if (D.30905 != 0) goto <D.30906>; else goto <D.30907>;
  <D.30906>:
  if (method != 0B) goto <D.30908>; else goto <D.30909>;
  <D.30908>:
  {
    char * s;

    s = mono_method_full_name (method, 1);
    log_level.74 = log_level;
    D.30903 = log_level.74 > 1;
    D.30904 = (long int) D.30903;
    D.30905 = __builtin_expect (D.30904, 0);
    if (D.30905 != 0) goto <D.30910>; else goto <D.30911>;
    <D.30910>:
    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.30911>:
    monoeg_g_free (s);
  }
  <D.30909>:
  <D.30907>:
}


buffer_add_long (struct Buffer * buf, guint64 l)
{
  long long unsigned int D.30913;
  unsigned int D.30914;
  unsigned int D.30915;

  D.30913 = l >> 32;
  D.30914 = (unsigned int) D.30913;
  buffer_add_int (buf, D.30914);
  D.30915 = (unsigned int) l;
  buffer_add_int (buf, D.30915);
}


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

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


get_objid (struct MonoObject * obj)
{
  int D.30917;
  struct ObjRef * D.30918;

  D.30918 = get_objref (obj);
  D.30917 = D.30918->id;
  return D.30917;
}


buffer_add_int (struct Buffer * buf, guint32 val)
{
  guint8 * D.30920;
  unsigned int D.30921;
  unsigned char D.30922;
  guint8 * D.30923;
  unsigned int D.30924;
  unsigned char D.30925;
  guint8 * D.30926;
  unsigned int D.30927;
  unsigned char D.30928;
  guint8 * D.30929;
  unsigned char D.30930;
  guint8 * D.30931;

  buffer_make_room (buf, 4);
  D.30920 = buf->p;
  D.30921 = val >> 24;
  D.30922 = (unsigned char) D.30921;
  *D.30920 = D.30922;
  D.30920 = buf->p;
  D.30923 = D.30920 + 1;
  D.30924 = val >> 16;
  D.30925 = (unsigned char) D.30924;
  *D.30923 = D.30925;
  D.30920 = buf->p;
  D.30926 = D.30920 + 2;
  D.30927 = val >> 8;
  D.30928 = (unsigned char) D.30927;
  *D.30926 = D.30928;
  D.30920 = buf->p;
  D.30929 = D.30920 + 3;
  D.30930 = (unsigned char) val;
  *D.30929 = D.30930;
  D.30920 = buf->p;
  D.30931 = D.30920 + 4;
  buf->p = D.30931;
}


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

  if (str == 0B) goto <D.30932>; else goto <D.30933>;
  <D.30932>:
  buffer_add_int (buf, 0);
  goto <D.30934>;
  <D.30933>:
  D.30935 = strlen (str);
  len = (int) D.30935;
  len.76 = (unsigned int) len;
  buffer_add_int (buf, len.76);
  buffer_add_data (buf, str, len);
  <D.30934>:
}


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

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


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

  D.30942 = __builtin_object_size (__dest, 0);
  D.30941 = __builtin___memcpy_chk (__dest, __src, __len, D.30942);
  return D.30941;
}


start_debugger_thread ()
{
  void * debugger_thread_handle.79;
  void * debugger_thread_handle.80;
  _Bool D.30946;
  long int D.30947;
  long int D.30948;

  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.30946 = debugger_thread_handle.80 == 0B;
  D.30947 = (long int) D.30946;
  D.30948 = __builtin_expect (D.30947, 0);
  if (D.30948 != 0) goto <D.30949>; else goto <D.30950>;
  <D.30949>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 1580, "debugger_thread_handle");
  <D.30950>:
}


debugger_thread (void * arg)
{
  int log_level.81;
  _Bool D.30952;
  long int D.30953;
  long int D.30954;
  struct FILE * log_file.82;
  unsigned int D.30958;
  void * D.30959;
  unsigned int debugger_thread_id.83;
  struct MonoDomain * D.30961;
  struct MonoInternalThread * D.30962;
  unsigned int D.30963;
  unsigned int D.30964;
  int D.30965;
  int D.30968;
  struct MonoThread * D.30974;
  guint8 * p.84;
  _Bool D.30980;
  long int D.30981;
  long int D.30982;
  <unnamed type> command_set.85;
  const char * D.30992;
  int D.30993;
  unsigned int D.30994;
  sizetype len.86;
  sizetype D.31002;
  _Bool D.31003;
  _Bool D.31004;
  _Bool D.31005;
  int err.87;
  unsigned int command.88;
  unsigned int D.31014;
  _Bool D.31018;
  _Bool D.31019;
  _Bool D.31020;
  int vm_death_event_sent.89;
  int D.31028;
  _Bool D.31031;
  long int D.31032;
  long int D.31033;
  guint32 D.31036;
  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.30952 = log_level.81 > 0;
      D.30953 = (long int) D.30952;
      D.30954 = __builtin_expect (D.30953, 0);
      if (D.30954 != 0) goto <D.30955>; else goto <D.30956>;
      <D.30955>:
      log_file.82 = log_file;
      D.30958 = GetCurrentThreadId ();
      D.30959 = (void *) D.30958;
      fprintf (log_file.82, "[dbg] Agent thread started, pid=%p\n", D.30959);
      log_file.82 = log_file;
      fflush (log_file.82);
      <D.30956>:
      debugger_thread_id.83 = GetCurrentThreadId ();
      debugger_thread_id = debugger_thread_id.83;
      D.30961 = mono_get_root_domain ();
      mono_jit_thread_attach (D.30961);
      D.30962 = mono_thread_internal_current ();
      D.30963 = D.30962->flags;
      D.30964 = D.30963 | 1;
      D.30962->flags = D.30964;
      mono_set_is_debugger_attached (1);
      D.30965 = agent_config.defer;
      if (D.30965 != 0) goto <D.30966>; else goto <D.30967>;
      <D.30966>:
      D.30968 = wait_for_attach ();
      if (D.30968 == 0) goto <D.30969>; else goto <D.30970>;
      <D.30969>:
      log_level.81 = log_level;
      D.30952 = log_level.81 > 0;
      D.30953 = (long int) D.30952;
      D.30954 = __builtin_expect (D.30953, 0);
      if (D.30954 != 0) goto <D.30971>; else goto <D.30972>;
      <D.30971>:
      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.30972>:
      attach_failed = 1;
      goto <D.30973>;
      <D.30970>:
      D.30974 = mono_thread_get_main ();
      process_profiler_event (0, D.30974);
      <D.30973>:
      <D.30967>:
      goto <D.29968>;
      <D.29967>:
      res = transport_recv (&header, 11);
      if (res != 11) goto <D.30975>; else goto <D.30976>;
      <D.30975>:
      log_level.81 = log_level;
      D.30952 = log_level.81 > 0;
      D.30953 = (long int) D.30952;
      D.30954 = __builtin_expect (D.30953, 0);
      if (D.30954 != 0) goto <D.30977>; else goto <D.30978>;
      <D.30977>:
      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.30978>:
      goto <D.29950>;
      <D.30976>:
      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.30980 = flags != 0;
      D.30981 = (long int) D.30980;
      D.30982 = __builtin_expect (D.30981, 0);
      if (D.30982 != 0) goto <D.30983>; else goto <D.30984>;
      <D.30983>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 9156, "flags == 0");
      <D.30984>:
      log_level.81 = log_level;
      if (log_level.81 != 0) goto <D.30985>; else goto <D.30986>;
      <D.30985>:
      {
        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.30988>; else goto <D.30989>;
            <D.30988>:
            sprintf (&cmd_num, "%d", command);
            cmd_str = &cmd_num;
            <D.30989>:
            log_level.81 = log_level;
            D.30952 = log_level.81 > 0;
            D.30953 = (long int) D.30952;
            D.30954 = __builtin_expect (D.30953, 0);
            if (D.30954 != 0) goto <D.30990>; else goto <D.30991>;
            <D.30990>:
            log_file.82 = log_file;
            command_set.85 = (<unnamed type>) command_set;
            D.30992 = command_set_to_string (command_set.85);
            fprintf (log_file.82, "[dbg] Command %s(%s) [%d].\n", D.30992, cmd_str, id);
            log_file.82 = log_file;
            fflush (log_file.82);
            <D.30991>:
          }
        finally
          {
            cmd_num = {CLOBBER};
          }
      }
      <D.30986>:
      D.30993 = len + -11;
      D.30994 = (unsigned int) D.30993;
      data = monoeg_malloc (D.30994);
      if (len > 11) goto <D.30995>; else goto <D.30996>;
      <D.30995>:
      D.30993 = len + -11;
      res = transport_recv (data, D.30993);
      D.30993 = len + -11;
      if (D.30993 != res) goto <D.30997>; else goto <D.30998>;
      <D.30997>:
      log_level.81 = log_level;
      D.30952 = log_level.81 > 0;
      D.30953 = (long int) D.30952;
      D.30954 = __builtin_expect (D.30953, 0);
      if (D.30954 != 0) goto <D.30999>; else goto <D.31000>;
      <D.30999>:
      log_file.82 = log_file;
      D.30993 = len + -11;
      fprintf (log_file.82, "[dbg] transport_recv () returned %d, expected %d.\n", res, D.30993);
      log_file.82 = log_file;
      fflush (log_file.82);
      <D.31000>:
      goto <D.29950>;
      <D.30998>:
      <D.30996>:
      p = data;
      len.86 = (sizetype) len;
      D.31002 = len.86 + 4294967285;
      end = data + D.31002;
      buffer_init (&buf, 128);
      err = 0;
      no_reply = 0;
      switch (command_set) <default: <D.29966>, case 1: <D.29953>, case 9: <D.29965>, case 10: <D.29964>, case 11: <D.29961>, case 13: <D.29963>, case 15: <D.29955>, case 16: <D.29962>, case 20: <D.29956>, case 21: <D.29957>, case 22: <D.29960>, case 23: <D.29959>, case 24: <D.29958>>
      <D.29953>:
      p.84 = p;
      err = vm_commands (command, id, p.84, end, &buf);
      D.31003 = err == 0;
      D.31004 = command == 7;
      D.31005 = D.31003 & D.31004;
      if (D.31005 != 0) goto <D.31006>; else goto <D.31007>;
      <D.31006>:
      no_reply = 1;
      <D.31007>:
      goto <D.29954>;
      <D.29955>:
      p.84 = p;
      err = event_commands (command, p.84, end, &buf);
      goto <D.29954>;
      <D.29956>:
      p.84 = p;
      err = domain_commands (command, p.84, end, &buf);
      goto <D.29954>;
      <D.29957>:
      p.84 = p;
      err = assembly_commands (command, p.84, end, &buf);
      goto <D.29954>;
      <D.29958>:
      p.84 = p;
      err = module_commands (command, p.84, end, &buf);
      goto <D.29954>;
      <D.29959>:
      p.84 = p;
      err = type_commands (command, p.84, end, &buf);
      goto <D.29954>;
      <D.29960>:
      p.84 = p;
      err = method_commands (command, p.84, end, &buf);
      goto <D.29954>;
      <D.29961>:
      p.84 = p;
      err = thread_commands (command, p.84, end, &buf);
      goto <D.29954>;
      <D.29962>:
      p.84 = p;
      err = frame_commands (command, p.84, end, &buf);
      goto <D.29954>;
      <D.29963>:
      p.84 = p;
      err = array_commands (command, p.84, end, &buf);
      goto <D.29954>;
      <D.29964>:
      p.84 = p;
      err = string_commands (command, p.84, end, &buf);
      goto <D.29954>;
      <D.29965>:
      p.84 = p;
      err = object_commands (command, p.84, end, &buf);
      goto <D.29954>;
      <D.29966>:
      err = 100;
      <D.29954>:
      if (no_reply == 0) goto <D.31008>; else goto <D.31009>;
      <D.31008>:
      err.87 = (int) err;
      send_reply_packet (id, err.87, &buf);
      <D.31009>:
      monoeg_g_free (data);
      buffer_free (&buf);
      if (command_set == 1) goto <D.31011>; else goto <D.31012>;
      <D.31011>:
      command.88 = (unsigned int) command;
      D.31014 = command.88 + 4294967291;
      if (D.31014 <= 1) goto <D.29950>; else goto <D.31015>;
      <D.31015>:
      <D.31012>:
      <D.29968>:
      if (attach_failed == 0) goto <D.29967>; else goto <D.29950>;
      <D.29950>:
      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.30952 = log_level.81 > 0;
      D.30953 = (long int) D.30952;
      D.30954 = __builtin_expect (D.30953, 0);
      if (D.30954 != 0) goto <D.31016>; else goto <D.31017>;
      <D.31016>:
      log_file.82 = log_file;
      fprintf (log_file.82, "[dbg] Debugger thread exited.\n");
      log_file.82 = log_file;
      fflush (log_file.82);
      <D.31017>:
      D.31018 = attach_failed == 0;
      D.31019 = command_set == 1;
      D.31020 = D.31018 & D.31019;
      if (D.31020 != 0) goto <D.31021>; else goto <D.31022>;
      <D.31021>:
      if (command == 6) goto <D.31023>; else goto <D.31024>;
      <D.31023>:
      vm_death_event_sent.89 = vm_death_event_sent;
      if (vm_death_event_sent.89 == 0) goto <D.31026>; else goto <D.31027>;
      <D.31026>:
      D.31028 = mono_runtime_is_shutting_down ();
      if (D.31028 == 0) goto <D.31029>; else goto <D.31030>;
      <D.31029>:
      log_level.81 = log_level;
      D.31031 = log_level.81 > 1;
      D.31032 = (long int) D.31031;
      D.31033 = __builtin_expect (D.31032, 0);
      if (D.31033 != 0) goto <D.31034>; else goto <D.31035>;
      <D.31034>:
      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.31035>:
      start_debugger_thread ();
      <D.31030>:
      <D.31027>:
      <D.31024>:
      <D.31022>:
      D.31036 = 0;
      return D.31036;
    }
  finally
    {
      header = {CLOBBER};
      p = {CLOBBER};
      buf = {CLOBBER};
    }
}


wait_for_attach ()
{
  int listen_fd.90;
  int log_level.91;
  _Bool D.31043;
  long int D.31044;
  long int D.31045;
  struct FILE * log_file.92;
  gboolean D.31049;
  int conn_fd.93;
  int conn_fd.94;
  int D.31058;
  _Bool D.31059;
  int disconnected.95;
  int disconnected.96;

  listen_fd.90 = listen_fd;
  if (listen_fd.90 == -1) goto <D.31040>; else goto <D.31041>;
  <D.31040>:
  log_level.91 = log_level;
  D.31043 = log_level.91 > 0;
  D.31044 = (long int) D.31043;
  D.31045 = __builtin_expect (D.31044, 0);
  if (D.31045 != 0) goto <D.31046>; else goto <D.31047>;
  <D.31046>:
  log_file.92 = log_file;
  fprintf (log_file.92, "[dbg] Invalid listening socket\n");
  log_file.92 = log_file;
  fflush (log_file.92);
  <D.31047>:
  D.31049 = 0;
  return D.31049;
  <D.31041>:
  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.31043 = log_level.91 > 0;
  D.31044 = (long int) D.31043;
  D.31045 = __builtin_expect (D.31044, 0);
  if (D.31045 != 0) goto <D.31051>; else goto <D.31052>;
  <D.31051>:
  log_file.92 = log_file;
  conn_fd.94 = conn_fd;
  fprintf (log_file.92, "Accepted connection on %d\n", conn_fd.94);
  log_file.92 = log_file;
  fflush (log_file.92);
  <D.31052>:
  conn_fd.94 = conn_fd;
  if (conn_fd.94 == -1) goto <D.31054>; else goto <D.31055>;
  <D.31054>:
  log_level.91 = log_level;
  D.31043 = log_level.91 > 0;
  D.31044 = (long int) D.31043;
  D.31045 = __builtin_expect (D.31044, 0);
  if (D.31045 != 0) goto <D.31056>; else goto <D.31057>;
  <D.31056>:
  log_file.92 = log_file;
  fprintf (log_file.92, "[dbg] Bad client connection\n");
  log_file.92 = log_file;
  fflush (log_file.92);
  <D.31057>:
  D.31049 = 0;
  return D.31049;
  <D.31055>:
  D.31058 = transport_handshake ();
  D.31059 = D.31058 == 0;
  disconnected.95 = (int) D.31059;
  disconnected = disconnected.95;
  disconnected.96 = disconnected;
  if (disconnected.96 != 0) goto <D.31062>; else goto <D.31063>;
  <D.31062>:
  log_level.91 = log_level;
  D.31043 = log_level.91 > 0;
  D.31044 = (long int) D.31043;
  D.31045 = __builtin_expect (D.31044, 0);
  if (D.31045 != 0) goto <D.31064>; else goto <D.31065>;
  <D.31064>:
  log_file.92 = log_file;
  fprintf (log_file.92, "Transport handshake failed!\n");
  log_file.92 = log_file;
  fflush (log_file.92);
  <D.31065>:
  D.31049 = 0;
  return D.31049;
  <D.31063>:
  D.31049 = 1;
  return D.31049;
}


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.31067;
  int conn_fd.97;
  int conn_fd.98;
  struct _IO_FILE * stderr.99;
  int log_level.100;
  _Bool D.31075;
  long int D.31076;
  long int D.31077;
  struct FILE * log_file.101;
  int D.31081;

  D.31067.__sockaddr__ = 0B;
  conn_fd.97 = accept (socket_fd, D.31067, 0B);
  conn_fd = conn_fd.97;
  conn_fd.98 = conn_fd;
  if (conn_fd.98 == -1) goto <D.31070>; else goto <D.31071>;
  <D.31070>:
  stderr.99 = stderr;
  fprintf (stderr.99, "debugger-agent: Unable to listen on %d\n", socket_fd);
  goto <D.31073>;
  <D.31071>:
  log_level.100 = log_level;
  D.31075 = log_level.100 > 0;
  D.31076 = (long int) D.31075;
  D.31077 = __builtin_expect (D.31076, 0);
  if (D.31077 != 0) goto <D.31078>; else goto <D.31079>;
  <D.31078>:
  log_file.101 = log_file;
  conn_fd.98 = conn_fd;
  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.31079>:
  <D.31073>:
  D.31081 = conn_fd;
  return D.31081;
}


transport_handshake ()
{
  unsigned int D.31083;
  int D.31084;
  int * D.31086;
  int D.31087;
  _Bool D.31088;
  long int D.31089;
  long int D.31090;
  unsigned int D.31093;
  int D.31094;
  unsigned int res.102;
  unsigned int D.31098;
  char[128] * handshake_msg.103;
  char D.31101;
  _Bool D.31102;
  unsigned int D.31103;
  int D.31104;
  struct _IO_FILE * stderr.104;
  gboolean D.31106;
  int conn_fd.105;
  _Bool D.31110;
  long int D.31111;
  long int D.31112;
  char handshake_msg[128];
  guint8 buf[128];
  int res;

  try
    {
      disconnected = 1;
      sprintf (&handshake_msg, "DWP-Handshake");
      <D.27483>:
      D.31083 = strlen (&handshake_msg);
      D.31084 = (int) D.31083;
      res = transport_send (&handshake_msg, D.31084);
      if (res == -1) goto <D.31085>; else goto <D.27484>;
      <D.31085>:
      D.31086 = __errno_location ();
      D.31087 = *D.31086;
      if (D.31087 == 4) goto <D.27483>; else goto <D.27484>;
      <D.27484>:
      D.31088 = res == -1;
      D.31089 = (long int) D.31088;
      D.31090 = __builtin_expect (D.31089, 0);
      if (D.31090 != 0) goto <D.31091>; else goto <D.31092>;
      <D.31091>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 1498, "res != -1");
      <D.31092>:
      D.31093 = strlen (&handshake_msg);
      D.31094 = (int) D.31093;
      res = transport_recv (&buf, D.31094);
      res.102 = (unsigned int) res;
      D.31098 = strlen (&handshake_msg);
      if (res.102 != D.31098) goto <D.31095>; else goto <D.31099>;
      <D.31099>:
      handshake_msg.103 = &handshake_msg;
      D.31101 = MEM[(const char *)handshake_msg.103];
      D.31102 = D.31101 != 0;
      D.31103 = (unsigned int) D.31102;
      D.31104 = memcmp (&buf, &handshake_msg, D.31103);
      if (D.31104 != 0) goto <D.31095>; else goto <D.31096>;
      <D.31095>:
      stderr.104 = stderr;
      fprintf (stderr.104, "debugger-agent: DWP handshake failed.\n");
      D.31106 = 0;
      return D.31106;
      <D.31096>:
      major_version = 2;
      minor_version = 27;
      protocol_version_set = 0;
      conn_fd.105 = conn_fd;
      if (conn_fd.105 != 0) goto <D.31108>; else goto <D.31109>;
      <D.31108>:
      {
        int flag;
        int result;

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


transport_send (void * buf, int len)
{
  int D.31117;
  struct DebuggerTransport * transport.106;
  gboolean (*<T4955>) (void *, int) D.31119;

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


set_keepalive ()
{
  int D.31123;
  int conn_fd.107;
  int D.31126;
  int D.31127;
  int D.31128;
  _Bool D.31129;
  long int D.31130;
  long int D.31131;
  struct timeval tv;
  int result;

  try
    {
      D.31123 = agent_config.keepalive;
      if (D.31123 == 0) goto <D.31121>; else goto <D.31124>;
      <D.31124>:
      conn_fd.107 = conn_fd;
      if (conn_fd.107 == 0) goto <D.31121>; else goto <D.31122>;
      <D.31121>:
      return;
      <D.31122>:
      D.31123 = agent_config.keepalive;
      D.31126 = D.31123 / 1000;
      tv.tv_sec = D.31126;
      D.31123 = agent_config.keepalive;
      D.31127 = D.31123 % 1000;
      D.31128 = D.31127 * 1000;
      tv.tv_usec = D.31128;
      conn_fd.107 = conn_fd;
      result = setsockopt (conn_fd.107, 1, 20, &tv, 8);
      D.31129 = result < 0;
      D.31130 = (long int) D.31129;
      D.31131 = __builtin_expect (D.31130, 0);
      if (D.31131 != 0) goto <D.31132>; else goto <D.31133>;
      <D.31132>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 1126, "result >= 0");
      <D.31133>:
    }
  finally
    {
      tv = {CLOBBER};
    }
}


decode_int (guint8 * buf, guint8 * * endbuf, guint8 * limit)
{
  guint8 * D.31137;
  guint8 * D.31138;
  _Bool D.31139;
  long int D.31140;
  long int D.31141;
  int D.31144;
  unsigned char D.31145;
  int D.31146;
  int D.31147;
  guint8 * D.31148;
  unsigned char D.31149;
  int D.31150;
  int D.31151;
  int D.31152;
  guint8 * D.31153;
  unsigned char D.31154;
  int D.31155;
  int D.31156;
  int D.31157;
  guint8 * D.31158;
  unsigned char D.31159;
  int D.31160;

  D.31137 = buf + 4;
  *endbuf = D.31137;
  D.31138 = *endbuf;
  D.31139 = D.31138 > limit;
  D.31140 = (long int) D.31139;
  D.31141 = __builtin_expect (D.31140, 0);
  if (D.31141 != 0) goto <D.31142>; else goto <D.31143>;
  <D.31142>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 1599, "*endbuf <= limit");
  <D.31143>:
  D.31145 = *buf;
  D.31146 = (int) D.31145;
  D.31147 = D.31146 << 24;
  D.31148 = buf + 1;
  D.31149 = *D.31148;
  D.31150 = (int) D.31149;
  D.31151 = D.31150 << 16;
  D.31152 = D.31147 | D.31151;
  D.31153 = buf + 2;
  D.31154 = *D.31153;
  D.31155 = (int) D.31154;
  D.31156 = D.31155 << 8;
  D.31157 = D.31152 | D.31156;
  D.31158 = buf + 3;
  D.31159 = *D.31158;
  D.31160 = (int) D.31159;
  D.31144 = D.31157 | D.31160;
  return D.31144;
}


decode_byte (guint8 * buf, guint8 * * endbuf, guint8 * limit)
{
  guint8 * D.31162;
  guint8 * D.31163;
  _Bool D.31164;
  long int D.31165;
  long int D.31166;
  int D.31169;
  unsigned char D.31170;

  D.31162 = buf + 1;
  *endbuf = D.31162;
  D.31163 = *endbuf;
  D.31164 = D.31163 > limit;
  D.31165 = (long int) D.31164;
  D.31166 = __builtin_expect (D.31165, 0);
  if (D.31166 != 0) goto <D.31167>; else goto <D.31168>;
  <D.31167>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 1591, "*endbuf <= limit");
  <D.31168>:
  D.31170 = *buf;
  D.31169 = (int) D.31170;
  return D.31169;
}


cmd_to_string (CommandSet set, int command)
{
  const char * D.31172;
  _Bool D.31173;
  _Bool D.31174;
  _Bool D.31175;
  sizetype command.108;
  sizetype D.31179;
  sizetype D.31180;
  const char * * D.31181;
  const char * * cmds;
  int cmds_len;

  cmds_len = 0;
  switch (set) <default: <D.29929>, case 1: <D.29915>, case 9: <D.29917>, case 10: <D.29918>, case 11: <D.29919>, case 13: <D.29920>, case 15: <D.29921>, case 16: <D.29922>, case 20: <D.29923>, case 21: <D.29924>, case 22: <D.29925>, case 23: <D.29926>, case 24: <D.29927>, case 64: <D.29928>>
  <D.29915>:
  cmds = &vm_cmds_str;
  cmds_len = 12;
  goto <D.29916>;
  <D.29917>:
  cmds = &object_cmds_str;
  cmds_len = 7;
  goto <D.29916>;
  <D.29918>:
  cmds = &string_cmds_str;
  cmds_len = 3;
  goto <D.29916>;
  <D.29919>:
  cmds = &thread_cmds_str;
  cmds_len = 6;
  goto <D.29916>;
  <D.29920>:
  cmds = &array_cmds_str;
  cmds_len = 3;
  goto <D.29916>;
  <D.29921>:
  cmds = &event_cmds_str;
  cmds_len = 3;
  goto <D.29916>;
  <D.29922>:
  cmds = &stack_frame_cmds_str;
  cmds_len = 3;
  goto <D.29916>;
  <D.29923>:
  cmds = &appdomain_cmds_str;
  cmds_len = 7;
  goto <D.29916>;
  <D.29924>:
  cmds = &assembly_cmds_str;
  cmds_len = 6;
  goto <D.29916>;
  <D.29925>:
  cmds = &method_cmds_str;
  cmds_len = 10;
  goto <D.29916>;
  <D.29926>:
  cmds = &type_cmds_str;
  cmds_len = 18;
  goto <D.29916>;
  <D.29927>:
  cmds = &module_cmds_str;
  cmds_len = 1;
  goto <D.29916>;
  <D.29928>:
  cmds = &event_cmds_str;
  cmds_len = 3;
  goto <D.29916>;
  <D.29929>:
  D.31172 = 0B;
  return D.31172;
  <D.29916>:
  D.31173 = command > 0;
  D.31174 = command <= cmds_len;
  D.31175 = D.31173 & D.31174;
  if (D.31175 != 0) goto <D.31176>; else goto <D.31177>;
  <D.31176>:
  command.108 = (sizetype) command;
  D.31179 = command.108 + 1073741823;
  D.31180 = D.31179 * 4;
  D.31181 = cmds + D.31180;
  D.31172 = *D.31181;
  return D.31172;
  <D.31177>:
  D.31172 = 0B;
  return D.31172;
}


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

  D.31184 = __builtin_object_size (__s, 1);
  D.31183 = __builtin___sprintf_chk (__s, 1, D.31184, __fmt, __builtin_va_arg_pack ());
  return D.31183;
}


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

  switch (command_set) <default: <D.29896>, case 1: <D.29883>, case 9: <D.29884>, case 10: <D.29885>, case 11: <D.29886>, case 13: <D.29887>, case 15: <D.29888>, case 16: <D.29889>, case 20: <D.29890>, case 21: <D.29891>, case 22: <D.29892>, case 23: <D.29893>, case 24: <D.29894>, case 64: <D.29895>>
  <D.29883>:
  D.31186 = "VM";
  return D.31186;
  <D.29884>:
  D.31186 = "OBJECT_REF";
  return D.31186;
  <D.29885>:
  D.31186 = "STRING_REF";
  return D.31186;
  <D.29886>:
  D.31186 = "THREAD";
  return D.31186;
  <D.29887>:
  D.31186 = "ARRAY_REF";
  return D.31186;
  <D.29888>:
  D.31186 = "EVENT_REQUEST";
  return D.31186;
  <D.29889>:
  D.31186 = "STACK_FRAME";
  return D.31186;
  <D.29890>:
  D.31186 = "APPDOMAIN";
  return D.31186;
  <D.29891>:
  D.31186 = "ASSEMBLY";
  return D.31186;
  <D.29892>:
  D.31186 = "METHOD";
  return D.31186;
  <D.29893>:
  D.31186 = "TYPE";
  return D.31186;
  <D.29894>:
  D.31186 = "MODULE";
  return D.31186;
  <D.29895>:
  D.31186 = "EVENT";
  return D.31186;
  <D.29896>:
  D.31186 = "";
  return D.31186;
}


transport_recv (void * buf, int len)
{
  int D.31188;
  struct DebuggerTransport * transport.109;
  int (*<T4956>) (void *, int) D.31190;

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


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.31196;
  long int D.31197;
  long int D.31198;
  struct FILE * log_file.114;
  int major_version.115;
  int minor_version.116;
  struct MonoGHashTable * tid_to_thread_obj.117;
  unsigned int D.31205;
  int suspend_count.118;
  ErrorCode D.31209;
  struct GPtrArray * event_requests.119;
  void * * D.31211;
  int D.31212;
  int D.31213;
  unsigned int D.31214;
  int D.31215;
  int D.31216;
  struct MonoImage * D.31217;
  struct MonoGHashTable * tid_to_thread.120;
  _Bool D.31221;
  _Bool D.31222;
  _Bool D.31223;
  struct MonoGHashTable * thread_to_tls.121;
  void * D.31227;
  void * D.31228;
  void * D.31229;
  struct InvokeData * D.31230;
  int D.31232;
  <unnamed type> D.31240;
  int D.31248;
  struct MonoThread * thread.122;
  struct _MonoInternalThread * D.31252;
  _Bool D.31253;
  long int D.31254;
  long int D.31255;
  int D.31258;
  struct InvokeData * D.31261;
  void * D.31264;
  int end.123;
  int p.124;
  int D.31267;
  unsigned int D.31268;
  void * D.31269;
  guint8 * D.31270;
  unsigned int D.31271;
  sizetype D.31272;
  guint8 * D.31273;
  unsigned int suspend_count.125;
  int D.31275;
  <unnamed type> D.31279;
  struct MonoThread * thread.126;
  struct _MonoInternalThread * D.31283;
  _Bool D.31284;
  long int D.31285;
  long int D.31286;
  int D.31289;
  struct InvokeData * D.31294;
  int D.31296;
  struct GHashTable * domains.127;
  struct MonoDomain * domain.128;
  void * D.31299;
  struct GHashTable * D.31300;
  struct GHashTable * D.31301;
  struct MonoClass * klass.129;
  void * D.31303;
  void * * D.31306;
  unsigned int i.130;
  unsigned int D.31308;
  void * * D.31309;
  struct GHashTable * D.31310;
  gchar * D.31313;
  struct GHashTable * D.31315;
  gchar * D.31318;
  unsigned int i.131;
  unsigned int D.31321;
  int D.31322;
  void * klass.132;
  int D.31327;
  unsigned int D.31328;
  void * * D.31329;
  void * * D.31330;
  void * D.31331;
  void * * D.31332;
  void * * D.31333;
  void * D.31334;
  int D.31335;
  struct MonoDomain * domain.133;
  union mono_mutex_t * D.31339;
  _Bool D.31342;
  long int D.31343;
  long int D.31344;
  struct MonoImage * D.31347;
  struct MonoClass * D.31352;
  _Bool D.31355;
  long int D.31356;
  long int D.31357;
  int D.31360;
  unsigned int D.31361;
  void * * D.31362;
  unsigned int i.134;
  unsigned int D.31364;
  void * * D.31365;
  void * D.31366;
  void * * D.31367;
  void * * D.31368;
  void * D.31369;
  unsigned int i.135;

  switch (command) <default: <D.29235>, case 1: <D.29123>, case 2: <D.29128>, case 3: <D.29129>, case 4: <D.29130>, case 5: <D.29139>, case 6: <D.29131>, case 7: <D.29156>, case 8: <D.29127>, case 9: <D.29169>, case 10: <D.29175>, case 11: <D.29177>, case 12: <D.29211>, case 13: <D.29157>>
  <D.29123>:
  {
    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.29126>;
  }
  <D.29127>:
  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.31196 = log_level.113 > 0;
  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>:
  log_file.114 = log_file;
  major_version.115 = major_version;
  minor_version.116 = minor_version;
  fprintf (log_file.114, "[dbg] Protocol version %d.%d, client protocol version %d.%d.\n", 2, 27, major_version.115, minor_version.116);
  log_file.114 = log_file;
  fflush (log_file.114);
  <D.31200>:
  goto <D.29126>;
  <D.29128>:
  mono_loader_lock ();
  tid_to_thread_obj.117 = tid_to_thread_obj;
  D.31205 = mono_g_hash_table_size (tid_to_thread_obj.117);
  buffer_add_int (buf, D.31205);
  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.29126>;
  <D.29129>:
  suspend_vm ();
  wait_for_suspend ();
  goto <D.29126>;
  <D.29130>:
  suspend_count.118 = suspend_count;
  if (suspend_count.118 == 0) goto <D.31207>; else goto <D.31208>;
  <D.31207>:
  D.31209 = 101;
  return D.31209;
  <D.31208>:
  resume_vm ();
  clear_suspended_objs ();
  goto <D.29126>;
  <D.29131>:
  mono_loader_lock ();
  goto <D.29134>;
  <D.29133>:
  {
    struct EventRequest * req;

    event_requests.119 = event_requests;
    D.31211 = event_requests.119->pdata;
    req = *D.31211;
    D.31212 = req->id;
    D.31213 = req->event_kind;
    clear_event_request (D.31212, D.31213);
  }
  <D.29134>:
  event_requests.119 = event_requests;
  D.31214 = event_requests.119->len;
  if (D.31214 != 0) goto <D.29133>; else goto <D.29135>;
  <D.29135>:
  mono_loader_unlock ();
  goto <D.29137>;
  <D.29136>:
  resume_vm ();
  <D.29137>:
  suspend_count.118 = suspend_count;
  if (suspend_count.118 > 0) goto <D.29136>; else goto <D.29138>;
  <D.29138>:
  disconnected = 1;
  vm_start_event_sent = 0;
  goto <D.29126>;
  <D.29139>:
  {
    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.29148>;
    <D.29147>:
    {
      struct EventRequest * req;

      event_requests.119 = event_requests;
      D.31211 = event_requests.119->pdata;
      req = *D.31211;
      D.31215 = req->id;
      D.31216 = req->event_kind;
      clear_event_request (D.31215, D.31216);
    }
    <D.29148>:
    event_requests.119 = event_requests;
    D.31214 = event_requests.119->len;
    if (D.31214 != 0) goto <D.29147>; else goto <D.29149>;
    <D.29149>:
    mono_loader_unlock ();
    suspend_vm ();
    wait_for_suspend ();
    D.31217 = mono_defaults.corlib;
    env_class = mono_class_from_name (D.31217, "System", "Environment");
    if (env_class != 0B) goto <D.31218>; else goto <D.31219>;
    <D.31218>:
    exit_method = mono_class_get_method_from_name (env_class, "Exit", 1);
    <D.31219>:
    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.31221 = thread != 0B;
    D.31222 = exit_method != 0B;
    D.31223 = D.31221 & D.31222;
    if (D.31223 != 0) goto <D.31224>; else goto <D.31225>;
    <D.31224>:
    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.31227 = monoeg_malloc (4);
    *args = D.31227;
    D.31228 = *args;
    MEM[(int *)D.31228] = exit_code;
    D.31229 = monoeg_malloc0 (248);
    tls->pending_invoke = D.31229;
    D.31230 = tls->pending_invoke;
    D.31230->method = exit_method;
    D.31230 = tls->pending_invoke;
    D.31230->args = args;
    D.31230 = tls->pending_invoke;
    D.31230->nmethods = 1;
    goto <D.29151>;
    <D.29150>:
    resume_vm ();
    <D.29151>:
    suspend_count.118 = suspend_count;
    if (suspend_count.118 > 0) goto <D.29150>; else goto <D.29152>;
    <D.29152>:
    goto <D.31231>;
    <D.31225>:
    goto <D.29154>;
    <D.29153>:
    resume_vm ();
    <D.29154>:
    suspend_count.118 = suspend_count;
    if (suspend_count.118 > 0) goto <D.29153>; else goto <D.29155>;
    <D.29155>:
    D.31232 = mono_runtime_try_shutdown ();
    if (D.31232 == 0) goto <D.29126>; else goto <D.31233>;
    <D.31233>:
    mono_environment_exitcode_set (exit_code);
    log_level.113 = log_level;
    D.31196 = log_level.113 > 0;
    D.31197 = (long int) D.31196;
    D.31198 = __builtin_expect (D.31197, 0);
    if (D.31198 != 0) goto <D.31234>; else goto <D.31235>;
    <D.31234>:
    log_file.114 = log_file;
    fprintf (log_file.114, "Suspending all threads...\n");
    log_file.114 = log_file;
    fflush (log_file.114);
    <D.31235>:
    mono_thread_suspend_all_other_threads ();
    log_level.113 = log_level;
    D.31196 = log_level.113 > 0;
    D.31197 = (long int) D.31196;
    D.31198 = __builtin_expect (D.31197, 0);
    if (D.31198 != 0) goto <D.31236>; else goto <D.31237>;
    <D.31236>:
    log_file.114 = log_file;
    fprintf (log_file.114, "Shutting down the runtime...\n");
    log_file.114 = log_file;
    fflush (log_file.114);
    <D.31237>:
    mono_runtime_quit ();
    transport_close2 ();
    log_level.113 = log_level;
    D.31196 = log_level.113 > 0;
    D.31197 = (long int) D.31196;
    D.31198 = __builtin_expect (D.31197, 0);
    if (D.31198 != 0) goto <D.31238>; else goto <D.31239>;
    <D.31238>:
    log_file.114 = log_file;
    fprintf (log_file.114, "Exiting...\n");
    log_file.114 = log_file;
    fflush (log_file.114);
    <D.31239>:
    exit (exit_code);
    <D.31231>:
    goto <D.29126>;
  }
  <D.29156>:
  <D.29157>:
  {
    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.31240 = get_object (objid, &thread);
        err = (int) D.31240;
        if (err != 0) goto <D.31241>; else goto <D.31242>;
        <D.31241>:
        D.31209 = (ErrorCode) err;
        return D.31209;
        <D.31242>:
        p.110 = p;
        flags = decode_int (p.110, &p, end);
        if (command == 13) goto <D.31243>; else goto <D.31244>;
        <D.31243>:
        p.110 = p;
        nmethods = decode_int (p.110, &p, end);
        goto <D.31245>;
        <D.31244>:
        nmethods = 1;
        <D.31245>:
        suspend_count.118 = suspend_count;
        if (suspend_count.118 != 0) goto <D.31246>; else goto <D.31247>;
        <D.31246>:
        wait_for_suspend ();
        <D.31247>:
        D.31248 = is_suspended ();
        if (D.31248 == 0) goto <D.31249>; else goto <D.31250>;
        <D.31249>:
        D.31209 = 101;
        return D.31209;
        <D.31250>:
        mono_loader_lock ();
        thread_to_tls.121 = thread_to_tls;
        thread.122 = thread;
        D.31252 = thread.122->internal_thread;
        tls = mono_g_hash_table_lookup (thread_to_tls.121, D.31252);
        mono_loader_unlock ();
        D.31253 = tls == 0B;
        D.31254 = (long int) D.31253;
        D.31255 = __builtin_expect (D.31254, 0);
        if (D.31255 != 0) goto <D.31256>; else goto <D.31257>;
        <D.31256>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 6722, "tls");
        <D.31257>:
        D.31258 = tls->really_suspended;
        if (D.31258 == 0) goto <D.31259>; else goto <D.31260>;
        <D.31259>:
        D.31209 = 101;
        return D.31209;
        <D.31260>:
        D.31261 = tls->pending_invoke;
        if (D.31261 != 0B) goto <D.31262>; else goto <D.31263>;
        <D.31262>:
        D.31209 = 101;
        return D.31209;
        <D.31263>:
        D.31264 = monoeg_malloc0 (248);
        tls->pending_invoke = D.31264;
        D.31261 = tls->pending_invoke;
        D.31261->id = id;
        D.31261 = tls->pending_invoke;
        D.31261->flags = flags;
        D.31261 = tls->pending_invoke;
        end.123 = (int) end;
        p.110 = p;
        p.124 = (int) p.110;
        D.31267 = end.123 - p.124;
        D.31268 = (unsigned int) D.31267;
        D.31269 = monoeg_malloc (D.31268);
        D.31261->p = D.31269;
        D.31261 = tls->pending_invoke;
        D.31270 = D.31261->p;
        p.110 = p;
        end.123 = (int) end;
        p.110 = p;
        p.124 = (int) p.110;
        D.31267 = end.123 - p.124;
        D.31271 = (unsigned int) D.31267;
        memcpy (D.31270, p.110, D.31271);
        D.31261 = tls->pending_invoke;
        D.31261 = tls->pending_invoke;
        D.31270 = D.31261->p;
        end.123 = (int) end;
        p.110 = p;
        p.124 = (int) p.110;
        D.31267 = end.123 - p.124;
        D.31272 = (sizetype) D.31267;
        D.31273 = D.31270 + D.31272;
        D.31261->endp = D.31273;
        D.31261 = tls->pending_invoke;
        suspend_count.118 = suspend_count;
        suspend_count.125 = (unsigned int) suspend_count.118;
        D.31261->suspend_count = suspend_count.125;
        D.31261 = tls->pending_invoke;
        D.31261->nmethods = nmethods;
        D.31275 = flags & 2;
        if (D.31275 != 0) goto <D.31276>; else goto <D.31277>;
        <D.31276>:
        thread.122 = thread;
        D.31252 = thread.122->internal_thread;
        resume_thread (D.31252);
        goto <D.31278>;
        <D.31277>:
        count = suspend_count;
        i = 0;
        goto <D.29167>;
        <D.29166>:
        resume_vm ();
        i = i + 1;
        <D.29167>:
        if (i < count) goto <D.29166>; else goto <D.29168>;
        <D.29168>:
        <D.31278>:
        goto <D.29126>;
      }
    finally
      {
        thread = {CLOBBER};
      }
  }
  <D.29169>:
  {
    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.31279 = get_object (objid, &thread);
        err = (int) D.31279;
        if (err != 0) goto <D.31280>; else goto <D.31281>;
        <D.31280>:
        D.31209 = (ErrorCode) err;
        return D.31209;
        <D.31281>:
        p.110 = p;
        invoke_id = decode_int (p.110, &p, end);
        mono_loader_lock ();
        thread_to_tls.121 = thread_to_tls;
        thread.126 = thread;
        D.31283 = thread.126->internal_thread;
        tls = mono_g_hash_table_lookup (thread_to_tls.121, D.31283);
        D.31284 = tls == 0B;
        D.31285 = (long int) D.31284;
        D.31286 = __builtin_expect (D.31285, 0);
        if (D.31286 != 0) goto <D.31287>; else goto <D.31288>;
        <D.31287>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 6767, "tls");
        <D.31288>:
        D.31289 = tls->abort_requested;
        if (D.31289 != 0) goto <D.31290>; else goto <D.31291>;
        <D.31290>:
        mono_loader_unlock ();
        goto <D.29126>;
        <D.31291>:
        D.31294 = tls->invoke;
        if (D.31294 == 0B) goto <D.31292>; else goto <D.31295>;
        <D.31295>:
        D.31294 = tls->invoke;
        D.31296 = D.31294->id;
        if (D.31296 != invoke_id) goto <D.31292>; else goto <D.31293>;
        <D.31292>:
        mono_loader_unlock ();
        D.31209 = 104;
        return D.31209;
        <D.31293>:
        tls->abort_requested = 1;
        thread.126 = thread;
        D.31283 = thread.126->internal_thread;
        ves_icall_System_Threading_Thread_Abort (D.31283, 0B);
        mono_loader_unlock ();
        goto <D.29126>;
      }
    finally
      {
        thread = {CLOBBER};
      }
  }
  <D.29175>:
  {
    int timeout;

    p.110 = p;
    timeout = decode_int (p.110, &p, end);
    agent_config.keepalive = timeout;
    set_keepalive ();
    goto <D.29126>;
  }
  <D.29177>:
  {
    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.29206>;
        <D.29205>:
        {
          struct AgentDomainInfo * info;

          domain.128 = domain;
          D.31299 = domain.128->runtime_info;
          info = MEM[(struct MonoJitDomainInfo *)D.31299].agent_info;
          D.31300 = info->loaded_classes;
          monoeg_g_hash_table_iter_init (&kiter, D.31300);
          goto <D.29199>;
          <D.29198>:
          D.31301 = info->source_files;
          klass.129 = klass;
          D.31303 = monoeg_g_hash_table_lookup (D.31301, klass.129);
          if (D.31303 == 0B) goto <D.31304>; else goto <D.31305>;
          <D.31304>:
          klass.129 = klass;
          files = get_source_files_for_type (klass.129);
          D.31301 = info->source_files;
          klass.129 = klass;
          monoeg_g_hash_table_insert_replace (D.31301, klass.129, files, 0);
          i = 0;
          goto <D.29196>;
          <D.29195>:
          {
            char * s;
            char * s2;
            char * s3;

            D.31306 = files->pdata;
            i.130 = (unsigned int) i;
            D.31308 = i.130 * 4;
            D.31309 = D.31306 + D.31308;
            s = *D.31309;
            s2 = monoeg_g_path_get_basename (s);
            D.31310 = info->source_file_to_class;
            class_list = monoeg_g_hash_table_lookup (D.31310, s2);
            if (class_list == 0B) goto <D.31311>; else goto <D.31312>;
            <D.31311>:
            klass.129 = klass;
            class_list = monoeg_g_slist_prepend (class_list, klass.129);
            D.31310 = info->source_file_to_class;
            D.31313 = monoeg_strdup (s2);
            monoeg_g_hash_table_insert_replace (D.31310, D.31313, class_list, 0);
            goto <D.31314>;
            <D.31312>:
            klass.129 = klass;
            class_list = monoeg_g_slist_prepend (class_list, klass.129);
            D.31310 = info->source_file_to_class;
            monoeg_g_hash_table_insert_replace (D.31310, s2, class_list, 0);
            <D.31314>:
            s3 = strdup_tolower (s2);
            D.31315 = info->source_file_to_class_ignorecase;
            class_list = monoeg_g_hash_table_lookup (D.31315, s3);
            if (class_list == 0B) goto <D.31316>; else goto <D.31317>;
            <D.31316>:
            klass.129 = klass;
            class_list = monoeg_g_slist_prepend (class_list, klass.129);
            D.31315 = info->source_file_to_class_ignorecase;
            D.31318 = monoeg_strdup (s3);
            monoeg_g_hash_table_insert_replace (D.31315, D.31318, class_list, 0);
            goto <D.31319>;
            <D.31317>:
            klass.129 = klass;
            class_list = monoeg_g_slist_prepend (class_list, klass.129);
            D.31315 = info->source_file_to_class_ignorecase;
            monoeg_g_hash_table_insert_replace (D.31315, s3, class_list, 0);
            <D.31319>:
            monoeg_g_free (s2);
            monoeg_g_free (s3);
          }
          i = i + 1;
          <D.29196>:
          i.131 = (unsigned int) i;
          D.31321 = files->len;
          if (i.131 < D.31321) goto <D.29195>; else goto <D.29197>;
          <D.29197>:
          <D.31305>:
          <D.29199>:
          D.31322 = monoeg_g_hash_table_iter_next (&kiter, 0B, &klass);
          if (D.31322 != 0) goto <D.29198>; else goto <D.29200>;
          <D.29200>:
          if (ignore_case != 0) goto <D.31323>; else goto <D.31324>;
          <D.31323>:
          {
            char * s;

            s = strdup_tolower (basename);
            D.31315 = info->source_file_to_class_ignorecase;
            class_list = monoeg_g_hash_table_lookup (D.31315, s);
            monoeg_g_free (s);
          }
          goto <D.31325>;
          <D.31324>:
          D.31310 = info->source_file_to_class;
          class_list = monoeg_g_hash_table_lookup (D.31310, basename);
          <D.31325>:
          l = class_list;
          goto <D.29203>;
          <D.29202>:
          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.29203>:
          if (l != 0B) goto <D.29202>; else goto <D.29204>;
          <D.29204>:
        }
        <D.29206>:
        D.31327 = monoeg_g_hash_table_iter_next (&iter, 0B, &domain);
        if (D.31327 != 0) goto <D.29205>; else goto <D.29207>;
        <D.29207>:
        mono_loader_unlock ();
        monoeg_g_free (fname);
        monoeg_g_free (basename);
        D.31328 = res_classes->len;
        buffer_add_int (buf, D.31328);
        i = 0;
        goto <D.29209>;
        <D.29208>:
        D.31329 = res_domains->pdata;
        i.130 = (unsigned int) i;
        D.31308 = i.130 * 4;
        D.31330 = D.31329 + D.31308;
        D.31331 = *D.31330;
        D.31332 = res_classes->pdata;
        i.130 = (unsigned int) i;
        D.31308 = i.130 * 4;
        D.31333 = D.31332 + D.31308;
        D.31334 = *D.31333;
        buffer_add_typeid (buf, D.31331, D.31334);
        i = i + 1;
        <D.29209>:
        i.131 = (unsigned int) i;
        D.31328 = res_classes->len;
        if (i.131 < D.31328) goto <D.29208>; else goto <D.29210>;
        <D.29210>:
        monoeg_g_ptr_array_free (res_classes, 1);
        monoeg_g_ptr_array_free (res_domains, 1);
        goto <D.29126>;
      }
    finally
      {
        iter = {CLOBBER};
        kiter = {CLOBBER};
        domain = {CLOBBER};
        klass = {CLOBBER};
      }
  }
  <D.29211>:
  {
    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.31335 = mono_reflection_parse_type (name, &info);
        if (D.31335 == 0) goto <D.31336>; else goto <D.31337>;
        <D.31336>:
        monoeg_g_free (name);
        mono_reflection_free_type_info (&info);
        D.31209 = 102;
        return D.31209;
        <D.31337>:
        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.29230>;
        <D.29229>:
        {
          struct MonoAssembly * ass;
          gboolean type_resolve;
          struct MonoType * t;
          struct GSList * tmp;

          try
            {
              {
                int ret;

                domain.133 = domain;
                D.31339 = &domain.133->assemblies_lock.mutex;
                ret = pthread_mutex_lock (D.31339);
                if (ret != 0) goto <D.31340>; else goto <D.31341>;
                <D.31340>:
                monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
                <D.31341>:
                D.31342 = ret != 0;
                D.31343 = (long int) D.31342;
                D.31344 = __builtin_expect (D.31343, 0);
                if (D.31344 != 0) goto <D.31345>; else goto <D.31346>;
                <D.31345>:
                monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 6927, "ret == 0");
                <D.31346>:
              }
              domain.133 = domain;
              tmp = domain.133->domain_assemblies;
              goto <D.29226>;
              <D.29225>:
              ass = tmp->data;
              D.31347 = ass->image;
              if (D.31347 != 0B) goto <D.31348>; else goto <D.31349>;
              <D.31348>:
              type_resolve = 1;
              D.31347 = ass->image;
              t = mono_reflection_get_type (D.31347, &info, ignore_case, &type_resolve);
              if (t != 0B) goto <D.31350>; else goto <D.31351>;
              <D.31350>:
              D.31352 = mono_type_get_class (t);
              monoeg_g_ptr_array_add (res_classes, D.31352);
              domain.133 = domain;
              monoeg_g_ptr_array_add (res_domains, domain.133);
              <D.31351>:
              <D.31349>:
              tmp = tmp->next;
              <D.29226>:
              if (tmp != 0B) goto <D.29225>; else goto <D.29227>;
              <D.29227>:
              {
                int ret;

                domain.133 = domain;
                D.31339 = &domain.133->assemblies_lock.mutex;
                ret = pthread_mutex_unlock (D.31339);
                if (ret != 0) goto <D.31353>; else goto <D.31354>;
                <D.31353>:
                monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
                <D.31354>:
                D.31355 = ret != 0;
                D.31356 = (long int) D.31355;
                D.31357 = __builtin_expect (D.31356, 0);
                if (D.31357 != 0) goto <D.31358>; else goto <D.31359>;
                <D.31358>:
                monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 6940, "ret == 0");
                <D.31359>:
              }
            }
          finally
            {
              type_resolve = {CLOBBER};
            }
        }
        <D.29230>:
        D.31360 = monoeg_g_hash_table_iter_next (&iter, 0B, &domain);
        if (D.31360 != 0) goto <D.29229>; else goto <D.29231>;
        <D.29231>:
        mono_loader_unlock ();
        monoeg_g_free (name);
        mono_reflection_free_type_info (&info);
        D.31361 = res_classes->len;
        buffer_add_int (buf, D.31361);
        i = 0;
        goto <D.29233>;
        <D.29232>:
        D.31362 = res_domains->pdata;
        i.134 = (unsigned int) i;
        D.31364 = i.134 * 4;
        D.31365 = D.31362 + D.31364;
        D.31366 = *D.31365;
        D.31367 = res_classes->pdata;
        i.134 = (unsigned int) i;
        D.31364 = i.134 * 4;
        D.31368 = D.31367 + D.31364;
        D.31369 = *D.31368;
        buffer_add_typeid (buf, D.31366, D.31369);
        i = i + 1;
        <D.29233>:
        i.135 = (unsigned int) i;
        D.31361 = res_classes->len;
        if (i.135 < D.31361) goto <D.29232>; else goto <D.29234>;
        <D.29234>:
        monoeg_g_ptr_array_free (res_classes, 1);
        monoeg_g_ptr_array_free (res_domains, 1);
        goto <D.29126>;
      }
    finally
      {
        iter = {CLOBBER};
        domain = {CLOBBER};
        info = {CLOBBER};
      }
  }
  <D.29235>:
  D.31209 = 100;
  return D.31209;
  <D.29126>:
  D.31209 = 0;
  return D.31209;
}


is_really_suspended (void * key, void * value, void * user_data)
{
  struct MonoGHashTable * thread_to_tls.136;
  _Bool D.31380;
  long int D.31381;
  long int D.31382;
  gboolean D.31385;
  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.31380 = tls == 0B;
  D.31381 = (long int) D.31380;
  D.31382 = __builtin_expect (D.31381, 0);
  if (D.31382 != 0) goto <D.31383>; else goto <D.31384>;
  <D.31383>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 6512, "tls");
  <D.31384>:
  res = tls->really_suspended;
  mono_loader_unlock ();
  D.31385 = res;
  return D.31385;
}


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

  D.31388 = 1;
  return D.31388;
}


clear_event_request (int req_id, int etype)
{
  struct GPtrArray * event_requests.138;
  void * * D.31391;
  unsigned int i.139;
  unsigned int D.31393;
  void * * D.31394;
  int D.31395;
  int D.31398;
  void * D.31403;
  unsigned int i.140;
  unsigned int D.31411;
  int i;

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

    event_requests.138 = event_requests;
    D.31391 = event_requests.138->pdata;
    i.139 = (unsigned int) i;
    D.31393 = i.139 * 4;
    D.31394 = D.31391 + D.31393;
    req = *D.31394;
    D.31395 = req->id;
    if (D.31395 == req_id) goto <D.31396>; else goto <D.31397>;
    <D.31396>:
    D.31398 = req->event_kind;
    if (D.31398 == etype) goto <D.31399>; else goto <D.31400>;
    <D.31399>:
    D.31398 = req->event_kind;
    if (D.31398 == 10) goto <D.31401>; else goto <D.31402>;
    <D.31401>:
    D.31403 = req->info;
    clear_breakpoint (D.31403);
    <D.31402>:
    D.31398 = req->event_kind;
    if (D.31398 == 11) goto <D.31404>; else goto <D.31405>;
    <D.31404>:
    D.31403 = req->info;
    ss_destroy (D.31403);
    <D.31405>:
    D.31398 = req->event_kind;
    if (D.31398 == 6) goto <D.31406>; else goto <D.31407>;
    <D.31406>:
    D.31403 = req->info;
    clear_breakpoint (D.31403);
    <D.31407>:
    D.31398 = req->event_kind;
    if (D.31398 == 7) goto <D.31408>; else goto <D.31409>;
    <D.31408>:
    D.31403 = req->info;
    clear_breakpoint (D.31403);
    <D.31409>:
    event_requests.138 = event_requests;
    i.140 = (unsigned int) i;
    monoeg_g_ptr_array_remove_index_fast (event_requests.138, i.140);
    monoeg_g_free (req);
    goto <D.28969>;
    <D.31400>:
    <D.31397>:
  }
  i = i + 1;
  <D.28971>:
  i.140 = (unsigned int) i;
  event_requests.138 = event_requests;
  D.31411 = event_requests.138->len;
  if (i.140 < D.31411) goto <D.28970>; else goto <D.28969>;
  <D.28969>:
  mono_loader_unlock ();
}


transport_close2 ()
{
  struct DebuggerTransport * transport.141;
  void (*<T1268>) (void) D.31413;

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


wait_for_suspend ()
{
  struct MonoGHashTable * thread_to_tls.142;
  unsigned int D.31415;
  int log_level.143;
  _Bool D.31418;
  long int D.31419;
  long int D.31420;
  struct FILE * log_file.144;
  _Bool D.31424;
  long int D.31425;
  long int D.31426;
  int nthreads;
  int nwait;
  int err;
  gboolean waited;

  waited = 0;
  mono_loader_lock ();
  thread_to_tls.142 = thread_to_tls;
  D.31415 = mono_g_hash_table_size (thread_to_tls.142);
  nthreads = (int) D.31415;
  mono_loader_unlock ();
  <D.27968>:
  nwait = count_threads_to_wait_for ();
  if (nwait != 0) goto <D.31416>; else goto <D.27967>;
  <D.31416>:
  log_level.143 = log_level;
  D.31418 = log_level.143 > 0;
  D.31419 = (long int) D.31418;
  D.31420 = __builtin_expect (D.31419, 0);
  if (D.31420 != 0) goto <D.31421>; else goto <D.31422>;
  <D.31421>:
  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.31422>:
  err = mono_sem_wait (&suspend_sem, 0);
  D.31424 = err != 0;
  D.31425 = (long int) D.31424;
  D.31426 = __builtin_expect (D.31425, 0);
  if (D.31426 != 0) goto <D.31427>; else goto <D.31428>;
  <D.31427>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 2962, "err == 0");
  <D.31428>:
  waited = 1;
  goto <D.27968>;
  <D.27967>:
  if (waited != 0) goto <D.31429>; else goto <D.31430>;
  <D.31429>:
  log_level.143 = log_level;
  D.31418 = log_level.143 > 0;
  D.31419 = (long int) D.31418;
  D.31420 = __builtin_expect (D.31419, 0);
  if (D.31420 != 0) goto <D.31431>; else goto <D.31432>;
  <D.31431>:
  log_file.144 = log_file;
  fprintf (log_file.144, "%d threads suspended.\n", nthreads);
  log_file.144 = log_file;
  fflush (log_file.144);
  <D.31432>:
  <D.31430>:
}


count_threads_to_wait_for ()
{
  struct MonoGHashTable * thread_to_tls.145;
  int D.31434;
  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.31434 = count;
      return D.31434;
    }
  finally
    {
      count = {CLOBBER};
    }
}


count_thread (void * key, void * value, void * user_data)
{
  int D.31437;
  int D.31440;
  int D.31443;
  int D.31444;
  struct DebuggerTlsData * tls;

  tls = value;
  D.31437 = tls->suspended;
  if (D.31437 == 0) goto <D.31438>; else goto <D.31439>;
  <D.31438>:
  D.31440 = tls->terminated;
  if (D.31440 == 0) goto <D.31441>; else goto <D.31442>;
  <D.31441>:
  D.31443 = MEM[(int *)user_data];
  D.31444 = D.31443 + 1;
  MEM[(int *)user_data] = D.31444;
  <D.31442>:
  <D.31439>:
}


is_suspended ()
{
  gboolean D.31445;
  int D.31446;
  _Bool D.31447;

  D.31446 = count_threads_to_wait_for ();
  D.31447 = D.31446 == 0;
  D.31445 = (gboolean) D.31447;
  return D.31445;
}


resume_thread (struct MonoInternalThread * thread)
{
  unsigned int D.31449;
  unsigned int debugger_thread_id.146;
  _Bool D.31451;
  long int D.31452;
  long int D.31453;
  struct MonoGHashTable * thread_to_tls.147;
  _Bool D.31457;
  long int D.31458;
  long int D.31459;
  int suspend_count.148;
  _Bool D.31463;
  long int D.31464;
  long int D.31465;
  int log_level.149;
  _Bool D.31469;
  long int D.31470;
  long int D.31471;
  struct FILE * log_file.150;
  long long unsigned int D.31475;
  int D.31476;
  void * D.31477;
  unsigned int D.31478;
  unsigned int suspend_count.151;
  unsigned int D.31480;
  _Bool D.31481;
  long int D.31482;
  long int D.31483;
  int err;
  struct DebuggerTlsData * tls;

  D.31449 = GetCurrentThreadId ();
  debugger_thread_id.146 = debugger_thread_id;
  D.31451 = D.31449 != debugger_thread_id.146;
  D.31452 = (long int) D.31451;
  D.31453 = __builtin_expect (D.31452, 0);
  if (D.31453 != 0) goto <D.31454>; else goto <D.31455>;
  <D.31454>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 2796, "debugger_thread_id == GetCurrentThreadId ()");
  <D.31455>:
  mono_loader_lock ();
  thread_to_tls.147 = thread_to_tls;
  tls = mono_g_hash_table_lookup (thread_to_tls.147, thread);
  D.31457 = tls == 0B;
  D.31458 = (long int) D.31457;
  D.31459 = __builtin_expect (D.31458, 0);
  if (D.31459 != 0) goto <D.31460>; else goto <D.31461>;
  <D.31460>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 2801, "tls");
  <D.31461>:
  pthread_mutex_lock (&suspend_mutex);
  suspend_count.148 = suspend_count;
  D.31463 = suspend_count.148 <= 0;
  D.31464 = (long int) D.31463;
  D.31465 = __builtin_expect (D.31464, 0);
  if (D.31465 != 0) goto <D.31466>; else goto <D.31467>;
  <D.31466>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 2805, "suspend_count > 0");
  <D.31467>:
  log_level.149 = log_level;
  D.31469 = log_level.149 > 0;
  D.31470 = (long int) D.31469;
  D.31471 = __builtin_expect (D.31470, 0);
  if (D.31471 != 0) goto <D.31472>; else goto <D.31473>;
  <D.31472>:
  log_file.150 = log_file;
  D.31475 = thread->tid;
  D.31476 = (int) D.31475;
  D.31477 = (void *) D.31476;
  fprintf (log_file.150, "[%p] Resuming thread...\n", D.31477);
  log_file.150 = log_file;
  fflush (log_file.150);
  <D.31473>:
  D.31478 = tls->resume_count;
  suspend_count.148 = suspend_count;
  suspend_count.151 = (unsigned int) suspend_count.148;
  D.31480 = D.31478 + suspend_count.151;
  tls->resume_count = D.31480;
  err = pthread_cond_broadcast (&suspend_cond);
  D.31481 = err != 0;
  D.31482 = (long int) D.31481;
  D.31483 = __builtin_expect (D.31482, 0);
  if (D.31483 != 0) goto <D.31484>; else goto <D.31485>;
  <D.31484>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 2816, "err == 0");
  <D.31485>:
  pthread_mutex_unlock (&suspend_mutex);
  mono_loader_unlock ();
}


resume_vm ()
{
  unsigned int D.31486;
  unsigned int debugger_thread_id.152;
  _Bool D.31488;
  long int D.31489;
  long int D.31490;
  int suspend_count.153;
  _Bool D.31494;
  long int D.31495;
  long int D.31496;
  int suspend_count.154;
  int log_level.155;
  _Bool D.31501;
  long int D.31502;
  long int D.31503;
  struct FILE * log_file.156;
  unsigned int D.31507;
  void * D.31508;
  struct MonoGHashTable * thread_to_tls.157;
  _Bool D.31512;
  long int D.31513;
  long int D.31514;
  int err;

  D.31486 = GetCurrentThreadId ();
  debugger_thread_id.152 = debugger_thread_id;
  D.31488 = D.31486 != debugger_thread_id.152;
  D.31489 = (long int) D.31488;
  D.31490 = __builtin_expect (D.31489, 0);
  if (D.31490 != 0) goto <D.31491>; else goto <D.31492>;
  <D.31491>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 2755, "debugger_thread_id == GetCurrentThreadId ()");
  <D.31492>:
  mono_loader_lock ();
  pthread_mutex_lock (&suspend_mutex);
  suspend_count.153 = suspend_count;
  D.31494 = suspend_count.153 <= 0;
  D.31495 = (long int) D.31494;
  D.31496 = __builtin_expect (D.31495, 0);
  if (D.31496 != 0) goto <D.31497>; else goto <D.31498>;
  <D.31497>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 2761, "suspend_count > 0");
  <D.31498>:
  suspend_count.153 = suspend_count;
  suspend_count.154 = suspend_count.153 + -1;
  suspend_count = suspend_count.154;
  log_level.155 = log_level;
  D.31501 = log_level.155 > 0;
  D.31502 = (long int) D.31501;
  D.31503 = __builtin_expect (D.31502, 0);
  if (D.31503 != 0) goto <D.31504>; else goto <D.31505>;
  <D.31504>:
  log_file.156 = log_file;
  D.31507 = GetCurrentThreadId ();
  D.31508 = (void *) D.31507;
  suspend_count.153 = suspend_count;
  fprintf (log_file.156, "[%p] Resuming vm, suspend count=%d...\n", D.31508, suspend_count.153);
  log_file.156 = log_file;
  fflush (log_file.156);
  <D.31505>:
  suspend_count.153 = suspend_count;
  if (suspend_count.153 == 0) goto <D.31509>; else goto <D.31510>;
  <D.31509>:
  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.31510>:
  err = pthread_cond_broadcast (&suspend_cond);
  D.31512 = err != 0;
  D.31513 = (long int) D.31512;
  D.31514 = __builtin_expect (D.31513, 0);
  if (D.31514 != 0) goto <D.31515>; else goto <D.31516>;
  <D.31515>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 2774, "err == 0");
  <D.31516>:
  pthread_mutex_unlock (&suspend_mutex);
  suspend_count.153 = suspend_count;
  if (suspend_count.153 == 0) goto <D.31517>; else goto <D.31518>;
  <D.31517>:
  mono_thread_pool_resume ();
  <D.31518>:
  mono_loader_unlock ();
}


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

  tls = value;
  D.31519 = tls->really_suspended;
  if (D.31519 == 0) goto <D.31520>; else goto <D.31521>;
  <D.31520>:
  D.31522 = tls->suspended;
  if (D.31522 != 0) goto <D.31523>; else goto <D.31524>;
  <D.31523>:
  tls->suspended = 0;
  tls->context.valid = 0;
  tls->async_state.valid = 0;
  invalidate_frames (tls);
  <D.31524>:
  <D.31521>:
}


invalidate_frames (struct DebuggerTlsData * tls)
{
  unsigned int debugger_tls_id.158;
  _Bool D.31528;
  long int D.31529;
  long int D.31530;
  struct StackFrame * * D.31533;
  unsigned int i.159;
  unsigned int D.31535;
  struct StackFrame * * D.31536;
  struct StackFrame * D.31537;
  struct MonoDebugMethodJitInfo * D.31538;
  int D.31541;
  int i;

  if (tls == 0B) goto <D.31525>; else goto <D.31526>;
  <D.31525>:
  debugger_tls_id.158 = debugger_tls_id;
  tls = pthread_getspecific (debugger_tls_id.158);
  <D.31526>:
  D.31528 = tls == 0B;
  D.31529 = (long int) D.31528;
  D.31530 = __builtin_expect (D.31529, 0);
  if (D.31530 != 0) goto <D.31531>; else goto <D.31532>;
  <D.31531>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 2831, "tls");
  <D.31532>:
  i = 0;
  goto <D.27940>;
  <D.27939>:
  D.31533 = tls->frames;
  i.159 = (unsigned int) i;
  D.31535 = i.159 * 4;
  D.31536 = D.31533 + D.31535;
  D.31537 = *D.31536;
  D.31538 = D.31537->jit;
  if (D.31538 != 0B) goto <D.31539>; else goto <D.31540>;
  <D.31539>:
  D.31533 = tls->frames;
  i.159 = (unsigned int) i;
  D.31535 = i.159 * 4;
  D.31536 = D.31533 + D.31535;
  D.31537 = *D.31536;
  D.31538 = D.31537->jit;
  mono_debug_free_method_jit_info (D.31538);
  <D.31540>:
  D.31533 = tls->frames;
  i.159 = (unsigned int) i;
  D.31535 = i.159 * 4;
  D.31536 = D.31533 + D.31535;
  D.31537 = *D.31536;
  monoeg_g_free (D.31537);
  i = i + 1;
  <D.27940>:
  D.31541 = tls->frame_count;
  if (D.31541 > i) goto <D.27939>; else goto <D.27941>;
  <D.27941>:
  D.31533 = tls->frames;
  monoeg_g_free (D.31533);
  tls->frame_count = 0;
  tls->frames = 0B;
}


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

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


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

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


get_object (int objid, struct MonoObject * * obj)
{
  <unnamed type> D.31546;
  ErrorCode D.31549;
  struct MonoObject * D.31550;
  int err;

  D.31546 = get_object_allow_null (objid, obj);
  err = (int) D.31546;
  if (err != 0) goto <D.31547>; else goto <D.31548>;
  <D.31547>:
  D.31549 = (ErrorCode) err;
  return D.31549;
  <D.31548>:
  D.31550 = *obj;
  if (D.31550 == 0B) goto <D.31551>; else goto <D.31552>;
  <D.31551>:
  D.31549 = 20;
  return D.31549;
  <D.31552>:
  D.31549 = 0;
  return D.31549;
}


get_object_allow_null (int objid, struct MonoObject * * obj)
{
  ErrorCode D.31556;
  struct GHashTable * objrefs.160;
  const void * objid.161;
  unsigned int D.31563;
  struct MonoObject * D.31564;
  struct MonoObject * D.31565;
  struct ObjRef * ref;

  if (objid == 0) goto <D.31554>; else goto <D.31555>;
  <D.31554>:
  *obj = 0B;
  D.31556 = 0;
  return D.31556;
  <D.31555>:
  objrefs.160 = objrefs;
  if (objrefs.160 == 0B) goto <D.31558>; else goto <D.31559>;
  <D.31558>:
  D.31556 = 20;
  return D.31556;
  <D.31559>:
  mono_loader_lock ();
  objrefs.160 = objrefs;
  objid.161 = (const void *) objid;
  ref = monoeg_g_hash_table_lookup (objrefs.160, objid.161);
  if (ref != 0B) goto <D.31561>; else goto <D.31562>;
  <D.31561>:
  D.31563 = ref->handle;
  D.31564 = mono_gchandle_get_target (D.31563);
  *obj = D.31564;
  mono_loader_unlock ();
  D.31565 = *obj;
  if (D.31565 == 0B) goto <D.31566>; else goto <D.31567>;
  <D.31566>:
  D.31556 = 20;
  return D.31556;
  <D.31567>:
  D.31556 = 0;
  return D.31556;
  <D.31562>:
  mono_loader_unlock ();
  D.31556 = 20;
  return D.31556;
}


get_source_files_for_type (struct MonoClass * klass)
{
  struct GPtrArray * source_file_list.162;
  void * * D.31572;
  unsigned int j.163;
  unsigned int D.31574;
  void * * D.31575;
  int D.29106;
  void * * D.31576;
  unsigned int i.164;
  unsigned int D.31578;
  void * * D.31579;
  void * D.31580;
  char * D.31581;
  unsigned int i.165;
  unsigned int D.31584;
  gchar * D.31587;
  unsigned int j.166;
  unsigned int D.31589;
  struct GPtrArray * D.31590;
  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.29114>;
      <D.29113>:
      {
        struct MonoDebugMethodInfo * minfo;
        struct GPtrArray * source_file_list;

        try
          {
            minfo = mono_debug_lookup_method (method);
            if (minfo != 0B) goto <D.31569>; else goto <D.31570>;
            <D.31569>:
            mono_debug_symfile_get_line_numbers_full (minfo, 0B, &source_file_list, 0B, 0B, 0B, 0B, 0B);
            j = 0;
            goto <D.29111>;
            <D.29110>:
            source_file_list.162 = source_file_list;
            D.31572 = source_file_list.162->pdata;
            j.163 = (unsigned int) j;
            D.31574 = j.163 * 4;
            D.31575 = D.31572 + D.31574;
            sinfo = *D.31575;
            i = 0;
            goto <D.29109>;
            <D.29108>:
            {
              size_t __s1_len;
              size_t __s2_len;

              D.31576 = files->pdata;
              i.164 = (unsigned int) i;
              D.31578 = i.164 * 4;
              D.31579 = D.31576 + D.31578;
              D.31580 = *D.31579;
              D.31581 = sinfo->source_file;
              D.29106 = __builtin_strcmp (D.31580, D.31581);
            }
            if (D.29106 == 0) goto <D.29107>; else goto <D.31582>;
            <D.31582>:
            i = i + 1;
            <D.29109>:
            i.165 = (unsigned int) i;
            D.31584 = files->len;
            if (i.165 < D.31584) goto <D.29108>; else goto <D.29107>;
            <D.29107>:
            i.165 = (unsigned int) i;
            D.31584 = files->len;
            if (i.165 == D.31584) goto <D.31585>; else goto <D.31586>;
            <D.31585>:
            D.31581 = sinfo->source_file;
            D.31587 = monoeg_strdup (D.31581);
            monoeg_g_ptr_array_add (files, D.31587);
            <D.31586>:
            j = j + 1;
            <D.29111>:
            j.166 = (unsigned int) j;
            source_file_list.162 = source_file_list;
            D.31589 = source_file_list.162->len;
            if (j.166 < D.31589) goto <D.29110>; else goto <D.29112>;
            <D.29112>:
            source_file_list.162 = source_file_list;
            monoeg_g_ptr_array_free (source_file_list.162, 1);
            <D.31570>:
          }
        finally
          {
            source_file_list = {CLOBBER};
          }
      }
      <D.29114>:
      method = mono_class_get_methods (klass, &iter);
      if (method != 0B) goto <D.29113>; else goto <D.29115>;
      <D.29115>:
      D.31590 = files;
      return D.31590;
    }
  finally
    {
      iter = {CLOBBER};
    }
}


decode_string (guint8 * buf, guint8 * * endbuf, guint8 * limit)
{
  guint8 * buf.167;
  char * D.31596;
  int D.31597;
  unsigned int D.31598;
  _Bool D.31599;
  long int D.31600;
  long int D.31601;
  unsigned int len.168;
  sizetype len.169;
  char * D.31606;
  guint8 * buf.170;
  int len;
  char * s;

  buf.167 = buf;
  len = decode_int (buf.167, &buf, limit);
  if (len < 0) goto <D.31594>; else goto <D.31595>;
  <D.31594>:
  buf.167 = buf;
  *endbuf = buf.167;
  D.31596 = 0B;
  return D.31596;
  <D.31595>:
  D.31597 = len + 1;
  D.31598 = (unsigned int) D.31597;
  s = monoeg_malloc (D.31598);
  D.31599 = s == 0B;
  D.31600 = (long int) D.31599;
  D.31601 = __builtin_expect (D.31600, 0);
  if (D.31601 != 0) goto <D.31602>; else goto <D.31603>;
  <D.31602>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 1633, "s");
  <D.31603>:
  buf.167 = buf;
  len.168 = (unsigned int) len;
  memcpy (s, buf.167, len.168);
  len.169 = (sizetype) len;
  D.31606 = s + len.169;
  *D.31606 = 0;
  buf.167 = buf;
  len.169 = (sizetype) len;
  buf.170 = buf.167 + len.169;
  buf = buf.170;
  buf.167 = buf;
  *endbuf = buf.167;
  D.31596 = s;
  return D.31596;
}


event_commands (int command, guint8 * p, guint8 * end, struct Buffer * buf)
{
  guint8 * p.171;
  unsigned int nmodifiers.172;
  unsigned int D.31611;
  unsigned int D.31612;
  int D.31613;
  <unnamed type> mod.173;
  int D.31617;
  int err.174;
  ErrorCode D.31624;
  long long int D.31625;
  int protocol_version_set.175;
  int major_version.176;
  int minor_version.177;
  <unnamed type> filter.178;
  <unnamed type> D.31644;
  unsigned int D.31645;
  unsigned int D.31648;
  struct MonoInternalThread * * D.31652;
  <unnamed type> D.31653;
  int err.179;
  int D.31662;
  int D.31663;
  int D.31670;
  int log_level.180;
  _Bool D.31672;
  long int D.31673;
  long int D.31674;
  struct FILE * log_file.181;
  const char * iftmp.182;
  const char * iftmp.183;
  int D.31683;
  const char * iftmp.184;
  int D.31688;
  const char * iftmp.185;
  int D.31693;
  struct MonoClass * D.31699;
  int D.31700;
  unsigned int n.186;
  unsigned int D.31707;
  void * D.31708;
  struct MonoAssembly * * D.31709;
  unsigned int j.187;
  unsigned int D.31711;
  struct MonoAssembly * * D.31712;
  struct MonoAssembly * D.31713;
  struct GHashTable * D.31719;
  struct GHashTable * D.31722;
  struct GHashTable * D.31726;
  struct GHashTable * D.31729;
  int D.31731;
  _Bool D.31734;
  long int D.31735;
  long int D.31736;
  struct MonoBreakpoint * D.31739;
  int D.31740;
  const char * D.31745;
  _Bool D.31749;
  long int D.31750;
  long int D.31751;
  <unnamed type> D.31754;
  int err.188;
  struct MonoThread * step_thread.189;
  struct _MonoInternalThread * D.31759;
  <unnamed type> size.190;
  <unnamed type> depth.191;
  <unnamed type> D.31762;
  int err.192;
  struct MonoBreakpoint * D.31769;
  struct MonoBreakpoint * D.31773;
  int D.31781;
  struct GPtrArray * event_requests.193;
  int D.31785;
  struct GHashTable * domains.194;
  struct MonoGHashTable * tid_to_thread.195;
  int D.31790;
  unsigned int D.31791;
  void * * D.31792;
  unsigned int i.196;
  unsigned int D.31794;
  void * * D.31795;
  int D.31796;
  void * D.31799;
  unsigned int i.197;
  unsigned int D.31802;
  int err;
  struct MonoError error;

  try
    {
      switch (command) <default: <D.29299>, case 1: <D.29244>, case 2: <D.29290>, case 3: <D.29293>>
      <D.29244>:
      {
        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.31611 = nmodifiers.172 + 1;
            D.31612 = D.31611 * 20;
            req = monoeg_malloc0 (D.31612);
            D.31613 = InterlockedIncrement (&event_request_id);
            req->id = D.31613;
            req->event_kind = event_kind;
            req->suspend_policy = suspend_policy;
            req->nmodifiers = nmodifiers;
            method = 0B;
            i = 0;
            goto <D.29281>;
            <D.29280>:
            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.31615>; else goto <D.31616>;
            <D.31615>:
            p.171 = p;
            D.31617 = decode_int (p.171, &p, end);
            req->modifiers[i].data.count = D.31617;
            goto <D.31618>;
            <D.31616>:
            if (mod == 7) goto <D.31619>; else goto <D.31620>;
            <D.31619>:
            p.171 = p;
            method = decode_methodid (p.171, &p, end, &domain, &err);
            err.174 = err;
            if (err.174 != 0) goto <D.31622>; else goto <D.31623>;
            <D.31622>:
            err.174 = err;
            D.31624 = (ErrorCode) err.174;
            return D.31624;
            <D.31623>:
            p.171 = p;
            D.31625 = decode_long (p.171, &p, end);
            location = (long int) D.31625;
            goto <D.31626>;
            <D.31620>:
            if (mod == 10) goto <D.31627>; else goto <D.31628>;
            <D.31627>:
            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.31632>; else goto <D.31633>;
            <D.31632>:
            major_version.176 = major_version;
            if (major_version.176 > 2) goto <D.31629>; else goto <D.31635>;
            <D.31635>:
            major_version.176 = major_version;
            if (major_version.176 == 2) goto <D.31636>; else goto <D.31630>;
            <D.31636>:
            minor_version.177 = minor_version;
            if (minor_version.177 > 15) goto <D.31629>; else goto <D.31630>;
            <D.31629>:
            p.171 = p;
            filter = decode_int (p.171, &p, end);
            <D.31630>:
            <D.31633>:
            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.31639>; else goto <D.31641>;
            <D.31641>:
            major_version.176 = major_version;
            if (major_version.176 <= 2) goto <D.31642>; else goto <D.31640>;
            <D.31642>:
            major_version.176 = major_version;
            if (major_version.176 != 2) goto <D.31639>; else goto <D.31643>;
            <D.31643>:
            minor_version.177 = minor_version;
            if (minor_version.177 <= 25) goto <D.31639>; else goto <D.31640>;
            <D.31639>:
            D.31644 = req->modifiers[i].data.filter;
            D.31645 = D.31644 & 2;
            if (D.31645 != 0) goto <D.31646>; else goto <D.31647>;
            <D.31646>:
            D.31644 = req->modifiers[i].data.filter;
            D.31648 = D.31644 | 4;
            req->modifiers[i].data.filter = D.31648;
            <D.31647>:
            <D.31640>:
            goto <D.31649>;
            <D.31628>:
            if (mod == 3) goto <D.31650>; else goto <D.31651>;
            <D.31650>:
            {
              int id;

              p.171 = p;
              id = decode_id (p.171, &p, end);
              D.31652 = &req->modifiers[i].data.thread;
              D.31653 = get_object (id, D.31652);
              err.179 = (int) D.31653;
              err = err.179;
              err.174 = err;
              if (err.174 != 0) goto <D.31655>; else goto <D.31656>;
              <D.31655>:
              monoeg_g_free (req);
              err.174 = err;
              D.31624 = (ErrorCode) err.174;
              return D.31624;
              <D.31656>:
            }
            goto <D.31657>;
            <D.31651>:
            if (mod == 8) goto <D.31658>; else goto <D.31659>;
            <D.31658>:
            {
              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.31660>; else goto <D.31661>;
              <D.31660>:
              err.174 = err;
              D.31624 = (ErrorCode) err.174;
              return D.31624;
              <D.31661>:
              p.171 = p;
              D.31662 = decode_byte (p.171, &p, end);
              req->modifiers[i].caught = D.31662;
              p.171 = p;
              D.31663 = decode_byte (p.171, &p, end);
              req->modifiers[i].uncaught = D.31663;
              protocol_version_set.175 = protocol_version_set;
              if (protocol_version_set.175 != 0) goto <D.31667>; else goto <D.31664>;
              <D.31667>:
              major_version.176 = major_version;
              if (major_version.176 > 2) goto <D.31665>; else goto <D.31668>;
              <D.31668>:
              major_version.176 = major_version;
              if (major_version.176 == 2) goto <D.31669>; else goto <D.31664>;
              <D.31669>:
              minor_version.177 = minor_version;
              if (minor_version.177 > 24) goto <D.31665>; else goto <D.31664>;
              <D.31665>:
              p.171 = p;
              D.31670 = decode_byte (p.171, &p, end);
              req->modifiers[i].subclasses = D.31670;
              goto <D.31666>;
              <D.31664>:
              req->modifiers[i].subclasses = 1;
              <D.31666>:
              log_level.180 = log_level;
              D.31672 = log_level.180 > 0;
              D.31673 = (long int) D.31672;
              D.31674 = __builtin_expect (D.31673, 0);
              if (D.31674 != 0) goto <D.31675>; else goto <D.31676>;
              <D.31675>:
              log_file.181 = log_file;
              if (exc_class != 0B) goto <D.31679>; else goto <D.31680>;
              <D.31679>:
              iftmp.182 = exc_class->name;
              goto <D.31681>;
              <D.31680>:
              iftmp.182 = "all";
              <D.31681>:
              D.31683 = req->modifiers[i].caught;
              if (D.31683 != 0) goto <D.31684>; else goto <D.31685>;
              <D.31684>:
              iftmp.183 = ", caught";
              goto <D.31686>;
              <D.31685>:
              iftmp.183 = "";
              <D.31686>:
              D.31688 = req->modifiers[i].uncaught;
              if (D.31688 != 0) goto <D.31689>; else goto <D.31690>;
              <D.31689>:
              iftmp.184 = ", uncaught";
              goto <D.31691>;
              <D.31690>:
              iftmp.184 = "";
              <D.31691>:
              D.31693 = req->modifiers[i].subclasses;
              if (D.31693 != 0) goto <D.31694>; else goto <D.31695>;
              <D.31694>:
              iftmp.185 = ", include-subclasses";
              goto <D.31696>;
              <D.31695>:
              iftmp.185 = "";
              <D.31696>:
              fprintf (log_file.181, "[dbg] \tEXCEPTION_ONLY filter (%s%s%s%s).\n", iftmp.182, iftmp.183, iftmp.184, iftmp.185);
              log_file.181 = log_file;
              fflush (log_file.181);
              <D.31676>:
              if (exc_class != 0B) goto <D.31697>; else goto <D.31698>;
              <D.31697>:
              req->modifiers[i].data.exc_class = exc_class;
              D.31699 = mono_defaults.exception_class;
              D.31700 = mono_class_is_assignable_from (D.31699, exc_class);
              if (D.31700 == 0) goto <D.31701>; else goto <D.31702>;
              <D.31701>:
              monoeg_g_free (req);
              D.31624 = 102;
              return D.31624;
              <D.31702>:
              <D.31698>:
            }
            goto <D.31703>;
            <D.31659>:
            if (mod == 11) goto <D.31704>; else goto <D.31705>;
            <D.31704>:
            {
              int n;
              int j;

              p.171 = p;
              n = decode_int (p.171, &p, end);
              n.186 = (unsigned int) n;
              D.31707 = n.186 * 4;
              D.31708 = monoeg_malloc0 (D.31707);
              req->modifiers[i].data.assemblies = D.31708;
              j = 0;
              goto <D.29265>;
              <D.29264>:
              D.31709 = req->modifiers[i].data.assemblies;
              j.187 = (unsigned int) j;
              D.31711 = j.187 * 4;
              D.31712 = D.31709 + D.31711;
              p.171 = p;
              D.31713 = decode_assemblyid (p.171, &p, end, &domain, &err);
              *D.31712 = D.31713;
              err.174 = err;
              if (err.174 != 0) goto <D.31714>; else goto <D.31715>;
              <D.31714>:
              D.31709 = req->modifiers[i].data.assemblies;
              monoeg_g_free (D.31709);
              err.174 = err;
              D.31624 = (ErrorCode) err.174;
              return D.31624;
              <D.31715>:
              j = j + 1;
              <D.29265>:
              if (j < n) goto <D.29264>; else goto <D.29266>;
              <D.29266>:
            }
            goto <D.31716>;
            <D.31705>:
            if (mod == 12) goto <D.31717>; else goto <D.31718>;
            <D.31717>:
            {
              int n;
              int j;

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

                p.171 = p;
                s = decode_string (p.171, &p, end);
                if (s != 0B) goto <D.31720>; else goto <D.31721>;
                <D.31720>:
                s2 = strdup_tolower (s);
                D.31722 = modifier->data.source_files;
                monoeg_g_hash_table_insert_replace (D.31722, s2, s2, 0);
                monoeg_g_free (s);
                <D.31721>:
              }
              j = j + 1;
              <D.29272>:
              if (j < n) goto <D.29271>; else goto <D.29273>;
              <D.29273>:
            }
            goto <D.31723>;
            <D.31718>:
            if (mod == 13) goto <D.31724>; else goto <D.31725>;
            <D.31724>:
            {
              int n;
              int j;

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

                p.171 = p;
                s = decode_string (p.171, &p, end);
                if (s != 0B) goto <D.31727>; else goto <D.31728>;
                <D.31727>:
                D.31729 = modifier->data.type_names;
                monoeg_g_hash_table_insert_replace (D.31729, s, s, 0);
                <D.31728>:
              }
              j = j + 1;
              <D.29278>:
              if (j < n) goto <D.29277>; else goto <D.29279>;
              <D.29279>:
            }
            goto <D.31730>;
            <D.31725>:
            monoeg_g_free (req);
            D.31624 = 100;
            return D.31624;
            <D.31730>:
            <D.31723>:
            <D.31716>:
            <D.31703>:
            <D.31657>:
            <D.31649>:
            <D.31626>:
            <D.31618>:
            i = i + 1;
            <D.29281>:
            if (i < nmodifiers) goto <D.29280>; else goto <D.29282>;
            <D.29282>:
            D.31731 = req->event_kind;
            if (D.31731 == 10) goto <D.31732>; else goto <D.31733>;
            <D.31732>:
            D.31734 = method == 0B;
            D.31735 = (long int) D.31734;
            D.31736 = __builtin_expect (D.31735, 0);
            if (D.31736 != 0) goto <D.31737>; else goto <D.31738>;
            <D.31737>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 7086, "method");
            <D.31738>:
            D.31739 = set_breakpoint (method, location, req, &error);
            req->info = D.31739;
            D.31740 = mono_error_ok (&error);
            if (D.31740 == 0) goto <D.31741>; else goto <D.31742>;
            <D.31741>:
            monoeg_g_free (req);
            log_level.180 = log_level;
            D.31672 = log_level.180 > 0;
            D.31673 = (long int) D.31672;
            D.31674 = __builtin_expect (D.31673, 0);
            if (D.31674 != 0) goto <D.31743>; else goto <D.31744>;
            <D.31743>:
            log_file.181 = log_file;
            D.31745 = mono_error_get_message (&error);
            fprintf (log_file.181, "[dbg] Failed to set breakpoint: %s\n", D.31745);
            log_file.181 = log_file;
            fflush (log_file.181);
            <D.31744>:
            mono_error_cleanup (&error);
            D.31624 = 106;
            return D.31624;
            <D.31742>:
            goto <D.31746>;
            <D.31733>:
            D.31731 = req->event_kind;
            if (D.31731 == 11) goto <D.31747>; else goto <D.31748>;
            <D.31747>:
            D.31749 = step_thread_id == 0;
            D.31750 = (long int) D.31749;
            D.31751 = __builtin_expect (D.31750, 0);
            if (D.31751 != 0) goto <D.31752>; else goto <D.31753>;
            <D.31752>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 7096, "step_thread_id");
            <D.31753>:
            D.31754 = get_object (step_thread_id, &step_thread);
            err.188 = (int) D.31754;
            err = err.188;
            err.174 = err;
            if (err.174 != 0) goto <D.31756>; else goto <D.31757>;
            <D.31756>:
            monoeg_g_free (req);
            err.174 = err;
            D.31624 = (ErrorCode) err.174;
            return D.31624;
            <D.31757>:
            step_thread.189 = step_thread;
            D.31759 = step_thread.189->internal_thread;
            size.190 = (<unnamed type>) size;
            depth.191 = (<unnamed type>) depth;
            D.31762 = ss_create (D.31759, size.190, depth.191, req);
            err.192 = (int) D.31762;
            err = err.192;
            err.174 = err;
            if (err.174 != 0) goto <D.31764>; else goto <D.31765>;
            <D.31764>:
            monoeg_g_free (req);
            err.174 = err;
            D.31624 = (ErrorCode) err.174;
            return D.31624;
            <D.31765>:
            goto <D.31766>;
            <D.31748>:
            D.31731 = req->event_kind;
            if (D.31731 == 6) goto <D.31767>; else goto <D.31768>;
            <D.31767>:
            D.31769 = set_breakpoint (0B, -1, req, 0B);
            req->info = D.31769;
            goto <D.31770>;
            <D.31768>:
            D.31731 = req->event_kind;
            if (D.31731 == 7) goto <D.31771>; else goto <D.31772>;
            <D.31771>:
            D.31773 = set_breakpoint (0B, 16777215, req, 0B);
            req->info = D.31773;
            goto <D.31774>;
            <D.31772>:
            D.31731 = req->event_kind;
            if (D.31731 == 13) goto <D.31775>; else goto <D.31776>;
            <D.31775>:
            goto <D.31777>;
            <D.31776>:
            D.31731 = req->event_kind;
            if (D.31731 == 12) goto <D.31778>; else goto <D.31779>;
            <D.31778>:
            goto <D.31780>;
            <D.31779>:
            D.31781 = req->nmodifiers;
            if (D.31781 != 0) goto <D.31782>; else goto <D.31783>;
            <D.31782>:
            monoeg_g_free (req);
            D.31624 = 100;
            return D.31624;
            <D.31783>:
            <D.31780>:
            <D.31777>:
            <D.31774>:
            <D.31770>:
            <D.31766>:
            <D.31746>:
            mono_loader_lock ();
            event_requests.193 = event_requests;
            monoeg_g_ptr_array_add (event_requests.193, req);
            D.31785 = agent_config.defer;
            if (D.31785 != 0) goto <D.31786>; else goto <D.31787>;
            <D.31786>:
            D.31731 = req->event_kind;
            switch (D.31731) <default: <D.29288>, case 2: <D.29286>, case 4: <D.29283>, case 8: <D.29285>, case 12: <D.29287>>
            <D.29283>:
            domains.194 = domains;
            monoeg_g_hash_table_foreach (domains.194, emit_appdomain_load, 0B);
            goto <D.29284>;
            <D.29285>:
            mono_assembly_foreach (emit_assembly_load, 0B);
            goto <D.29284>;
            <D.29286>:
            tid_to_thread.195 = tid_to_thread;
            mono_g_hash_table_foreach (tid_to_thread.195, emit_thread_start, 0B);
            goto <D.29284>;
            <D.29287>:
            mono_domain_foreach (send_types_for_domain, 0B);
            goto <D.29284>;
            <D.29288>:
            goto <D.29284>;
            <D.29284>:
            <D.31787>:
            mono_loader_unlock ();
            D.31790 = req->id;
            D.31791 = (unsigned int) D.31790;
            buffer_add_int (buf, D.31791);
            goto <D.29289>;
          }
        finally
          {
            step_thread = {CLOBBER};
            domain = {CLOBBER};
          }
      }
      <D.29290>:
      {
        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.29289>;
      }
      <D.29293>:
      {
        int i;

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

          event_requests.193 = event_requests;
          D.31792 = event_requests.193->pdata;
          i.196 = (unsigned int) i;
          D.31794 = i.196 * 4;
          D.31795 = D.31792 + D.31794;
          req = *D.31795;
          D.31796 = req->event_kind;
          if (D.31796 == 10) goto <D.31797>; else goto <D.31798>;
          <D.31797>:
          D.31799 = req->info;
          clear_breakpoint (D.31799);
          event_requests.193 = event_requests;
          i.197 = (unsigned int) i;
          monoeg_g_ptr_array_remove_index_fast (event_requests.193, i.197);
          monoeg_g_free (req);
          goto <D.31801>;
          <D.31798>:
          i = i + 1;
          <D.31801>:
        }
        <D.29297>:
        i.197 = (unsigned int) i;
        event_requests.193 = event_requests;
        D.31802 = event_requests.193->len;
        if (i.197 < D.31802) goto <D.29296>; else goto <D.29298>;
        <D.29298>:
        mono_loader_unlock ();
        goto <D.29289>;
      }
      <D.29299>:
      D.31624 = 100;
      return D.31624;
      <D.29289>:
      D.31624 = 0;
      return D.31624;
    }
  finally
    {
      err = {CLOBBER};
      error = {CLOBBER};
    }
}


send_types_for_domain (struct MonoDomain * domain, void * user_data)
{
  union mono_mutex_t * D.31808;
  _Bool D.31811;
  long int D.31812;
  long int D.31813;
  _Bool D.31816;
  long int D.31817;
  long int D.31818;
  struct GHashTable * D.31821;
  _Bool D.31824;
  long int D.31825;
  long int D.31826;
  struct AgentDomainInfo * info;

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

    D.31808 = &domain->lock.mutex;
    ret = pthread_mutex_lock (D.31808);
    if (ret != 0) goto <D.31809>; else goto <D.31810>;
    <D.31809>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.31810>:
    D.31811 = ret != 0;
    D.31812 = (long int) D.31811;
    D.31813 = __builtin_expect (D.31812, 0);
    if (D.31813 != 0) goto <D.31814>; else goto <D.31815>;
    <D.31814>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 4009, "ret == 0");
    <D.31815>:
  }
  info = get_agent_domain_info (domain);
  D.31816 = info == 0B;
  D.31817 = (long int) D.31816;
  D.31818 = __builtin_expect (D.31817, 0);
  if (D.31818 != 0) goto <D.31819>; else goto <D.31820>;
  <D.31819>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 4011, "info");
  <D.31820>:
  D.31821 = info->loaded_classes;
  monoeg_g_hash_table_foreach (D.31821, emit_type_load, 0B);
  {
    int ret;

    D.31808 = &domain->lock.mutex;
    ret = pthread_mutex_unlock (D.31808);
    if (ret != 0) goto <D.31822>; else goto <D.31823>;
    <D.31822>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.31823>:
    D.31824 = ret != 0;
    D.31825 = (long int) D.31824;
    D.31826 = __builtin_expect (D.31825, 0);
    if (D.31826 != 0) goto <D.31827>; else goto <D.31828>;
    <D.31827>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 4013, "ret == 0");
    <D.31828>:
  }
  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.31831>; else goto <D.31832>;
  <D.31831>:
  process_profiler_event (2, value);
  <D.31832>:
}


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.31833;
  struct GHashTable * D.31834;

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


InterlockedIncrement (volatile gint32 * val)
{
  gint32 D.31835;
  unsigned int D.31836;

  D.31836 = __sync_add_and_fetch_4 (val, 1);
  D.31835 = (gint32) D.31836;
  return D.31835;
}


decode_methodid (guint8 * buf, guint8 * * endbuf, guint8 * limit, struct MonoDomain * * domain, int * err)
{
  int log_level.200;
  _Bool D.31839;
  long int D.31840;
  long int D.31841;
  struct FILE * log_file.201;
  struct MonoMethod * D.31849;
  struct MonoMethod * m;

  m = decode_ptr_id (buf, endbuf, limit, 3, domain, err);
  log_level.200 = log_level;
  D.31839 = log_level.200 > 1;
  D.31840 = (long int) D.31839;
  D.31841 = __builtin_expect (D.31840, 0);
  if (D.31841 != 0) goto <D.31842>; else goto <D.31843>;
  <D.31842>:
  if (m != 0B) goto <D.31844>; else goto <D.31845>;
  <D.31844>:
  {
    char * s;

    s = mono_method_full_name (m, 1);
    log_level.200 = log_level;
    D.31839 = log_level.200 > 1;
    D.31840 = (long int) D.31839;
    D.31841 = __builtin_expect (D.31840, 0);
    if (D.31841 != 0) goto <D.31846>; else goto <D.31847>;
    <D.31846>:
    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.31847>:
    monoeg_g_free (s);
  }
  <D.31845>:
  <D.31843>:
  D.31849 = m;
  return D.31849;
}


decode_ptr_id (guint8 * buf, guint8 * * endbuf, guint8 * limit, IdType type, struct MonoDomain * * domain, int * err)
{
  void * D.31855;
  int iftmp.202;
  unsigned int id.203;
  struct GPtrArray * D.31862;
  unsigned int D.31863;
  _Bool D.31864;
  long int D.31865;
  long int D.31866;
  void * * D.31869;
  sizetype id.204;
  sizetype D.31871;
  sizetype D.31872;
  void * * D.31873;
  struct MonoDomain * D.31874;
  struct Id * res;
  int id;

  id = decode_id (buf, endbuf, limit);
  *err = 0;
  if (domain != 0B) goto <D.31851>; else goto <D.31852>;
  <D.31851>:
  *domain = 0B;
  <D.31852>:
  if (id == 0) goto <D.31853>; else goto <D.31854>;
  <D.31853>:
  D.31855 = 0B;
  return D.31855;
  <D.31854>:
  mono_loader_lock ();
  if (id <= 0) goto <D.31857>; else goto <D.31860>;
  <D.31860>:
  id.203 = (unsigned int) id;
  D.31862 = ids[type];
  D.31863 = D.31862->len;
  if (id.203 > D.31863) goto <D.31857>; else goto <D.31858>;
  <D.31857>:
  iftmp.202 = 1;
  goto <D.31859>;
  <D.31858>:
  iftmp.202 = 0;
  <D.31859>:
  D.31864 = iftmp.202 != 0;
  D.31865 = (long int) D.31864;
  D.31866 = __builtin_expect (D.31865, 0);
  if (D.31866 != 0) goto <D.31867>; else goto <D.31868>;
  <D.31867>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 2196, "id > 0 && id <= ids [type]->len");
  <D.31868>:
  D.31862 = ids[type];
  D.31869 = D.31862->pdata;
  id.204 = (sizetype) id;
  D.31871 = id.204 + 1073741823;
  D.31872 = D.31871 * 4;
  D.31873 = D.31869 + D.31872;
  res = *D.31873;
  mono_loader_unlock ();
  D.31874 = res->domain;
  if (D.31874 == 0B) goto <D.31875>; else goto <D.31876>;
  <D.31875>:
  *err = 103;
  D.31855 = 0B;
  return D.31855;
  <D.31876>:
  if (domain != 0B) goto <D.31877>; else goto <D.31878>;
  <D.31877>:
  D.31874 = res->domain;
  *domain = D.31874;
  <D.31878>:
  D.31855 = res->data.val;
  return D.31855;
}


decode_long (guint8 * buf, guint8 * * endbuf, guint8 * limit)
{
  guint8 * buf.205;
  int D.31881;
  int D.31882;
  gint64 D.31883;
  long long unsigned int D.31884;
  long long unsigned int D.31885;
  long long unsigned int D.31886;
  long long unsigned int D.31887;
  guint32 high;
  guint32 low;

  buf.205 = buf;
  D.31881 = decode_int (buf.205, &buf, limit);
  high = (guint32) D.31881;
  buf.205 = buf;
  D.31882 = decode_int (buf.205, &buf, limit);
  low = (guint32) D.31882;
  buf.205 = buf;
  *endbuf = buf.205;
  D.31884 = (long long unsigned int) high;
  D.31885 = D.31884 << 32;
  D.31886 = (long long unsigned int) low;
  D.31887 = D.31885 | D.31886;
  D.31883 = (gint64) D.31887;
  return D.31883;
}


decode_typeid (guint8 * buf, guint8 * * endbuf, guint8 * limit, struct MonoDomain * * domain, int * err)
{
  int log_level.206;
  _Bool D.31890;
  long int D.31891;
  long int D.31892;
  struct MonoType * D.31897;
  struct FILE * log_file.207;
  struct MonoClass * D.31901;
  struct MonoClass * klass;

  klass = decode_ptr_id (buf, endbuf, limit, 2, domain, err);
  log_level.206 = log_level;
  D.31890 = log_level.206 > 1;
  D.31891 = (long int) D.31890;
  D.31892 = __builtin_expect (D.31891, 0);
  if (D.31892 != 0) goto <D.31893>; else goto <D.31894>;
  <D.31893>:
  if (klass != 0B) goto <D.31895>; else goto <D.31896>;
  <D.31895>:
  {
    char * s;

    D.31897 = &klass->byval_arg;
    s = mono_type_full_name (D.31897);
    log_level.206 = log_level;
    D.31890 = log_level.206 > 1;
    D.31891 = (long int) D.31890;
    D.31892 = __builtin_expect (D.31891, 0);
    if (D.31892 != 0) goto <D.31898>; else goto <D.31899>;
    <D.31898>:
    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.31899>:
    monoeg_g_free (s);
  }
  <D.31896>:
  <D.31894>:
  D.31901 = klass;
  return D.31901;
}


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

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


ss_create (struct MonoInternalThread * thread, StepSize size, StepDepth depth, struct EventRequest * req)
{
  int suspend_count.208;
  ErrorCode D.31908;
  struct SingleStepReq * ss_req.209;
  int log_level.210;
  _Bool D.31913;
  long int D.31914;
  long int D.31915;
  struct FILE * log_file.211;
  _Bool D.31919;
  long int D.31920;
  long int D.31921;
  const char * D.31924;
  void * ss_req.212;
  struct MonoGHashTable * thread_to_tls.213;
  _Bool D.31927;
  long int D.31928;
  long int D.31929;
  int D.31932;
  _Bool D.31933;
  long int D.31934;
  long int D.31935;
  int D.31938;
  void * D.31939;
  void * D.31940;
  int D.31941;
  void * D.31944;
  void * D.31945;
  struct MonoContext * D.31946;
  _Bool D.31947;
  long int D.31948;
  long int D.31949;
  <unnamed type> D.31952;
  _Bool D.31953;
  long int D.31954;
  long int D.31955;
  struct MonoDomain * D.31958;
  struct MonoMethod * D.31959;
  int D.31960;
  _Bool D.31963;
  long int D.31964;
  long int D.31965;
  <unnamed type> D.31970;
  int D.31973;
  struct StackFrame * * D.31976;
  struct MonoMethod * D.31977;
  unsigned int D.31980;
  unsigned int D.31985;
  int D.31986;
  unsigned int D.31993;
  struct MonoDomain * D.31996;
  struct MonoMethod * D.31997;
  unsigned int D.31998;
  int D.31999;
  struct MonoSeqPointInfo * info.214;
  struct MonoContext * D.32005;
  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.31906>; else goto <D.31907>;
      <D.31906>:
      D.31908 = 101;
      return D.31908;
      <D.31907>:
      wait_for_suspend ();
      ss_req.209 = ss_req;
      if (ss_req.209 != 0B) goto <D.31910>; else goto <D.31911>;
      <D.31910>:
      log_level.210 = log_level;
      D.31913 = log_level.210 >= 0;
      D.31914 = (long int) D.31913;
      D.31915 = __builtin_expect (D.31914, 0);
      if (D.31915 != 0) goto <D.31916>; else goto <D.31917>;
      <D.31916>:
      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.31917>:
      D.31908 = 100;
      return D.31908;
      <D.31911>:
      log_level.210 = log_level;
      D.31919 = log_level.210 > 0;
      D.31920 = (long int) D.31919;
      D.31921 = __builtin_expect (D.31920, 0);
      if (D.31921 != 0) goto <D.31922>; else goto <D.31923>;
      <D.31922>:
      log_file.211 = log_file;
      D.31924 = ss_depth_to_string (depth);
      fprintf (log_file.211, "[dbg] Starting single step of thread %p (depth=%s).\n", thread, D.31924);
      log_file.211 = log_file;
      fflush (log_file.211);
      <D.31923>:
      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.31927 = tls == 0B;
      D.31928 = (long int) D.31927;
      D.31929 = __builtin_expect (D.31928, 0);
      if (D.31929 != 0) goto <D.31930>; else goto <D.31931>;
      <D.31930>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 5168, "tls");
      <D.31931>:
      D.31932 = tls->context.valid;
      D.31933 = D.31932 == 0;
      D.31934 = (long int) D.31933;
      D.31935 = __builtin_expect (D.31934, 0);
      if (D.31935 != 0) goto <D.31936>; else goto <D.31937>;
      <D.31936>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 5169, "tls->context.valid");
      <D.31937>:
      ss_req.209 = ss_req;
      ss_req.209 = ss_req;
      D.31938 = tls->context.ctx.regs[13];
      D.31939 = (void *) D.31938;
      ss_req.209->last_sp = D.31939;
      D.31940 = ss_req.209->last_sp;
      ss_req.209->start_sp = D.31940;
      D.31941 = tls->catch_state.valid;
      if (D.31941 != 0) goto <D.31942>; else goto <D.31943>;
      <D.31942>:
      {
        gboolean res;
        struct StackFrameInfo frame;
        struct MonoContext new_ctx;
        struct MonoLMF * lmf;

        try
          {
            lmf = 0B;
            D.31944 = tls->catch_state.unwind_data[0];
            D.31945 = thread->jit_data;
            D.31946 = &tls->catch_state.ctx;
            res = mono_find_jit_info_ext (D.31944, D.31945, 0B, D.31946, &new_ctx, 0B, &lmf, 0B, &frame);
            D.31947 = res == 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", 5184, "res");
            <D.31951>:
            D.31952 = frame.type;
            D.31953 = D.31952 != 0;
            D.31954 = (long int) D.31953;
            D.31955 = __builtin_expect (D.31954, 0);
            if (D.31955 != 0) goto <D.31956>; else goto <D.31957>;
            <D.31956>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 5185, "frame.type == FRAME_TYPE_MANAGED");
            <D.31957>:
            D.31958 = frame.domain;
            D.31959 = frame.method;
            D.31960 = frame.native_offset;
            sp = find_next_seq_point_for_native_offset (D.31958, D.31959, D.31960, &info);
            if (sp == 0B) goto <D.31961>; else goto <D.31962>;
            <D.31961>:
            D.31959 = frame.method;
            no_seq_points_found (D.31959);
            <D.31962>:
            D.31963 = sp == 0B;
            D.31964 = (long int) D.31963;
            D.31965 = __builtin_expect (D.31964, 0);
            if (D.31965 != 0) goto <D.31966>; else goto <D.31967>;
            <D.31966>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 5194, "sp");
            <D.31967>:
            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.31943>:
      if (step_to_catch == 0) goto <D.31968>; else goto <D.31969>;
      <D.31968>:
      ss_req.209 = ss_req;
      D.31970 = ss_req.209->size;
      if (D.31970 == 1) goto <D.31971>; else goto <D.31972>;
      <D.31971>:
      {
        struct StackFrame * frame;

        compute_frame_info (thread, tls);
        D.31973 = tls->frame_count;
        if (D.31973 != 0) goto <D.31974>; else goto <D.31975>;
        <D.31974>:
        D.31976 = tls->frames;
        frame = *D.31976;
        ss_req.209 = ss_req;
        D.31977 = frame->method;
        ss_req.209->last_method = D.31977;
        ss_req.209 = ss_req;
        ss_req.209->last_line = -1;
        D.31977 = frame->method;
        minfo = mono_debug_lookup_method (D.31977);
        if (minfo != 0B) goto <D.31978>; else goto <D.31979>;
        <D.31978>:
        D.31980 = frame->il_offset;
        if (D.31980 != 4294967295) goto <D.31981>; else goto <D.31982>;
        <D.31981>:
        {
          struct MonoDebugSourceLocation * loc;

          D.31980 = frame->il_offset;
          loc = mono_debug_symfile_lookup_location (minfo, D.31980);
          if (loc != 0B) goto <D.31983>; else goto <D.31984>;
          <D.31983>:
          ss_req.209 = ss_req;
          D.31985 = loc->row;
          D.31986 = (int) D.31985;
          ss_req.209->last_line = D.31986;
          monoeg_g_free (loc);
          <D.31984>:
        }
        <D.31982>:
        <D.31979>:
        <D.31975>:
      }
      <D.31972>:
      <D.31969>:
      if (step_to_catch == 0) goto <D.31987>; else goto <D.31988>;
      <D.31987>:
      {
        struct StackFrame * frame;

        compute_frame_info (thread, tls);
        D.31973 = tls->frame_count;
        if (D.31973 != 0) goto <D.31989>; else goto <D.31990>;
        <D.31989>:
        D.31976 = tls->frames;
        frame = *D.31976;
        if (method == 0B) goto <D.31991>; else goto <D.31992>;
        <D.31991>:
        D.31993 = frame->il_offset;
        if (D.31993 != 4294967295) goto <D.31994>; else goto <D.31995>;
        <D.31994>:
        D.31996 = frame->domain;
        D.31997 = frame->method;
        D.31998 = frame->native_offset;
        D.31999 = (int) D.31998;
        sp = find_prev_seq_point_for_native_offset (D.31996, D.31997, D.31999, &info);
        if (sp == 0B) goto <D.32000>; else goto <D.32001>;
        <D.32000>:
        D.31997 = frame->method;
        no_seq_points_found (D.31997);
        <D.32001>:
        D.31963 = sp == 0B;
        D.31964 = (long int) D.31963;
        D.31965 = __builtin_expect (D.31964, 0);
        if (D.31965 != 0) goto <D.32002>; else goto <D.32003>;
        <D.32002>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 5240, "sp");
        <D.32003>:
        method = frame->method;
        <D.31995>:
        <D.31992>:
        <D.31990>:
      }
      <D.31988>:
      ss_req.209 = ss_req;
      info.214 = info;
      D.32005 = &tls->context.ctx;
      ss_start (ss_req.209, method, sp, info.214, D.32005, tls, step_to_catch);
      D.31908 = 0;
      return D.31908;
    }
  finally
    {
      info = {CLOBBER};
    }
}


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

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


find_next_seq_point_for_native_offset (struct MonoDomain * domain, struct MonoMethod * method, gint32 native_offset, struct MonoSeqPointInfo * * info)
{
  struct SeqPoint * D.32014;
  _Bool D.32015;
  long int D.32016;
  long int D.32017;
  int D.32022;
  int D.32025;
  struct MonoSeqPointInfo * seq_points;
  int i;

  seq_points = get_seq_points (domain, method);
  if (seq_points == 0B) goto <D.32010>; else goto <D.32011>;
  <D.32010>:
  if (info != 0B) goto <D.32012>; else goto <D.32013>;
  <D.32012>:
  *info = 0B;
  <D.32013>:
  D.32014 = 0B;
  return D.32014;
  <D.32011>:
  D.32015 = seq_points == 0B;
  D.32016 = (long int) D.32015;
  D.32017 = __builtin_expect (D.32016, 0);
  if (D.32017 != 0) goto <D.32018>; else goto <D.32019>;
  <D.32018>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 3028, "seq_points");
  <D.32019>:
  if (info != 0B) goto <D.32020>; else goto <D.32021>;
  <D.32020>:
  *info = seq_points;
  <D.32021>:
  i = 0;
  goto <D.27991>;
  <D.27990>:
  D.32022 = seq_points->seq_points[i].native_offset;
  if (D.32022 >= native_offset) goto <D.32023>; else goto <D.32024>;
  <D.32023>:
  D.32014 = &seq_points->seq_points[i];
  return D.32014;
  <D.32024>:
  i = i + 1;
  <D.27991>:
  D.32025 = seq_points->len;
  if (D.32025 > i) goto <D.27990>; else goto <D.27992>;
  <D.27992>:
  D.32014 = 0B;
  return D.32014;
}


get_seq_points (struct MonoDomain * domain, struct MonoMethod * method)
{
  union mono_mutex_t * D.32027;
  _Bool D.32030;
  long int D.32031;
  long int D.32032;
  void * D.32035;
  struct GHashTable * D.32036;
  unsigned char D.32039;
  unsigned char D.32040;
  struct MonoMethod * D.32043;
  struct MonoMethod * D.32046;
  _Bool D.32049;
  long int D.32050;
  long int D.32051;
  struct MonoSeqPointInfo * D.32054;
  struct MonoSeqPointInfo * seq_points;

  {
    int ret;

    D.32027 = &domain->lock.mutex;
    ret = pthread_mutex_lock (D.32027);
    if (ret != 0) goto <D.32028>; else goto <D.32029>;
    <D.32028>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.32029>:
    D.32030 = ret != 0;
    D.32031 = (long int) D.32030;
    D.32032 = __builtin_expect (D.32031, 0);
    if (D.32032 != 0) goto <D.32033>; else goto <D.32034>;
    <D.32033>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 2989, "ret == 0");
    <D.32034>:
  }
  D.32035 = domain->runtime_info;
  D.32036 = MEM[(struct MonoJitDomainInfo *)D.32035].seq_points;
  seq_points = monoeg_g_hash_table_lookup (D.32036, method);
  if (seq_points == 0B) goto <D.32037>; else goto <D.32038>;
  <D.32037>:
  D.32039 = BIT_FIELD_REF <*method, 8, 168>;
  D.32040 = D.32039 & 16;
  if (D.32040 != 0) goto <D.32041>; else goto <D.32042>;
  <D.32041>:
  D.32035 = domain->runtime_info;
  D.32036 = MEM[(struct MonoJitDomainInfo *)D.32035].seq_points;
  D.32043 = mono_method_get_declaring_generic_method (method);
  seq_points = monoeg_g_hash_table_lookup (D.32036, D.32043);
  if (seq_points == 0B) goto <D.32044>; else goto <D.32045>;
  <D.32044>:
  D.32035 = domain->runtime_info;
  D.32036 = MEM[(struct MonoJitDomainInfo *)D.32035].seq_points;
  D.32046 = mini_get_shared_method (method);
  seq_points = monoeg_g_hash_table_lookup (D.32036, D.32046);
  <D.32045>:
  <D.32042>:
  <D.32038>:
  {
    int ret;

    D.32027 = &domain->lock.mutex;
    ret = pthread_mutex_unlock (D.32027);
    if (ret != 0) goto <D.32047>; else goto <D.32048>;
    <D.32047>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.32048>:
    D.32049 = ret != 0;
    D.32050 = (long int) D.32049;
    D.32051 = __builtin_expect (D.32050, 0);
    if (D.32051 != 0) goto <D.32052>; else goto <D.32053>;
    <D.32052>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 2997, "ret == 0");
    <D.32053>:
  }
  D.32054 = seq_points;
  return D.32054;
}


compute_frame_info (struct MonoInternalThread * thread, struct DebuggerTlsData * tls)
{
  struct StackFrame * * D.32056;
  int D.32059;
  int log_level.215;
  _Bool D.32063;
  long int D.32064;
  long int D.32065;
  struct FILE * log_file.216;
  long long unsigned int D.32069;
  long int D.32070;
  int D.32071;
  int D.32076;
  int D.32078;
  struct StackFrameInfo * D.32080;
  struct MonoThreadUnwindState * D.32081;
  int D.32082;
  int D.32085;
  struct MonoThreadUnwindState * D.32088;
  struct MonoThreadUnwindState * D.32089;
  struct GSList * D.32094;
  unsigned int D.32095;
  unsigned int new_frame_count.217;
  unsigned int D.32097;
  unsigned int i.218;
  unsigned int D.32099;
  struct StackFrame * * D.32100;
  struct StackFrame * D.32101;
  int D.32102;
  void * D.32103;
  int D.32104;
  void * D.32105;
  int D.32108;
  int D.32109;
  int D.32112;
  int findex.219;
  unsigned int findex.220;
  unsigned int D.32115;
  struct StackFrame * * D.32116;
  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.32056 = tls->frames;
      if (D.32056 != 0B) goto <D.32057>; else goto <D.32058>;
      <D.32057>:
      D.32059 = tls->frames_up_to_date;
      if (D.32059 != 0) goto <D.32060>; else goto <D.32061>;
      <D.32060>:
      return;
      <D.32061>:
      <D.32058>:
      log_level.215 = log_level;
      D.32063 = log_level.215 > 0;
      D.32064 = (long int) D.32063;
      D.32065 = __builtin_expect (D.32064, 0);
      if (D.32065 != 0) goto <D.32066>; else goto <D.32067>;
      <D.32066>:
      log_file.216 = log_file;
      D.32069 = thread->tid;
      D.32070 = (long int) D.32069;
      fprintf (log_file.216, "Frames for %p(tid=%lx):\n", thread, D.32070);
      log_file.216 = log_file;
      fflush (log_file.216);
      <D.32067>:
      user_data.tls = tls;
      user_data.frames = 0B;
      D.32071 = tls->terminated;
      if (D.32071 != 0) goto <D.32072>; else goto <D.32073>;
      <D.32072>:
      tls->frame_count = 0;
      return;
      <D.32073>:
      D.32076 = tls->really_suspended;
      if (D.32076 == 0) goto <D.32077>; else goto <D.32074>;
      <D.32077>:
      D.32078 = tls->async_state.valid;
      if (D.32078 != 0) goto <D.32079>; else goto <D.32074>;
      <D.32079>:
      D.32080 = &tls->async_last_frame;
      process_frame (D.32080, 0B, &user_data);
      D.32081 = &tls->async_state;
      mono_walk_stack_with_state (process_frame, D.32081, opts, &user_data);
      goto <D.32075>;
      <D.32074>:
      D.32082 = tls->filter_state.valid;
      if (D.32082 != 0) goto <D.32083>; else goto <D.32084>;
      <D.32083>:
      D.32085 = tls->context.valid;
      if (D.32085 != 0) goto <D.32086>; else goto <D.32087>;
      <D.32086>:
      D.32088 = &tls->context;
      mono_walk_stack_with_state (process_filter_frame, D.32088, opts, &user_data);
      <D.32087>:
      D.32089 = &tls->filter_state;
      mono_walk_stack_with_state (process_frame, D.32089, opts, &user_data);
      goto <D.32090>;
      <D.32084>:
      D.32085 = tls->context.valid;
      if (D.32085 != 0) goto <D.32091>; else goto <D.32092>;
      <D.32091>:
      D.32088 = &tls->context;
      mono_walk_stack_with_state (process_frame, D.32088, opts, &user_data);
      goto <D.32093>;
      <D.32092>:
      tls->frame_count = 0;
      return;
      <D.32093>:
      <D.32090>:
      <D.32075>:
      D.32094 = user_data.frames;
      D.32095 = monoeg_g_slist_length (D.32094);
      new_frame_count = (int) D.32095;
      new_frame_count.217 = (unsigned int) new_frame_count;
      D.32097 = new_frame_count.217 * 4;
      new_frames = monoeg_malloc0 (D.32097);
      findex = 0;
      tmp = user_data.frames;
      goto <D.28053>;
      <D.28052>:
      f = tmp->data;
      i = 0;
      goto <D.28051>;
      <D.28050>:
      D.32056 = tls->frames;
      i.218 = (unsigned int) i;
      D.32099 = i.218 * 4;
      D.32100 = D.32056 + D.32099;
      D.32101 = *D.32100;
      D.32102 = D.32101->ctx.regs[13];
      D.32103 = (void *) D.32102;
      D.32104 = f->ctx.regs[13];
      D.32105 = (void *) D.32104;
      if (D.32103 == D.32105) goto <D.32106>; else goto <D.32107>;
      <D.32106>:
      D.32056 = tls->frames;
      i.218 = (unsigned int) i;
      D.32099 = i.218 * 4;
      D.32100 = D.32056 + D.32099;
      D.32101 = *D.32100;
      D.32108 = D.32101->id;
      f->id = D.32108;
      goto <D.28049>;
      <D.32107>:
      i = i + 1;
      <D.28051>:
      D.32109 = tls->frame_count;
      if (D.32109 > i) goto <D.28050>; else goto <D.28049>;
      <D.28049>:
      D.32109 = tls->frame_count;
      if (D.32109 <= i) goto <D.32110>; else goto <D.32111>;
      <D.32110>:
      D.32112 = InterlockedIncrement (&frame_id);
      f->id = D.32112;
      <D.32111>:
      findex.219 = findex;
      findex = findex.219 + 1;
      findex.220 = (unsigned int) findex.219;
      D.32115 = findex.220 * 4;
      D.32116 = new_frames + D.32115;
      *D.32116 = f;
      tmp = tmp->next;
      <D.28053>:
      if (tmp != 0B) goto <D.28052>; else goto <D.28054>;
      <D.28054>:
      D.32094 = user_data.frames;
      monoeg_g_slist_free (D.32094);
      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.32120;
  void * D.32121;
  struct DebuggerTlsData * D.32122;
  int D.32123;
  void * D.32124;
  gboolean D.32127;
  struct ComputeFramesUserData * ud;

  ud = user_data;
  D.32120 = ctx->regs[13];
  D.32121 = (void *) D.32120;
  D.32122 = ud->tls;
  D.32123 = D.32122->filter_state.ctx.regs[13];
  D.32124 = (void *) D.32123;
  if (D.32121 >= D.32124) goto <D.32125>; else goto <D.32126>;
  <D.32125>:
  D.32127 = 1;
  return D.32127;
  <D.32126>:
  D.32127 = process_frame (info, ctx, user_data);
  return D.32127;
}


process_frame (struct StackFrameInfo * info, struct MonoContext * ctx, void * user_data)
{
  <unnamed type> D.32129;
  struct GSList * D.32134;
  struct GSList * D.32137;
  void * D.32138;
  int D.32139;
  int D.32140;
  gboolean D.32141;
  struct MonoJitInfo * D.32142;
  unsigned char D.32151;
  unsigned char D.32152;
  _Bool D.32153;
  _Bool D.32154;
  _Bool D.32155;
  unsigned char D.32157;
  int D.32158;
  struct MonoDomain * D.32163;
  int D.32164;
  int D.32167;
  unsigned int D.32170;
  int D.32171;
  int log_level.221;
  _Bool D.32173;
  long int D.32174;
  long int D.32175;
  struct FILE * log_file.222;
  char * D.32179;
  int D.32180;
  int protocol_version_set.223;
  int major_version.224;
  int minor_version.225;
  unsigned int D.32193;
  unsigned int D.32194;
  mgreg_t * * D.32195;
  mgreg_t *[16] * D.32198;
  struct GSList * D.32201;
  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.32129 = info->type;
  if (D.32129 != 0) goto <D.32130>; else goto <D.32131>;
  <D.32130>:
  D.32129 = info->type;
  if (D.32129 == 1) goto <D.32132>; else goto <D.32133>;
  <D.32132>:
  D.32134 = ud->frames;
  if (D.32134 != 0B) goto <D.32135>; else goto <D.32136>;
  <D.32135>:
  D.32134 = ud->frames;
  D.32137 = monoeg_g_slist_last (D.32134);
  D.32138 = D.32137->data;
  D.32139 = MEM[(struct StackFrame *)D.32138].flags;
  D.32140 = D.32139 | 1;
  MEM[(struct StackFrame *)D.32138].flags = D.32140;
  <D.32136>:
  <D.32133>:
  D.32141 = 0;
  return D.32141;
  <D.32131>:
  D.32142 = info->ji;
  if (D.32142 != 0B) goto <D.32143>; else goto <D.32144>;
  <D.32143>:
  D.32142 = info->ji;
  method = jinfo_get_method (D.32142);
  goto <D.32145>;
  <D.32144>:
  method = info->method;
  <D.32145>:
  actual_method = info->actual_method;
  api_method = method;
  if (method == 0B) goto <D.32146>; else goto <D.32147>;
  <D.32146>:
  D.32141 = 0;
  return D.32141;
  <D.32147>:
  if (method == 0B) goto <D.32148>; else goto <D.32150>;
  <D.32150>:
  D.32151 = BIT_FIELD_REF <*method, 8, 160>;
  D.32152 = D.32151 & 124;
  D.32153 = D.32152 != 0;
  D.32154 = D.32152 != 68;
  D.32155 = D.32153 & D.32154;
  if (D.32155 != 0) goto <D.32156>; else goto <D.32149>;
  <D.32156>:
  D.32151 = BIT_FIELD_REF <*method, 8, 160>;
  D.32157 = D.32151 & 124;
  if (D.32157 != 24) goto <D.32148>; else goto <D.32149>;
  <D.32148>:
  D.32141 = 0;
  return D.32141;
  <D.32149>:
  D.32158 = info->il_offset;
  if (D.32158 == -1) goto <D.32159>; else goto <D.32160>;
  <D.32159>:
  D.32134 = ud->frames;
  if (D.32134 == 0B) goto <D.32161>; else goto <D.32162>;
  <D.32161>:
  D.32163 = info->domain;
  D.32164 = info->native_offset;
  sp = find_prev_seq_point_for_native_offset (D.32163, method, D.32164, 0B);
  if (sp != 0B) goto <D.32165>; else goto <D.32166>;
  <D.32165>:
  D.32167 = sp->il_offset;
  info->il_offset = D.32167;
  <D.32166>:
  <D.32162>:
  D.32158 = info->il_offset;
  if (D.32158 == -1) goto <D.32168>; else goto <D.32169>;
  <D.32168>:
  D.32163 = info->domain;
  D.32164 = info->native_offset;
  D.32170 = (unsigned int) D.32164;
  D.32171 = mono_debug_il_offset_from_address (method, D.32163, D.32170);
  info->il_offset = D.32171;
  <D.32169>:
  <D.32160>:
  log_level.221 = log_level;
  D.32173 = log_level.221 > 0;
  D.32174 = (long int) D.32173;
  D.32175 = __builtin_expect (D.32174, 0);
  if (D.32175 != 0) goto <D.32176>; else goto <D.32177>;
  <D.32176>:
  log_file.222 = log_file;
  D.32179 = mono_method_full_name (method, 1);
  D.32158 = info->il_offset;
  D.32164 = info->native_offset;
  D.32180 = info->managed;
  fprintf (log_file.222, "\tFrame: %s:%x(%x) %d\n", D.32179, D.32158, D.32164, D.32180);
  log_file.222 = log_file;
  fflush (log_file.222);
  <D.32177>:
  D.32151 = BIT_FIELD_REF <*method, 8, 160>;
  D.32157 = D.32151 & 124;
  if (D.32157 == 24) goto <D.32181>; else goto <D.32182>;
  <D.32181>:
  protocol_version_set.223 = protocol_version_set;
  if (protocol_version_set.223 == 0) goto <D.32183>; else goto <D.32186>;
  <D.32186>:
  major_version.224 = major_version;
  if (major_version.224 <= 2) goto <D.32188>; else goto <D.32184>;
  <D.32188>:
  major_version.224 = major_version;
  if (major_version.224 != 2) goto <D.32183>; else goto <D.32189>;
  <D.32189>:
  minor_version.225 = minor_version;
  if (minor_version.225 <= 16) goto <D.32183>; else goto <D.32184>;
  <D.32183>:
  D.32141 = 0;
  return D.32141;
  <D.32184>:
  api_method = mono_marshal_method_from_wrapper (method);
  if (api_method == 0B) goto <D.32191>; else goto <D.32192>;
  <D.32191>:
  D.32141 = 0;
  return D.32141;
  <D.32192>:
  actual_method = api_method;
  flags = flags | 2;
  <D.32182>:
  frame = monoeg_malloc0 (320);
  frame->method = method;
  frame->actual_method = actual_method;
  frame->api_method = api_method;
  D.32158 = info->il_offset;
  D.32193 = (unsigned int) D.32158;
  frame->il_offset = D.32193;
  D.32164 = info->native_offset;
  D.32194 = (unsigned int) D.32164;
  frame->native_offset = D.32194;
  frame->flags = flags;
  D.32142 = info->ji;
  frame->ji = D.32142;
  D.32195 = info->reg_locations;
  if (D.32195 != 0B) goto <D.32196>; else goto <D.32197>;
  <D.32196>:
  D.32198 = &frame->reg_locations;
  D.32195 = info->reg_locations;
  memcpy (D.32198, D.32195, 64);
  <D.32197>:
  if (ctx != 0B) goto <D.32199>; else goto <D.32200>;
  <D.32199>:
  frame->ctx = *ctx;
  frame->has_ctx = 1;
  <D.32200>:
  D.32163 = info->domain;
  frame->domain = D.32163;
  D.32134 = ud->frames;
  D.32201 = monoeg_g_slist_append (D.32134, frame);
  ud->frames = D.32201;
  D.32141 = 0;
  return D.32141;
}


find_prev_seq_point_for_native_offset (struct MonoDomain * domain, struct MonoMethod * method, gint32 native_offset, struct MonoSeqPointInfo * * info)
{
  struct SeqPoint * D.32207;
  int D.32208;
  int D.32209;
  struct MonoSeqPointInfo * seq_points;
  int i;

  seq_points = get_seq_points (domain, method);
  if (info != 0B) goto <D.32203>; else goto <D.32204>;
  <D.32203>:
  *info = seq_points;
  <D.32204>:
  if (seq_points == 0B) goto <D.32205>; else goto <D.32206>;
  <D.32205>:
  D.32207 = 0B;
  return D.32207;
  <D.32206>:
  D.32208 = seq_points->len;
  i = D.32208 + -1;
  goto <D.28002>;
  <D.28001>:
  D.32209 = seq_points->seq_points[i].native_offset;
  if (D.32209 <= native_offset) goto <D.32210>; else goto <D.32211>;
  <D.32210>:
  D.32207 = &seq_points->seq_points[i];
  return D.32207;
  <D.32211>:
  i = i + -1;
  <D.28002>:
  if (i >= 0) goto <D.28001>; else goto <D.28003>;
  <D.28003>:
  D.32207 = 0B;
  return D.32207;
}


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

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


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

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


ss_start (struct SingleStepReq * ss_req, struct MonoMethod * method, struct SeqPoint * sp, struct MonoSeqPointInfo * info, struct MonoContext * ctx, struct DebuggerTlsData * tls, gboolean step_to_catch)
{
  int D.32218;
  struct EventRequest * D.32219;
  struct GSList * D.32220;
  struct GSList * D.32221;
  int D.32226;
  <unnamed type> D.32228;
  int D.32232;
  struct MonoThreadUnwindState * D.32235;
  struct MonoInternalThread * D.32236;
  struct StackFrame * * D.32239;
  unsigned int frame_index.226;
  unsigned int D.32241;
  struct StackFrame * * D.32242;
  struct MonoDomain * D.32243;
  struct MonoMethod * D.32244;
  unsigned int D.32245;
  int D.32246;
  int D.32250;
  struct MonoDomain * D.32256;
  struct MonoMethod * D.32257;
  unsigned int D.32258;
  int D.32259;
  struct MonoSeqPointInfo * info.227;
  int * D.32268;
  unsigned int i.228;
  unsigned int D.32270;
  int * D.32271;
  int D.32272;
  int D.32273;
  struct GSList * D.32274;
  int D.32277;
  struct StackFrame * * D.32280;
  struct MonoJitInfo * D.32281;
  struct MonoDomain * D.32284;
  struct MonoMethod * D.32285;
  void * D.32286;
  int D.32287;
  void * D.32288;
  int D.32289;
  int D.32290;
  struct GSList * D.32293;
  <unnamed-unsigned:15> D.32294;
  int D.32295;
  int log_level.229;
  _Bool D.32301;
  long int D.32302;
  long int D.32303;
  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.32216>; else goto <D.32217>;
  <D.32216>:
  D.32218 = sp->il_offset;
  D.32219 = ss_req->req;
  bp = set_breakpoint (method, D.32218, D.32219, 0B);
  D.32220 = ss_req->bps;
  D.32221 = monoeg_g_slist_append (D.32220, bp);
  ss_req->bps = D.32221;
  goto <D.32222>;
  <D.32217>:
  frame_index = 1;
  if (sp == 0B) goto <D.32223>; else goto <D.32225>;
  <D.32225>:
  D.32226 = sp->next_len;
  if (D.32226 == 0) goto <D.32223>; else goto <D.32227>;
  <D.32227>:
  D.32228 = ss_req->depth;
  if (D.32228 == 2) goto <D.32223>; else goto <D.32229>;
  <D.32229>:
  D.32228 = ss_req->depth;
  if (D.32228 == 1) goto <D.32223>; else goto <D.32224>;
  <D.32223>:
  if (ctx != 0B) goto <D.32230>; else goto <D.32231>;
  <D.32230>:
  D.32232 = tls->context.valid;
  if (D.32232 == 0) goto <D.32233>; else goto <D.32234>;
  <D.32233>:
  D.32235 = &tls->context;
  mono_thread_state_init_from_monoctx (D.32235, ctx);
  <D.32234>:
  D.32236 = tls->thread;
  compute_frame_info (D.32236, tls);
  <D.32231>:
  <D.32224>:
  D.32228 = ss_req->depth;
  if (D.32228 == 2) goto <D.32237>; else goto <D.32238>;
  <D.32237>:
  goto <D.28610>;
  <D.28609>:
  {
    struct StackFrame * frame;

    D.32239 = tls->frames;
    frame_index.226 = (unsigned int) frame_index;
    D.32241 = frame_index.226 * 4;
    D.32242 = D.32239 + D.32241;
    frame = *D.32242;
    method = frame->method;
    D.32243 = frame->domain;
    D.32244 = frame->method;
    D.32245 = frame->native_offset;
    D.32246 = (int) D.32245;
    sp = find_prev_seq_point_for_native_offset (D.32243, D.32244, D.32246, &info);
    frame_index = frame_index + 1;
    if (sp != 0B) goto <D.32247>; else goto <D.32248>;
    <D.32247>:
    D.32226 = sp->next_len;
    if (D.32226 != 0) goto <D.28608>; else goto <D.32249>;
    <D.32249>:
    <D.32248>:
  }
  <D.28610>:
  D.32250 = tls->frame_count;
  if (D.32250 > frame_index) goto <D.28609>; else goto <D.28608>;
  <D.28608>:
  goto <D.32251>;
  <D.32238>:
  if (sp != 0B) goto <D.32252>; else goto <D.32253>;
  <D.32252>:
  D.32226 = sp->next_len;
  if (D.32226 == 0) goto <D.32254>; else goto <D.32255>;
  <D.32254>:
  sp = 0B;
  goto <D.28614>;
  <D.28613>:
  {
    struct StackFrame * frame;

    D.32239 = tls->frames;
    frame_index.226 = (unsigned int) frame_index;
    D.32241 = frame_index.226 * 4;
    D.32242 = D.32239 + D.32241;
    frame = *D.32242;
    method = frame->method;
    D.32256 = frame->domain;
    D.32257 = frame->method;
    D.32258 = frame->native_offset;
    D.32259 = (int) D.32258;
    sp = find_prev_seq_point_for_native_offset (D.32256, D.32257, D.32259, &info);
    if (sp != 0B) goto <D.32260>; else goto <D.32261>;
    <D.32260>:
    D.32226 = sp->next_len;
    if (D.32226 != 0) goto <D.28612>; else goto <D.32262>;
    <D.32262>:
    <D.32261>:
    sp = 0B;
    frame_index = frame_index + 1;
  }
  <D.28614>:
  D.32250 = tls->frame_count;
  if (D.32250 > frame_index) goto <D.28613>; else goto <D.28612>;
  <D.28612>:
  <D.32255>:
  <D.32253>:
  <D.32251>:
  if (sp != 0B) goto <D.32263>; else goto <D.32264>;
  <D.32263>:
  D.32226 = sp->next_len;
  if (D.32226 > 0) goto <D.32265>; else goto <D.32266>;
  <D.32265>:
  i = 0;
  goto <D.28616>;
  <D.28615>:
  info.227 = info;
  D.32268 = sp->next;
  i.228 = (unsigned int) i;
  D.32270 = i.228 * 4;
  D.32271 = D.32268 + D.32270;
  D.32272 = *D.32271;
  next_sp = &info.227->seq_points[D.32272];
  D.32273 = next_sp->il_offset;
  D.32219 = ss_req->req;
  bp = set_breakpoint (method, D.32273, D.32219, 0B);
  D.32220 = ss_req->bps;
  D.32274 = monoeg_g_slist_append (D.32220, bp);
  ss_req->bps = D.32274;
  i = i + 1;
  <D.28616>:
  D.32226 = sp->next_len;
  if (D.32226 > i) goto <D.28615>; else goto <D.28617>;
  <D.28617>:
  <D.32266>:
  <D.32264>:
  D.32228 = ss_req->depth;
  if (D.32228 == 1) goto <D.32275>; else goto <D.32276>;
  <D.32275>:
  D.32277 = ss_req->nframes;
  if (D.32277 == 0) goto <D.32278>; else goto <D.32279>;
  <D.32278>:
  D.32250 = tls->frame_count;
  ss_req->nframes = D.32250;
  <D.32279>:
  i = 0;
  goto <D.28625>;
  <D.28624>:
  {
    struct StackFrame * frame;

    D.32239 = tls->frames;
    i.228 = (unsigned int) i;
    D.32270 = i.228 * 4;
    D.32280 = D.32239 + D.32270;
    frame = *D.32280;
    D.32281 = frame->ji;
    if (D.32281 != 0B) goto <D.32282>; else goto <D.32283>;
    <D.32282>:
    {
      struct MonoJitInfo * jinfo;

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

        ei = &jinfo->clauses[j];
        D.32284 = frame->domain;
        D.32285 = frame->method;
        D.32286 = ei->handler_start;
        D.32287 = (int) D.32286;
        D.32288 = jinfo->code_start;
        D.32289 = (int) D.32288;
        D.32290 = D.32287 - D.32289;
        sp = find_next_seq_point_for_native_offset (D.32284, D.32285, D.32290, 0B);
        if (sp != 0B) goto <D.32291>; else goto <D.32292>;
        <D.32291>:
        D.32285 = frame->method;
        D.32218 = sp->il_offset;
        D.32219 = ss_req->req;
        bp = set_breakpoint (D.32285, D.32218, D.32219, 0B);
        D.32220 = ss_req->bps;
        D.32293 = monoeg_g_slist_append (D.32220, bp);
        ss_req->bps = D.32293;
        <D.32292>:
      }
      j = j + 1;
      <D.28622>:
      D.32294 = jinfo->num_clauses;
      D.32295 = (int) D.32294;
      if (D.32295 > j) goto <D.28621>; else goto <D.28623>;
      <D.28623>:
    }
    <D.32283>:
  }
  i = i + 1;
  <D.28625>:
  D.32250 = tls->frame_count;
  if (D.32250 > i) goto <D.28624>; else goto <D.28626>;
  <D.28626>:
  <D.32276>:
  D.32228 = ss_req->depth;
  if (D.32228 == 0) goto <D.32296>; else goto <D.32297>;
  <D.32296>:
  enable_global = 1;
  <D.32297>:
  tls->context.valid = 0;
  tls->async_state.valid = 0;
  invalidate_frames (tls);
  <D.32222>:
  if (enable_global != 0) goto <D.32298>; else goto <D.32299>;
  <D.32298>:
  log_level.229 = log_level;
  D.32301 = log_level.229 > 0;
  D.32302 = (long int) D.32301;
  D.32303 = __builtin_expect (D.32302, 0);
  if (D.32303 != 0) goto <D.32304>; else goto <D.32305>;
  <D.32304>:
  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.32305>:
  ss_req->global = 1;
  start_single_stepping ();
  goto <D.32307>;
  <D.32299>:
  D.32220 = ss_req->bps;
  if (D.32220 == 0B) goto <D.32308>; else goto <D.32309>;
  <D.32308>:
  log_level.229 = log_level;
  D.32301 = log_level.229 > 0;
  D.32302 = (long int) D.32301;
  D.32303 = __builtin_expect (D.32302, 0);
  if (D.32303 != 0) goto <D.32310>; else goto <D.32311>;
  <D.32310>:
  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.32311>:
  ss_req->global = 1;
  start_single_stepping ();
  goto <D.32312>;
  <D.32309>:
  ss_req->global = 0;
  <D.32312>:
  <D.32307>:
}


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

  val = InterlockedIncrement (&ss_count);
  if (val == 1) goto <D.32313>; else goto <D.32314>;
  <D.32313>:
  mono_arch_start_single_stepping ();
  <D.32314>:
  ss_req.231 = ss_req;
  if (ss_req.231 != 0B) goto <D.32316>; else goto <D.32317>;
  <D.32316>:
  ss_invoke_addr.232 = ss_invoke_addr;
  if (ss_invoke_addr.232 == 0B) goto <D.32319>; else goto <D.32320>;
  <D.32319>:
  {
    struct DebuggerTlsData * tls;

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


set_breakpoint (struct MonoMethod * method, long int il_offset, struct EventRequest * req, struct MonoError * error)
{
  struct GPtrArray * D.32326;
  int log_level.235;
  _Bool D.32328;
  long int D.32329;
  long int D.32330;
  struct FILE * log_file.236;
  const char * iftmp.237;
  int D.32335;
  const char * iftmp.238;
  struct GHashTable * domains.239;
  struct MonoDomain * domain.240;
  union mono_mutex_t * D.32345;
  _Bool D.32348;
  long int D.32349;
  long int D.32350;
  void * D.32353;
  struct GHashTable * D.32354;
  struct MonoMethod * m.241;
  int D.32356;
  struct MonoSeqPointInfo * seq_points.242;
  int D.32360;
  _Bool D.32363;
  long int D.32364;
  long int D.32365;
  int D.32368;
  struct GPtrArray * breakpoints.243;
  int D.32372;
  struct MonoBreakpoint * D.32375;
  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.32324>; else goto <D.32325>;
      <D.32324>:
      mono_error_init (error);
      <D.32325>:
      bp = monoeg_malloc0 (16);
      bp->method = method;
      bp->il_offset = il_offset;
      bp->req = req;
      D.32326 = monoeg_g_ptr_array_new ();
      bp->children = D.32326;
      log_level.235 = log_level;
      D.32328 = log_level.235 > 0;
      D.32329 = (long int) D.32328;
      D.32330 = __builtin_expect (D.32329, 0);
      if (D.32330 != 0) goto <D.32331>; else goto <D.32332>;
      <D.32331>:
      log_file.236 = log_file;
      D.32335 = req->event_kind;
      if (D.32335 == 11) goto <D.32336>; else goto <D.32337>;
      <D.32336>:
      iftmp.237 = "single step ";
      goto <D.32338>;
      <D.32337>:
      iftmp.237 = "";
      <D.32338>:
      if (method != 0B) goto <D.32340>; else goto <D.32341>;
      <D.32340>:
      iftmp.238 = mono_method_full_name (method, 1);
      goto <D.32342>;
      <D.32341>:
      iftmp.238 = "<all>";
      <D.32342>:
      fprintf (log_file.236, "[dbg] Setting %sbreakpoint at %s:0x%x.\n", iftmp.237, iftmp.238, il_offset);
      log_file.236 = log_file;
      fflush (log_file.236);
      <D.32332>:
      mono_loader_lock ();
      domains.239 = domains;
      monoeg_g_hash_table_iter_init (&iter, domains.239);
      goto <D.28405>;
      <D.28404>:
      {
        int ret;

        domain.240 = domain;
        D.32345 = &domain.240->lock.mutex;
        ret = pthread_mutex_lock (D.32345);
        if (ret != 0) goto <D.32346>; else goto <D.32347>;
        <D.32346>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
        <D.32347>:
        D.32348 = ret != 0;
        D.32349 = (long int) D.32348;
        D.32350 = __builtin_expect (D.32349, 0);
        if (D.32350 != 0) goto <D.32351>; else goto <D.32352>;
        <D.32351>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 4353, "ret == 0");
        <D.32352>:
      }
      domain.240 = domain;
      D.32353 = domain.240->runtime_info;
      D.32354 = MEM[(struct MonoJitDomainInfo *)D.32353].seq_points;
      monoeg_g_hash_table_iter_init (&iter2, D.32354);
      goto <D.28401>;
      <D.28400>:
      m.241 = m;
      D.32356 = bp_matches_method (bp, m.241);
      if (D.32356 != 0) goto <D.32357>; else goto <D.32358>;
      <D.32357>:
      domain.240 = domain;
      m.241 = m;
      seq_points.242 = seq_points;
      set_bp_in_method (domain.240, m.241, seq_points.242, bp, error);
      <D.32358>:
      <D.28401>:
      D.32360 = monoeg_g_hash_table_iter_next (&iter2, &m, &seq_points);
      if (D.32360 != 0) goto <D.28400>; else goto <D.28402>;
      <D.28402>:
      {
        int ret;

        domain.240 = domain;
        D.32345 = &domain.240->lock.mutex;
        ret = pthread_mutex_unlock (D.32345);
        if (ret != 0) goto <D.32361>; else goto <D.32362>;
        <D.32361>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.32362>:
        D.32363 = ret != 0;
        D.32364 = (long int) D.32363;
        D.32365 = __builtin_expect (D.32364, 0);
        if (D.32365 != 0) goto <D.32366>; else goto <D.32367>;
        <D.32366>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 4361, "ret == 0");
        <D.32367>:
      }
      <D.28405>:
      D.32368 = monoeg_g_hash_table_iter_next (&iter, &domain, 0B);
      if (D.32368 != 0) goto <D.28404>; else goto <D.28406>;
      <D.28406>:
      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.32370>; else goto <D.32371>;
      <D.32370>:
      D.32372 = mono_error_ok (error);
      if (D.32372 == 0) goto <D.32373>; else goto <D.32374>;
      <D.32373>:
      clear_breakpoint (bp);
      D.32375 = 0B;
      return D.32375;
      <D.32374>:
      <D.32371>:
      D.32375 = bp;
      return D.32375;
    }
  finally
    {
      iter = {CLOBBER};
      iter2 = {CLOBBER};
      domain = {CLOBBER};
      m = {CLOBBER};
      seq_points = {CLOBBER};
    }
}


bp_matches_method (struct MonoBreakpoint * bp, struct MonoMethod * method)
{
  struct MonoMethod * D.32378;
  gboolean D.32381;
  unsigned char D.32384;
  unsigned char D.32385;
  struct MonoMethod * D.32388;
  unsigned char D.32391;
  unsigned char D.32392;
  struct MonoMethod * D.32397;
  struct MonoMethod * D.32398;
  struct MonoGenericInst * D.32401;
  struct MonoGenericInst * D.32402;
  struct MonoGenericInst * D.32405;
  unsigned char D.32408;
  unsigned char D.32409;
  unsigned char D.32412;
  <unnamed-unsigned:22> D.32415;
  int D.32416;
  int i;

  D.32378 = bp->method;
  if (D.32378 == 0B) goto <D.32379>; else goto <D.32380>;
  <D.32379>:
  D.32381 = 1;
  return D.32381;
  <D.32380>:
  D.32378 = bp->method;
  if (D.32378 == method) goto <D.32382>; else goto <D.32383>;
  <D.32382>:
  D.32381 = 1;
  return D.32381;
  <D.32383>:
  D.32384 = BIT_FIELD_REF <*method, 8, 168>;
  D.32385 = D.32384 & 16;
  if (D.32385 != 0) goto <D.32386>; else goto <D.32387>;
  <D.32386>:
  D.32388 = MEM[(struct MonoMethodInflated *)method].declaring;
  D.32378 = bp->method;
  if (D.32388 == D.32378) goto <D.32389>; else goto <D.32390>;
  <D.32389>:
  D.32381 = 1;
  return D.32381;
  <D.32390>:
  <D.32387>:
  D.32378 = bp->method;
  D.32391 = BIT_FIELD_REF <*D.32378, 8, 168>;
  D.32392 = D.32391 & 16;
  if (D.32392 != 0) goto <D.32393>; else goto <D.32394>;
  <D.32393>:
  D.32384 = BIT_FIELD_REF <*method, 8, 168>;
  D.32385 = D.32384 & 16;
  if (D.32385 != 0) goto <D.32395>; else goto <D.32396>;
  <D.32395>:
  {
    struct MonoMethodInflated * bpimethod;
    struct MonoMethodInflated * imethod;

    bpimethod = bp->method;
    imethod = method;
    D.32397 = bpimethod->declaring;
    D.32398 = imethod->declaring;
    if (D.32397 == D.32398) goto <D.32399>; else goto <D.32400>;
    <D.32399>:
    D.32401 = bpimethod->context.class_inst;
    D.32402 = imethod->context.class_inst;
    if (D.32401 == D.32402) goto <D.32403>; else goto <D.32404>;
    <D.32403>:
    D.32405 = bpimethod->context.method_inst;
    if (D.32405 != 0B) goto <D.32406>; else goto <D.32407>;
    <D.32406>:
    D.32405 = bpimethod->context.method_inst;
    D.32408 = BIT_FIELD_REF <*D.32405, 8, 48>;
    D.32409 = D.32408 & 64;
    if (D.32409 != 0) goto <D.32410>; else goto <D.32411>;
    <D.32410>:
    i = 0;
    goto <D.28353>;
    <D.28352>:
    {
      struct MonoType * t1;

      D.32405 = bpimethod->context.method_inst;
      t1 = D.32405->type_argv[i];
      D.32412 = t1->type;
      if (D.32412 != 30) goto <D.32413>; else goto <D.32414>;
      <D.32413>:
      D.32381 = 0;
      return D.32381;
      <D.32414>:
    }
    i = i + 1;
    <D.28353>:
    D.32405 = bpimethod->context.method_inst;
    D.32415 = D.32405->type_argc;
    D.32416 = (int) D.32415;
    if (D.32416 > i) goto <D.28352>; else goto <D.28354>;
    <D.28354>:
    D.32381 = 1;
    return D.32381;
    <D.32411>:
    <D.32407>:
    <D.32404>:
    <D.32400>:
  }
  <D.32396>:
  <D.32394>:
  D.32381 = 0;
  return D.32381;
}


set_bp_in_method (struct MonoDomain * domain, struct MonoMethod * method, struct MonoSeqPointInfo * seq_points, struct MonoBreakpoint * bp, struct MonoError * error)
{
  _Bool D.32422;
  long int D.32423;
  long int D.32424;
  struct MonoJitInfo * ji.244;
  struct MonoJitInfo * ji.245;
  _Bool D.32429;
  long int D.32430;
  long int D.32431;
  void * code;
  struct MonoJitInfo * ji;

  try
    {
      if (error != 0B) goto <D.32418>; else goto <D.32419>;
      <D.32418>:
      mono_error_init (error);
      <D.32419>:
      code = mono_jit_find_compiled_method_with_jit_info (domain, method, &ji);
      if (code == 0B) goto <D.32420>; else goto <D.32421>;
      <D.32420>:
      code = mono_aot_get_method (domain, method);
      D.32422 = code == 0B;
      D.32423 = (long int) D.32422;
      D.32424 = __builtin_expect (D.32423, 0);
      if (D.32424 != 0) goto <D.32425>; else goto <D.32426>;
      <D.32425>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 4301, "code");
      <D.32426>:
      ji.244 = mono_jit_info_table_find (domain, code);
      ji = ji.244;
      ji.245 = ji;
      D.32429 = ji.245 == 0B;
      D.32430 = (long int) D.32429;
      D.32431 = __builtin_expect (D.32430, 0);
      if (D.32431 != 0) goto <D.32432>; else goto <D.32433>;
      <D.32432>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 4303, "ji");
      <D.32433>:
      <D.32421>:
      D.32422 = code == 0B;
      D.32423 = (long int) D.32422;
      D.32424 = __builtin_expect (D.32423, 0);
      if (D.32424 != 0) goto <D.32434>; else goto <D.32435>;
      <D.32434>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 4305, "code");
      <D.32435>:
      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.32438;
  long int D.32439;
  int D.32441;
  int D.32444;
  _Bool D.32445;
  _Bool D.32446;
  _Bool D.32447;
  int D.32450;
  struct MonoMethod * D.32454;
  char * D.32455;
  int log_level.246;
  _Bool D.32457;
  long int D.32458;
  long int D.32459;
  struct FILE * log_file.247;
  int D.32463;
  int D.32466;
  void * D.32467;
  sizetype D.32468;
  guint8 * D.32469;
  struct GPtrArray * D.32470;
  struct GHashTable * bp_locs.248;
  guint8 * D.32472;
  void * D.32473;
  int D.32474;
  void * D.32475;
  struct MonoMethod * D.32485;
  char * D.32486;
  int i;
  int count;
  struct BreakpointInstance * inst;
  struct SeqPoint * sp;

  sp = 0B;
  if (error != 0B) goto <D.32436>; else goto <D.32437>;
  <D.32436>:
  mono_error_init (error);
  <D.32437>:
  i = 0;
  goto <D.28330>;
  <D.28329>:
  sp = &seq_points->seq_points[i];
  D.32438 = sp->il_offset;
  D.32439 = bp->il_offset;
  if (D.32438 == D.32439) goto <D.28328>; else goto <D.32440>;
  <D.32440>:
  i = i + 1;
  <D.28330>:
  D.32441 = seq_points->len;
  if (D.32441 > i) goto <D.28329>; else goto <D.28328>;
  <D.28328>:
  D.32441 = seq_points->len;
  if (D.32441 == i) goto <D.32442>; else goto <D.32443>;
  <D.32442>:
  i = 0;
  goto <D.28333>;
  <D.28332>:
  sp = &seq_points->seq_points[i];
  D.32444 = sp->il_offset;
  D.32445 = D.32444 != -1;
  D.32446 = D.32444 != 16777215;
  D.32447 = D.32445 & D.32446;
  if (D.32447 != 0) goto <D.32448>; else goto <D.32449>;
  <D.32448>:
  D.32438 = sp->il_offset;
  D.32450 = D.32438 + 1;
  D.32439 = bp->il_offset;
  if (D.32450 == D.32439) goto <D.28331>; else goto <D.32451>;
  <D.32451>:
  <D.32449>:
  i = i + 1;
  <D.28333>:
  D.32441 = seq_points->len;
  if (D.32441 > i) goto <D.28332>; else goto <D.28331>;
  <D.28331>:
  <D.32443>:
  D.32441 = seq_points->len;
  if (D.32441 == i) goto <D.32452>; else goto <D.32453>;
  <D.32452>:
  {
    char * s;

    D.32454 = jinfo_get_method (ji);
    D.32455 = mono_method_full_name (D.32454, 1);
    D.32439 = bp->il_offset;
    D.32441 = seq_points->len;
    s = monoeg_g_strdup_printf ("Unable to insert breakpoint at %s:%d, seq_points=%d\n", D.32455, D.32439, D.32441);
    i = 0;
    goto <D.28336>;
    <D.28335>:
    log_level.246 = log_level;
    D.32457 = log_level.246 > 0;
    D.32458 = (long int) D.32457;
    D.32459 = __builtin_expect (D.32458, 0);
    if (D.32459 != 0) goto <D.32460>; else goto <D.32461>;
    <D.32460>:
    log_file.247 = log_file;
    D.32463 = seq_points->seq_points[i].il_offset;
    fprintf (log_file.247, "%d\n", D.32463);
    log_file.247 = log_file;
    fflush (log_file.247);
    <D.32461>:
    i = i + 1;
    <D.28336>:
    D.32441 = seq_points->len;
    if (D.32441 > i) goto <D.28335>; else goto <D.28337>;
    <D.28337>:
    if (error != 0B) goto <D.32464>; else goto <D.32465>;
    <D.32464>:
    mono_error_set_error (error, 9, "%s", s);
    monoeg_g_log (0B, 16, "%s", s);
    monoeg_g_free (s);
    return;
    <D.32465>:
    monoeg_g_log (0B, 16, "%s", s);
    monoeg_g_free (s);
    return;
  }
  <D.32453>:
  inst = monoeg_malloc0 (24);
  inst->sp = sp;
  D.32466 = sp->native_offset;
  inst->native_offset = D.32466;
  D.32467 = ji->code_start;
  D.32466 = sp->native_offset;
  D.32468 = (sizetype) D.32466;
  D.32469 = D.32467 + D.32468;
  inst->ip = D.32469;
  inst->ji = ji;
  inst->domain = domain;
  mono_loader_lock ();
  D.32470 = bp->children;
  monoeg_g_ptr_array_add (D.32470, inst);
  bp_locs.248 = bp_locs;
  D.32472 = inst->ip;
  D.32473 = monoeg_g_hash_table_lookup (bp_locs.248, D.32472);
  count = (int) D.32473;
  bp_locs.248 = bp_locs;
  D.32472 = inst->ip;
  D.32474 = count + 1;
  D.32475 = (void *) D.32474;
  monoeg_g_hash_table_insert_replace (bp_locs.248, D.32472, D.32475, 0);
  mono_loader_unlock ();
  D.32466 = sp->native_offset;
  if (D.32466 == -1) goto <D.32476>; else goto <D.32477>;
  <D.32476>:
  log_level.246 = log_level;
  D.32457 = log_level.246 > 0;
  D.32458 = (long int) D.32457;
  D.32459 = __builtin_expect (D.32458, 0);
  if (D.32459 != 0) goto <D.32478>; else goto <D.32479>;
  <D.32478>:
  log_file.247 = log_file;
  D.32439 = bp->il_offset;
  fprintf (log_file.247, "[dbg] Attempting to insert seq point at dead IL offset %d, ignoring.\n", D.32439);
  log_file.247 = log_file;
  fflush (log_file.247);
  <D.32479>:
  goto <D.32480>;
  <D.32477>:
  if (count == 0) goto <D.32481>; else goto <D.32482>;
  <D.32481>:
  D.32472 = inst->ip;
  mono_arch_set_breakpoint (ji, D.32472);
  <D.32482>:
  <D.32480>:
  log_level.246 = log_level;
  D.32457 = log_level.246 > 0;
  D.32458 = (long int) D.32457;
  D.32459 = __builtin_expect (D.32458, 0);
  if (D.32459 != 0) goto <D.32483>; else goto <D.32484>;
  <D.32483>:
  log_file.247 = log_file;
  D.32485 = jinfo_get_method (ji);
  D.32486 = mono_method_full_name (D.32485, 1);
  D.32438 = sp->il_offset;
  fprintf (log_file.247, "[dbg] Inserted breakpoint at %s:0x%x.\n", D.32486, D.32438);
  log_file.247 = log_file;
  fflush (log_file.247);
  <D.32484>:
}


domain_commands (int command, guint8 * p, guint8 * end, struct Buffer * buf)
{
  struct MonoDomain * D.32488;
  guint8 * p.249;
  int err.250;
  ErrorCode D.32493;
  char * D.32494;
  unsigned int count.251;
  struct MonoAssembly * D.32500;
  struct MonoAppDomain * D.32503;
  struct MonoVTable * D.32504;
  struct MonoClass * D.32505;
  struct MonoImage * D.32506;
  struct MonoAssembly * D.32507;
  struct MonoDomain * domain2.252;
  _Bool D.32515;
  long int D.32516;
  long int D.32517;
  struct MonoType * D.32520;
  void * D.32521;
  <unnamed type> D.32522;
  int err.253;
  int err;
  struct MonoDomain * domain;

  try
    {
      switch (command) <default: <D.29330>, case 1: <D.29308>, case 2: <D.29310>, case 3: <D.29311>, case 4: <D.29321>, case 5: <D.29323>, case 6: <D.29322>, case 7: <D.29326>>
      <D.29308>:
      D.32488 = mono_get_root_domain ();
      buffer_add_domainid (buf, D.32488);
      goto <D.29309>;
      <D.29310>:
      p.249 = p;
      domain = decode_domainid (p.249, &p, end, 0B, &err);
      err.250 = err;
      if (err.250 != 0) goto <D.32491>; else goto <D.32492>;
      <D.32491>:
      err.250 = err;
      D.32493 = (ErrorCode) err.250;
      return D.32493;
      <D.32492>:
      D.32494 = domain->friendly_name;
      buffer_add_string (buf, D.32494);
      goto <D.29309>;
      <D.29311>:
      {
        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.32495>; else goto <D.32496>;
        <D.32495>:
        err.250 = err;
        D.32493 = (ErrorCode) err.250;
        return D.32493;
        <D.32496>:
        mono_loader_lock ();
        count = 0;
        tmp = domain->domain_assemblies;
        goto <D.29316>;
        <D.29315>:
        count = count + 1;
        tmp = tmp->next;
        <D.29316>:
        if (tmp != 0B) goto <D.29315>; else goto <D.29317>;
        <D.29317>:
        count.251 = (unsigned int) count;
        buffer_add_int (buf, count.251);
        tmp = domain->domain_assemblies;
        goto <D.29319>;
        <D.29318>:
        ass = tmp->data;
        buffer_add_assemblyid (buf, domain, ass);
        tmp = tmp->next;
        <D.29319>:
        if (tmp != 0B) goto <D.29318>; else goto <D.29320>;
        <D.29320>:
        mono_loader_unlock ();
        goto <D.29309>;
      }
      <D.29321>:
      p.249 = p;
      domain = decode_domainid (p.249, &p, end, 0B, &err);
      err.250 = err;
      if (err.250 != 0) goto <D.32498>; else goto <D.32499>;
      <D.32498>:
      err.250 = err;
      D.32493 = (ErrorCode) err.250;
      return D.32493;
      <D.32499>:
      D.32500 = domain->entry_assembly;
      buffer_add_assemblyid (buf, domain, D.32500);
      goto <D.29309>;
      <D.29322>:
      p.249 = p;
      domain = decode_domainid (p.249, &p, end, 0B, &err);
      err.250 = err;
      if (err.250 != 0) goto <D.32501>; else goto <D.32502>;
      <D.32501>:
      err.250 = err;
      D.32493 = (ErrorCode) err.250;
      return D.32493;
      <D.32502>:
      D.32503 = domain->domain;
      D.32504 = D.32503->mbr.obj.vtable;
      D.32505 = D.32504->klass;
      D.32506 = D.32505->image;
      D.32507 = D.32506->assembly;
      buffer_add_assemblyid (buf, domain, D.32507);
      goto <D.29309>;
      <D.29323>:
      {
        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.32508>; else goto <D.32509>;
        <D.32508>:
        err.250 = err;
        D.32493 = (ErrorCode) err.250;
        return D.32493;
        <D.32509>:
        p.249 = p;
        s = decode_string (p.249, &p, end);
        o = mono_string_new (domain, s);
        buffer_add_objid (buf, o);
        goto <D.29309>;
      }
      <D.29326>:
      {
        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.32510>; else goto <D.32511>;
            <D.32510>:
            err.250 = err;
            D.32493 = (ErrorCode) err.250;
            return D.32493;
            <D.32511>:
            p.249 = p;
            klass = decode_typeid (p.249, &p, end, &domain2, &err);
            err.250 = err;
            if (err.250 != 0) goto <D.32512>; else goto <D.32513>;
            <D.32512>:
            err.250 = err;
            D.32493 = (ErrorCode) err.250;
            return D.32493;
            <D.32513>:
            domain2.252 = domain2;
            D.32515 = domain != domain2.252;
            D.32516 = (long int) D.32515;
            D.32517 = __builtin_expect (D.32516, 0);
            if (D.32517 != 0) goto <D.32518>; else goto <D.32519>;
            <D.32518>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 7271, "domain == domain2");
            <D.32519>:
            o = mono_object_new (domain, klass);
            D.32520 = &klass->byval_arg;
            D.32521 = mono_object_unbox (o);
            p.249 = p;
            D.32522 = decode_value (D.32520, domain, D.32521, p.249, &p, end);
            err.253 = (int) D.32522;
            err = err.253;
            err.250 = err;
            if (err.250 != 0) goto <D.32524>; else goto <D.32525>;
            <D.32524>:
            err.250 = err;
            D.32493 = (ErrorCode) err.250;
            return D.32493;
            <D.32525>:
            buffer_add_objid (buf, o);
            goto <D.29309>;
          }
        finally
          {
            domain2 = {CLOBBER};
          }
      }
      <D.29330>:
      D.32493 = 100;
      return D.32493;
      <D.29309>:
      D.32493 = 0;
      return D.32493;
    }
  finally
    {
      err = {CLOBBER};
    }
}


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

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


decode_value (struct MonoType * t, struct MonoDomain * domain, guint8 * addr, guint8 * buf, guint8 * * endbuf, guint8 * limit)
{
  guint8 * buf.254;
  unsigned char D.32533;
  struct MonoClass * D.32536;
  int D.32537;
  struct MonoGenericClass * D.32540;
  struct MonoGenericInst * D.32541;
  <unnamed type> D.32542;
  ErrorCode D.32545;
  unsigned char D.32546;
  int D.32547;
  struct MonoClass * D.32550;
  int D.32551;
  unsigned int D.32552;
  <unnamed type> D.32553;
  struct MonoClass * D.32556;
  struct MonoObject * D.32557;
  struct MonoClass * D.32558;
  struct MonoClass * D.32561;
  int err;
  int type;

  buf.254 = buf;
  type = decode_byte (buf.254, &buf, limit);
  D.32533 = t->type;
  if (D.32533 == 21) goto <D.32534>; else goto <D.32535>;
  <D.32534>:
  D.32536 = mono_class_from_mono_type (t);
  D.32537 = mono_class_is_nullable (D.32536);
  if (D.32537 != 0) goto <D.32538>; else goto <D.32539>;
  <D.32538>:
  {
    struct MonoType * targ;
    guint8 * nullable_buf;

    D.32540 = t->data.generic_class;
    D.32541 = D.32540->context.class_inst;
    targ = D.32541->type_argv[0];
    buf.254 = buf;
    D.32542 = decode_value_internal (t, type, domain, addr, buf.254, endbuf, limit);
    err = (int) D.32542;
    if (err == 0) goto <D.32543>; else goto <D.32544>;
    <D.32543>:
    D.32545 = (ErrorCode) err;
    return D.32545;
    <D.32544>:
    D.32546 = targ->type;
    D.32547 = (int) D.32546;
    if (D.32547 == type) goto <D.32548>; else goto <D.32549>;
    <D.32548>:
    D.32550 = mono_class_from_mono_type (targ);
    D.32551 = mono_class_instance_size (D.32550);
    D.32552 = (unsigned int) D.32551;
    nullable_buf = monoeg_malloc (D.32552);
    buf.254 = buf;
    D.32553 = decode_value_internal (targ, type, domain, nullable_buf, buf.254, endbuf, limit);
    err = (int) D.32553;
    if (err != 0) goto <D.32554>; else goto <D.32555>;
    <D.32554>:
    monoeg_g_free (nullable_buf);
    D.32545 = (ErrorCode) err;
    return D.32545;
    <D.32555>:
    D.32556 = mono_class_from_mono_type (targ);
    D.32557 = mono_value_box (domain, D.32556, nullable_buf);
    D.32558 = mono_class_from_mono_type (t);
    mono_nullable_init (addr, D.32557, D.32558);
    monoeg_g_free (nullable_buf);
    buf.254 = buf;
    *endbuf = buf.254;
    D.32545 = 0;
    return D.32545;
    <D.32549>:
    if (type == 240) goto <D.32559>; else goto <D.32560>;
    <D.32559>:
    D.32561 = mono_class_from_mono_type (t);
    mono_nullable_init (addr, 0B, D.32561);
    buf.254 = buf;
    *endbuf = buf.254;
    D.32545 = 0;
    return D.32545;
    <D.32560>:
  }
  <D.32539>:
  <D.32535>:
  buf.254 = buf;
  D.32545 = decode_value_internal (t, type, domain, addr, buf.254, endbuf, limit);
  return D.32545;
}


decode_value_internal (struct MonoType * t, int type, struct MonoDomain * domain, guint8 * addr, guint8 * buf, guint8 * * endbuf, guint8 * limit)
{
  unsigned char D.32568;
  int D.32569;
  int D.32572;
  int log_level.255;
  _Bool D.32580;
  long int D.32581;
  long int D.32582;
  struct FILE * log_file.256;
  unsigned int D.32586;
  void * D.32587;
  ErrorCode D.32588;
  guint8 * buf.257;
  int D.32590;
  unsigned char D.32591;
  int D.32592;
  short unsigned int D.32593;
  int D.32594;
  signed char D.32595;
  int D.32596;
  unsigned char D.32597;
  int D.32598;
  short int D.32599;
  int D.32600;
  short unsigned int D.32601;
  int D.32602;
  int D.32603;
  unsigned int D.32604;
  long long int D.32605;
  long long int D.32606;
  long long unsigned int D.32607;
  int D.32608;
  unsigned int D.32609;
  long long int D.32610;
  long long unsigned int D.32611;
  _Bool D.32612;
  long int D.32613;
  long int D.32614;
  long long int D.32617;
  int D.32618;
  int D.32619;
  _Bool D.32620;
  long int D.32621;
  long int D.32622;
  <unnamed type> D.32625;
  int err.258;
  int err.259;
  int D.32630;
  <unnamed type> D.32635;
  struct MonoObject * obj.260;
  int D.32641;
  char * D.32646;
  struct MonoVTable * D.32647;
  struct MonoClass * D.32648;
  const char * D.32649;
  struct MonoDomain * D.32652;
  unsigned int vtype_buf_size.261;
  _Bool D.32666;
  long int D.32667;
  long int D.32668;
  <unnamed type> D.32671;
  int err.262;
  struct MonoDomain * d.263;
  struct MonoObject * D.32676;
  unsigned int D.32680;
  void * D.32681;
  int err;
  void handle_vtype = <<< error >>>;
  void handle_ref = <<< error >>>;

  try
    {
      D.32568 = t->type;
      D.32569 = (int) D.32568;
      if (D.32569 != type) goto <D.32570>; else goto <D.32571>;
      <D.32570>:
      D.32572 = mono_type_is_reference (t);
      if (D.32572 == 0) goto <D.32573>; else goto <D.32574>;
      <D.32573>:
      D.32568 = t->type;
      if (D.32568 != 24) goto <D.32567>; else goto <D.32575>;
      <D.32575>:
      if (type != 17) goto <D.32567>; else goto <D.32564>;
      <D.32567>:
      D.32568 = t->type;
      if (D.32568 != 25) goto <D.32566>; else goto <D.32576>;
      <D.32576>:
      if (type != 17) goto <D.32566>; else goto <D.32564>;
      <D.32566>:
      D.32568 = t->type;
      if (D.32568 != 15) goto <D.32565>; else goto <D.32577>;
      <D.32577>:
      if (type != 10) goto <D.32565>; else goto <D.32564>;
      <D.32565>:
      D.32568 = t->type;
      if (D.32568 != 21) goto <D.32563>; else goto <D.32578>;
      <D.32578>:
      if (type != 17) goto <D.32563>; else goto <D.32564>;
      <D.32563>:
      {
        char * name;

        name = mono_type_full_name (t);
        log_level.255 = log_level;
        D.32580 = log_level.255 > 0;
        D.32581 = (long int) D.32580;
        D.32582 = __builtin_expect (D.32581, 0);
        if (D.32582 != 0) goto <D.32583>; else goto <D.32584>;
        <D.32583>:
        log_file.256 = log_file;
        D.32586 = GetCurrentThreadId ();
        D.32587 = (void *) D.32586;
        fprintf (log_file.256, "[%p] Expected value of type %s, got 0x%0x.\n", D.32587, name, type);
        log_file.256 = log_file;
        fflush (log_file.256);
        <D.32584>:
        monoeg_g_free (name);
        D.32588 = 102;
        return D.32588;
      }
      <D.32564>:
      <D.32574>:
      <D.32571>:
      D.32568 = t->type;
      D.32569 = (int) D.32568;
      switch (D.32569) <default: <D.28885>, case 2: <D.28865>, case 3: <D.28867>, case 4: <D.28868>, case 5: <D.28869>, case 6: <D.28870>, case 7: <D.28871>, case 8: <D.28872>, case 9: <D.28873>, case 10: <D.28874>, case 11: <D.28875>, case 12: <D.28876>, case 13: <D.28877>, case 15: <D.28878>, case 17: <D.28884>, case 21: <D.28879>, case 24: <D.28882>, case 25: <D.28883>>
      <D.28865>:
      buf.257 = buf;
      D.32590 = decode_int (buf.257, &buf, limit);
      D.32591 = (unsigned char) D.32590;
      *addr = D.32591;
      goto <D.28866>;
      <D.28867>:
      buf.257 = buf;
      D.32592 = decode_int (buf.257, &buf, limit);
      D.32593 = (short unsigned int) D.32592;
      MEM[(gunichar2 *)addr] = D.32593;
      goto <D.28866>;
      <D.28868>:
      buf.257 = buf;
      D.32594 = decode_int (buf.257, &buf, limit);
      D.32595 = (signed char) D.32594;
      MEM[(gint8 *)addr] = D.32595;
      goto <D.28866>;
      <D.28869>:
      buf.257 = buf;
      D.32596 = decode_int (buf.257, &buf, limit);
      D.32597 = (unsigned char) D.32596;
      *addr = D.32597;
      goto <D.28866>;
      <D.28870>:
      buf.257 = buf;
      D.32598 = decode_int (buf.257, &buf, limit);
      D.32599 = (short int) D.32598;
      MEM[(gint16 *)addr] = D.32599;
      goto <D.28866>;
      <D.28871>:
      buf.257 = buf;
      D.32600 = decode_int (buf.257, &buf, limit);
      D.32601 = (short unsigned int) D.32600;
      MEM[(guint16 *)addr] = D.32601;
      goto <D.28866>;
      <D.28872>:
      buf.257 = buf;
      D.32602 = decode_int (buf.257, &buf, limit);
      MEM[(gint32 *)addr] = D.32602;
      goto <D.28866>;
      <D.28873>:
      buf.257 = buf;
      D.32603 = decode_int (buf.257, &buf, limit);
      D.32604 = (unsigned int) D.32603;
      MEM[(guint32 *)addr] = D.32604;
      goto <D.28866>;
      <D.28874>:
      buf.257 = buf;
      D.32605 = decode_long (buf.257, &buf, limit);
      MEM[(gint64 *)addr] = D.32605;
      goto <D.28866>;
      <D.28875>:
      buf.257 = buf;
      D.32606 = decode_long (buf.257, &buf, limit);
      D.32607 = (long long unsigned int) D.32606;
      MEM[(guint64 *)addr] = D.32607;
      goto <D.28866>;
      <D.28876>:
      buf.257 = buf;
      D.32608 = decode_int (buf.257, &buf, limit);
      D.32609 = (unsigned int) D.32608;
      MEM[(guint32 *)addr] = D.32609;
      goto <D.28866>;
      <D.28877>:
      buf.257 = buf;
      D.32610 = decode_long (buf.257, &buf, limit);
      D.32611 = (long long unsigned int) D.32610;
      MEM[(guint64 *)addr] = D.32611;
      goto <D.28866>;
      <D.28878>:
      D.32612 = type != 10;
      D.32613 = (long int) D.32612;
      D.32614 = __builtin_expect (D.32613, 0);
      if (D.32614 != 0) goto <D.32615>; else goto <D.32616>;
      <D.32615>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 5775, "type == MONO_TYPE_I8");
      <D.32616>:
      buf.257 = buf;
      D.32617 = decode_long (buf.257, &buf, limit);
      D.32618 = (int) D.32617;
      MEM[(gssize *)addr] = D.32618;
      goto <D.28866>;
      <D.28879>:
      D.32619 = mono_type_is_struct (t);
      if (D.32619 != 0) goto handle_vtype; else goto handle_ref;
      <D.28882>:
      <D.28883>:
      D.32620 = type != 17;
      D.32621 = (long int) D.32620;
      D.32622 = __builtin_expect (D.32621, 0);
      if (D.32622 != 0) goto <D.32623>; else goto <D.32624>;
      <D.32623>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 5789, "type == MONO_TYPE_VALUETYPE");
      <D.32624>:
      handle_vtype:
      <D.28884>:
      buf.257 = buf;
      D.32625 = decode_vtype (t, domain, addr, buf.257, &buf, limit);
      err.258 = (int) D.32625;
      err = err.258;
      err.259 = err;
      if (err.259 != 0) goto <D.32628>; else goto <D.32629>;
      <D.32628>:
      err.259 = err;
      D.32588 = (ErrorCode) err.259;
      return D.32588;
      <D.32629>:
      goto <D.28866>;
      handle_ref:
      <D.28885>:
      D.32630 = mono_type_is_reference (t);
      if (D.32630 != 0) goto <D.32631>; else goto <D.32632>;
      <D.32631>:
      if (type == 28) goto <D.32633>; else goto <D.32634>;
      <D.32633>:
      {
        int objid;
        int err;
        struct MonoObject * obj;

        try
          {
            buf.257 = buf;
            objid = decode_objid (buf.257, &buf, limit);
            D.32635 = get_object (objid, &obj);
            err = (int) D.32635;
            if (err != 0) goto <D.32636>; else goto <D.32637>;
            <D.32636>:
            D.32588 = (ErrorCode) err;
            return D.32588;
            <D.32637>:
            obj.260 = obj;
            if (obj.260 != 0B) goto <D.32639>; else goto <D.32640>;
            <D.32639>:
            obj.260 = obj;
            D.32641 = obj_is_of_type (obj.260, t);
            if (D.32641 == 0) goto <D.32642>; else goto <D.32643>;
            <D.32642>:
            log_level.255 = log_level;
            D.32580 = log_level.255 > 0;
            D.32581 = (long int) D.32580;
            D.32582 = __builtin_expect (D.32581, 0);
            if (D.32582 != 0) goto <D.32644>; else goto <D.32645>;
            <D.32644>:
            log_file.256 = log_file;
            D.32646 = mono_type_full_name (t);
            obj.260 = obj;
            D.32647 = obj.260->vtable;
            D.32648 = D.32647->klass;
            D.32649 = D.32648->name;
            fprintf (log_file.256, "Expected type \'%s\', got \'%s\'\n", D.32646, D.32649);
            log_file.256 = log_file;
            fflush (log_file.256);
            <D.32645>:
            D.32588 = 102;
            return D.32588;
            <D.32643>:
            <D.32640>:
            obj.260 = obj;
            if (obj.260 != 0B) goto <D.32650>; else goto <D.32651>;
            <D.32650>:
            obj.260 = obj;
            D.32647 = obj.260->vtable;
            D.32652 = D.32647->domain;
            if (D.32652 != domain) goto <D.32653>; else goto <D.32654>;
            <D.32653>:
            D.32588 = 102;
            return D.32588;
            <D.32654>:
            <D.32651>:
            obj.260 = obj;
            mono_gc_wbarrier_generic_store (addr, obj.260);
          }
        finally
          {
            obj = {CLOBBER};
          }
      }
      goto <D.32655>;
      <D.32634>:
      if (type == 240) goto <D.32656>; else goto <D.32657>;
      <D.32656>:
      MEM[(struct MonoObject * *)addr] = 0B;
      goto <D.32658>;
      <D.32657>:
      if (type == 17) goto <D.32659>; else goto <D.32660>;
      <D.32659>:
      {
        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.32661>; else goto <D.32662>;
            <D.32661>:
            D.32588 = 100;
            return D.32588;
            <D.32662>:
            buf.257 = buf;
            klass = decode_typeid (buf.257, &buf, limit, &d, &err);
            err.259 = err;
            if (err.259 != 0) goto <D.32663>; else goto <D.32664>;
            <D.32663>:
            err.259 = err;
            D.32588 = (ErrorCode) err.259;
            return D.32588;
            <D.32664>:
            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.32666 = vtype_buf == 0B;
            D.32667 = (long int) D.32666;
            D.32668 = __builtin_expect (D.32667, 0);
            if (D.32668 != 0) goto <D.32669>; else goto <D.32670>;
            <D.32669>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 5845, "vtype_buf");
            <D.32670>:
            buf = buf2;
            buf.257 = buf;
            D.32671 = decode_vtype (0B, domain, vtype_buf, buf.257, &buf, limit);
            err.262 = (int) D.32671;
            err = err.262;
            err.259 = err;
            if (err.259 != 0) goto <D.32673>; else goto <D.32674>;
            <D.32673>:
            monoeg_g_free (vtype_buf);
            err.259 = err;
            D.32588 = (ErrorCode) err.259;
            return D.32588;
            <D.32674>:
            d.263 = d;
            D.32676 = mono_value_box (d.263, klass, vtype_buf);
            MEM[(struct MonoObject * *)addr] = D.32676;
            monoeg_g_free (vtype_buf);
          }
        finally
          {
            d = {CLOBBER};
          }
      }
      goto <D.32677>;
      <D.32660>:
      {
        char * name;

        name = mono_type_full_name (t);
        log_level.255 = log_level;
        D.32580 = log_level.255 > 0;
        D.32581 = (long int) D.32580;
        D.32582 = __builtin_expect (D.32581, 0);
        if (D.32582 != 0) goto <D.32678>; else goto <D.32679>;
        <D.32678>:
        log_file.256 = log_file;
        D.32680 = GetCurrentThreadId ();
        D.32681 = (void *) D.32680;
        fprintf (log_file.256, "[%p] Expected value of type %s, got 0x%0x.\n", D.32681, name, type);
        log_file.256 = log_file;
        fflush (log_file.256);
        <D.32679>:
        monoeg_g_free (name);
        D.32588 = 102;
        return D.32588;
      }
      <D.32677>:
      <D.32658>:
      <D.32655>:
      goto <D.32682>;
      <D.32632>:
      monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "debugger-agent.c", 5862);
      <D.32682>:
      goto <D.28866>;
      <D.28866>:
      buf.257 = buf;
      *endbuf = buf.257;
      D.32588 = 0;
      return D.32588;
    }
  finally
    {
      err = {CLOBBER};
    }
}


obj_is_of_type (struct MonoObject * obj, struct MonoType * t)
{
  struct MonoVTable * D.32689;
  struct MonoClass * D.32690;
  int D.32691;
  struct MonoClass * D.32694;
  struct MonoRemoteClass * D.32697;
  struct MonoClass * D.32698;
  int D.32699;
  gboolean D.32702;
  struct MonoClass * klass;

  D.32689 = obj->vtable;
  klass = D.32689->klass;
  D.32690 = mono_class_from_mono_type (t);
  D.32691 = mono_class_is_assignable_from (D.32690, klass);
  if (D.32691 == 0) goto <D.32692>; else goto <D.32693>;
  <D.32692>:
  D.32694 = mono_defaults.transparent_proxy_class;
  if (D.32694 == klass) goto <D.32695>; else goto <D.32696>;
  <D.32695>:
  D.32697 = MEM[(struct MonoTransparentProxy *)obj].remote_class;
  klass = D.32697->proxy_class;
  D.32698 = mono_class_from_mono_type (t);
  D.32699 = mono_class_is_assignable_from (D.32698, klass);
  if (D.32699 != 0) goto <D.32700>; else goto <D.32701>;
  <D.32700>:
  D.32702 = 1;
  return D.32702;
  <D.32701>:
  <D.32696>:
  D.32702 = 0;
  return D.32702;
  <D.32693>:
  D.32702 = 1;
  return D.32702;
}


decode_vtype (struct MonoType * t, struct MonoDomain * domain, guint8 * addr, guint8 * buf, guint8 * * endbuf, guint8 * limit)
{
  guint8 * buf.264;
  ErrorCode D.32707;
  int err.265;
  struct MonoClass * D.32713;
  struct MonoType * D.32716;
  int log_level.266;
  _Bool D.32718;
  long int D.32719;
  long int D.32720;
  struct FILE * log_file.267;
  unsigned int D.32724;
  void * D.32725;
  struct MonoType * D.32726;
  short unsigned int D.32727;
  int D.32728;
  int D.32729;
  int D.32732;
  int D.28851;
  int iftmp.268;
  int D.28850;
  const char[9] * D.32738;
  unsigned char D.32739;
  int D.32740;
  unsigned char D.32741;
  int D.32742;
  _Bool D.32743;
  _Bool D.32744;
  _Bool D.32745;
  const unsigned char * D.32748;
  unsigned char D.32749;
  int D.32750;
  const unsigned char * D.32751;
  unsigned char D.32752;
  int D.32753;
  _Bool D.32754;
  _Bool D.32755;
  const unsigned char * D.32758;
  unsigned char D.32759;
  int D.32760;
  const unsigned char * D.32761;
  unsigned char D.32762;
  int D.32763;
  _Bool D.32764;
  _Bool D.32765;
  const unsigned char * D.32768;
  unsigned char D.32769;
  int D.32770;
  const unsigned char * D.32771;
  unsigned char D.32772;
  int D.32773;
  const char * D.32775;
  int D.32778;
  sizetype D.32779;
  sizetype D.32780;
  guint8 * D.32781;
  <unnamed type> D.32782;
  int err.269;
  _Bool D.32786;
  long int D.32787;
  long int D.32788;
  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.32705>; else goto <D.32706>;
      <D.32705>:
      D.32707 = 100;
      return D.32707;
      <D.32706>:
      buf.264 = buf;
      klass = decode_typeid (buf.264, &buf, limit, &d, &err);
      err.265 = err;
      if (err.265 != 0) goto <D.32709>; else goto <D.32710>;
      <D.32709>:
      err.265 = err;
      D.32707 = (ErrorCode) err.265;
      return D.32707;
      <D.32710>:
      if (t != 0B) goto <D.32711>; else goto <D.32712>;
      <D.32711>:
      D.32713 = mono_class_from_mono_type (t);
      if (D.32713 != klass) goto <D.32714>; else goto <D.32715>;
      <D.32714>:
      {
        char * name;
        char * name2;

        name = mono_type_full_name (t);
        D.32716 = &klass->byval_arg;
        name2 = mono_type_full_name (D.32716);
        log_level.266 = log_level;
        D.32718 = log_level.266 > 0;
        D.32719 = (long int) D.32718;
        D.32720 = __builtin_expect (D.32719, 0);
        if (D.32720 != 0) goto <D.32721>; else goto <D.32722>;
        <D.32721>:
        log_file.267 = log_file;
        D.32724 = GetCurrentThreadId ();
        D.32725 = (void *) D.32724;
        fprintf (log_file.267, "[%p] Expected value of type %s, got %s.\n", D.32725, name, name2);
        log_file.267 = log_file;
        fflush (log_file.267);
        <D.32722>:
        monoeg_g_free (name);
        monoeg_g_free (name2);
        D.32707 = 102;
        return D.32707;
      }
      <D.32715>:
      <D.32712>:
      buf.264 = buf;
      nfields = decode_int (buf.264, &buf, limit);
      goto <D.28842>;
      <D.28852>:
      D.32726 = f->type;
      D.32727 = D.32726->attrs;
      D.32728 = (int) D.32727;
      D.32729 = D.32728 & 16;
      if (D.32729 != 0) goto <D.32730>; else goto <D.32731>;
      <D.32730>:
      // predicted unlikely by continue predictor.
      goto <D.28842>;
      <D.32731>:
      D.32726 = f->type;
      D.32727 = D.32726->attrs;
      D.32728 = (int) D.32727;
      D.32732 = D.32728 & 1536;
      if (D.32732 != 0) goto <D.32733>; else goto <D.32734>;
      <D.32733>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          __s2 = mono_field_get_name (f);
          D.32738 = "_Deleted";
          D.32739 = MEM[(const unsigned char *)D.32738];
          D.32740 = (int) D.32739;
          D.32741 = *__s2;
          D.32742 = (int) D.32741;
          __result = D.32740 - D.32742;
          {
            D.32743 = __s2_len != 0;
            D.32744 = __result == 0;
            D.32745 = D.32743 & D.32744;
            if (D.32745 != 0) goto <D.32746>; else goto <D.32747>;
            <D.32746>:
            D.32748 = &MEM[(void *)"_Deleted" + 1B];
            D.32749 = *D.32748;
            D.32750 = (int) D.32749;
            D.32751 = __s2 + 1;
            D.32752 = *D.32751;
            D.32753 = (int) D.32752;
            __result = D.32750 - D.32753;
            D.32754 = __s2_len > 1;
            D.32744 = __result == 0;
            D.32755 = D.32754 & D.32744;
            if (D.32755 != 0) goto <D.32756>; else goto <D.32757>;
            <D.32756>:
            D.32758 = &MEM[(void *)"_Deleted" + 2B];
            D.32759 = *D.32758;
            D.32760 = (int) D.32759;
            D.32761 = __s2 + 2;
            D.32762 = *D.32761;
            D.32763 = (int) D.32762;
            __result = D.32760 - D.32763;
            D.32764 = __s2_len > 2;
            D.32744 = __result == 0;
            D.32765 = D.32764 & D.32744;
            if (D.32765 != 0) goto <D.32766>; else goto <D.32767>;
            <D.32766>:
            D.32768 = &MEM[(void *)"_Deleted" + 3B];
            D.32769 = *D.32768;
            D.32770 = (int) D.32769;
            D.32771 = __s2 + 3;
            D.32772 = *D.32771;
            D.32773 = (int) D.32772;
            __result = D.32770 - D.32773;
            <D.32767>:
            <D.32757>:
            <D.32747>:
          }
          D.28850 = __result;
        }
        iftmp.268 = -D.28850;
        goto <D.32774>;
        <D.32737>:
        D.32775 = mono_field_get_name (f);
        iftmp.268 = __builtin_strcmp (D.32775, "_Deleted");
        <D.32774>:
        D.28851 = iftmp.268;
      }
      if (D.28851 == 0) goto <D.32776>; else goto <D.32777>;
      <D.32776>:
      // predicted unlikely by continue predictor.
      goto <D.28842>;
      <D.32777>:
      <D.32734>:
      D.32726 = f->type;
      D.32778 = f->offset;
      D.32779 = (sizetype) D.32778;
      D.32780 = D.32779 + 4294967288;
      D.32781 = addr + D.32780;
      buf.264 = buf;
      D.32782 = decode_value (D.32726, domain, D.32781, buf.264, &buf, limit);
      err.269 = (int) D.32782;
      err = err.269;
      err.265 = err;
      if (err.265 != 0) goto <D.32784>; else goto <D.32785>;
      <D.32784>:
      err.265 = err;
      D.32707 = (ErrorCode) err.265;
      return D.32707;
      <D.32785>:
      nfields = nfields + -1;
      <D.28842>:
      f = mono_class_get_fields (klass, &iter);
      if (f != 0B) goto <D.28852>; else goto <D.28853>;
      <D.28853>:
      D.32786 = nfields != 0;
      D.32787 = (long int) D.32786;
      D.32788 = __builtin_expect (D.32787, 0);
      if (D.32788 != 0) goto <D.32789>; else goto <D.32790>;
      <D.32789>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 5713, "nfields == 0");
      <D.32790>:
      buf.264 = buf;
      *endbuf = buf.264;
      D.32707 = 0;
      return D.32707;
    }
  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.32797;
  struct MonoImage * D.32798;
  const char * D.32799;
  unsigned char D.32800;
  unsigned char D.32801;
  struct MonoDomain * domain.272;
  _Bool D.32809;
  long int D.32810;
  long int D.32811;
  int D.32814;
  const char * D.32818;
  struct MonoClass * iftmp.273;
  const char * D.32825;
  short unsigned int D.32826;
  int D.32827;
  short unsigned int D.32828;
  int D.32829;
  short unsigned int D.32830;
  int D.32831;
  short unsigned int D.32832;
  int D.32833;
  const char * iftmp.274;
  const char * D.32837;
  char D.32839;
  const char * iftmp.275;
  unsigned char D.32842;
  const char * iftmp.276;
  unsigned int D.32847;
  unsigned int D.32848;
  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.32795>; else goto <D.32796>;
      <D.32795>:
      err.271 = err;
      D.32797 = (ErrorCode) err.271;
      return D.32797;
      <D.32796>:
      switch (command) <default: <D.29359>, case 1: <D.29340>, case 2: <D.29342>, case 3: <D.29345>, case 4: <D.29346>, case 5: <D.29348>, case 6: <D.29356>>
      <D.29340>:
      D.32798 = ass->image;
      D.32799 = mono_image_get_filename (D.32798);
      buffer_add_string (buf, D.32799);
      goto <D.29341>;
      <D.29342>:
      {
        guint32 token;
        struct MonoMethod * m;

        D.32798 = ass->image;
        D.32800 = BIT_FIELD_REF <*D.32798, 8, 128>;
        D.32801 = D.32800 & 8;
        if (D.32801 != 0) goto <D.32802>; else goto <D.32803>;
        <D.32802>:
        buffer_add_id (buf, 0);
        goto <D.32804>;
        <D.32803>:
        D.32798 = ass->image;
        token = mono_image_get_entry_point (D.32798);
        if (token == 0) goto <D.32805>; else goto <D.32806>;
        <D.32805>:
        buffer_add_id (buf, 0);
        goto <D.32807>;
        <D.32806>:
        D.32798 = ass->image;
        m = mono_get_method (D.32798, token, 0B);
        domain.272 = domain;
        buffer_add_methodid (buf, domain.272, m);
        <D.32807>:
        <D.32804>:
        goto <D.29341>;
      }
      <D.29345>:
      domain.272 = domain;
      D.32798 = ass->image;
      buffer_add_moduleid (buf, domain.272, D.32798);
      goto <D.29341>;
      <D.29346>:
      {
        struct MonoObject * o;

        domain.272 = domain;
        o = mono_assembly_get_object (domain.272, ass);
        buffer_add_objid (buf, o);
        goto <D.29341>;
      }
      <D.29348>:
      {
        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.32809 = res == 0;
            D.32810 = (long int) D.32809;
            D.32811 = __builtin_expect (D.32810, 0);
            if (D.32811 != 0) goto <D.32812>; else goto <D.32813>;
            <D.32812>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 7341, "res");
            <D.32813>:
            D.32814 = mono_reflection_parse_type (s, &info);
            if (D.32814 == 0) goto <D.32815>; else goto <D.32816>;
            <D.32815>:
            t = 0B;
            goto <D.32817>;
            <D.32816>:
            D.32818 = info.assembly.name;
            if (D.32818 != 0B) goto <D.32819>; else goto <D.32820>;
            <D.32819>:
            monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "debugger-agent.c", 7347);
            <D.32820>:
            D.32798 = ass->image;
            t = mono_reflection_get_type (D.32798, &info, ignorecase, &type_resolve);
            <D.32817>:
            domain.272 = domain;
            if (t != 0B) goto <D.32822>; else goto <D.32823>;
            <D.32822>:
            iftmp.273 = mono_class_from_mono_type (t);
            goto <D.32824>;
            <D.32823>:
            iftmp.273 = 0B;
            <D.32824>:
            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.29341>;
          }
        finally
          {
            info = {CLOBBER};
            type_resolve = {CLOBBER};
          }
      }
      <D.29356>:
      {
        gchar * name;
        struct MonoAssembly * mass;

        mass = ass;
        D.32825 = mass->aname.name;
        D.32826 = mass->aname.major;
        D.32827 = (int) D.32826;
        D.32828 = mass->aname.minor;
        D.32829 = (int) D.32828;
        D.32830 = mass->aname.build;
        D.32831 = (int) D.32830;
        D.32832 = mass->aname.revision;
        D.32833 = (int) D.32832;
        D.32837 = mass->aname.culture;
        if (D.32837 != 0B) goto <D.32838>; else goto <D.32835>;
        <D.32838>:
        D.32837 = mass->aname.culture;
        D.32839 = *D.32837;
        if (D.32839 != 0) goto <D.32840>; else goto <D.32835>;
        <D.32840>:
        iftmp.274 = mass->aname.culture;
        goto <D.32836>;
        <D.32835>:
        iftmp.274 = "neutral";
        <D.32836>:
        D.32842 = mass->aname.public_key_token[0];
        if (D.32842 != 0) goto <D.32843>; else goto <D.32844>;
        <D.32843>:
        iftmp.275 = &mass->aname.public_key_token;
        goto <D.32845>;
        <D.32844>:
        iftmp.275 = "null";
        <D.32845>:
        D.32847 = mass->aname.flags;
        D.32848 = D.32847 & 256;
        if (D.32848 != 0) goto <D.32849>; else goto <D.32850>;
        <D.32849>:
        iftmp.276 = ", Retargetable=Yes";
        goto <D.32851>;
        <D.32850>:
        iftmp.276 = "";
        <D.32851>:
        name = monoeg_g_strdup_printf ("%s, Version=%d.%d.%d.%d, Culture=%s, PublicKeyToken=%s%s", D.32825, D.32827, D.32829, D.32831, D.32833, iftmp.274, iftmp.275, iftmp.276);
        buffer_add_string (buf, name);
        monoeg_g_free (name);
        goto <D.29341>;
      }
      <D.29359>:
      D.32797 = 100;
      return D.32797;
      <D.29341>:
      D.32797 = 0;
      return D.32797;
    }
  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.32856;
  const char * D.32857;
  const char * D.32858;
  struct MonoDomain * domain.278;
  struct MonoAssembly * D.32860;
  ErrorCode D.32861;
  int err;
  struct MonoDomain * domain;

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

        p.277 = p;
        image = decode_moduleid (p.277, &p, end, &domain, &err);
        D.32856 = image->name;
        basename = monoeg_g_path_get_basename (D.32856);
        buffer_add_string (buf, basename);
        D.32857 = image->module_name;
        buffer_add_string (buf, D.32857);
        D.32856 = image->name;
        buffer_add_string (buf, D.32856);
        D.32858 = mono_image_get_guid (image);
        buffer_add_string (buf, D.32858);
        domain.278 = domain;
        D.32860 = image->assembly;
        buffer_add_assemblyid (buf, domain.278, D.32860);
        monoeg_g_free (basename);
        goto <D.29371>;
      }
      <D.29372>:
      D.32861 = 100;
      return D.32861;
      <D.29371>:
      D.32861 = 0;
      return D.32861;
    }
  finally
    {
      err = {CLOBBER};
      domain = {CLOBBER};
    }
}


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

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


type_commands (int command, guint8 * p, guint8 * end, struct Buffer * buf)
{
  guint8 * p.279;
  int err.280;
  ErrorCode D.32870;
  struct MonoDomain * domain.281;
  <unnamed type> D.32872;
  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.32868>; else goto <D.32869>;
      <D.32868>:
      err.280 = err;
      D.32870 = (ErrorCode) err.280;
      return D.32870;
      <D.32869>:
      old_domain = mono_domain_get ();
      domain.281 = domain;
      mono_domain_set (domain.281, 1);
      domain.281 = domain;
      p.279 = p;
      D.32872 = type_commands_internal (command, klass, domain.281, p.279, end, buf);
      err.282 = (int) D.32872;
      err = err.282;
      mono_domain_set (old_domain, 1);
      err.280 = err;
      D.32870 = (ErrorCode) err.280;
      return D.32870;
    }
  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.32876;
  const char * D.32877;
  struct MonoType * D.32878;
  struct MonoImage * D.32879;
  struct MonoAssembly * D.32880;
  struct MonoClass * D.32881;
  unsigned char D.32885;
  unsigned char D.32887;
  struct MonoClass * D.32888;
  unsigned int D.32889;
  unsigned int D.32890;
  unsigned char D.32893;
  unsigned char D.32898;
  unsigned char D.32899;
  unsigned char D.32902;
  unsigned char D.32903;
  _Bool D.32904;
  _Bool D.32905;
  _Bool D.32906;
  unsigned char D.32910;
  unsigned char D.32911;
  struct MonoGenericContainer * D.32914;
  struct MonoGenericClass * D.32920;
  unsigned int nnested.283;
  int protocol_version_set.284;
  int major_version.285;
  int minor_version.286;
  struct MonoClass * D.32936;
  <unnamed-unsigned:22> D.32946;
  unsigned int count.287;
  struct MonoType * D.32948;
  struct MonoClass * D.32949;
  <unnamed-signed:31> D.32953;
  struct MonoGenericParamFull * D.32954;
  unsigned int i.288;
  unsigned int D.32956;
  struct MonoGenericParam * D.32957;
  unsigned int nmethods.289;
  _Bool D.32960;
  long int D.32961;
  long int D.32962;
  unsigned int nfields.290;
  const char * D.32966;
  struct MonoType * D.32967;
  struct MonoClass * D.32968;
  short unsigned int D.32969;
  unsigned int D.32970;
  _Bool D.32971;
  long int D.32972;
  long int D.32973;
  unsigned int nprops.291;
  const char * D.32977;
  struct MonoMethod * D.32978;
  struct MonoMethod * D.32979;
  unsigned int D.32980;
  _Bool D.32981;
  long int D.32982;
  long int D.32983;
  guint8 * p.292;
  int err.293;
  ErrorCode D.32990;
  <unnamed type> D.33001;
  struct MonoThread * thread_obj.294;
  struct MonoType * D.33007;
  short unsigned int D.33008;
  int D.33009;
  int D.33010;
  _Bool D.33015;
  _Bool D.33016;
  _Bool D.33017;
  struct MonoClass * D.33020;
  struct MonoClass * D.33025;
  int D.33026;
  unsigned int D.33027;
  struct MonoInternalThread * iftmp.295;
  struct MonoType * D.33034;
  short unsigned int D.33035;
  int D.33036;
  int D.33037;
  int D.33040;
  struct MonoClass * D.33043;
  struct MonoClass * D.33048;
  int D.33049;
  unsigned int D.33050;
  <unnamed type> D.33051;
  int err.296;
  int D.33055;
  void * D.33058;
  unsigned int D.33060;
  void * * D.33061;
  unsigned int i.297;
  unsigned int D.33063;
  void * * D.33064;
  unsigned int i.298;
  int D.33071;
  unsigned int flags.299;
  unsigned int D.33076;
  int D.33077;
  _Bool D.33078;
  int D.33079;
  unsigned int D.33082;
  void * * D.33083;
  unsigned int i.300;
  unsigned int D.33085;
  void * * D.33086;
  unsigned int i.301;
  int D.33088;
  int D.33091;
  unsigned int D.33094;
  struct MonoClass * iface.302;
  int D.33096;
  unsigned int nmethods.303;
  struct MonoMethod * * D.33102;
  int D.33103;
  unsigned int D.33104;
  unsigned int D.33105;
  struct MonoMethod * * D.33106;
  struct MonoMethod * D.33107;
  unsigned char D.33110;
  unsigned char D.33111;
  _Bool D.33112;
  unsigned int D.33113;
  struct MonoClass * nested;
  struct MonoType * type;
  void * iter;
  guint8 b;
  int err;
  int nnested;
  char * name;

  try
    {
      switch (command) <default: <D.29579>, case 1: <D.29434>, case 2: <D.29453>, case 3: <D.29461>, case 4: <D.29488>, case 5: <D.29522>, case 6: <D.29524>, case 7: <D.29508>, case 8: <D.29533>, case 9: <D.29469>, case 10: <D.29477>, case 11: <D.29480>, case 12: <D.29484>, case 13: <D.29525>, case 14: <D.29489>, case 15: <D.29535>, case 16: <D.29545>, case 17: <D.29558>, case 18: <D.29577>>
      <D.29434>:
      D.32876 = klass->name_space;
      buffer_add_string (buf, D.32876);
      D.32877 = klass->name;
      buffer_add_string (buf, D.32877);
      D.32878 = &klass->byval_arg;
      name = mono_type_get_name_full (D.32878, 2);
      buffer_add_string (buf, name);
      monoeg_g_free (name);
      D.32879 = klass->image;
      D.32880 = D.32879->assembly;
      buffer_add_assemblyid (buf, domain, D.32880);
      D.32879 = klass->image;
      buffer_add_moduleid (buf, domain, D.32879);
      D.32881 = klass->parent;
      buffer_add_typeid (buf, domain, D.32881);
      D.32885 = klass->rank;
      if (D.32885 != 0) goto <D.32882>; else goto <D.32886>;
      <D.32886>:
      D.32887 = klass->byval_arg.type;
      if (D.32887 == 15) goto <D.32882>; else goto <D.32883>;
      <D.32882>:
      D.32888 = klass->element_class;
      buffer_add_typeid (buf, domain, D.32888);
      goto <D.32884>;
      <D.32883>:
      buffer_add_id (buf, 0);
      <D.32884>:
      D.32889 = klass->type_token;
      buffer_add_int (buf, D.32889);
      D.32885 = klass->rank;
      buffer_add_byte (buf, D.32885);
      D.32890 = klass->flags;
      buffer_add_int (buf, D.32890);
      b = 0;
      type = &klass->byval_arg;
      if (0 != 0) goto <D.32891>; else goto <D.32892>;
      <D.32891>:
      b = b | 1;
      <D.32892>:
      D.32893 = type->type;
      if (D.32893 == 15) goto <D.32894>; else goto <D.32895>;
      <D.32894>:
      b = b | 2;
      <D.32895>:
      D.32898 = BIT_FIELD_REF <*type, 8, 56>;
      D.32899 = D.32898 & 64;
      if (D.32899 == 0) goto <D.32900>; else goto <D.32901>;
      <D.32900>:
      D.32902 = type->type;
      D.32903 = D.32902 + 254;
      D.32904 = D.32903 <= 11;
      D.32905 = D.32902 == 24;
      D.32906 = D.32904 | D.32905;
      if (D.32906 != 0) goto <D.32896>; else goto <D.32907>;
      <D.32907>:
      D.32893 = type->type;
      if (D.32893 == 25) goto <D.32896>; else goto <D.32897>;
      <D.32896>:
      b = b | 4;
      <D.32897>:
      <D.32901>:
      D.32893 = type->type;
      if (D.32893 == 17) goto <D.32908>; else goto <D.32909>;
      <D.32908>:
      b = b | 8;
      <D.32909>:
      D.32910 = BIT_FIELD_REF <*klass, 8, 160>;
      D.32911 = D.32910 & 16;
      if (D.32911 != 0) goto <D.32912>; else goto <D.32913>;
      <D.32912>:
      b = b | 16;
      <D.32913>:
      D.32914 = klass->generic_container;
      if (D.32914 != 0B) goto <D.32915>; else goto <D.32916>;
      <D.32915>:
      b = b | 32;
      <D.32916>:
      D.32914 = klass->generic_container;
      if (D.32914 != 0B) goto <D.32917>; else goto <D.32919>;
      <D.32919>:
      D.32920 = klass->generic_class;
      if (D.32920 != 0B) goto <D.32917>; else goto <D.32918>;
      <D.32917>:
      b = b | 64;
      <D.32918>:
      buffer_add_byte (buf, b);
      nnested = 0;
      iter = 0B;
      goto <D.29436>;
      <D.29435>:
      nnested = nnested + 1;
      <D.29436>:
      nested = mono_class_get_nested_types (klass, &iter);
      if (nested != 0B) goto <D.29435>; else goto <D.29437>;
      <D.29437>:
      nnested.283 = (unsigned int) nnested;
      buffer_add_int (buf, nnested.283);
      iter = 0B;
      goto <D.29439>;
      <D.29438>:
      buffer_add_typeid (buf, domain, nested);
      <D.29439>:
      nested = mono_class_get_nested_types (klass, &iter);
      if (nested != 0B) goto <D.29438>; else goto <D.29440>;
      <D.29440>:
      protocol_version_set.284 = protocol_version_set;
      if (protocol_version_set.284 != 0) goto <D.32925>; else goto <D.32926>;
      <D.32925>:
      major_version.285 = major_version;
      if (major_version.285 > 2) goto <D.32922>; else goto <D.32928>;
      <D.32928>:
      major_version.285 = major_version;
      if (major_version.285 == 2) goto <D.32929>; else goto <D.32923>;
      <D.32929>:
      minor_version.286 = minor_version;
      if (minor_version.286 > 11) goto <D.32922>; else goto <D.32923>;
      <D.32922>:
      D.32914 = klass->generic_container;
      if (D.32914 != 0B) goto <D.32931>; else goto <D.32932>;
      <D.32931>:
      buffer_add_typeid (buf, domain, klass);
      goto <D.32933>;
      <D.32932>:
      D.32920 = klass->generic_class;
      if (D.32920 != 0B) goto <D.32934>; else goto <D.32935>;
      <D.32934>:
      D.32920 = klass->generic_class;
      D.32936 = D.32920->container_class;
      buffer_add_typeid (buf, domain, D.32936);
      goto <D.32937>;
      <D.32935>:
      buffer_add_id (buf, 0);
      <D.32937>:
      <D.32933>:
      <D.32923>:
      <D.32926>:
      protocol_version_set.284 = protocol_version_set;
      if (protocol_version_set.284 != 0) goto <D.32940>; else goto <D.32941>;
      <D.32940>:
      major_version.285 = major_version;
      if (major_version.285 > 2) goto <D.32938>; else goto <D.32942>;
      <D.32942>:
      major_version.285 = major_version;
      if (major_version.285 == 2) goto <D.32943>; else goto <D.32939>;
      <D.32943>:
      minor_version.286 = minor_version;
      if (minor_version.286 > 14) goto <D.32938>; else goto <D.32939>;
      <D.32938>:
      {
        int count;
        int i;

        D.32920 = klass->generic_class;
        if (D.32920 != 0B) goto <D.32944>; else goto <D.32945>;
        <D.32944>:
        {
          struct MonoGenericInst * inst;

          D.32920 = klass->generic_class;
          inst = D.32920->context.class_inst;
          D.32946 = inst->type_argc;
          count = (int) D.32946;
          count.287 = (unsigned int) count;
          buffer_add_int (buf, count.287);
          i = 0;
          goto <D.29445>;
          <D.29444>:
          D.32948 = inst->type_argv[i];
          D.32949 = mono_class_from_mono_type (D.32948);
          buffer_add_typeid (buf, domain, D.32949);
          i = i + 1;
          <D.29445>:
          if (i < count) goto <D.29444>; else goto <D.29446>;
          <D.29446>:
        }
        goto <D.32950>;
        <D.32945>:
        D.32914 = klass->generic_container;
        if (D.32914 != 0B) goto <D.32951>; else goto <D.32952>;
        <D.32951>:
        {
          struct MonoGenericContainer * container;
          struct MonoClass * pklass;

          container = klass->generic_container;
          D.32953 = container->type_argc;
          count = (int) D.32953;
          count.287 = (unsigned int) count;
          buffer_add_int (buf, count.287);
          i = 0;
          goto <D.29450>;
          <D.29449>:
          D.32954 = container->type_params;
          i.288 = (unsigned int) i;
          D.32956 = i.288 * 32;
          D.32957 = D.32954 + D.32956;
          D.32879 = klass->image;
          pklass = mono_class_from_generic_parameter (D.32957, D.32879, 0);
          buffer_add_typeid (buf, domain, pklass);
          i = i + 1;
          <D.29450>:
          if (i < count) goto <D.29449>; else goto <D.29451>;
          <D.29451>:
        }
        goto <D.32958>;
        <D.32952>:
        buffer_add_int (buf, 0);
        <D.32958>:
        <D.32950>:
      }
      <D.32939>:
      <D.32941>:
      goto <D.29452>;
      <D.29453>:
      {
        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.29459>;
            <D.29458>:
            buffer_add_methodid (buf, domain, m);
            i = i + 1;
            <D.29459>:
            m = mono_class_get_methods (klass, &iter);
            if (m != 0B) goto <D.29458>; else goto <D.29460>;
            <D.29460>:
            D.32960 = i != nmethods;
            D.32961 = (long int) D.32960;
            D.32962 = __builtin_expect (D.32961, 0);
            if (D.32962 != 0) goto <D.32963>; else goto <D.32964>;
            <D.32963>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 7618, "i == nmethods");
            <D.32964>:
            goto <D.29452>;
          }
        finally
          {
            iter = {CLOBBER};
          }
      }
      <D.29461>:
      {
        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.29467>;
            <D.29466>:
            buffer_add_fieldid (buf, domain, f);
            D.32966 = f->name;
            buffer_add_string (buf, D.32966);
            D.32967 = f->type;
            D.32968 = mono_class_from_mono_type (D.32967);
            buffer_add_typeid (buf, domain, D.32968);
            D.32967 = f->type;
            D.32969 = D.32967->attrs;
            D.32970 = (unsigned int) D.32969;
            buffer_add_int (buf, D.32970);
            i = i + 1;
            <D.29467>:
            f = mono_class_get_fields (klass, &iter);
            if (f != 0B) goto <D.29466>; else goto <D.29468>;
            <D.29468>:
            D.32971 = i != nfields;
            D.32972 = (long int) D.32971;
            D.32973 = __builtin_expect (D.32972, 0);
            if (D.32973 != 0) goto <D.32974>; else goto <D.32975>;
            <D.32974>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 7638, "i == nfields");
            <D.32975>:
            goto <D.29452>;
          }
        finally
          {
            iter = {CLOBBER};
          }
      }
      <D.29469>:
      {
        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.29475>;
            <D.29474>:
            buffer_add_propertyid (buf, domain, p);
            D.32977 = p->name;
            buffer_add_string (buf, D.32977);
            D.32978 = p->get;
            buffer_add_methodid (buf, domain, D.32978);
            D.32979 = p->set;
            buffer_add_methodid (buf, domain, D.32979);
            D.32980 = p->attrs;
            buffer_add_int (buf, D.32980);
            i = i + 1;
            <D.29475>:
            p = mono_class_get_properties (klass, &iter);
            if (p != 0B) goto <D.29474>; else goto <D.29476>;
            <D.29476>:
            D.32981 = i != nprops;
            D.32982 = (long int) D.32981;
            D.32983 = __builtin_expect (D.32982, 0);
            if (D.32983 != 0) goto <D.32984>; else goto <D.32985>;
            <D.32984>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 7659, "i == nprops");
            <D.32985>:
            goto <D.29452>;
          }
        finally
          {
            iter = {CLOBBER};
          }
      }
      <D.29477>:
      {
        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.32988>; else goto <D.32989>;
        <D.32988>:
        err.293 = err;
        D.32990 = (ErrorCode) err.293;
        return D.32990;
        <D.32989>:
        cinfo = mono_custom_attrs_from_class (klass);
        D.32879 = klass->image;
        buffer_add_cattrs (buf, domain, D.32879, attr_klass, cinfo);
        goto <D.29452>;
      }
      <D.29480>:
      {
        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.32991>; else goto <D.32992>;
        <D.32991>:
        err.293 = err;
        D.32990 = (ErrorCode) err.293;
        return D.32990;
        <D.32992>:
        p.292 = p;
        attr_klass = decode_typeid (p.292, &p, end, 0B, &err);
        err.293 = err;
        if (err.293 != 0) goto <D.32993>; else goto <D.32994>;
        <D.32993>:
        err.293 = err;
        D.32990 = (ErrorCode) err.293;
        return D.32990;
        <D.32994>:
        cinfo = mono_custom_attrs_from_field (klass, field);
        D.32879 = klass->image;
        buffer_add_cattrs (buf, domain, D.32879, attr_klass, cinfo);
        goto <D.29452>;
      }
      <D.29484>:
      {
        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.32995>; else goto <D.32996>;
        <D.32995>:
        err.293 = err;
        D.32990 = (ErrorCode) err.293;
        return D.32990;
        <D.32996>:
        p.292 = p;
        attr_klass = decode_typeid (p.292, &p, end, 0B, &err);
        err.293 = err;
        if (err.293 != 0) goto <D.32997>; else goto <D.32998>;
        <D.32997>:
        err.293 = err;
        D.32990 = (ErrorCode) err.293;
        return D.32990;
        <D.32998>:
        cinfo = mono_custom_attrs_from_property (klass, prop);
        D.32879 = klass->image;
        buffer_add_cattrs (buf, domain, D.32879, attr_klass, cinfo);
        goto <D.29452>;
      }
      <D.29488>:
      <D.29489>:
      {
        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.32999>; else goto <D.33000>;
            <D.32999>:
            {
              int objid;
              int err;

              p.292 = p;
              objid = decode_objid (p.292, &p, end);
              D.33001 = get_object (objid, &thread_obj);
              err = (int) D.33001;
              if (err != 0) goto <D.33002>; else goto <D.33003>;
              <D.33002>:
              D.32990 = (ErrorCode) err;
              return D.32990;
              <D.33003>:
              thread_obj.294 = thread_obj;
              thread = thread_obj.294->internal_thread;
            }
            <D.33000>:
            p.292 = p;
            len = decode_int (p.292, &p, end);
            i = 0;
            goto <D.29506>;
            <D.29505>:
            p.292 = p;
            f = decode_fieldid (p.292, &p, end, 0B, &err);
            err.293 = err;
            if (err.293 != 0) goto <D.33005>; else goto <D.33006>;
            <D.33005>:
            err.293 = err;
            D.32990 = (ErrorCode) err.293;
            return D.32990;
            <D.33006>:
            D.33007 = f->type;
            D.33008 = D.33007->attrs;
            D.33009 = (int) D.33008;
            D.33010 = D.33009 & 16;
            if (D.33010 == 0) goto <D.33011>; else goto <D.33012>;
            <D.33011>:
            D.32990 = 25;
            return D.32990;
            <D.33012>:
            special_static_type = mono_class_field_get_special_static_type (f);
            if (special_static_type != 0) goto <D.33013>; else goto <D.33014>;
            <D.33013>:
            D.33015 = thread == 0B;
            D.33016 = special_static_type != 1;
            D.33017 = D.33015 | D.33016;
            if (D.33017 != 0) goto <D.33018>; else goto <D.33019>;
            <D.33018>:
            D.32990 = 25;
            return D.32990;
            <D.33019>:
            <D.33014>:
            found = 0;
            k = klass;
            goto <D.29504>;
            <D.29503>:
            D.33020 = f->parent;
            if (D.33020 == k) goto <D.33021>; else goto <D.33022>;
            <D.33021>:
            found = 1;
            goto <D.29502>;
            <D.33022>:
            k = k->parent;
            <D.29504>:
            if (k != 0B) goto <D.29503>; else goto <D.29502>;
            <D.29502>:
            if (found == 0) goto <D.33023>; else goto <D.33024>;
            <D.33023>:
            D.32990 = 25;
            return D.32990;
            <D.33024>:
            D.33020 = f->parent;
            vtable = mono_class_vtable (domain, D.33020);
            D.33007 = f->type;
            D.33025 = mono_class_from_mono_type (D.33007);
            D.33026 = mono_class_instance_size (D.33025);
            D.33027 = (unsigned int) D.33026;
            val = monoeg_malloc (D.33027);
            if (thread == 0B) goto <D.33029>; else goto <D.33030>;
            <D.33029>:
            iftmp.295 = mono_thread_internal_current ();
            goto <D.33031>;
            <D.33030>:
            iftmp.295 = thread;
            <D.33031>:
            mono_field_static_get_value_for_thread (iftmp.295, vtable, f, val);
            D.33007 = f->type;
            buffer_add_value (buf, D.33007, val, domain);
            monoeg_g_free (val);
            i = i + 1;
            <D.29506>:
            if (i < len) goto <D.29505>; else goto <D.29507>;
            <D.29507>:
            goto <D.29452>;
          }
        finally
          {
            thread_obj = {CLOBBER};
          }
      }
      <D.29508>:
      {
        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.29520>;
        <D.29519>:
        p.292 = p;
        f = decode_fieldid (p.292, &p, end, 0B, &err);
        err.293 = err;
        if (err.293 != 0) goto <D.33032>; else goto <D.33033>;
        <D.33032>:
        err.293 = err;
        D.32990 = (ErrorCode) err.293;
        return D.32990;
        <D.33033>:
        D.33034 = f->type;
        D.33035 = D.33034->attrs;
        D.33036 = (int) D.33035;
        D.33037 = D.33036 & 16;
        if (D.33037 == 0) goto <D.33038>; else goto <D.33039>;
        <D.33038>:
        D.32990 = 25;
        return D.32990;
        <D.33039>:
        D.33040 = mono_class_field_is_special_static (f);
        if (D.33040 != 0) goto <D.33041>; else goto <D.33042>;
        <D.33041>:
        D.32990 = 25;
        return D.32990;
        <D.33042>:
        found = 0;
        k = klass;
        goto <D.29518>;
        <D.29517>:
        D.33043 = f->parent;
        if (D.33043 == k) goto <D.33044>; else goto <D.33045>;
        <D.33044>:
        found = 1;
        goto <D.29516>;
        <D.33045>:
        k = k->parent;
        <D.29518>:
        if (k != 0B) goto <D.29517>; else goto <D.29516>;
        <D.29516>:
        if (found == 0) goto <D.33046>; else goto <D.33047>;
        <D.33046>:
        D.32990 = 25;
        return D.32990;
        <D.33047>:
        D.33043 = f->parent;
        vtable = mono_class_vtable (domain, D.33043);
        D.33034 = f->type;
        D.33048 = mono_class_from_mono_type (D.33034);
        D.33049 = mono_class_instance_size (D.33048);
        D.33050 = (unsigned int) D.33049;
        val = monoeg_malloc (D.33050);
        D.33034 = f->type;
        p.292 = p;
        D.33051 = decode_value (D.33034, domain, val, p.292, &p, end);
        err.296 = (int) D.33051;
        err = err.296;
        err.293 = err;
        if (err.293 != 0) goto <D.33053>; else goto <D.33054>;
        <D.33053>:
        monoeg_g_free (val);
        err.293 = err;
        D.32990 = (ErrorCode) err.293;
        return D.32990;
        <D.33054>:
        D.33034 = f->type;
        D.33055 = mono_type_is_reference (D.33034);
        if (D.33055 != 0) goto <D.33056>; else goto <D.33057>;
        <D.33056>:
        D.33058 = MEM[(void * *)val];
        mono_field_static_set_value (vtable, f, D.33058);
        goto <D.33059>;
        <D.33057>:
        mono_field_static_set_value (vtable, f, val);
        <D.33059>:
        monoeg_g_free (val);
        i = i + 1;
        <D.29520>:
        if (i < len) goto <D.29519>; else goto <D.29521>;
        <D.29521>:
        goto <D.29452>;
      }
      <D.29522>:
      {
        struct MonoObject * o;

        D.32878 = &klass->byval_arg;
        o = mono_type_get_object (domain, D.32878);
        buffer_add_objid (buf, o);
        goto <D.29452>;
      }
      <D.29524>:
      <D.29525>:
      {
        char * source_file;
        char * base;
        struct GPtrArray * files;
        int i;

        files = get_source_files_for_type (klass);
        D.33060 = files->len;
        buffer_add_int (buf, D.33060);
        i = 0;
        goto <D.29531>;
        <D.29530>:
        D.33061 = files->pdata;
        i.297 = (unsigned int) i;
        D.33063 = i.297 * 4;
        D.33064 = D.33061 + D.33063;
        source_file = *D.33064;
        if (command == 13) goto <D.33065>; else goto <D.33066>;
        <D.33065>:
        buffer_add_string (buf, source_file);
        goto <D.33067>;
        <D.33066>:
        base = monoeg_g_path_get_basename (source_file);
        buffer_add_string (buf, base);
        monoeg_g_free (base);
        <D.33067>:
        monoeg_g_free (source_file);
        i = i + 1;
        <D.29531>:
        i.298 = (unsigned int) i;
        D.33060 = files->len;
        if (i.298 < D.33060) goto <D.29530>; else goto <D.29532>;
        <D.29532>:
        monoeg_g_ptr_array_free (files, 1);
        goto <D.29452>;
      }
      <D.29533>:
      {
        struct MonoClass * oklass;

        p.292 = p;
        oklass = decode_typeid (p.292, &p, end, 0B, &err);
        err.293 = err;
        if (err.293 != 0) goto <D.33069>; else goto <D.33070>;
        <D.33069>:
        err.293 = err;
        D.32990 = (ErrorCode) err.293;
        return D.32990;
        <D.33070>:
        D.33071 = mono_class_is_assignable_from (klass, oklass);
        if (D.33071 != 0) goto <D.33072>; else goto <D.33073>;
        <D.33072>:
        buffer_add_byte (buf, 1);
        goto <D.33074>;
        <D.33073>:
        buffer_add_byte (buf, 0);
        <D.33074>:
        goto <D.29452>;
      }
      <D.29535>:
      {
        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;
            flags.299 = (unsigned int) flags;
            D.33076 = flags.299 & 2415919103;
            D.33077 = flags & 1879048192;
            D.33078 = D.33077 != 0;
            D.33079 = (int) D.33078;
            array = mono_class_get_methods_by_name (klass, name, D.33076, D.33079, 1, &ex);
            if (array == 0B) goto <D.33080>; else goto <D.33081>;
            <D.33080>:
            D.32990 = 200;
            return D.32990;
            <D.33081>:
            D.33082 = array->len;
            buffer_add_int (buf, D.33082);
            i = 0;
            goto <D.29543>;
            <D.29542>:
            {
              struct MonoMethod * method;

              D.33083 = array->pdata;
              i.300 = (unsigned int) i;
              D.33085 = i.300 * 4;
              D.33086 = D.33083 + D.33085;
              method = *D.33086;
              buffer_add_methodid (buf, domain, method);
            }
            i = i + 1;
            <D.29543>:
            i.301 = (unsigned int) i;
            D.33082 = array->len;
            if (i.301 < D.33082) goto <D.29542>; else goto <D.29544>;
            <D.29544>:
            monoeg_g_ptr_array_free (array, 1);
            monoeg_g_free (name);
            goto <D.29452>;
          }
        finally
          {
            ex = {CLOBBER};
          }
      }
      <D.29545>:
      {
        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.29553>;
            <D.29552>:
            mono_class_setup_interfaces (parent, &error);
            D.33088 = mono_error_ok (&error);
            if (D.33088 == 0) goto <D.33089>; else goto <D.33090>;
            <D.33089>:
            D.32990 = 200;
            return D.32990;
            <D.33090>:
            collect_interfaces (parent, iface_hash, &error);
            D.33091 = mono_error_ok (&error);
            if (D.33091 == 0) goto <D.33092>; else goto <D.33093>;
            <D.33092>:
            D.32990 = 200;
            return D.32990;
            <D.33093>:
            parent = parent->parent;
            <D.29553>:
            if (parent != 0B) goto <D.29552>; else goto <D.29554>;
            <D.29554>:
            D.33094 = monoeg_g_hash_table_size (iface_hash);
            buffer_add_int (buf, D.33094);
            monoeg_g_hash_table_iter_init (&iter, iface_hash);
            goto <D.29556>;
            <D.29555>:
            iface.302 = iface;
            buffer_add_typeid (buf, domain, iface.302);
            <D.29556>:
            D.33096 = monoeg_g_hash_table_iter_next (&iter, 0B, &iface);
            if (D.33096 != 0) goto <D.29555>; else goto <D.29557>;
            <D.29557>:
            monoeg_g_hash_table_destroy (iface_hash);
            goto <D.29452>;
          }
        finally
          {
            error = {CLOBBER};
            iface = {CLOBBER};
            iter = {CLOBBER};
          }
      }
      <D.29558>:
      {
        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.29575>;
            <D.29574>:
            p.292 = p;
            iclass = decode_typeid (p.292, &p, end, 0B, &err);
            err.293 = err;
            if (err.293 != 0) goto <D.33097>; else goto <D.33098>;
            <D.33097>:
            err.293 = err;
            D.32990 = (ErrorCode) err.293;
            return D.32990;
            <D.33098>:
            ioffset = mono_class_interface_offset_with_variance (klass, iclass, &variance_used);
            if (ioffset == -1) goto <D.33099>; else goto <D.33100>;
            <D.33099>:
            D.32990 = 102;
            return D.32990;
            <D.33100>:
            nmethods = mono_class_num_methods (iclass);
            nmethods.303 = (unsigned int) nmethods;
            buffer_add_int (buf, nmethods.303);
            iter = 0B;
            goto <D.29569>;
            <D.29568>:
            buffer_add_methodid (buf, domain, method);
            <D.29569>:
            method = mono_class_get_methods (iclass, &iter);
            if (method != 0B) goto <D.29568>; else goto <D.29570>;
            <D.29570>:
            i = 0;
            goto <D.29572>;
            <D.29571>:
            D.33102 = klass->vtable;
            D.33103 = i + ioffset;
            D.33104 = (unsigned int) D.33103;
            D.33105 = D.33104 * 4;
            D.33106 = D.33102 + D.33105;
            D.33107 = *D.33106;
            buffer_add_methodid (buf, domain, D.33107);
            i = i + 1;
            <D.29572>:
            if (i < nmethods) goto <D.29571>; else goto <D.29573>;
            <D.29573>:
            tindex = tindex + 1;
            <D.29575>:
            if (tindex < len) goto <D.29574>; else goto <D.29576>;
            <D.29576>:
            goto <D.29452>;
          }
        finally
          {
            variance_used = {CLOBBER};
            iter = {CLOBBER};
          }
      }
      <D.29577>:
      {
        struct MonoVTable * vtable;

        vtable = mono_class_vtable (domain, klass);
        if (vtable != 0B) goto <D.33108>; else goto <D.33109>;
        <D.33108>:
        D.33110 = BIT_FIELD_REF <*vtable, 8, 184>;
        D.33111 = D.33110 & 6;
        D.33112 = D.33111 != 0;
        D.33113 = (unsigned int) D.33112;
        buffer_add_int (buf, D.33113);
        goto <D.33114>;
        <D.33109>:
        buffer_add_int (buf, 0);
        <D.33114>:
        goto <D.29452>;
      }
      <D.29579>:
      D.32990 = 100;
      return D.32990;
      <D.29452>:
      D.32990 = 0;
      return D.32990;
    }
  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.33128;

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


buffer_add_cattrs (struct Buffer * buf, struct MonoDomain * domain, struct MonoImage * image, struct MonoClass * attr_klass, struct MonoCustomAttrInfo * cinfo)
{
  struct MonoMethod * D.33135;
  struct MonoClass * D.33136;
  int D.33137;
  int D.33138;
  unsigned int nattrs.304;
  struct MonoMethod * D.33143;
  struct MonoClass * D.33144;
  int D.33145;
  const mono_byte * D.33146;
  unsigned int D.33147;
  int D.33148;
  _Bool D.33149;
  long int D.33150;
  long int D.33151;
  struct MonoArray * typed_args.305;
  unsigned int D.33157;
  unsigned int j.306;
  char * D.33159;
  struct MonoMethodSignature * D.33160;
  unsigned int D.33161;
  struct MonoArray * named_args.307;
  unsigned int D.33166;
  char * D.33167;
  struct CattrNamedArg * arginfo.308;
  unsigned int j.309;
  unsigned int D.33170;
  struct CattrNamedArg * D.33171;
  struct MonoProperty * D.33172;
  struct MonoClassField * D.33176;
  struct MonoType * D.33180;
  unsigned int D.33181;
  int i;
  int j;
  int nattrs;

  nattrs = 0;
  if (cinfo == 0B) goto <D.33130>; else goto <D.33131>;
  <D.33130>:
  buffer_add_int (buf, 0);
  return;
  <D.33131>:
  i = 0;
  goto <D.29390>;
  <D.29389>:
  if (attr_klass == 0B) goto <D.33132>; else goto <D.33134>;
  <D.33134>:
  D.33135 = cinfo->attrs[i].ctor;
  D.33136 = D.33135->klass;
  D.33137 = mono_class_has_parent (D.33136, attr_klass);
  if (D.33137 != 0) goto <D.33132>; else goto <D.33133>;
  <D.33132>:
  nattrs = nattrs + 1;
  <D.33133>:
  i = i + 1;
  <D.29390>:
  D.33138 = cinfo->num_attrs;
  if (D.33138 > i) goto <D.29389>; else goto <D.29391>;
  <D.29391>:
  nattrs.304 = (unsigned int) nattrs;
  buffer_add_int (buf, nattrs.304);
  i = 0;
  goto <D.29407>;
  <D.29406>:
  {
    struct MonoCustomAttrEntry * attr;

    attr = &cinfo->attrs[i];
    if (attr_klass == 0B) goto <D.33140>; else goto <D.33142>;
    <D.33142>:
    D.33143 = attr->ctor;
    D.33144 = D.33143->klass;
    D.33145 = mono_class_has_parent (D.33144, attr_klass);
    if (D.33145 != 0) goto <D.33140>; else goto <D.33141>;
    <D.33140>:
    {
      struct MonoArray * typed_args;
      struct MonoArray * named_args;
      struct MonoType * t;
      struct CattrNamedArg * arginfo;
      struct MonoError error;

      try
        {
          arginfo = 0B;
          D.33143 = attr->ctor;
          D.33146 = attr->data;
          D.33147 = attr->data_size;
          mono_reflection_create_custom_attr_data_args (image, D.33143, D.33146, D.33147, &typed_args, &named_args, &arginfo, &error);
          D.33148 = mono_error_ok (&error);
          D.33149 = D.33148 == 0;
          D.33150 = (long int) D.33149;
          D.33151 = __builtin_expect (D.33150, 0);
          if (D.33151 != 0) goto <D.33152>; else goto <D.33153>;
          <D.33152>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 7448, "mono_error_ok (&error)");
          <D.33153>:
          D.33143 = attr->ctor;
          buffer_add_methodid (buf, domain, D.33143);
          typed_args.305 = typed_args;
          if (typed_args.305 != 0B) goto <D.33155>; else goto <D.33156>;
          <D.33155>:
          typed_args.305 = typed_args;
          D.33157 = mono_array_length (typed_args.305);
          buffer_add_int (buf, D.33157);
          j = 0;
          goto <D.29400>;
          <D.29399>:
          {
            struct MonoObject * val;

            typed_args.305 = typed_args;
            j.306 = (unsigned int) j;
            D.33159 = mono_array_addr_with_size (typed_args.305, 4, j.306);
            val = MEM[(struct MonoObject * *)D.33159];
            D.33143 = attr->ctor;
            D.33160 = mono_method_signature (D.33143);
            t = D.33160->params[j];
            buffer_add_cattr_arg (buf, t, domain, val);
          }
          j = j + 1;
          <D.29400>:
          j.306 = (unsigned int) j;
          typed_args.305 = typed_args;
          D.33161 = mono_array_length (typed_args.305);
          if (j.306 < D.33161) goto <D.29399>; else goto <D.29401>;
          <D.29401>:
          goto <D.33162>;
          <D.33156>:
          buffer_add_int (buf, 0);
          <D.33162>:
          named_args.307 = named_args;
          if (named_args.307 != 0B) goto <D.33164>; else goto <D.33165>;
          <D.33164>:
          named_args.307 = named_args;
          D.33166 = mono_array_length (named_args.307);
          buffer_add_int (buf, D.33166);
          j = 0;
          goto <D.29404>;
          <D.29403>:
          {
            struct MonoObject * val;

            named_args.307 = named_args;
            j.306 = (unsigned int) j;
            D.33167 = mono_array_addr_with_size (named_args.307, 4, j.306);
            val = MEM[(struct MonoObject * *)D.33167];
            arginfo.308 = arginfo;
            j.309 = (unsigned int) j;
            D.33170 = j.309 * 12;
            D.33171 = arginfo.308 + D.33170;
            D.33172 = D.33171->prop;
            if (D.33172 != 0B) goto <D.33173>; else goto <D.33174>;
            <D.33173>:
            buffer_add_byte (buf, 84);
            arginfo.308 = arginfo;
            j.309 = (unsigned int) j;
            D.33170 = j.309 * 12;
            D.33171 = arginfo.308 + D.33170;
            D.33172 = D.33171->prop;
            buffer_add_propertyid (buf, domain, D.33172);
            goto <D.33175>;
            <D.33174>:
            arginfo.308 = arginfo;
            j.309 = (unsigned int) j;
            D.33170 = j.309 * 12;
            D.33171 = arginfo.308 + D.33170;
            D.33176 = D.33171->field;
            if (D.33176 != 0B) goto <D.33177>; else goto <D.33178>;
            <D.33177>:
            buffer_add_byte (buf, 83);
            arginfo.308 = arginfo;
            j.309 = (unsigned int) j;
            D.33170 = j.309 * 12;
            D.33171 = arginfo.308 + D.33170;
            D.33176 = D.33171->field;
            buffer_add_fieldid (buf, domain, D.33176);
            goto <D.33179>;
            <D.33178>:
            monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "debugger-agent.c", 7480);
            <D.33179>:
            <D.33175>:
            arginfo.308 = arginfo;
            j.309 = (unsigned int) j;
            D.33170 = j.309 * 12;
            D.33171 = arginfo.308 + D.33170;
            D.33180 = D.33171->type;
            buffer_add_cattr_arg (buf, D.33180, domain, val);
          }
          j = j + 1;
          <D.29404>:
          j.306 = (unsigned int) j;
          named_args.307 = named_args;
          D.33181 = mono_array_length (named_args.307);
          if (j.306 < D.33181) goto <D.29403>; else goto <D.29405>;
          <D.29405>:
          goto <D.33182>;
          <D.33165>:
          buffer_add_int (buf, 0);
          <D.33182>:
          arginfo.308 = arginfo;
          monoeg_g_free (arginfo.308);
        }
      finally
        {
          typed_args = {CLOBBER};
          named_args = {CLOBBER};
          arginfo = {CLOBBER};
          error = {CLOBBER};
        }
    }
    <D.33141>:
  }
  i = i + 1;
  <D.29407>:
  D.33138 = cinfo->num_attrs;
  if (D.33138 > i) goto <D.29406>; else goto <D.29408>;
  <D.29408>:
}


mono_class_has_parent (struct MonoClass * klass, struct MonoClass * parent)
{
  struct MonoClass * * D.33184;
  _Bool D.33185;
  long int D.33186;
  long int D.33187;
  struct MonoClass * * D.33190;
  _Bool D.33191;
  long int D.33192;
  long int D.33193;
  gboolean D.33196;

  D.33184 = klass->supertypes;
  D.33185 = D.33184 == 0B;
  D.33186 = (long int) D.33185;
  D.33187 = __builtin_expect (D.33186, 0);
  if (D.33187 != 0) goto <D.33188>; else goto <D.33189>;
  <D.33188>:
  mono_class_setup_supertypes (klass);
  <D.33189>:
  D.33190 = parent->supertypes;
  D.33191 = D.33190 == 0B;
  D.33192 = (long int) D.33191;
  D.33193 = __builtin_expect (D.33192, 0);
  if (D.33193 != 0) goto <D.33194>; else goto <D.33195>;
  <D.33194>:
  mono_class_setup_supertypes (parent);
  <D.33195>:
  D.33196 = mono_class_has_parent_fast (klass, parent);
  return D.33196;
}


mono_class_has_parent_fast (struct MonoClass * klass, struct MonoClass * parent)
{
  gboolean D.33198;
  int iftmp.310;
  short unsigned int D.33202;
  short unsigned int D.33203;
  struct MonoClass * * D.33205;
  sizetype D.33206;
  sizetype D.33207;
  sizetype D.33208;
  struct MonoClass * * D.33209;
  struct MonoClass * D.33210;

  D.33202 = klass->idepth;
  D.33203 = parent->idepth;
  if (D.33202 >= D.33203) goto <D.33204>; else goto <D.33200>;
  <D.33204>:
  D.33205 = klass->supertypes;
  D.33203 = parent->idepth;
  D.33206 = (sizetype) D.33203;
  D.33207 = D.33206 + 1073741823;
  D.33208 = D.33207 * 4;
  D.33209 = D.33205 + D.33208;
  D.33210 = *D.33209;
  if (D.33210 == parent) goto <D.33211>; else goto <D.33200>;
  <D.33211>:
  iftmp.310 = 1;
  goto <D.33201>;
  <D.33200>:
  iftmp.310 = 0;
  <D.33201>:
  D.33198 = iftmp.310;
  return D.33198;
}


buffer_add_cattr_arg (struct Buffer * buf, struct MonoType * t, struct MonoDomain * domain, struct MonoObject * val)
{
  struct MonoObject * val.311;
  struct MonoVTable * D.33217;
  struct MonoClass * D.33218;
  struct MonoClass * D.33219;
  struct MonoType * D.33221;
  struct MonoClass * D.33222;
  int D.33223;
  void * D.33227;

  val.311 = val;
  if (val.311 != 0B) goto <D.33216>; else goto <D.33213>;
  <D.33216>:
  val.311 = val;
  D.33217 = val.311->vtable;
  D.33218 = D.33217->klass;
  D.33219 = mono_defaults.monotype_class;
  if (D.33218 == D.33219) goto <D.33220>; else goto <D.33213>;
  <D.33220>:
  buffer_add_byte (buf, 241);
  val.311 = val;
  D.33221 = MEM[(struct MonoReflectionType *)val.311].type;
  D.33222 = mono_class_from_mono_type (D.33221);
  buffer_add_typeid (buf, domain, D.33222);
  goto <D.33214>;
  <D.33213>:
  D.33223 = mono_type_is_reference (t);
  if (D.33223 != 0) goto <D.33224>; else goto <D.33225>;
  <D.33224>:
  buffer_add_value (buf, t, &val, domain);
  goto <D.33226>;
  <D.33225>:
  val.311 = val;
  D.33227 = mono_object_unbox (val.311);
  buffer_add_value (buf, t, D.33227, domain);
  <D.33226>:
  <D.33214>:
}


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.33228;
  unsigned char D.33229;
  void * D.33232;
  _Bool D.33235;
  long int D.33236;
  long int D.33237;
  unsigned char D.33242;
  int D.33243;
  signed char D.33244;
  unsigned int D.33245;
  short int D.33246;
  unsigned int D.33247;
  int D.33248;
  unsigned int D.33249;
  long long int D.33250;
  long long unsigned int D.33251;
  long long unsigned int D.33252;
  struct MonoVTable * D.33256;
  struct MonoClass * D.33257;
  unsigned char D.33258;
  unsigned char D.33259;
  unsigned char D.33262;
  unsigned char D.33265;
  <unnamed-unsigned:1> D.33270;
  unsigned char D.33271;
  struct MonoType * D.33272;
  short unsigned int D.33273;
  int D.33274;
  int D.33275;
  int D.33278;
  int D.28790;
  int iftmp.312;
  int D.28789;
  const char[9] * D.33284;
  unsigned char D.33285;
  int D.33286;
  unsigned char D.33287;
  int D.33288;
  _Bool D.33289;
  _Bool D.33290;
  _Bool D.33291;
  const unsigned char * D.33294;
  unsigned char D.33295;
  int D.33296;
  const unsigned char * D.33297;
  unsigned char D.33298;
  int D.33299;
  _Bool D.33300;
  _Bool D.33301;
  const unsigned char * D.33304;
  unsigned char D.33305;
  int D.33306;
  const unsigned char * D.33307;
  unsigned char D.33308;
  int D.33309;
  _Bool D.33310;
  _Bool D.33311;
  const unsigned char * D.33314;
  unsigned char D.33315;
  int D.33316;
  const unsigned char * D.33317;
  unsigned char D.33318;
  int D.33319;
  const char * D.33321;
  unsigned int nfields.313;
  int D.28802;
  int iftmp.314;
  int D.28801;
  unsigned char D.33332;
  int D.33333;
  _Bool D.33334;
  _Bool D.33335;
  _Bool D.33336;
  const unsigned char * D.33339;
  unsigned char D.33340;
  int D.33341;
  _Bool D.33342;
  _Bool D.33343;
  const unsigned char * D.33346;
  unsigned char D.33347;
  int D.33348;
  _Bool D.33349;
  _Bool D.33350;
  const unsigned char * D.33353;
  unsigned char D.33354;
  int D.33355;
  const char * D.33357;
  int D.33360;
  sizetype D.33361;
  sizetype D.33362;
  void * D.33363;
  int D.33364;
  struct MonoObject * obj;
  void handle_vtype = <<< error >>>;
  void handle_ref = <<< error >>>;

  D.33228 = BIT_FIELD_REF <*t, 8, 56>;
  D.33229 = D.33228 & 64;
  if (D.33229 != 0) goto <D.33230>; else goto <D.33231>;
  <D.33230>:
  D.33232 = MEM[(void * *)addr];
  if (D.33232 == 0B) goto <D.33233>; else goto <D.33234>;
  <D.33233>:
  buffer_add_byte (buf, 240);
  return;
  <D.33234>:
  D.33232 = MEM[(void * *)addr];
  D.33235 = D.33232 == 0B;
  D.33236 = (long int) D.33235;
  D.33237 = __builtin_expect (D.33236, 0);
  if (D.33237 != 0) goto <D.33238>; else goto <D.33239>;
  <D.33238>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 5513, "*(void**)addr");
  <D.33239>:
  addr = MEM[(void * *)addr];
  <D.33231>:
  if (as_vtype != 0) goto <D.33240>; else goto <D.33241>;
  <D.33240>:
  D.33242 = t->type;
  D.33243 = (int) D.33242;
  switch (D.33243) <default: <D.28750>, case 2: <D.28734>, case 3: <D.28737>, case 4: <D.28735>, case 5: <D.28736>, case 6: <D.28738>, case 7: <D.28739>, case 8: <D.28740>, case 9: <D.28741>, case 10: <D.28743>, case 11: <D.28744>, case 12: <D.28742>, case 13: <D.28745>, case 15: <D.28748>, case 24: <D.28746>, case 25: <D.28747>>
  <D.28734>:
  <D.28735>:
  <D.28736>:
  <D.28737>:
  <D.28738>:
  <D.28739>:
  <D.28740>:
  <D.28741>:
  <D.28742>:
  <D.28743>:
  <D.28744>:
  <D.28745>:
  <D.28746>:
  <D.28747>:
  <D.28748>:
  goto handle_vtype;
  <D.28750>:
  goto <D.28751>;
  <D.28751>:
  <D.33241>:
  D.33242 = t->type;
  D.33243 = (int) D.33242;
  switch (D.33243) <default: <D.28806>, case 1: <D.28752>, case 2: <D.28754>, case 3: <D.28757>, case 4: <D.28755>, case 5: <D.28756>, case 6: <D.28758>, case 7: <D.28759>, case 8: <D.28760>, case 9: <D.28761>, case 10: <D.28763>, case 11: <D.28764>, case 12: <D.28762>, case 13: <D.28765>, case 14: <D.28771>, case 15: <D.28768>, case 17: <D.28776>, case 18: <D.28774>, case 20: <D.28775>, case 21: <D.28805>, case 24: <D.28766>, case 25: <D.28767>, case 28: <D.28773>, case 29: <D.28772>>
  <D.28752>:
  D.33242 = t->type;
  buffer_add_byte (buf, D.33242);
  goto <D.28753>;
  <D.28754>:
  <D.28755>:
  <D.28756>:
  D.33242 = t->type;
  buffer_add_byte (buf, D.33242);
  D.33244 = MEM[(gint8 *)addr];
  D.33245 = (unsigned int) D.33244;
  buffer_add_int (buf, D.33245);
  goto <D.28753>;
  <D.28757>:
  <D.28758>:
  <D.28759>:
  D.33242 = t->type;
  buffer_add_byte (buf, D.33242);
  D.33246 = MEM[(gint16 *)addr];
  D.33247 = (unsigned int) D.33246;
  buffer_add_int (buf, D.33247);
  goto <D.28753>;
  <D.28760>:
  <D.28761>:
  <D.28762>:
  D.33242 = t->type;
  buffer_add_byte (buf, D.33242);
  D.33248 = MEM[(gint32 *)addr];
  D.33249 = (unsigned int) D.33248;
  buffer_add_int (buf, D.33249);
  goto <D.28753>;
  <D.28763>:
  <D.28764>:
  <D.28765>:
  D.33242 = t->type;
  buffer_add_byte (buf, D.33242);
  D.33250 = MEM[(gint64 *)addr];
  D.33251 = (long long unsigned int) D.33250;
  buffer_add_long (buf, D.33251);
  goto <D.28753>;
  <D.28766>:
  <D.28767>:
  goto handle_vtype;
  <D.28768>:
  {
    gssize val;

    val = MEM[(gssize *)addr];
    D.33242 = t->type;
    buffer_add_byte (buf, D.33242);
    D.33252 = (long long unsigned int) val;
    buffer_add_long (buf, D.33252);
    goto <D.28753>;
  }
  handle_ref:
  <D.28771>:
  <D.28772>:
  <D.28773>:
  <D.28774>:
  <D.28775>:
  obj = MEM[(struct MonoObject * *)addr];
  if (obj == 0B) goto <D.33253>; else goto <D.33254>;
  <D.33253>:
  buffer_add_byte (buf, 240);
  goto <D.33255>;
  <D.33254>:
  D.33256 = obj->vtable;
  D.33257 = D.33256->klass;
  D.33258 = BIT_FIELD_REF <*D.33257, 8, 160>;
  D.33259 = D.33258 & 8;
  if (D.33259 != 0) goto <D.33260>; else goto <D.33261>;
  <D.33260>:
  D.33256 = obj->vtable;
  D.33257 = D.33256->klass;
  t = &D.33257->byval_arg;
  addr = mono_object_unbox (obj);
  goto handle_vtype;
  <D.33261>:
  D.33256 = obj->vtable;
  D.33257 = D.33256->klass;
  D.33262 = D.33257->rank;
  if (D.33262 != 0) goto <D.33263>; else goto <D.33264>;
  <D.33263>:
  D.33256 = obj->vtable;
  D.33257 = D.33256->klass;
  D.33265 = D.33257->byval_arg.type;
  buffer_add_byte (buf, D.33265);
  goto <D.33266>;
  <D.33264>:
  D.33256 = obj->vtable;
  D.33257 = D.33256->klass;
  D.33265 = D.33257->byval_arg.type;
  if (D.33265 == 21) goto <D.33267>; else goto <D.33268>;
  <D.33267>:
  buffer_add_byte (buf, 18);
  goto <D.33269>;
  <D.33268>:
  D.33256 = obj->vtable;
  D.33257 = D.33256->klass;
  D.33265 = D.33257->byval_arg.type;
  buffer_add_byte (buf, D.33265);
  <D.33269>:
  <D.33266>:
  buffer_add_objid (buf, obj);
  <D.33255>:
  goto <D.28753>;
  handle_vtype:
  <D.28776>:
  {
    int nfields;
    void * iter;
    struct MonoClassField * f;
    struct MonoClass * klass;

    try
      {
        klass = mono_class_from_mono_type (t);
        buffer_add_byte (buf, 17);
        D.33270 = klass->enumtype;
        D.33271 = (unsigned char) D.33270;
        buffer_add_byte (buf, D.33271);
        buffer_add_typeid (buf, domain, klass);
        nfields = 0;
        iter = 0B;
        goto <D.28781>;
        <D.28791>:
        D.33272 = f->type;
        D.33273 = D.33272->attrs;
        D.33274 = (int) D.33273;
        D.33275 = D.33274 & 16;
        if (D.33275 != 0) goto <D.33276>; else goto <D.33277>;
        <D.33276>:
        // predicted unlikely by continue predictor.
        goto <D.28781>;
        <D.33277>:
        D.33272 = f->type;
        D.33273 = D.33272->attrs;
        D.33274 = (int) D.33273;
        D.33278 = D.33274 & 1536;
        if (D.33278 != 0) goto <D.33279>; else goto <D.33280>;
        <D.33279>:
        {
          size_t __s1_len;
          size_t __s2_len;

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

            __s2 = mono_field_get_name (f);
            D.33284 = "_Deleted";
            D.33285 = MEM[(const unsigned char *)D.33284];
            D.33286 = (int) D.33285;
            D.33287 = *__s2;
            D.33288 = (int) D.33287;
            __result = D.33286 - D.33288;
            {
              D.33289 = __s2_len != 0;
              D.33290 = __result == 0;
              D.33291 = D.33289 & D.33290;
              if (D.33291 != 0) goto <D.33292>; else goto <D.33293>;
              <D.33292>:
              D.33294 = &MEM[(void *)"_Deleted" + 1B];
              D.33295 = *D.33294;
              D.33296 = (int) D.33295;
              D.33297 = __s2 + 1;
              D.33298 = *D.33297;
              D.33299 = (int) D.33298;
              __result = D.33296 - D.33299;
              D.33300 = __s2_len > 1;
              D.33290 = __result == 0;
              D.33301 = D.33300 & D.33290;
              if (D.33301 != 0) goto <D.33302>; else goto <D.33303>;
              <D.33302>:
              D.33304 = &MEM[(void *)"_Deleted" + 2B];
              D.33305 = *D.33304;
              D.33306 = (int) D.33305;
              D.33307 = __s2 + 2;
              D.33308 = *D.33307;
              D.33309 = (int) D.33308;
              __result = D.33306 - D.33309;
              D.33310 = __s2_len > 2;
              D.33290 = __result == 0;
              D.33311 = D.33310 & D.33290;
              if (D.33311 != 0) goto <D.33312>; else goto <D.33313>;
              <D.33312>:
              D.33314 = &MEM[(void *)"_Deleted" + 3B];
              D.33315 = *D.33314;
              D.33316 = (int) D.33315;
              D.33317 = __s2 + 3;
              D.33318 = *D.33317;
              D.33319 = (int) D.33318;
              __result = D.33316 - D.33319;
              <D.33313>:
              <D.33303>:
              <D.33293>:
            }
            D.28789 = __result;
          }
          iftmp.312 = -D.28789;
          goto <D.33320>;
          <D.33283>:
          D.33321 = mono_field_get_name (f);
          iftmp.312 = __builtin_strcmp (D.33321, "_Deleted");
          <D.33320>:
          D.28790 = iftmp.312;
        }
        if (D.28790 == 0) goto <D.33322>; else goto <D.33323>;
        <D.33322>:
        // predicted unlikely by continue predictor.
        goto <D.28781>;
        <D.33323>:
        <D.33280>:
        nfields = nfields + 1;
        <D.28781>:
        f = mono_class_get_fields (klass, &iter);
        if (f != 0B) goto <D.28791>; else goto <D.28792>;
        <D.28792>:
        nfields.313 = (unsigned int) nfields;
        buffer_add_int (buf, nfields.313);
        iter = 0B;
        goto <D.28793>;
        <D.28803>:
        D.33272 = f->type;
        D.33273 = D.33272->attrs;
        D.33274 = (int) D.33273;
        D.33275 = D.33274 & 16;
        if (D.33275 != 0) goto <D.33325>; else goto <D.33326>;
        <D.33325>:
        // predicted unlikely by continue predictor.
        goto <D.28793>;
        <D.33326>:
        D.33272 = f->type;
        D.33273 = D.33272->attrs;
        D.33274 = (int) D.33273;
        D.33278 = D.33274 & 1536;
        if (D.33278 != 0) goto <D.33327>; else goto <D.33328>;
        <D.33327>:
        {
          size_t __s1_len;
          size_t __s2_len;

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

            __s2 = mono_field_get_name (f);
            D.33284 = "_Deleted";
            D.33285 = MEM[(const unsigned char *)D.33284];
            D.33286 = (int) D.33285;
            D.33332 = *__s2;
            D.33333 = (int) D.33332;
            __result = D.33286 - D.33333;
            {
              D.33334 = __s2_len != 0;
              D.33335 = __result == 0;
              D.33336 = D.33334 & D.33335;
              if (D.33336 != 0) goto <D.33337>; else goto <D.33338>;
              <D.33337>:
              D.33294 = &MEM[(void *)"_Deleted" + 1B];
              D.33295 = *D.33294;
              D.33296 = (int) D.33295;
              D.33339 = __s2 + 1;
              D.33340 = *D.33339;
              D.33341 = (int) D.33340;
              __result = D.33296 - D.33341;
              D.33342 = __s2_len > 1;
              D.33335 = __result == 0;
              D.33343 = D.33342 & D.33335;
              if (D.33343 != 0) goto <D.33344>; else goto <D.33345>;
              <D.33344>:
              D.33304 = &MEM[(void *)"_Deleted" + 2B];
              D.33305 = *D.33304;
              D.33306 = (int) D.33305;
              D.33346 = __s2 + 2;
              D.33347 = *D.33346;
              D.33348 = (int) D.33347;
              __result = D.33306 - D.33348;
              D.33349 = __s2_len > 2;
              D.33335 = __result == 0;
              D.33350 = D.33349 & D.33335;
              if (D.33350 != 0) goto <D.33351>; else goto <D.33352>;
              <D.33351>:
              D.33314 = &MEM[(void *)"_Deleted" + 3B];
              D.33315 = *D.33314;
              D.33316 = (int) D.33315;
              D.33353 = __s2 + 3;
              D.33354 = *D.33353;
              D.33355 = (int) D.33354;
              __result = D.33316 - D.33355;
              <D.33352>:
              <D.33345>:
              <D.33338>:
            }
            D.28801 = __result;
          }
          iftmp.314 = -D.28801;
          goto <D.33356>;
          <D.33331>:
          D.33357 = mono_field_get_name (f);
          iftmp.314 = __builtin_strcmp (D.33357, "_Deleted");
          <D.33356>:
          D.28802 = iftmp.314;
        }
        if (D.28802 == 0) goto <D.33358>; else goto <D.33359>;
        <D.33358>:
        // predicted unlikely by continue predictor.
        goto <D.28793>;
        <D.33359>:
        <D.33328>:
        D.33272 = f->type;
        D.33360 = f->offset;
        D.33361 = (sizetype) D.33360;
        D.33362 = D.33361 + 4294967288;
        D.33363 = addr + D.33362;
        buffer_add_value_full (buf, D.33272, D.33363, domain, 0);
        <D.28793>:
        f = mono_class_get_fields (klass, &iter);
        if (f != 0B) goto <D.28803>; else goto <D.28804>;
        <D.28804>:
        goto <D.28753>;
      }
    finally
      {
        iter = {CLOBBER};
      }
  }
  <D.28805>:
  D.33364 = mono_type_generic_inst_is_valuetype (t);
  if (D.33364 != 0) goto handle_vtype; else goto handle_ref;
  <D.28806>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "debugger-agent.c", 5645);
  <D.28753>:
}


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

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


collect_interfaces (struct MonoClass * klass, struct GHashTable * ifaces, struct MonoError * error)
{
  int D.33370;
  struct MonoClass * * D.33373;
  unsigned int i.315;
  unsigned int D.33375;
  struct MonoClass * * D.33376;
  int D.33377;
  short unsigned int D.33380;
  int D.33381;
  int i;
  struct MonoClass * ic;

  mono_class_setup_interfaces (klass, error);
  D.33370 = mono_error_ok (error);
  if (D.33370 == 0) goto <D.33371>; else goto <D.33372>;
  <D.33371>:
  return;
  <D.33372>:
  i = 0;
  goto <D.29417>;
  <D.29416>:
  D.33373 = klass->interfaces;
  i.315 = (unsigned int) i;
  D.33375 = i.315 * 4;
  D.33376 = D.33373 + D.33375;
  ic = *D.33376;
  monoeg_g_hash_table_insert_replace (ifaces, ic, ic, 0);
  collect_interfaces (ic, ifaces, error);
  D.33377 = mono_error_ok (error);
  if (D.33377 == 0) goto <D.33378>; else goto <D.33379>;
  <D.33378>:
  return;
  <D.33379>:
  i = i + 1;
  <D.29417>:
  D.33380 = klass->interface_count;
  D.33381 = (int) D.33380;
  if (D.33381 > i) goto <D.29416>; else goto <D.29418>;
  <D.29418>:
}


method_commands (int command, guint8 * p, guint8 * end, struct Buffer * buf)
{
  guint8 * p.316;
  int err.317;
  ErrorCode D.33387;
  struct MonoDomain * domain.318;
  <unnamed type> D.33389;
  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.33385>; else goto <D.33386>;
      <D.33385>:
      err.317 = err;
      D.33387 = (ErrorCode) err.317;
      return D.33387;
      <D.33386>:
      old_domain = mono_domain_get ();
      domain.318 = domain;
      mono_domain_set (domain.318, 1);
      domain.318 = domain;
      p.316 = p;
      D.33389 = method_commands_internal (command, method, domain.318, p.316, end, buf);
      err.319 = (int) D.33389;
      err = err.319;
      mono_domain_set (old_domain, 1);
      err.317 = err;
      D.33387 = (ErrorCode) err.317;
      return D.33387;
    }
  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.33393;
  struct MonoClass * D.33394;
  unsigned int D.33399;
  int protocol_version_set.320;
  int major_version.321;
  int minor_version.322;
  struct GPtrArray * source_file_list.323;
  unsigned int D.33410;
  void * * D.33411;
  unsigned int i.324;
  unsigned int D.33413;
  void * * D.33414;
  char * D.33415;
  guint8 * D.33421;
  sizetype j.325;
  guint8 * D.33423;
  unsigned char D.33424;
  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.33430;
  long int D.33431;
  long int D.33432;
  struct FILE * log_file.331;
  char * D.33436;
  int * source_files.332;
  int * D.33438;
  int D.33439;
  unsigned int D.33442;
  unsigned int D.33443;
  void * * D.33444;
  int * il_offsets.333;
  int * D.33448;
  int D.33449;
  int * line_numbers.334;
  int * D.33451;
  int D.33452;
  int iftmp.335;
  int * column_numbers.336;
  int * D.33457;
  unsigned int D.33459;
  unsigned int D.33460;
  unsigned int D.33467;
  guint32 iftmp.337;
  int D.33477;
  <unnamed-unsigned:6> D.33479;
  unsigned int D.33480;
  short unsigned int D.33481;
  unsigned int D.33482;
  short unsigned int D.33483;
  unsigned int D.33484;
  struct MonoType * D.33485;
  struct MonoClass * D.33486;
  struct MonoType * D.33487;
  struct MonoClass * D.33488;
  unsigned int D.33489;
  unsigned int D.33490;
  unsigned int D.33491;
  char * * D.33492;
  char * D.33493;
  ErrorCode D.33496;
  short unsigned int D.33497;
  unsigned int D.33498;
  struct MonoType * D.33499;
  struct MonoClass * D.33500;
  int D.33501;
  struct MonoDebugLocalVar * D.33505;
  unsigned int j.338;
  unsigned int D.33507;
  struct MonoDebugLocalVar * D.33508;
  int D.33509;
  char * D.33513;
  struct MonoDebugCodeBlock * D.33519;
  int D.33521;
  unsigned int D.33522;
  int D.33523;
  unsigned int D.33524;
  short unsigned int D.33527;
  unsigned int D.33528;
  short unsigned int D.33529;
  unsigned int D.33530;
  unsigned int D.33531;
  unsigned char D.33538;
  unsigned char D.33539;
  struct MonoMethodSignature * D.33542;
  short unsigned int D.33543;
  unsigned char D.33546;
  struct MonoGenericInst * D.33552;
  struct MonoGenericContext * D.33555;
  struct MonoGenericContext * D.33558;
  struct MonoMethodSignature * D.33566;
  short unsigned int D.33567;
  unsigned char D.33570;
  struct MonoGenericContext * D.33573;
  <unnamed-unsigned:22> D.33576;
  unsigned int count.339;
  struct MonoType * D.33578;
  struct MonoClass * D.33579;
  struct MonoMethodSignature * D.33584;
  short unsigned int D.33585;
  struct MonoGenericParamFull * D.33586;
  unsigned int i.340;
  unsigned int D.33588;
  struct MonoImage * D.33589;
  const unsigned char * D.33601;
  sizetype i.341;
  const unsigned char * D.33603;
  unsigned char D.33604;
  unsigned int i.342;
  <unnamed-unsigned:15> D.33611;
  unsigned int D.33612;
  struct MonoExceptionClause * D.33613;
  unsigned int i.343;
  unsigned int D.33615;
  unsigned int D.33616;
  unsigned int D.33617;
  unsigned int D.33618;
  unsigned int D.33619;
  unsigned int D.33620;
  struct MonoClass * D.33623;
  unsigned int D.33627;
  int D.33628;
  guint8 * p.344;
  int D.33630;
  unsigned int D.33631;
  unsigned int D.33632;
  _Bool D.33633;
  long int D.33634;
  long int D.33635;
  unsigned char D.33638;
  unsigned char D.33639;
  unsigned int D.33642;
  void * handle_class.345;
  struct MonoClass * handle_class.346;
  _Bool D.33648;
  long int D.33649;
  long int D.33650;
  struct MonoClass * D.33653;
  struct MonoClass * D.33659;
  struct MonoClass * D.33661;
  struct MonoClass * D.33665;
  struct MonoClass * D.33669;
  int err.347;
  unsigned int type_argc.348;
  unsigned int D.33677;
  struct MonoDomain * d.349;
  unsigned int i.350;
  unsigned int D.33684;
  struct MonoType * * D.33685;
  struct MonoType * D.33686;
  struct MonoGenericInst * iftmp.351;
  struct MonoGenericClass * D.33688;
  int D.33692;
  struct MonoMethodHeader * header;
  int err;

  try
    {
      switch (command) <default: <D.29707>, case 1: <D.29600>, case 2: <D.29602>, case 3: <D.29603>, case 4: <D.29626>, case 5: <D.29636>, case 6: <D.29656>, case 7: <D.29673>, case 8: <D.29682>, case 9: <D.29692>, case 10: <D.29695>>
      <D.29600>:
      D.33393 = method->name;
      buffer_add_string (buf, D.33393);
      goto <D.29601>;
      <D.29602>:
      D.33394 = method->klass;
      buffer_add_typeid (buf, domain, D.33394);
      goto <D.29601>;
      <D.29603>:
      {
        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.33395>; else goto <D.33396>;
            <D.33395>:
            buffer_add_int (buf, 0);
            buffer_add_string (buf, "");
            buffer_add_int (buf, 0);
            goto <D.29601>;
            <D.33396>:
            minfo = mono_debug_lookup_method (method);
            if (minfo == 0B) goto <D.33397>; else goto <D.33398>;
            <D.33397>:
            D.33399 = header->code_size;
            buffer_add_int (buf, D.33399);
            buffer_add_string (buf, "");
            buffer_add_int (buf, 0);
            mono_metadata_free_mh (header);
            goto <D.29601>;
            <D.33398>:
            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.33399 = header->code_size;
            buffer_add_int (buf, D.33399);
            protocol_version_set.320 = protocol_version_set;
            if (protocol_version_set.320 != 0) goto <D.33404>; else goto <D.33400>;
            <D.33404>:
            major_version.321 = major_version;
            if (major_version.321 > 2) goto <D.33401>; else goto <D.33406>;
            <D.33406>:
            major_version.321 = major_version;
            if (major_version.321 == 2) goto <D.33407>; else goto <D.33400>;
            <D.33407>:
            minor_version.322 = minor_version;
            if (minor_version.322 > 12) goto <D.33401>; else goto <D.33400>;
            <D.33401>:
            source_file_list.323 = source_file_list;
            D.33410 = source_file_list.323->len;
            buffer_add_int (buf, D.33410);
            i = 0;
            goto <D.29619>;
            <D.29618>:
            {
              struct MonoDebugSourceInfo * sinfo;

              source_file_list.323 = source_file_list;
              D.33411 = source_file_list.323->pdata;
              i.324 = (unsigned int) i;
              D.33413 = i.324 * 4;
              D.33414 = D.33411 + D.33413;
              sinfo = *D.33414;
              D.33415 = sinfo->source_file;
              buffer_add_string (buf, D.33415);
              protocol_version_set.320 = protocol_version_set;
              if (protocol_version_set.320 != 0) goto <D.33417>; else goto <D.33418>;
              <D.33417>:
              major_version.321 = major_version;
              if (major_version.321 > 2) goto <D.33416>; else goto <D.33419>;
              <D.33419>:
              major_version.321 = major_version;
              if (major_version.321 == 2) goto <D.33420>; else goto <D.29617>;
              <D.33420>:
              minor_version.322 = minor_version;
              if (minor_version.322 > 13) goto <D.33416>; else goto <D.29617>;
              <D.33416>:
              j = 0;
              goto <D.29616>;
              <D.29615>:
              D.33421 = sinfo->hash;
              j.325 = (sizetype) j;
              D.33423 = D.33421 + j.325;
              D.33424 = *D.33423;
              buffer_add_byte (buf, D.33424);
              j = j + 1;
              <D.29616>:
              if (j <= 15) goto <D.29615>; else goto <D.29617>;
              <D.29617>:
              <D.33418>:
            }
            i = i + 1;
            <D.29619>:
            i.326 = (unsigned int) i;
            source_file_list.323 = source_file_list;
            D.33410 = source_file_list.323->len;
            if (i.326 < D.33410) goto <D.29618>; else goto <D.29620>;
            <D.29620>:
            goto <D.33402>;
            <D.33400>:
            source_file.327 = source_file;
            buffer_add_string (buf, source_file.327);
            <D.33402>:
            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.33430 = log_level.330 > 9;
            D.33431 = (long int) D.33430;
            D.33432 = __builtin_expect (D.33431, 0);
            if (D.33432 != 0) goto <D.33433>; else goto <D.33434>;
            <D.33433>:
            log_file.331 = log_file;
            D.33436 = mono_method_full_name (method, 1);
            fprintf (log_file.331, "Line number table for method %s:\n", D.33436);
            log_file.331 = log_file;
            fflush (log_file.331);
            <D.33434>:
            i = 0;
            goto <D.29624>;
            <D.29623>:
            {
              const char * srcfile;

              srcfile = "";
              source_files.332 = source_files;
              i.324 = (unsigned int) i;
              D.33413 = i.324 * 4;
              D.33438 = source_files.332 + D.33413;
              D.33439 = *D.33438;
              if (D.33439 != -1) goto <D.33440>; else goto <D.33441>;
              <D.33440>:
              {
                struct MonoDebugSourceInfo * sinfo;

                source_file_list.323 = source_file_list;
                D.33411 = source_file_list.323->pdata;
                source_files.332 = source_files;
                i.324 = (unsigned int) i;
                D.33413 = i.324 * 4;
                D.33438 = source_files.332 + D.33413;
                D.33439 = *D.33438;
                D.33442 = (unsigned int) D.33439;
                D.33443 = D.33442 * 4;
                D.33444 = D.33411 + D.33443;
                sinfo = *D.33444;
                srcfile = sinfo->source_file;
              }
              <D.33441>:
              log_level.330 = log_level;
              D.33430 = log_level.330 > 9;
              D.33431 = (long int) D.33430;
              D.33432 = __builtin_expect (D.33431, 0);
              if (D.33432 != 0) goto <D.33445>; else goto <D.33446>;
              <D.33445>:
              log_file.331 = log_file;
              il_offsets.333 = il_offsets;
              i.324 = (unsigned int) i;
              D.33413 = i.324 * 4;
              D.33448 = il_offsets.333 + D.33413;
              D.33449 = *D.33448;
              line_numbers.334 = line_numbers;
              i.324 = (unsigned int) i;
              D.33413 = i.324 * 4;
              D.33451 = line_numbers.334 + D.33413;
              D.33452 = *D.33451;
              column_numbers.336 = column_numbers;
              if (column_numbers.336 != 0B) goto <D.33455>; else goto <D.33456>;
              <D.33455>:
              column_numbers.336 = column_numbers;
              i.324 = (unsigned int) i;
              D.33413 = i.324 * 4;
              D.33457 = column_numbers.336 + D.33413;
              iftmp.335 = *D.33457;
              goto <D.33458>;
              <D.33456>:
              iftmp.335 = -1;
              <D.33458>:
              fprintf (log_file.331, "IL%x -> %s:%d %d\n", D.33449, srcfile, D.33452, iftmp.335);
              log_file.331 = log_file;
              fflush (log_file.331);
              <D.33446>:
              il_offsets.333 = il_offsets;
              i.324 = (unsigned int) i;
              D.33413 = i.324 * 4;
              D.33448 = il_offsets.333 + D.33413;
              D.33449 = *D.33448;
              D.33459 = (unsigned int) D.33449;
              buffer_add_int (buf, D.33459);
              line_numbers.334 = line_numbers;
              i.324 = (unsigned int) i;
              D.33413 = i.324 * 4;
              D.33451 = line_numbers.334 + D.33413;
              D.33452 = *D.33451;
              D.33460 = (unsigned int) D.33452;
              buffer_add_int (buf, D.33460);
              protocol_version_set.320 = protocol_version_set;
              if (protocol_version_set.320 != 0) goto <D.33463>; else goto <D.33464>;
              <D.33463>:
              major_version.321 = major_version;
              if (major_version.321 > 2) goto <D.33461>; else goto <D.33465>;
              <D.33465>:
              major_version.321 = major_version;
              if (major_version.321 == 2) goto <D.33466>; else goto <D.33462>;
              <D.33466>:
              minor_version.322 = minor_version;
              if (minor_version.322 > 12) goto <D.33461>; else goto <D.33462>;
              <D.33461>:
              source_files.332 = source_files;
              i.324 = (unsigned int) i;
              D.33413 = i.324 * 4;
              D.33438 = source_files.332 + D.33413;
              D.33439 = *D.33438;
              D.33467 = (unsigned int) D.33439;
              buffer_add_int (buf, D.33467);
              <D.33462>:
              <D.33464>:
              protocol_version_set.320 = protocol_version_set;
              if (protocol_version_set.320 != 0) goto <D.33470>; else goto <D.33471>;
              <D.33470>:
              major_version.321 = major_version;
              if (major_version.321 > 2) goto <D.33468>; else goto <D.33472>;
              <D.33472>:
              major_version.321 = major_version;
              if (major_version.321 == 2) goto <D.33473>; else goto <D.33469>;
              <D.33473>:
              minor_version.322 = minor_version;
              if (minor_version.322 > 18) goto <D.33468>; else goto <D.33469>;
              <D.33468>:
              column_numbers.336 = column_numbers;
              if (column_numbers.336 != 0B) goto <D.33475>; else goto <D.33476>;
              <D.33475>:
              column_numbers.336 = column_numbers;
              i.324 = (unsigned int) i;
              D.33413 = i.324 * 4;
              D.33457 = column_numbers.336 + D.33413;
              D.33477 = *D.33457;
              iftmp.337 = (guint32) D.33477;
              goto <D.33478>;
              <D.33476>:
              iftmp.337 = 4294967295;
              <D.33478>:
              buffer_add_int (buf, iftmp.337);
              <D.33469>:
              <D.33471>:
            }
            i = i + 1;
            <D.29624>:
            n_il_offsets.328 = n_il_offsets;
            if (i < n_il_offsets.328) goto <D.29623>; else goto <D.29625>;
            <D.29625>:
            source_file.327 = source_file;
            monoeg_g_free (source_file.327);
            il_offsets.333 = il_offsets;
            monoeg_g_free (il_offsets.333);
            line_numbers.334 = line_numbers;
            monoeg_g_free (line_numbers.334);
            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.29601>;
          }
        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.29626>:
      {
        struct MonoMethodSignature * sig;
        guint32 i;
        char * * names;

        sig = mono_method_signature (method);
        D.33479 = sig->call_convention;
        D.33480 = (unsigned int) D.33479;
        buffer_add_int (buf, D.33480);
        D.33481 = sig->param_count;
        D.33482 = (unsigned int) D.33481;
        buffer_add_int (buf, D.33482);
        D.33483 = sig->generic_param_count;
        D.33484 = (unsigned int) D.33483;
        buffer_add_int (buf, D.33484);
        D.33485 = sig->ret;
        D.33486 = mono_class_from_mono_type (D.33485);
        buffer_add_typeid (buf, domain, D.33486);
        i = 0;
        goto <D.29631>;
        <D.29630>:
        D.33487 = sig->params[i];
        D.33488 = mono_class_from_mono_type (D.33487);
        buffer_add_typeid (buf, domain, D.33488);
        i = i + 1;
        <D.29631>:
        D.33481 = sig->param_count;
        D.33482 = (unsigned int) D.33481;
        if (D.33482 > i) goto <D.29630>; else goto <D.29632>;
        <D.29632>:
        D.33481 = sig->param_count;
        D.33489 = (unsigned int) D.33481;
        D.33490 = D.33489 * 4;
        names = monoeg_malloc (D.33490);
        mono_method_get_param_names (method, names);
        i = 0;
        goto <D.29634>;
        <D.29633>:
        D.33491 = i * 4;
        D.33492 = names + D.33491;
        D.33493 = *D.33492;
        buffer_add_string (buf, D.33493);
        i = i + 1;
        <D.29634>:
        D.33481 = sig->param_count;
        D.33482 = (unsigned int) D.33481;
        if (D.33482 > i) goto <D.29633>; else goto <D.29635>;
        <D.29635>:
        monoeg_g_free (names);
        goto <D.29601>;
      }
      <D.29636>:
      {
        int i;
        int j;
        int num_locals;
        struct MonoDebugLocalsInfo * locals;

        header = mono_method_get_header (method);
        if (header == 0B) goto <D.33494>; else goto <D.33495>;
        <D.33494>:
        D.33496 = 102;
        return D.33496;
        <D.33495>:
        D.33497 = header->num_locals;
        D.33498 = (unsigned int) D.33497;
        buffer_add_int (buf, D.33498);
        i = 0;
        goto <D.29642>;
        <D.29641>:
        D.33499 = header->locals[i];
        D.33500 = mono_class_from_mono_type (D.33499);
        buffer_add_typeid (buf, domain, D.33500);
        i = i + 1;
        <D.29642>:
        D.33497 = header->num_locals;
        D.33501 = (int) D.33497;
        if (D.33501 > i) goto <D.29641>; else goto <D.29643>;
        <D.29643>:
        locals = mono_debug_lookup_locals (method);
        if (locals != 0B) goto <D.33502>; else goto <D.33503>;
        <D.33502>:
        num_locals = locals->num_locals;
        goto <D.33504>;
        <D.33503>:
        num_locals = 0;
        <D.33504>:
        i = 0;
        goto <D.29648>;
        <D.29647>:
        j = 0;
        goto <D.29646>;
        <D.29645>:
        D.33505 = locals->locals;
        j.338 = (unsigned int) j;
        D.33507 = j.338 * 12;
        D.33508 = D.33505 + D.33507;
        D.33509 = D.33508->index;
        if (D.33509 == i) goto <D.29644>; else goto <D.33510>;
        <D.33510>:
        j = j + 1;
        <D.29646>:
        if (j < num_locals) goto <D.29645>; else goto <D.29644>;
        <D.29644>:
        if (j < num_locals) goto <D.33511>; else goto <D.33512>;
        <D.33511>:
        D.33505 = locals->locals;
        j.338 = (unsigned int) j;
        D.33507 = j.338 * 12;
        D.33508 = D.33505 + D.33507;
        D.33513 = D.33508->name;
        buffer_add_string (buf, D.33513);
        goto <D.33514>;
        <D.33512>:
        buffer_add_string (buf, "");
        <D.33514>:
        i = i + 1;
        <D.29648>:
        D.33497 = header->num_locals;
        D.33501 = (int) D.33497;
        if (D.33501 > i) goto <D.29647>; else goto <D.29649>;
        <D.29649>:
        i = 0;
        goto <D.29654>;
        <D.29653>:
        j = 0;
        goto <D.29652>;
        <D.29651>:
        D.33505 = locals->locals;
        j.338 = (unsigned int) j;
        D.33507 = j.338 * 12;
        D.33508 = D.33505 + D.33507;
        D.33509 = D.33508->index;
        if (D.33509 == i) goto <D.29650>; else goto <D.33515>;
        <D.33515>:
        j = j + 1;
        <D.29652>:
        if (j < num_locals) goto <D.29651>; else goto <D.29650>;
        <D.29650>:
        if (j < num_locals) goto <D.33518>; else goto <D.33516>;
        <D.33518>:
        D.33505 = locals->locals;
        j.338 = (unsigned int) j;
        D.33507 = j.338 * 12;
        D.33508 = D.33505 + D.33507;
        D.33519 = D.33508->block;
        if (D.33519 != 0B) goto <D.33520>; else goto <D.33516>;
        <D.33520>:
        D.33505 = locals->locals;
        j.338 = (unsigned int) j;
        D.33507 = j.338 * 12;
        D.33508 = D.33505 + D.33507;
        D.33519 = D.33508->block;
        D.33521 = D.33519->start_offset;
        D.33522 = (unsigned int) D.33521;
        buffer_add_int (buf, D.33522);
        D.33505 = locals->locals;
        j.338 = (unsigned int) j;
        D.33507 = j.338 * 12;
        D.33508 = D.33505 + D.33507;
        D.33519 = D.33508->block;
        D.33523 = D.33519->end_offset;
        D.33524 = (unsigned int) D.33523;
        buffer_add_int (buf, D.33524);
        goto <D.33517>;
        <D.33516>:
        buffer_add_int (buf, 0);
        D.33399 = header->code_size;
        buffer_add_int (buf, D.33399);
        <D.33517>:
        i = i + 1;
        <D.29654>:
        D.33497 = header->num_locals;
        D.33501 = (int) D.33497;
        if (D.33501 > i) goto <D.29653>; else goto <D.29655>;
        <D.29655>:
        mono_metadata_free_mh (header);
        if (locals != 0B) goto <D.33525>; else goto <D.33526>;
        <D.33525>:
        mono_debug_symfile_free_locals (locals);
        <D.33526>:
        goto <D.29601>;
      }
      <D.29656>:
      D.33527 = method->flags;
      D.33528 = (unsigned int) D.33527;
      buffer_add_int (buf, D.33528);
      D.33529 = method->iflags;
      D.33530 = (unsigned int) D.33529;
      buffer_add_int (buf, D.33530);
      D.33531 = method->token;
      buffer_add_int (buf, D.33531);
      protocol_version_set.320 = protocol_version_set;
      if (protocol_version_set.320 != 0) goto <D.33534>; else goto <D.33535>;
      <D.33534>:
      major_version.321 = major_version;
      if (major_version.321 > 2) goto <D.33532>; else goto <D.33536>;
      <D.33536>:
      major_version.321 = major_version;
      if (major_version.321 == 2) goto <D.33537>; else goto <D.33533>;
      <D.33537>:
      minor_version.322 = minor_version;
      if (minor_version.322 > 11) goto <D.33532>; else goto <D.33533>;
      <D.33532>:
      {
        guint8 attrs;

        attrs = 0;
        D.33538 = BIT_FIELD_REF <*method, 8, 168>;
        D.33539 = D.33538 & 8;
        if (D.33539 != 0) goto <D.33540>; else goto <D.33541>;
        <D.33540>:
        attrs = attrs | 1;
        <D.33541>:
        D.33542 = mono_method_signature (method);
        D.33543 = D.33542->generic_param_count;
        if (D.33543 != 0) goto <D.33544>; else goto <D.33545>;
        <D.33544>:
        attrs = attrs | 2;
        <D.33545>:
        buffer_add_byte (buf, attrs);
        D.33538 = BIT_FIELD_REF <*method, 8, 168>;
        D.33546 = D.33538 & 24;
        if (D.33546 != 0) goto <D.33547>; else goto <D.33548>;
        <D.33547>:
        {
          struct MonoMethod * result;

          D.33538 = BIT_FIELD_REF <*method, 8, 168>;
          D.33539 = D.33538 & 8;
          if (D.33539 != 0) goto <D.33549>; else goto <D.33550>;
          <D.33549>:
          result = method;
          goto <D.33551>;
          <D.33550>:
          {
            struct MonoMethodInflated * imethod;

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

              klass = MEM[(struct MonoMethod *)imethod].klass;
              D.33555 = mono_class_get_context (klass);
              if (D.33555 != 0B) goto <D.33556>; else goto <D.33557>;
              <D.33556>:
              D.33558 = mono_class_get_context (klass);
              result = mono_class_inflate_generic_method_full (result, klass, D.33558);
              <D.33557>:
            }
            <D.33554>:
          }
          <D.33551>:
          buffer_add_methodid (buf, domain, result);
        }
        goto <D.33559>;
        <D.33548>:
        buffer_add_id (buf, 0);
        <D.33559>:
        protocol_version_set.320 = protocol_version_set;
        if (protocol_version_set.320 != 0) goto <D.33562>; else goto <D.33563>;
        <D.33562>:
        major_version.321 = major_version;
        if (major_version.321 > 2) goto <D.33560>; else goto <D.33564>;
        <D.33564>:
        major_version.321 = major_version;
        if (major_version.321 == 2) goto <D.33565>; else goto <D.33561>;
        <D.33565>:
        minor_version.322 = minor_version;
        if (minor_version.322 > 14) goto <D.33560>; else goto <D.33561>;
        <D.33560>:
        D.33566 = mono_method_signature (method);
        D.33567 = D.33566->generic_param_count;
        if (D.33567 != 0) goto <D.33568>; else goto <D.33569>;
        <D.33568>:
        {
          int count;
          int i;

          D.33538 = BIT_FIELD_REF <*method, 8, 168>;
          D.33570 = D.33538 & 16;
          if (D.33570 != 0) goto <D.33571>; else goto <D.33572>;
          <D.33571>:
          {
            struct MonoGenericInst * inst;

            D.33573 = mono_method_get_context (method);
            inst = D.33573->method_inst;
            if (inst != 0B) goto <D.33574>; else goto <D.33575>;
            <D.33574>:
            D.33576 = inst->type_argc;
            count = (int) D.33576;
            count.339 = (unsigned int) count;
            buffer_add_int (buf, count.339);
            i = 0;
            goto <D.29665>;
            <D.29664>:
            D.33578 = inst->type_argv[i];
            D.33579 = mono_class_from_mono_type (D.33578);
            buffer_add_typeid (buf, domain, D.33579);
            i = i + 1;
            <D.29665>:
            if (i < count) goto <D.29664>; else goto <D.29666>;
            <D.29666>:
            goto <D.33580>;
            <D.33575>:
            buffer_add_int (buf, 0);
            <D.33580>:
          }
          goto <D.33581>;
          <D.33572>:
          D.33538 = BIT_FIELD_REF <*method, 8, 168>;
          D.33539 = D.33538 & 8;
          if (D.33539 != 0) goto <D.33582>; else goto <D.33583>;
          <D.33582>:
          {
            struct MonoGenericContainer * container;

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

              D.33586 = container->type_params;
              i.340 = (unsigned int) i;
              D.33588 = i.340 * 32;
              param = D.33586 + D.33588;
              D.33394 = method->klass;
              D.33589 = D.33394->image;
              pklass = mono_class_from_generic_parameter (param, D.33589, 1);
              buffer_add_typeid (buf, domain, pklass);
            }
            i = i + 1;
            <D.29671>:
            if (i < count) goto <D.29670>; else goto <D.29672>;
            <D.29672>:
          }
          goto <D.33590>;
          <D.33583>:
          buffer_add_int (buf, 0);
          <D.33590>:
          <D.33581>:
        }
        goto <D.33591>;
        <D.33569>:
        buffer_add_int (buf, 0);
        <D.33591>:
        <D.33561>:
        <D.33563>:
      }
      <D.33533>:
      <D.33535>:
      goto <D.29601>;
      <D.29673>:
      {
        int i;

        header = mono_method_get_header (method);
        if (header == 0B) goto <D.33592>; else goto <D.33593>;
        <D.33592>:
        buffer_add_int (buf, 0);
        protocol_version_set.320 = protocol_version_set;
        if (protocol_version_set.320 != 0) goto <D.33596>; else goto <D.33597>;
        <D.33596>:
        major_version.321 = major_version;
        if (major_version.321 > 2) goto <D.33594>; else goto <D.33598>;
        <D.33598>:
        major_version.321 = major_version;
        if (major_version.321 == 2) goto <D.33599>; else goto <D.33595>;
        <D.33599>:
        minor_version.322 = minor_version;
        if (minor_version.322 > 17) goto <D.33594>; else goto <D.33595>;
        <D.33594>:
        buffer_add_int (buf, 0);
        <D.33595>:
        <D.33597>:
        goto <D.33600>;
        <D.33593>:
        D.33399 = header->code_size;
        buffer_add_int (buf, D.33399);
        i = 0;
        goto <D.29676>;
        <D.29675>:
        D.33601 = header->code;
        i.341 = (sizetype) i;
        D.33603 = D.33601 + i.341;
        D.33604 = *D.33603;
        buffer_add_byte (buf, D.33604);
        i = i + 1;
        <D.29676>:
        i.342 = (unsigned int) i;
        D.33399 = header->code_size;
        if (i.342 < D.33399) goto <D.29675>; else goto <D.29677>;
        <D.29677>:
        protocol_version_set.320 = protocol_version_set;
        if (protocol_version_set.320 != 0) goto <D.33607>; else goto <D.33608>;
        <D.33607>:
        major_version.321 = major_version;
        if (major_version.321 > 2) goto <D.33606>; else goto <D.33609>;
        <D.33609>:
        major_version.321 = major_version;
        if (major_version.321 == 2) goto <D.33610>; else goto <D.29681>;
        <D.33610>:
        minor_version.322 = minor_version;
        if (minor_version.322 > 17) goto <D.33606>; else goto <D.29681>;
        <D.33606>:
        D.33611 = header->num_clauses;
        D.33612 = (unsigned int) D.33611;
        buffer_add_int (buf, D.33612);
        i = 0;
        goto <D.29680>;
        <D.29679>:
        {
          struct MonoExceptionClause * clause;

          D.33613 = header->clauses;
          i.343 = (unsigned int) i;
          D.33615 = i.343 * 24;
          clause = D.33613 + D.33615;
          D.33616 = clause->flags;
          buffer_add_int (buf, D.33616);
          D.33617 = clause->try_offset;
          buffer_add_int (buf, D.33617);
          D.33618 = clause->try_len;
          buffer_add_int (buf, D.33618);
          D.33619 = clause->handler_offset;
          buffer_add_int (buf, D.33619);
          D.33620 = clause->handler_len;
          buffer_add_int (buf, D.33620);
          D.33616 = clause->flags;
          if (D.33616 == 0) goto <D.33621>; else goto <D.33622>;
          <D.33621>:
          D.33623 = clause->data.catch_class;
          buffer_add_typeid (buf, domain, D.33623);
          goto <D.33624>;
          <D.33622>:
          D.33616 = clause->flags;
          if (D.33616 == 1) goto <D.33625>; else goto <D.33626>;
          <D.33625>:
          D.33627 = clause->data.filter_offset;
          buffer_add_int (buf, D.33627);
          <D.33626>:
          <D.33624>:
        }
        i = i + 1;
        <D.29680>:
        D.33611 = header->num_clauses;
        D.33628 = (int) D.33611;
        if (D.33628 > i) goto <D.29679>; else goto <D.29681>;
        <D.29681>:
        <D.33608>:
        mono_metadata_free_mh (header);
        <D.33600>:
        goto <D.29601>;
      }
      <D.29682>:
      {
        guint32 token;

        p.344 = p;
        D.33630 = decode_int (p.344, &p, end);
        token = (guint32) D.33630;
        D.33631 = token & 4278190080;
        switch (D.33631) <default: <D.29688>, case 1879048192: <D.29684>>
        <D.29684>:
        {
          struct MonoString * s;
          char * s2;

          D.33394 = method->klass;
          D.33589 = D.33394->image;
          D.33632 = token & 16777215;
          s = mono_ldstr (domain, D.33589, D.33632);
          D.33633 = s == 0B;
          D.33634 = (long int) D.33633;
          D.33635 = __builtin_expect (D.33634, 0);
          if (D.33635 != 0) goto <D.33636>; else goto <D.33637>;
          <D.33636>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 8237, "s");
          <D.33637>:
          s2 = mono_string_to_utf8 (s);
          buffer_add_byte (buf, 0);
          buffer_add_string (buf, s2);
          monoeg_g_free (s2);
          goto <D.29687>;
        }
        <D.29688>:
        {
          void * val;
          struct MonoClass * handle_class;

          try
            {
              D.33638 = BIT_FIELD_REF <*method, 8, 160>;
              D.33639 = D.33638 & 124;
              if (D.33639 == 68) goto <D.33640>; else goto <D.33641>;
              <D.33640>:
              val = mono_method_get_wrapper_data (method, token);
              D.33642 = token + 1;
              handle_class.345 = mono_method_get_wrapper_data (method, D.33642);
              handle_class = handle_class.345;
              handle_class.346 = handle_class;
              if (handle_class.346 == 0B) goto <D.33645>; else goto <D.33646>;
              <D.33645>:
              buffer_add_byte (buf, 4);
              goto <D.29687>;
              <D.33646>:
              goto <D.33647>;
              <D.33641>:
              D.33394 = method->klass;
              D.33589 = D.33394->image;
              val = mono_ldtoken (D.33589, token, &handle_class, 0B);
              D.33648 = val == 0B;
              D.33649 = (long int) D.33648;
              D.33650 = __builtin_expect (D.33649, 0);
              if (D.33650 != 0) goto <D.33651>; else goto <D.33652>;
              <D.33651>:
              monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 8261, "val");
              <D.33652>:
              <D.33647>:
              D.33653 = mono_defaults.typehandle_class;
              handle_class.346 = handle_class;
              if (D.33653 == handle_class.346) goto <D.33654>; else goto <D.33655>;
              <D.33654>:
              buffer_add_byte (buf, 1);
              D.33638 = BIT_FIELD_REF <*method, 8, 160>;
              D.33639 = D.33638 & 124;
              if (D.33639 == 68) goto <D.33656>; else goto <D.33657>;
              <D.33656>:
              buffer_add_typeid (buf, domain, val);
              goto <D.33658>;
              <D.33657>:
              D.33659 = mono_class_from_mono_type (val);
              buffer_add_typeid (buf, domain, D.33659);
              <D.33658>:
              goto <D.33660>;
              <D.33655>:
              D.33661 = mono_defaults.fieldhandle_class;
              handle_class.346 = handle_class;
              if (D.33661 == handle_class.346) goto <D.33662>; else goto <D.33663>;
              <D.33662>:
              buffer_add_byte (buf, 2);
              buffer_add_fieldid (buf, domain, val);
              goto <D.33664>;
              <D.33663>:
              D.33665 = mono_defaults.methodhandle_class;
              handle_class.346 = handle_class;
              if (D.33665 == handle_class.346) goto <D.33666>; else goto <D.33667>;
              <D.33666>:
              buffer_add_byte (buf, 3);
              buffer_add_methodid (buf, domain, val);
              goto <D.33668>;
              <D.33667>:
              D.33669 = mono_defaults.string_class;
              handle_class.346 = handle_class;
              if (D.33669 == handle_class.346) goto <D.33670>; else goto <D.33671>;
              <D.33670>:
              {
                char * s;

                s = mono_string_to_utf8 (val);
                buffer_add_byte (buf, 0);
                buffer_add_string (buf, s);
                monoeg_g_free (s);
              }
              goto <D.33672>;
              <D.33671>:
              monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "debugger-agent.c", 8284);
              <D.33672>:
              <D.33668>:
              <D.33664>:
              <D.33660>:
              goto <D.29687>;
            }
          finally
            {
              handle_class = {CLOBBER};
            }
        }
        <D.29687>:
        goto <D.29601>;
      }
      <D.29692>:
      {
        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.33674>; else goto <D.33675>;
        <D.33674>:
        err.347 = err;
        D.33496 = (ErrorCode) err.347;
        return D.33496;
        <D.33675>:
        cinfo = mono_custom_attrs_from_method (method);
        D.33394 = method->klass;
        D.33589 = D.33394->image;
        buffer_add_cattrs (buf, domain, D.33589, attr_klass, cinfo);
        goto <D.29601>;
      }
      <D.29695>:
      {
        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.33677 = type_argc.348 * 4;
            type_argv = monoeg_malloc0 (D.33677);
            i = 0;
            goto <D.29705>;
            <D.29704>:
            p.344 = p;
            klass = decode_typeid (p.344, &p, end, &d, &err);
            err.347 = err;
            if (err.347 != 0) goto <D.33678>; else goto <D.33679>;
            <D.33678>:
            monoeg_g_free (type_argv);
            err.347 = err;
            D.33496 = (ErrorCode) err.347;
            return D.33496;
            <D.33679>:
            d.349 = d;
            if (domain != d.349) goto <D.33681>; else goto <D.33682>;
            <D.33681>:
            monoeg_g_free (type_argv);
            D.33496 = 102;
            return D.33496;
            <D.33682>:
            i.350 = (unsigned int) i;
            D.33684 = i.350 * 4;
            D.33685 = type_argv + D.33684;
            D.33686 = &klass->byval_arg;
            *D.33685 = D.33686;
            i = i + 1;
            <D.29705>:
            if (i < type_argc) goto <D.29704>; else goto <D.29706>;
            <D.29706>:
            ginst = mono_metadata_get_generic_inst (type_argc, type_argv);
            monoeg_g_free (type_argv);
            D.33394 = method->klass;
            D.33688 = D.33394->generic_class;
            if (D.33688 != 0B) goto <D.33689>; else goto <D.33690>;
            <D.33689>:
            D.33394 = method->klass;
            D.33688 = D.33394->generic_class;
            iftmp.351 = D.33688->context.class_inst;
            goto <D.33691>;
            <D.33690>:
            iftmp.351 = 0B;
            <D.33691>:
            tmp_context.class_inst = iftmp.351;
            tmp_context.method_inst = ginst;
            inflated = mono_class_inflate_generic_method (method, &tmp_context);
            D.33692 = mono_verifier_is_method_valid_generic_instantiation (inflated);
            if (D.33692 == 0) goto <D.33693>; else goto <D.33694>;
            <D.33693>:
            D.33496 = 102;
            return D.33496;
            <D.33694>:
            buffer_add_methodid (buf, domain, inflated);
            goto <D.29601>;
          }
        finally
          {
            d = {CLOBBER};
            tmp_context = {CLOBBER};
          }
      }
      <D.29707>:
      D.33496 = 100;
      return D.33496;
      <D.29601>:
      D.33496 = 0;
      return D.33496;
    }
  finally
    {
      err = {CLOBBER};
    }
}


thread_commands (int command, guint8 * p, guint8 * end, struct Buffer * buf)
{
  guint8 * p.352;
  <unnamed type> D.33702;
  ErrorCode D.33705;
  struct MonoThread * thread_obj.353;
  unsigned int name_len.354;
  long int name_len.355;
  _Bool D.33712;
  long int D.33713;
  long int D.33714;
  long int len.356;
  unsigned int len.357;
  int suspend_count.358;
  int D.33722;
  _Bool D.33723;
  _Bool D.33724;
  _Bool D.33725;
  struct MonoGHashTable * thread_to_tls.359;
  _Bool D.33729;
  long int D.33730;
  long int D.33731;
  int D.33734;
  unsigned int D.33735;
  struct StackFrame * * D.33736;
  unsigned int i.360;
  unsigned int D.33738;
  struct StackFrame * * D.33739;
  struct StackFrame * D.33740;
  int D.33741;
  unsigned int D.33742;
  struct MonoDomain * D.33743;
  struct MonoMethod * D.33744;
  unsigned int D.33745;
  int D.33746;
  unsigned char D.33747;
  unsigned int D.33748;
  unsigned char D.33749;
  unsigned int thread.361;
  long long unsigned int D.33751;
  long long unsigned int D.33752;
  int objid;
  int err;
  struct MonoThread * thread_obj;
  struct MonoInternalThread * thread;

  try
    {
      p.352 = p;
      objid = decode_objid (p.352, &p, end);
      D.33702 = get_object (objid, &thread_obj);
      err = (int) D.33702;
      if (err != 0) goto <D.33703>; else goto <D.33704>;
      <D.33703>:
      D.33705 = (ErrorCode) err;
      return D.33705;
      <D.33704>:
      thread_obj.353 = thread_obj;
      thread = thread_obj.353->internal_thread;
      switch (command) <default: <D.29749>, case 1: <D.29734>, case 2: <D.29728>, case 3: <D.29745>, case 4: <D.29746>, case 5: <D.29747>, case 6: <D.29748>>
      <D.29728>:
      {
        guint32 name_len;
        gunichar2 * s;

        try
          {
            s = mono_thread_get_name (thread, &name_len);
            if (s == 0B) goto <D.33707>; else goto <D.33708>;
            <D.33707>:
            buffer_add_int (buf, 0);
            goto <D.33709>;
            <D.33708>:
            {
              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.33712 = name == 0B;
                  D.33713 = (long int) D.33712;
                  D.33714 = __builtin_expect (D.33713, 0);
                  if (D.33714 != 0) goto <D.33715>; else goto <D.33716>;
                  <D.33715>:
                  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 8395, "name");
                  <D.33716>:
                  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.33709>:
            goto <D.29733>;
          }
        finally
          {
            name_len = {CLOBBER};
          }
      }
      <D.29734>:
      {
        struct DebuggerTlsData * tls;
        int i;
        int start_frame;
        int length;

        goto <D.29740>;
        <D.29739>:
        suspend_count.358 = suspend_count;
        if (suspend_count.358 != 0) goto <D.33720>; else goto <D.33721>;
        <D.33720>:
        wait_for_suspend ();
        <D.33721>:
        <D.29740>:
        D.33722 = is_suspended ();
        if (D.33722 == 0) goto <D.29739>; else goto <D.29741>;
        <D.29741>:
        p.352 = p;
        start_frame = decode_int (p.352, &p, end);
        p.352 = p;
        length = decode_int (p.352, &p, end);
        D.33723 = start_frame != 0;
        D.33724 = length != -1;
        D.33725 = D.33723 | D.33724;
        if (D.33725 != 0) goto <D.33726>; else goto <D.33727>;
        <D.33726>:
        D.33705 = 100;
        return D.33705;
        <D.33727>:
        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.33729 = tls == 0B;
        D.33730 = (long int) D.33729;
        D.33731 = __builtin_expect (D.33730, 0);
        if (D.33731 != 0) goto <D.33732>; else goto <D.33733>;
        <D.33732>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 8428, "tls");
        <D.33733>:
        compute_frame_info (thread, tls);
        D.33734 = tls->frame_count;
        D.33735 = (unsigned int) D.33734;
        buffer_add_int (buf, D.33735);
        i = 0;
        goto <D.29743>;
        <D.29742>:
        D.33736 = tls->frames;
        i.360 = (unsigned int) i;
        D.33738 = i.360 * 4;
        D.33739 = D.33736 + D.33738;
        D.33740 = *D.33739;
        D.33741 = D.33740->id;
        D.33742 = (unsigned int) D.33741;
        buffer_add_int (buf, D.33742);
        D.33736 = tls->frames;
        i.360 = (unsigned int) i;
        D.33738 = i.360 * 4;
        D.33739 = D.33736 + D.33738;
        D.33740 = *D.33739;
        D.33743 = D.33740->domain;
        D.33736 = tls->frames;
        i.360 = (unsigned int) i;
        D.33738 = i.360 * 4;
        D.33739 = D.33736 + D.33738;
        D.33740 = *D.33739;
        D.33744 = D.33740->actual_method;
        buffer_add_methodid (buf, D.33743, D.33744);
        D.33736 = tls->frames;
        i.360 = (unsigned int) i;
        D.33738 = i.360 * 4;
        D.33739 = D.33736 + D.33738;
        D.33740 = *D.33739;
        D.33745 = D.33740->il_offset;
        buffer_add_int (buf, D.33745);
        D.33736 = tls->frames;
        i.360 = (unsigned int) i;
        D.33738 = i.360 * 4;
        D.33739 = D.33736 + D.33738;
        D.33740 = *D.33739;
        D.33746 = D.33740->flags;
        D.33747 = (unsigned char) D.33746;
        buffer_add_byte (buf, D.33747);
        i = i + 1;
        <D.29743>:
        D.33734 = tls->frame_count;
        if (D.33734 > i) goto <D.29742>; else goto <D.29744>;
        <D.29744>:
        goto <D.29733>;
      }
      <D.29745>:
      D.33748 = thread->state;
      buffer_add_int (buf, D.33748);
      goto <D.29733>;
      <D.29746>:
      D.33749 = thread->threadpool_thread;
      buffer_add_byte (buf, D.33749);
      goto <D.29733>;
      <D.29747>:
      thread.361 = (unsigned int) thread;
      D.33751 = (long long unsigned int) thread.361;
      buffer_add_long (buf, D.33751);
      goto <D.29733>;
      <D.29748>:
      D.33752 = thread->tid;
      buffer_add_long (buf, D.33752);
      goto <D.29733>;
      <D.29749>:
      D.33705 = 100;
      return D.33705;
      <D.29733>:
      D.33705 = 0;
      return D.33705;
    }
  finally
    {
      thread_obj = {CLOBBER};
    }
}


frame_commands (int command, guint8 * p, guint8 * end, struct Buffer * buf)
{
  guint8 * p.362;
  <unnamed type> D.33758;
  ErrorCode D.33761;
  struct MonoThread * thread_obj.363;
  struct MonoGHashTable * thread_to_tls.364;
  _Bool D.33764;
  long int D.33765;
  long int D.33766;
  struct StackFrame * * D.33769;
  unsigned int i.365;
  unsigned int D.33771;
  struct StackFrame * * D.33772;
  struct StackFrame * D.33773;
  int D.33774;
  int D.33776;
  unsigned int frame_idx.366;
  unsigned int D.33780;
  struct StackFrame * * D.33781;
  int D.33782;
  struct MonoDebugMethodJitInfo * D.33785;
  struct MonoMethod * D.33788;
  struct MonoDomain * D.33789;
  struct MonoDebugMethodJitInfo * D.33790;
  unsigned char D.33793;
  unsigned char D.33794;
  struct MonoMethod * D.33797;
  struct MonoDebugMethodJitInfo * D.33798;
  int log_level.367;
  _Bool D.33802;
  long int D.33803;
  long int D.33804;
  struct FILE * log_file.368;
  struct MonoMethod * D.33808;
  struct MonoSeqPointInfo * D.33809;
  int iftmp.369;
  unsigned int pos.370;
  unsigned int D.33820;
  _Bool D.33821;
  long int D.33822;
  long int D.33823;
  struct MonoDebugVarInfo * D.33826;
  unsigned int pos.371;
  unsigned int D.33828;
  struct MonoType * D.33829;
  struct MonoDebugVarInfo * D.33830;
  struct MonoContext * D.33831;
  int iftmp.372;
  unsigned int D.33838;
  _Bool D.33839;
  long int D.33840;
  long int D.33841;
  struct MonoDebugVarInfo * D.33844;
  struct MonoType * D.33845;
  struct MonoDebugVarInfo * D.33846;
  struct MonoClass * D.33847;
  unsigned char D.33848;
  unsigned char D.33849;
  unsigned char D.33852;
  unsigned char D.33853;
  struct MonoClass * D.33856;
  struct MonoType * D.33857;
  struct MonoClass * D.33859;
  struct MonoType * D.33860;
  struct MonoDebugVarInfo * D.33861;
  struct MonoType * D.33865;
  struct MonoType * D.33867;
  int iftmp.373;
  _Bool D.33875;
  long int D.33876;
  long int D.33877;
  int iftmp.374;
  _Bool D.33886;
  long int D.33887;
  long int D.33888;
  int D.33891;
  struct MonoClass * D.33895;
  int D.33896;
  unsigned int D.33897;
  <unnamed type> D.33898;
  mgreg_t *[16] * D.33901;
  struct MonoContext * D.33902;
  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.33758 = get_object (objid, &thread_obj);
      err = (int) D.33758;
      if (err != 0) goto <D.33759>; else goto <D.33760>;
      <D.33759>:
      D.33761 = (ErrorCode) err;
      return D.33761;
      <D.33760>:
      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.33764 = tls == 0B;
      D.33765 = (long int) D.33764;
      D.33766 = __builtin_expect (D.33765, 0);
      if (D.33766 != 0) goto <D.33767>; else goto <D.33768>;
      <D.33767>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 8495, "tls");
      <D.33768>:
      i = 0;
      goto <D.29773>;
      <D.29772>:
      D.33769 = tls->frames;
      i.365 = (unsigned int) i;
      D.33771 = i.365 * 4;
      D.33772 = D.33769 + D.33771;
      D.33773 = *D.33772;
      D.33774 = D.33773->id;
      if (D.33774 == id) goto <D.29771>; else goto <D.33775>;
      <D.33775>:
      i = i + 1;
      <D.29773>:
      D.33776 = tls->frame_count;
      if (D.33776 > i) goto <D.29772>; else goto <D.29771>;
      <D.29771>:
      D.33776 = tls->frame_count;
      if (D.33776 == i) goto <D.33777>; else goto <D.33778>;
      <D.33777>:
      D.33761 = 30;
      return D.33761;
      <D.33778>:
      frame_idx = i;
      D.33769 = tls->frames;
      frame_idx.366 = (unsigned int) frame_idx;
      D.33780 = frame_idx.366 * 4;
      D.33781 = D.33769 + D.33780;
      frame = *D.33781;
      D.33782 = frame->has_ctx;
      if (D.33782 == 0) goto <D.33783>; else goto <D.33784>;
      <D.33783>:
      D.33761 = 105;
      return D.33761;
      <D.33784>:
      D.33785 = frame->jit;
      if (D.33785 == 0B) goto <D.33786>; else goto <D.33787>;
      <D.33786>:
      D.33788 = frame->api_method;
      D.33789 = frame->domain;
      D.33790 = mono_debug_find_method (D.33788, D.33789);
      frame->jit = D.33790;
      D.33785 = frame->jit;
      if (D.33785 == 0B) goto <D.33791>; else goto <D.33792>;
      <D.33791>:
      D.33788 = frame->api_method;
      D.33793 = BIT_FIELD_REF <*D.33788, 8, 168>;
      D.33794 = D.33793 & 16;
      if (D.33794 != 0) goto <D.33795>; else goto <D.33796>;
      <D.33795>:
      D.33788 = frame->api_method;
      D.33797 = mono_method_get_declaring_generic_method (D.33788);
      D.33789 = frame->domain;
      D.33798 = mono_debug_find_method (D.33797, D.33789);
      frame->jit = D.33798;
      <D.33796>:
      <D.33792>:
      D.33785 = frame->jit;
      if (D.33785 == 0B) goto <D.33799>; else goto <D.33800>;
      <D.33799>:
      {
        char * s;

        D.33788 = frame->api_method;
        s = mono_method_full_name (D.33788, 1);
        log_level.367 = log_level;
        D.33802 = log_level.367 > 0;
        D.33803 = (long int) D.33802;
        D.33804 = __builtin_expect (D.33803, 0);
        if (D.33804 != 0) goto <D.33805>; else goto <D.33806>;
        <D.33805>:
        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.33806>:
        monoeg_g_free (s);
        D.33761 = 105;
        return D.33761;
      }
      <D.33800>:
      <D.33787>:
      jit = frame->jit;
      D.33808 = frame->actual_method;
      sig = mono_method_signature (D.33808);
      D.33789 = frame->domain;
      D.33808 = frame->actual_method;
      D.33809 = get_seq_points (D.33789, D.33808);
      if (D.33809 == 0B) goto <D.33810>; else goto <D.33811>;
      <D.33810>:
      D.33761 = 105;
      return D.33761;
      <D.33811>:
      switch (command) <default: <D.29790>, case 1: <D.29775>, case 2: <D.29780>, case 3: <D.29783>>
      <D.29775>:
      p.362 = p;
      len = decode_int (p.362, &p, end);
      D.33808 = frame->actual_method;
      header = mono_method_get_header (D.33808);
      i = 0;
      goto <D.29777>;
      <D.29776>:
      p.362 = p;
      pos = decode_int (p.362, &p, end);
      if (pos < 0) goto <D.33812>; else goto <D.33813>;
      <D.33812>:
      pos = ~pos;
      if (pos < 0) goto <D.33815>; else goto <D.33818>;
      <D.33818>:
      pos.370 = (unsigned int) pos;
      D.33820 = jit->num_params;
      if (pos.370 >= D.33820) goto <D.33815>; else goto <D.33816>;
      <D.33815>:
      iftmp.369 = 1;
      goto <D.33817>;
      <D.33816>:
      iftmp.369 = 0;
      <D.33817>:
      D.33821 = iftmp.369 != 0;
      D.33822 = (long int) D.33821;
      D.33823 = __builtin_expect (D.33822, 0);
      if (D.33823 != 0) goto <D.33824>; else goto <D.33825>;
      <D.33824>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 8545, "pos >= 0 && pos < jit->num_params");
      <D.33825>:
      D.33826 = jit->params;
      pos.371 = (unsigned int) pos;
      D.33828 = pos.371 * 24;
      var = D.33826 + D.33828;
      D.33829 = sig->params[pos];
      D.33826 = jit->params;
      pos.371 = (unsigned int) pos;
      D.33828 = pos.371 * 24;
      D.33830 = D.33826 + D.33828;
      D.33831 = &frame->ctx;
      D.33789 = frame->domain;
      add_var (buf, jit, D.33829, D.33830, D.33831, D.33789, 0);
      goto <D.33832>;
      <D.33813>:
      if (pos < 0) goto <D.33834>; else goto <D.33837>;
      <D.33837>:
      pos.370 = (unsigned int) pos;
      D.33838 = jit->num_locals;
      if (pos.370 >= D.33838) goto <D.33834>; else goto <D.33835>;
      <D.33834>:
      iftmp.372 = 1;
      goto <D.33836>;
      <D.33835>:
      iftmp.372 = 0;
      <D.33836>:
      D.33839 = iftmp.372 != 0;
      D.33840 = (long int) D.33839;
      D.33841 = __builtin_expect (D.33840, 0);
      if (D.33841 != 0) goto <D.33842>; else goto <D.33843>;
      <D.33842>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 8551, "pos >= 0 && pos < jit->num_locals");
      <D.33843>:
      D.33844 = jit->locals;
      pos.371 = (unsigned int) pos;
      D.33828 = pos.371 * 24;
      var = D.33844 + D.33828;
      D.33845 = header->locals[pos];
      D.33844 = jit->locals;
      pos.371 = (unsigned int) pos;
      D.33828 = pos.371 * 24;
      D.33846 = D.33844 + D.33828;
      D.33831 = &frame->ctx;
      D.33789 = frame->domain;
      add_var (buf, jit, D.33845, D.33846, D.33831, D.33789, 0);
      <D.33832>:
      i = i + 1;
      <D.29777>:
      if (i < len) goto <D.29776>; else goto <D.29778>;
      <D.29778>:
      mono_metadata_free_mh (header);
      goto <D.29779>;
      <D.29780>:
      D.33788 = frame->api_method;
      D.33847 = D.33788->klass;
      D.33848 = BIT_FIELD_REF <*D.33847, 8, 160>;
      D.33849 = D.33848 & 8;
      if (D.33849 != 0) goto <D.33850>; else goto <D.33851>;
      <D.33850>:
      D.33852 = BIT_FIELD_REF <*sig, 8, 80>;
      D.33853 = D.33852 & 64;
      if (D.33853 == 0) goto <D.33854>; else goto <D.33855>;
      <D.33854>:
      {
        struct MonoObject * p;

        try
          {
            p = 0B;
            D.33856 = mono_defaults.object_class;
            D.33857 = &D.33856->byval_arg;
            D.33789 = frame->domain;
            buffer_add_value (buf, D.33857, &p, D.33789);
          }
        finally
          {
            p = {CLOBBER};
          }
      }
      goto <D.33858>;
      <D.33855>:
      D.33808 = frame->actual_method;
      D.33859 = D.33808->klass;
      D.33860 = &D.33859->this_arg;
      D.33861 = jit->this_var;
      D.33831 = &frame->ctx;
      D.33789 = frame->domain;
      add_var (buf, jit, D.33860, D.33861, D.33831, D.33789, 1);
      <D.33858>:
      goto <D.33862>;
      <D.33851>:
      D.33852 = BIT_FIELD_REF <*sig, 8, 80>;
      D.33853 = D.33852 & 64;
      if (D.33853 == 0) goto <D.33863>; else goto <D.33864>;
      <D.33863>:
      {
        struct MonoObject * p;

        try
          {
            p = 0B;
            D.33808 = frame->actual_method;
            D.33859 = D.33808->klass;
            D.33865 = &D.33859->byval_arg;
            D.33789 = frame->domain;
            buffer_add_value (buf, D.33865, &p, D.33789);
          }
        finally
          {
            p = {CLOBBER};
          }
      }
      goto <D.33866>;
      <D.33864>:
      D.33788 = frame->api_method;
      D.33847 = D.33788->klass;
      D.33867 = &D.33847->byval_arg;
      D.33861 = jit->this_var;
      D.33831 = &frame->ctx;
      D.33789 = frame->domain;
      add_var (buf, jit, D.33867, D.33861, D.33831, D.33789, 1);
      <D.33866>:
      <D.33862>:
      goto <D.29779>;
      <D.29783>:
      {
        guint8 * val_buf;
        struct MonoType * t;
        struct MonoDebugVarInfo * var;

        p.362 = p;
        len = decode_int (p.362, &p, end);
        D.33808 = frame->actual_method;
        header = mono_method_get_header (D.33808);
        i = 0;
        goto <D.29788>;
        <D.29787>:
        p.362 = p;
        pos = decode_int (p.362, &p, end);
        if (pos < 0) goto <D.33868>; else goto <D.33869>;
        <D.33868>:
        pos = ~pos;
        if (pos < 0) goto <D.33871>; else goto <D.33874>;
        <D.33874>:
        pos.370 = (unsigned int) pos;
        D.33820 = jit->num_params;
        if (pos.370 >= D.33820) goto <D.33871>; else goto <D.33872>;
        <D.33871>:
        iftmp.373 = 1;
        goto <D.33873>;
        <D.33872>:
        iftmp.373 = 0;
        <D.33873>:
        D.33875 = iftmp.373 != 0;
        D.33876 = (long int) D.33875;
        D.33877 = __builtin_expect (D.33876, 0);
        if (D.33877 != 0) goto <D.33878>; else goto <D.33879>;
        <D.33878>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 8593, "pos >= 0 && pos < jit->num_params");
        <D.33879>:
        t = sig->params[pos];
        D.33826 = jit->params;
        pos.371 = (unsigned int) pos;
        D.33828 = pos.371 * 24;
        var = D.33826 + D.33828;
        goto <D.33880>;
        <D.33869>:
        if (pos < 0) goto <D.33882>; else goto <D.33885>;
        <D.33885>:
        pos.370 = (unsigned int) pos;
        D.33838 = jit->num_locals;
        if (pos.370 >= D.33838) goto <D.33882>; else goto <D.33883>;
        <D.33882>:
        iftmp.374 = 1;
        goto <D.33884>;
        <D.33883>:
        iftmp.374 = 0;
        <D.33884>:
        D.33886 = iftmp.374 != 0;
        D.33887 = (long int) D.33886;
        D.33888 = __builtin_expect (D.33887, 0);
        if (D.33888 != 0) goto <D.33889>; else goto <D.33890>;
        <D.33889>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 8598, "pos >= 0 && pos < jit->num_locals");
        <D.33890>:
        t = header->locals[pos];
        D.33844 = jit->locals;
        pos.371 = (unsigned int) pos;
        D.33828 = pos.371 * 24;
        var = D.33844 + D.33828;
        <D.33880>:
        D.33891 = mono_type_is_reference (t);
        if (D.33891 != 0) goto <D.33892>; else goto <D.33893>;
        <D.33892>:
        val_buf = __builtin_alloca (4);
        goto <D.33894>;
        <D.33893>:
        D.33895 = mono_class_from_mono_type (t);
        D.33896 = mono_class_instance_size (D.33895);
        D.33897 = (unsigned int) D.33896;
        val_buf = __builtin_alloca (D.33897);
        <D.33894>:
        D.33789 = frame->domain;
        p.362 = p;
        D.33898 = decode_value (t, D.33789, val_buf, p.362, &p, end);
        err = (int) D.33898;
        if (err != 0) goto <D.33899>; else goto <D.33900>;
        <D.33899>:
        D.33761 = (ErrorCode) err;
        return D.33761;
        <D.33900>:
        D.33831 = &frame->ctx;
        D.33789 = frame->domain;
        D.33901 = &frame->reg_locations;
        D.33902 = &tls->restore_ctx;
        set_var (t, var, D.33831, D.33789, val_buf, D.33901, D.33902);
        i = i + 1;
        <D.29788>:
        if (i < len) goto <D.29787>; else goto <D.29789>;
        <D.29789>:
        mono_metadata_free_mh (header);
        goto <D.29779>;
      }
      <D.29790>:
      D.33761 = 100;
      return D.33761;
      <D.29779>:
      D.33761 = 0;
      return D.33761;
    }
  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.33905;
  int D.33906;
  int reg_val.375;
  int D.33908;
  unsigned int D.33909;
  int D.33910;
  _Bool D.33911;
  long int D.33912;
  long int D.33913;
  _Bool D.33916;
  long int D.33917;
  long int D.33918;
  _Bool D.33921;
  long int D.33922;
  long int D.33923;
  unsigned int D.33926;
  int D.33927;
  int D.33930;
  unsigned int D.33931;
  int D.33935;
  _Bool D.33937;
  long int D.33938;
  long int D.33939;
  unsigned int D.33942;
  int D.33943;
  int D.33946;
  unsigned int D.33947;
  int D.33951;
  _Bool D.33953;
  long int D.33954;
  long int D.33955;
  void * D.33958;
  sizetype D.33959;
  guint32 flags;
  int reg;
  guint8 * addr;
  guint8 * gaddr;
  mgreg_t reg_val;

  try
    {
      D.33905 = var->index;
      flags = D.33905 & 4026531840;
      D.33905 = var->index;
      D.33906 = (int) D.33905;
      reg = D.33906 & 268435455;
      switch (flags) <default: <D.28934>, case 0: <D.28922>, case 268435456: <D.28924>, case 805306368: <D.28925>, case 1073741824: <D.28926>, case 1342177280: <D.28928>, case 1610612736: <D.28927>>
      <D.28922>:
      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.28923>;
      <D.28924>:
      D.33908 = mono_arch_context_get_int_reg (ctx, reg);
      addr = (guint8 *) D.33908;
      D.33909 = var->offset;
      addr = addr + D.33909;
      buffer_add_value_full (buf, t, addr, domain, as_vtype);
      goto <D.28923>;
      <D.28925>:
      monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "debugger-agent.c", 5939);
      <D.28926>:
      <D.28927>:
      D.33910 = mono_arch_context_get_int_reg (ctx, reg);
      addr = (guint8 *) D.33910;
      D.33909 = var->offset;
      addr = addr + D.33909;
      gaddr = MEM[(void * *)addr];
      D.33911 = gaddr == 0B;
      D.33912 = (long int) D.33911;
      D.33913 = __builtin_expect (D.33912, 0);
      if (D.33913 != 0) goto <D.33914>; else goto <D.33915>;
      <D.33914>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 5948, "gaddr");
      <D.33915>:
      buffer_add_value_full (buf, t, gaddr, domain, as_vtype);
      goto <D.28923>;
      <D.28928>:
      {
        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.33916 = info_var == 0B;
        D.33917 = (long int) D.33916;
        D.33918 = __builtin_expect (D.33917, 0);
        if (D.33918 != 0) goto <D.33919>; else goto <D.33920>;
        <D.33919>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 5960, "info_var");
        <D.33920>:
        D.33921 = locals_var == 0B;
        D.33922 = (long int) D.33921;
        D.33923 = __builtin_expect (D.33922, 0);
        if (D.33923 != 0) goto <D.33924>; else goto <D.33925>;
        <D.33924>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 5961, "locals_var");
        <D.33925>:
        D.33926 = info_var->index;
        flags = D.33926 & 4026531840;
        D.33926 = info_var->index;
        D.33927 = (int) D.33926;
        reg = D.33927 & 268435455;
        if (flags == 268435456) goto <D.33928>; else goto <D.33929>;
        <D.33928>:
        D.33930 = mono_arch_context_get_int_reg (ctx, reg);
        addr = (guint8 *) D.33930;
        D.33931 = info_var->offset;
        addr = addr + D.33931;
        info = MEM[(void * *)addr];
        goto <D.33932>;
        <D.33929>:
        if (flags == 0) goto <D.33933>; else goto <D.33934>;
        <D.33933>:
        D.33935 = mono_arch_context_get_int_reg (ctx, reg);
        info = (struct MonoGSharedVtMethodRuntimeInfo *) D.33935;
        goto <D.33936>;
        <D.33934>:
        monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "debugger-agent.c", 5972);
        <D.33936>:
        <D.33932>:
        D.33937 = info == 0B;
        D.33938 = (long int) D.33937;
        D.33939 = __builtin_expect (D.33938, 0);
        if (D.33939 != 0) goto <D.33940>; else goto <D.33941>;
        <D.33940>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 5974, "info");
        <D.33941>:
        D.33942 = locals_var->index;
        flags = D.33942 & 4026531840;
        D.33942 = locals_var->index;
        D.33943 = (int) D.33942;
        reg = D.33943 & 268435455;
        if (flags == 268435456) goto <D.33944>; else goto <D.33945>;
        <D.33944>:
        D.33946 = mono_arch_context_get_int_reg (ctx, reg);
        addr = (guint8 *) D.33946;
        D.33947 = locals_var->offset;
        addr = addr + D.33947;
        locals = MEM[(void * *)addr];
        goto <D.33948>;
        <D.33945>:
        if (flags == 0) goto <D.33949>; else goto <D.33950>;
        <D.33949>:
        D.33951 = mono_arch_context_get_int_reg (ctx, reg);
        locals = (guint8 *) D.33951;
        goto <D.33952>;
        <D.33950>:
        monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "debugger-agent.c", 5985);
        <D.33952>:
        <D.33948>:
        D.33953 = locals == 0B;
        D.33954 = (long int) D.33953;
        D.33955 = __builtin_expect (D.33954, 0);
        if (D.33955 != 0) goto <D.33956>; else goto <D.33957>;
        <D.33956>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 5987, "locals");
        <D.33957>:
        D.33958 = info->entries[idx];
        D.33959 = (sizetype) D.33958;
        addr = locals + D.33959;
        buffer_add_value_full (buf, t, addr, domain, as_vtype);
        goto <D.28923>;
      }
      <D.28934>:
      monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "debugger-agent.c", 5996);
      <D.28923>:
    }
  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.33960;
  int D.33961;
  int D.33962;
  struct MonoClass * D.33966;
  unsigned char D.33967;
  unsigned char D.33968;
  int D.33971;
  unsigned int size.376;
  unsigned char D.33979;
  _Bool D.33980;
  _Bool D.33981;
  _Bool D.33982;
  unsigned char D.33984;
  int iftmp.377;
  signed char D.33989;
  unsigned char D.33991;
  int iftmp.378;
  short int D.33995;
  short unsigned int D.33997;
  mgreg_t iftmp.379;
  long long int D.34001;
  long long unsigned int D.34003;
  unsigned int reg.380;
  unsigned int D.34005;
  mgreg_t * * D.34006;
  mgreg_t * D.34007;
  int log_level.381;
  _Bool D.34011;
  long int D.34012;
  long int D.34013;
  struct FILE * log_file.382;
  void * v.383;
  int D.34021;
  unsigned int D.34022;
  int D.34026;
  _Bool D.34027;
  long int D.34028;
  long int D.34029;
  guint32 flags;
  int reg;
  int size;
  guint8 * addr;
  guint8 * gaddr;

  D.33960 = var->index;
  flags = D.33960 & 4026531840;
  D.33960 = var->index;
  D.33961 = (int) D.33960;
  reg = D.33961 & 268435455;
  D.33962 = mono_type_is_reference (t);
  if (D.33962 != 0) goto <D.33963>; else goto <D.33964>;
  <D.33963>:
  size = 4;
  goto <D.33965>;
  <D.33964>:
  D.33966 = mono_class_from_mono_type (t);
  size = mono_class_value_size (D.33966, 0B);
  <D.33965>:
  switch (flags) <default: <D.28962>, case 0: <D.28949>, case 268435456: <D.28959>, case 805306368: <D.28961>, case 1073741824: <D.28960>>
  <D.28949>:
  {
    mgreg_t v;
    gboolean is_signed;

    is_signed = 0;
    D.33967 = BIT_FIELD_REF <*t, 8, 56>;
    D.33968 = D.33967 & 64;
    if (D.33968 != 0) goto <D.33969>; else goto <D.33970>;
    <D.33969>:
    D.33971 = mono_arch_context_get_int_reg (ctx, reg);
    addr = (guint8 *) D.33971;
    if (addr != 0B) goto <D.33972>; else goto <D.33973>;
    <D.33972>:
    size.376 = (unsigned int) size;
    mono_gc_memmove_atomic (addr, val, size.376);
    <D.33973>:
    goto <D.28952>;
    <D.33970>:
    D.33967 = BIT_FIELD_REF <*t, 8, 56>;
    D.33968 = D.33967 & 64;
    if (D.33968 == 0) goto <D.33977>; else goto <D.33978>;
    <D.33977>:
    D.33979 = t->type;
    D.33980 = D.33979 == 4;
    D.33981 = D.33979 == 6;
    D.33982 = D.33980 | D.33981;
    if (D.33982 != 0) goto <D.33975>; else goto <D.33983>;
    <D.33983>:
    D.33984 = t->type;
    if (D.33984 == 8) goto <D.33975>; else goto <D.33985>;
    <D.33985>:
    D.33984 = t->type;
    if (D.33984 == 10) goto <D.33975>; else goto <D.33976>;
    <D.33975>:
    is_signed = 1;
    <D.33976>:
    <D.33978>:
    switch (size) <default: <D.28958>, case 1: <D.28953>, case 2: <D.28955>, case 4: <D.28956>, case 8: <D.28957>>
    <D.28953>:
    if (is_signed != 0) goto <D.33987>; else goto <D.33988>;
    <D.33987>:
    D.33989 = MEM[(gint8 *)val];
    iftmp.377 = (int) D.33989;
    goto <D.33990>;
    <D.33988>:
    D.33991 = *val;
    iftmp.377 = (int) D.33991;
    <D.33990>:
    v = iftmp.377;
    goto <D.28954>;
    <D.28955>:
    if (is_signed != 0) goto <D.33993>; else goto <D.33994>;
    <D.33993>:
    D.33995 = MEM[(gint16 *)val];
    iftmp.378 = (int) D.33995;
    goto <D.33996>;
    <D.33994>:
    D.33997 = MEM[(guint16 *)val];
    iftmp.378 = (int) D.33997;
    <D.33996>:
    v = iftmp.378;
    goto <D.28954>;
    <D.28956>:
    v = MEM[(gint32 *)val];
    goto <D.28954>;
    <D.28957>:
    if (is_signed != 0) goto <D.33999>; else goto <D.34000>;
    <D.33999>:
    D.34001 = MEM[(gint64 *)val];
    iftmp.379 = (mgreg_t) D.34001;
    goto <D.34002>;
    <D.34000>:
    D.34003 = MEM[(guint64 *)val];
    iftmp.379 = (mgreg_t) D.34003;
    <D.34002>:
    v = iftmp.379;
    goto <D.28954>;
    <D.28958>:
    monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "debugger-agent.c", 6048);
    <D.28954>:
    reg.380 = (unsigned int) reg;
    D.34005 = reg.380 * 4;
    D.34006 = reg_locations + D.34005;
    D.34007 = *D.34006;
    if (D.34007 != 0B) goto <D.34008>; else goto <D.34009>;
    <D.34008>:
    log_level.381 = log_level;
    D.34011 = log_level.381 > 0;
    D.34012 = (long int) D.34011;
    D.34013 = __builtin_expect (D.34012, 0);
    if (D.34013 != 0) goto <D.34014>; else goto <D.34015>;
    <D.34014>:
    log_file.382 = log_file;
    reg.380 = (unsigned int) reg;
    D.34005 = reg.380 * 4;
    D.34006 = reg_locations + D.34005;
    D.34007 = *D.34006;
    v.383 = (void *) v;
    fprintf (log_file.382, "[dbg] Setting stack location %p for reg %x to %p.\n", D.34007, reg, v.383);
    log_file.382 = log_file;
    fflush (log_file.382);
    <D.34015>:
    reg.380 = (unsigned int) reg;
    D.34005 = reg.380 * 4;
    D.34006 = reg_locations + D.34005;
    D.34007 = *D.34006;
    *D.34007 = v;
    goto <D.34018>;
    <D.34009>:
    log_level.381 = log_level;
    D.34011 = log_level.381 > 0;
    D.34012 = (long int) D.34011;
    D.34013 = __builtin_expect (D.34012, 0);
    if (D.34013 != 0) goto <D.34019>; else goto <D.34020>;
    <D.34019>:
    log_file.382 = log_file;
    v.383 = (void *) v;
    fprintf (log_file.382, "[dbg] Setting context location for reg %x to %p.\n", reg, v.383);
    log_file.382 = log_file;
    fflush (log_file.382);
    <D.34020>:
    mono_arch_context_set_int_reg (restore_ctx, reg, v);
    <D.34018>:
    mono_arch_context_set_int_reg (ctx, reg, v);
    goto <D.28952>;
  }
  <D.28959>:
  D.34021 = mono_arch_context_get_int_reg (ctx, reg);
  addr = (guint8 *) D.34021;
  D.34022 = var->offset;
  addr = addr + D.34022;
  D.33967 = BIT_FIELD_REF <*t, 8, 56>;
  D.33968 = D.33967 & 64;
  if (D.33968 != 0) goto <D.34023>; else goto <D.34024>;
  <D.34023>:
  addr = MEM[(guint8 * *)addr];
  if (addr == 0B) goto <D.28952>; else goto <D.34025>;
  <D.34025>:
  <D.34024>:
  size.376 = (unsigned int) size;
  mono_gc_memmove_atomic (addr, val, size.376);
  goto <D.28952>;
  <D.28960>:
  D.34026 = mono_arch_context_get_int_reg (ctx, reg);
  addr = (guint8 *) D.34026;
  D.34022 = var->offset;
  addr = addr + D.34022;
  gaddr = MEM[(void * *)addr];
  D.34027 = gaddr == 0B;
  D.34028 = (long int) D.34027;
  D.34029 = __builtin_expect (D.34028, 0);
  if (D.34029 != 0) goto <D.34030>; else goto <D.34031>;
  <D.34030>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 6092, "gaddr");
  <D.34031>:
  size.376 = (unsigned int) size;
  mono_gc_memmove_atomic (gaddr, val, size.376);
  goto <D.28952>;
  <D.28961>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "debugger-agent.c", 6097);
  <D.28962>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "debugger-agent.c", 6100);
  <D.28952>:
}


array_commands (int command, guint8 * p, guint8 * end, struct Buffer * buf)
{
  guint8 * p.384;
  <unnamed type> D.34033;
  ErrorCode D.34036;
  struct MonoArray * arr.385;
  struct MonoVTable * D.34038;
  struct MonoClass * D.34039;
  unsigned char D.34040;
  unsigned int D.34041;
  struct MonoArrayBounds * D.34042;
  unsigned int D.34045;
  unsigned int i.386;
  unsigned int D.34048;
  struct MonoArrayBounds * D.34049;
  unsigned int D.34050;
  int D.34051;
  unsigned int D.34052;
  int D.34053;
  _Bool D.34054;
  _Bool D.34055;
  _Bool D.34056;
  int D.34057;
  _Bool D.34058;
  long int D.34059;
  long int D.34060;
  unsigned int index.387;
  unsigned int len.388;
  unsigned int D.34065;
  _Bool D.34066;
  long int D.34067;
  long int D.34068;
  double[0:] * D.34071;
  int D.34072;
  sizetype D.34073;
  struct MonoClass * D.34074;
  struct MonoType * D.34075;
  struct MonoDomain * D.34076;
  int D.34077;
  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.34033 = get_object (objid, &arr);
      err = (int) D.34033;
      if (err != 0) goto <D.34034>; else goto <D.34035>;
      <D.34034>:
      D.34036 = (ErrorCode) err;
      return D.34036;
      <D.34035>:
      switch (command) <default: <D.29818>, case 1: <D.29805>, case 2: <D.29810>, case 3: <D.29814>>
      <D.29805>:
      arr.385 = arr;
      D.34038 = arr.385->obj.vtable;
      D.34039 = D.34038->klass;
      D.34040 = D.34039->rank;
      D.34041 = (unsigned int) D.34040;
      buffer_add_int (buf, D.34041);
      arr.385 = arr;
      D.34042 = arr.385->bounds;
      if (D.34042 == 0B) goto <D.34043>; else goto <D.34044>;
      <D.34043>:
      arr.385 = arr;
      D.34045 = arr.385->max_length;
      buffer_add_int (buf, D.34045);
      buffer_add_int (buf, 0);
      goto <D.34046>;
      <D.34044>:
      i = 0;
      goto <D.29807>;
      <D.29806>:
      arr.385 = arr;
      D.34042 = arr.385->bounds;
      i.386 = (unsigned int) i;
      D.34048 = i.386 * 8;
      D.34049 = D.34042 + D.34048;
      D.34050 = D.34049->length;
      buffer_add_int (buf, D.34050);
      arr.385 = arr;
      D.34042 = arr.385->bounds;
      i.386 = (unsigned int) i;
      D.34048 = i.386 * 8;
      D.34049 = D.34042 + D.34048;
      D.34051 = D.34049->lower_bound;
      D.34052 = (unsigned int) D.34051;
      buffer_add_int (buf, D.34052);
      i = i + 1;
      <D.29807>:
      arr.385 = arr;
      D.34038 = arr.385->obj.vtable;
      D.34039 = D.34038->klass;
      D.34040 = D.34039->rank;
      D.34053 = (int) D.34040;
      if (D.34053 > i) goto <D.29806>; else goto <D.29808>;
      <D.29808>:
      <D.34046>:
      goto <D.29809>;
      <D.29810>:
      p.384 = p;
      index = decode_int (p.384, &p, end);
      p.384 = p;
      len = decode_int (p.384, &p, end);
      D.34054 = index < 0;
      D.34055 = len < 0;
      D.34056 = D.34054 | D.34055;
      D.34057 = (int) D.34056;
      D.34058 = D.34057 != 0;
      D.34059 = (long int) D.34058;
      D.34060 = __builtin_expect (D.34059, 0);
      if (D.34060 != 0) goto <D.34061>; else goto <D.34062>;
      <D.34061>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 8653, "index >= 0 && len >= 0");
      <D.34062>:
      index.387 = (unsigned int) index;
      arr.385 = arr;
      D.34045 = arr.385->max_length;
      len.388 = (unsigned int) len;
      D.34065 = D.34045 - len.388;
      D.34066 = index.387 > D.34065;
      D.34067 = (long int) D.34066;
      D.34068 = __builtin_expect (D.34067, 0);
      if (D.34068 != 0) goto <D.34069>; else goto <D.34070>;
      <D.34069>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 8655, "!(index > arr->max_length - len)");
      <D.34070>:
      arr.385 = arr;
      D.34038 = arr.385->obj.vtable;
      D.34039 = D.34038->klass;
      esize = mono_array_element_size (D.34039);
      i = index;
      goto <D.29812>;
      <D.29811>:
      arr.385 = arr;
      D.34071 = &arr.385->vector;
      D.34072 = i * esize;
      D.34073 = (sizetype) D.34072;
      elem = D.34071 + D.34073;
      arr.385 = arr;
      D.34038 = arr.385->obj.vtable;
      D.34039 = D.34038->klass;
      D.34074 = D.34039->element_class;
      D.34075 = &D.34074->byval_arg;
      arr.385 = arr;
      D.34038 = arr.385->obj.vtable;
      D.34076 = D.34038->domain;
      buffer_add_value (buf, D.34075, elem, D.34076);
      i = i + 1;
      <D.29812>:
      D.34077 = index + len;
      if (D.34077 > i) goto <D.29811>; else goto <D.29813>;
      <D.29813>:
      goto <D.29809>;
      <D.29814>:
      p.384 = p;
      index = decode_int (p.384, &p, end);
      p.384 = p;
      len = decode_int (p.384, &p, end);
      D.34054 = index < 0;
      D.34055 = len < 0;
      D.34056 = D.34054 | D.34055;
      D.34057 = (int) D.34056;
      D.34058 = D.34057 != 0;
      D.34059 = (long int) D.34058;
      D.34060 = __builtin_expect (D.34059, 0);
      if (D.34060 != 0) goto <D.34078>; else goto <D.34079>;
      <D.34078>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 8667, "index >= 0 && len >= 0");
      <D.34079>:
      index.387 = (unsigned int) index;
      arr.385 = arr;
      D.34045 = arr.385->max_length;
      len.388 = (unsigned int) len;
      D.34065 = D.34045 - len.388;
      D.34066 = index.387 > D.34065;
      D.34067 = (long int) D.34066;
      D.34068 = __builtin_expect (D.34067, 0);
      if (D.34068 != 0) goto <D.34080>; else goto <D.34081>;
      <D.34080>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 8669, "!(index > arr->max_length - len)");
      <D.34081>:
      arr.385 = arr;
      D.34038 = arr.385->obj.vtable;
      D.34039 = D.34038->klass;
      esize = mono_array_element_size (D.34039);
      i = index;
      goto <D.29816>;
      <D.29815>:
      arr.385 = arr;
      D.34071 = &arr.385->vector;
      D.34072 = i * esize;
      D.34073 = (sizetype) D.34072;
      elem = D.34071 + D.34073;
      arr.385 = arr;
      D.34038 = arr.385->obj.vtable;
      D.34039 = D.34038->klass;
      D.34074 = D.34039->element_class;
      D.34075 = &D.34074->byval_arg;
      arr.385 = arr;
      D.34038 = arr.385->obj.vtable;
      D.34076 = D.34038->domain;
      p.384 = p;
      decode_value (D.34075, D.34076, elem, p.384, &p, end);
      i = i + 1;
      <D.29816>:
      D.34077 = index + len;
      if (D.34077 > i) goto <D.29815>; else goto <D.29817>;
      <D.29817>:
      goto <D.29809>;
      <D.29818>:
      D.34036 = 100;
      return D.34036;
      <D.29809>:
      D.34036 = 0;
      return D.34036;
    }
  finally
    {
      arr = {CLOBBER};
    }
}


string_commands (int command, guint8 * p, guint8 * end, struct Buffer * buf)
{
  guint8 * p.389;
  <unnamed type> D.34085;
  ErrorCode D.34088;
  struct MonoString * str.390;
  int D.34090;
  long long unsigned int D.34091;
  long long int D.34092;
  long long int D.34093;
  int D.34094;
  int D.34095;
  mono_unichar2 * D.34098;
  unsigned int index.391;
  unsigned int D.34100;
  unsigned int i.392;
  unsigned int D.34102;
  gunichar2 * D.34103;
  short unsigned int D.34104;
  unsigned int D.34105;
  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.34085 = get_object (objid, &str);
      err = (int) D.34085;
      if (err != 0) goto <D.34086>; else goto <D.34087>;
      <D.34086>:
      D.34088 = (ErrorCode) err;
      return D.34088;
      <D.34087>:
      switch (command) <default: <D.29840>, case 1: <D.29833>, case 2: <D.29835>, case 3: <D.29836>>
      <D.29833>:
      str.390 = str;
      s = mono_string_to_utf8 (str.390);
      buffer_add_string (buf, s);
      monoeg_g_free (s);
      goto <D.29834>;
      <D.29835>:
      str.390 = str;
      D.34090 = mono_string_length (str.390);
      D.34091 = (long long unsigned int) D.34090;
      buffer_add_long (buf, D.34091);
      goto <D.29834>;
      <D.29836>:
      p.389 = p;
      D.34092 = decode_long (p.389, &p, end);
      index = (int) D.34092;
      p.389 = p;
      D.34093 = decode_long (p.389, &p, end);
      length = (int) D.34093;
      str.390 = str;
      D.34094 = mono_string_length (str.390);
      D.34095 = D.34094 - length;
      if (D.34095 < index) goto <D.34096>; else goto <D.34097>;
      <D.34096>:
      D.34088 = 102;
      return D.34088;
      <D.34097>:
      str.390 = str;
      D.34098 = mono_string_chars (str.390);
      index.391 = (unsigned int) index;
      D.34100 = index.391 * 2;
      c = D.34098 + D.34100;
      i = 0;
      goto <D.29838>;
      <D.29837>:
      i.392 = (unsigned int) i;
      D.34102 = i.392 * 2;
      D.34103 = c + D.34102;
      D.34104 = *D.34103;
      D.34105 = (unsigned int) D.34104;
      buffer_add_short (buf, D.34105);
      i = i + 1;
      <D.29838>:
      if (i < length) goto <D.29837>; else goto <D.29839>;
      <D.29839>:
      goto <D.29834>;
      <D.29840>:
      D.34088 = 100;
      return D.34088;
      <D.29834>:
      D.34088 = 0;
      return D.34088;
    }
  finally
    {
      str = {CLOBBER};
    }
}


buffer_add_short (struct Buffer * buf, guint32 val)
{
  guint8 * D.34108;
  unsigned int D.34109;
  unsigned char D.34110;
  guint8 * D.34111;
  unsigned char D.34112;
  guint8 * D.34113;

  buffer_make_room (buf, 2);
  D.34108 = buf->p;
  D.34109 = val >> 8;
  D.34110 = (unsigned char) D.34109;
  *D.34108 = D.34110;
  D.34108 = buf->p;
  D.34111 = D.34108 + 1;
  D.34112 = (unsigned char) val;
  *D.34111 = D.34112;
  D.34108 = buf->p;
  D.34113 = D.34108 + 2;
  buf->p = D.34113;
}


object_commands (int command, guint8 * p, guint8 * end, struct Buffer * buf)
{
  guint8 * p.393;
  <unnamed type> D.34117;
  int err.394;
  int err.395;
  ErrorCode D.34123;
  <unnamed type> D.34124;
  int err.396;
  struct MonoObject * obj.397;
  struct MonoVTable * D.34129;
  struct MonoDomain * D.34130;
  void * D.34131;
  struct MonoType * D.34132;
  struct MonoClass * D.34133;
  struct MonoClass * D.34136;
  struct MonoType * D.34141;
  short unsigned int D.34142;
  int D.34143;
  int D.34144;
  int D.34147;
  _Bool D.34150;
  long int D.34151;
  long int D.34152;
  struct MonoClass * D.34155;
  int D.34156;
  unsigned int D.34157;
  int D.34159;
  sizetype D.34160;
  void * D.34161;
  struct MonoClass * D.34164;
  struct MonoType * D.34169;
  short unsigned int D.34170;
  int D.34171;
  int D.34172;
  int D.34175;
  _Bool D.34178;
  long int D.34179;
  long int D.34180;
  struct MonoClass * D.34183;
  int D.34184;
  unsigned int D.34185;
  <unnamed type> D.34186;
  int err.398;
  int D.34191;
  sizetype D.34192;
  guint8 * D.34193;
  <unnamed type> D.34194;
  int err.399;
  int obj.400;
  long long unsigned int D.34199;
  struct MonoClass * D.34200;
  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.34114>; else goto <D.34115>;
      <D.34114>:
      p.393 = p;
      objid = decode_objid (p.393, &p, end);
      D.34117 = get_object (objid, &obj);
      err.394 = (int) D.34117;
      err = err.394;
      err.395 = err;
      if (err.395 != 0) goto <D.34120>; else goto <D.34121>;
      <D.34120>:
      buffer_add_int (buf, 1);
      goto <D.34122>;
      <D.34121>:
      buffer_add_int (buf, 0);
      <D.34122>:
      D.34123 = 0;
      return D.34123;
      <D.34115>:
      p.393 = p;
      objid = decode_objid (p.393, &p, end);
      D.34124 = get_object (objid, &obj);
      err.396 = (int) D.34124;
      err = err.396;
      err.395 = err;
      if (err.395 != 0) goto <D.34126>; else goto <D.34127>;
      <D.34126>:
      err.395 = err;
      D.34123 = (ErrorCode) err.395;
      return D.34123;
      <D.34127>:
      switch (command) <default: <D.29879>, case 1: <D.29855>, case 2: <D.29857>, case 4: <D.29876>, case 5: <D.29877>, case 6: <D.29867>, case 7: <D.29878>>
      <D.29855>:
      obj.397 = obj;
      D.34129 = obj.397->vtable;
      D.34130 = D.34129->domain;
      obj.397 = obj;
      D.34129 = obj.397->vtable;
      D.34131 = D.34129->type;
      D.34132 = MEM[(struct MonoReflectionType *)D.34131].type;
      D.34133 = mono_class_from_mono_type (D.34132);
      buffer_add_typeid (buf, D.34130, D.34133);
      goto <D.29856>;
      <D.29857>:
      p.393 = p;
      len = decode_int (p.393, &p, end);
      i = 0;
      goto <D.29865>;
      <D.29864>:
      {
        struct MonoClassField * f;

        p.393 = p;
        f = decode_fieldid (p.393, &p, end, 0B, &err);
        err.395 = err;
        if (err.395 != 0) goto <D.34134>; else goto <D.34135>;
        <D.34134>:
        err.395 = err;
        D.34123 = (ErrorCode) err.395;
        return D.34123;
        <D.34135>:
        found = 0;
        obj.397 = obj;
        D.34129 = obj.397->vtable;
        k = D.34129->klass;
        goto <D.29861>;
        <D.29860>:
        D.34136 = f->parent;
        if (D.34136 == k) goto <D.34137>; else goto <D.34138>;
        <D.34137>:
        found = 1;
        goto <D.29859>;
        <D.34138>:
        k = k->parent;
        <D.29861>:
        if (k != 0B) goto <D.29860>; else goto <D.29859>;
        <D.29859>:
        if (found == 0) goto <D.34139>; else goto <D.34140>;
        <D.34139>:
        D.34123 = 25;
        return D.34123;
        <D.34140>:
        D.34141 = f->type;
        D.34142 = D.34141->attrs;
        D.34143 = (int) D.34142;
        D.34144 = D.34143 & 16;
        if (D.34144 != 0) goto <D.34145>; else goto <D.34146>;
        <D.34145>:
        {
          guint8 * val;
          struct MonoVTable * vtable;

          D.34147 = mono_class_field_is_special_static (f);
          if (D.34147 != 0) goto <D.34148>; else goto <D.34149>;
          <D.34148>:
          D.34123 = 25;
          return D.34123;
          <D.34149>:
          D.34141 = f->type;
          D.34142 = D.34141->attrs;
          D.34143 = (int) D.34142;
          D.34144 = D.34143 & 16;
          D.34150 = D.34144 == 0;
          D.34151 = (long int) D.34150;
          D.34152 = __builtin_expect (D.34151, 0);
          if (D.34152 != 0) goto <D.34153>; else goto <D.34154>;
          <D.34153>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 8780, "f->type->attrs & FIELD_ATTRIBUTE_STATIC");
          <D.34154>:
          obj.397 = obj;
          D.34129 = obj.397->vtable;
          D.34130 = D.34129->domain;
          D.34136 = f->parent;
          vtable = mono_class_vtable (D.34130, D.34136);
          D.34141 = f->type;
          D.34155 = mono_class_from_mono_type (D.34141);
          D.34156 = mono_class_instance_size (D.34155);
          D.34157 = (unsigned int) D.34156;
          val = monoeg_malloc (D.34157);
          mono_field_static_get_value (vtable, f, val);
          D.34141 = f->type;
          obj.397 = obj;
          D.34129 = obj.397->vtable;
          D.34130 = D.34129->domain;
          buffer_add_value (buf, D.34141, val, D.34130);
          monoeg_g_free (val);
        }
        goto <D.34158>;
        <D.34146>:
        D.34141 = f->type;
        obj.397 = obj;
        D.34159 = f->offset;
        D.34160 = (sizetype) D.34159;
        D.34161 = obj.397 + D.34160;
        obj.397 = obj;
        D.34129 = obj.397->vtable;
        D.34130 = D.34129->domain;
        buffer_add_value (buf, D.34141, D.34161, D.34130);
        <D.34158>:
      }
      i = i + 1;
      <D.29865>:
      if (i < len) goto <D.29864>; else goto <D.29866>;
      <D.29866>:
      goto <D.29856>;
      <D.29867>:
      p.393 = p;
      len = decode_int (p.393, &p, end);
      i = 0;
      goto <D.29874>;
      <D.29873>:
      p.393 = p;
      f = decode_fieldid (p.393, &p, end, 0B, &err);
      err.395 = err;
      if (err.395 != 0) goto <D.34162>; else goto <D.34163>;
      <D.34162>:
      err.395 = err;
      D.34123 = (ErrorCode) err.395;
      return D.34123;
      <D.34163>:
      found = 0;
      obj.397 = obj;
      D.34129 = obj.397->vtable;
      k = D.34129->klass;
      goto <D.29870>;
      <D.29869>:
      D.34164 = f->parent;
      if (D.34164 == k) goto <D.34165>; else goto <D.34166>;
      <D.34165>:
      found = 1;
      goto <D.29868>;
      <D.34166>:
      k = k->parent;
      <D.29870>:
      if (k != 0B) goto <D.29869>; else goto <D.29868>;
      <D.29868>:
      if (found == 0) goto <D.34167>; else goto <D.34168>;
      <D.34167>:
      D.34123 = 25;
      return D.34123;
      <D.34168>:
      D.34169 = f->type;
      D.34170 = D.34169->attrs;
      D.34171 = (int) D.34170;
      D.34172 = D.34171 & 16;
      if (D.34172 != 0) goto <D.34173>; else goto <D.34174>;
      <D.34173>:
      {
        guint8 * val;
        struct MonoVTable * vtable;

        D.34175 = mono_class_field_is_special_static (f);
        if (D.34175 != 0) goto <D.34176>; else goto <D.34177>;
        <D.34176>:
        D.34123 = 25;
        return D.34123;
        <D.34177>:
        D.34169 = f->type;
        D.34170 = D.34169->attrs;
        D.34171 = (int) D.34170;
        D.34172 = D.34171 & 16;
        D.34178 = D.34172 == 0;
        D.34179 = (long int) D.34178;
        D.34180 = __builtin_expect (D.34179, 0);
        if (D.34180 != 0) goto <D.34181>; else goto <D.34182>;
        <D.34181>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 8817, "f->type->attrs & FIELD_ATTRIBUTE_STATIC");
        <D.34182>:
        obj.397 = obj;
        D.34129 = obj.397->vtable;
        D.34130 = D.34129->domain;
        D.34164 = f->parent;
        vtable = mono_class_vtable (D.34130, D.34164);
        D.34169 = f->type;
        D.34183 = mono_class_from_mono_type (D.34169);
        D.34184 = mono_class_instance_size (D.34183);
        D.34185 = (unsigned int) D.34184;
        val = monoeg_malloc (D.34185);
        D.34169 = f->type;
        obj.397 = obj;
        D.34129 = obj.397->vtable;
        D.34130 = D.34129->domain;
        p.393 = p;
        D.34186 = decode_value (D.34169, D.34130, val, p.393, &p, end);
        err.398 = (int) D.34186;
        err = err.398;
        err.395 = err;
        if (err.395 != 0) goto <D.34188>; else goto <D.34189>;
        <D.34188>:
        monoeg_g_free (val);
        err.395 = err;
        D.34123 = (ErrorCode) err.395;
        return D.34123;
        <D.34189>:
        mono_field_static_set_value (vtable, f, val);
        monoeg_g_free (val);
      }
      goto <D.34190>;
      <D.34174>:
      D.34169 = f->type;
      obj.397 = obj;
      D.34129 = obj.397->vtable;
      D.34130 = D.34129->domain;
      obj.397 = obj;
      D.34191 = f->offset;
      D.34192 = (sizetype) D.34191;
      D.34193 = obj.397 + D.34192;
      p.393 = p;
      D.34194 = decode_value (D.34169, D.34130, D.34193, p.393, &p, end);
      err.399 = (int) D.34194;
      err = err.399;
      err.395 = err;
      if (err.395 != 0) goto <D.34196>; else goto <D.34197>;
      <D.34196>:
      err.395 = err;
      D.34123 = (ErrorCode) err.395;
      return D.34123;
      <D.34197>:
      <D.34190>:
      i = i + 1;
      <D.29874>:
      if (i < len) goto <D.29873>; else goto <D.29875>;
      <D.29875>:
      goto <D.29856>;
      <D.29876>:
      obj.397 = obj;
      obj.400 = (int) obj.397;
      D.34199 = (long long unsigned int) obj.400;
      buffer_add_long (buf, D.34199);
      goto <D.29856>;
      <D.29877>:
      obj.397 = obj;
      D.34129 = obj.397->vtable;
      D.34130 = D.34129->domain;
      buffer_add_domainid (buf, D.34130);
      goto <D.29856>;
      <D.29878>:
      obj.397 = obj;
      D.34129 = obj.397->vtable;
      D.34130 = D.34129->domain;
      obj.397 = obj;
      D.34129 = obj.397->vtable;
      D.34131 = D.34129->type;
      D.34132 = MEM[(struct MonoReflectionType *)D.34131].type;
      D.34200 = mono_class_from_mono_type (D.34132);
      buffer_add_typeid (buf, D.34130, D.34200);
      obj.397 = obj;
      D.34129 = obj.397->vtable;
      D.34130 = D.34129->domain;
      buffer_add_domainid (buf, D.34130);
      goto <D.29856>;
      <D.29879>:
      D.34123 = 100;
      return D.34123;
      <D.29856>:
      D.34123 = 0;
      return D.34123;
    }
  finally
    {
      err = {CLOBBER};
      obj = {CLOBBER};
    }
}


send_reply_packet (int id, int error, struct Buffer * data)
{
  guint8 * D.34203;
  int D.34204;
  guint8 * D.34205;
  int D.34206;
  int D.34207;
  unsigned int len.401;
  unsigned int id.402;
  int D.34210;
  unsigned char D.34211;
  unsigned char D.34212;
  guint8 * D.34213;
  guint8 * D.34214;
  unsigned int D.34215;
  gboolean D.34216;
  struct Buffer buf;
  int len;
  gboolean res;

  try
    {
      D.34203 = data->p;
      D.34204 = (int) D.34203;
      D.34205 = data->buf;
      D.34206 = (int) D.34205;
      D.34207 = D.34204 - D.34206;
      len = D.34207 + 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.34210 = error >> 8;
      D.34211 = (unsigned char) D.34210;
      buffer_add_byte (&buf, D.34211);
      D.34212 = (unsigned char) error;
      buffer_add_byte (&buf, D.34212);
      D.34213 = buf.buf;
      D.34214 = D.34213 + 11;
      D.34205 = data->buf;
      D.34203 = data->p;
      D.34204 = (int) D.34203;
      D.34205 = data->buf;
      D.34206 = (int) D.34205;
      D.34207 = D.34204 - D.34206;
      D.34215 = (unsigned int) D.34207;
      memcpy (D.34214, D.34205, D.34215);
      D.34213 = buf.buf;
      res = transport_send (D.34213, len);
      buffer_free (&buf);
      D.34216 = res;
      return D.34216;
    }
  finally
    {
      buf = {CLOBBER};
    }
}


save_thread_context (struct MonoContext * ctx)
{
  unsigned int debugger_tls_id.403;
  _Bool D.34220;
  long int D.34221;
  long int D.34222;
  struct MonoThreadUnwindState * D.34227;
  struct DebuggerTlsData * tls;

  debugger_tls_id.403 = debugger_tls_id;
  tls = pthread_getspecific (debugger_tls_id.403);
  D.34220 = tls == 0B;
  D.34221 = (long int) D.34220;
  D.34222 = __builtin_expect (D.34221, 0);
  if (D.34222 != 0) goto <D.34223>; else goto <D.34224>;
  <D.34223>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 2357, "tls");
  <D.34224>:
  if (ctx != 0B) goto <D.34225>; else goto <D.34226>;
  <D.34225>:
  D.34227 = &tls->context;
  mono_thread_state_init_from_monoctx (D.34227, ctx);
  goto <D.34228>;
  <D.34226>:
  D.34227 = &tls->context;
  mono_thread_state_init_from_current (D.34227);
  <D.34228>:
}


suspend_vm ()
{
  int suspend_count.404;
  int suspend_count.405;
  int log_level.406;
  _Bool D.34232;
  long int D.34233;
  long int D.34234;
  struct FILE * log_file.407;
  unsigned int D.34238;
  void * D.34239;
  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.34232 = log_level.406 > 0;
  D.34233 = (long int) D.34232;
  D.34234 = __builtin_expect (D.34233, 0);
  if (D.34234 != 0) goto <D.34235>; else goto <D.34236>;
  <D.34235>:
  log_file.407 = log_file;
  D.34238 = GetCurrentThreadId ();
  D.34239 = (void *) D.34238;
  fprintf (log_file.407, "[%p] Suspending vm...\n", D.34239);
  log_file.407 = log_file;
  fflush (log_file.407);
  <D.34236>:
  suspend_count.404 = suspend_count;
  if (suspend_count.404 == 1) goto <D.34240>; else goto <D.34241>;
  <D.34240>:
  start_single_stepping ();
  thread_to_tls.408 = thread_to_tls;
  mono_g_hash_table_foreach (thread_to_tls.408, notify_thread, 0B);
  <D.34241>:
  pthread_mutex_unlock (&suspend_mutex);
  suspend_count.404 = suspend_count;
  if (suspend_count.404 == 1) goto <D.34243>; else goto <D.34244>;
  <D.34243>:
  mono_thread_pool_suspend ();
  <D.34244>:
  mono_loader_unlock ();
}


notify_thread (void * key, void * value, void * user_data)
{
  long long unsigned int D.34245;
  unsigned int D.34248;
  int D.34250;
  int log_level.409;
  _Bool D.34252;
  long int D.34253;
  long int D.34254;
  struct FILE * log_file.410;
  unsigned int D.34258;
  void * D.34259;
  void * tid.411;
  gint32 * D.34261;
  int D.34262;
  long unsigned int D.34265;
  unsigned int D.34270;
  void * D.34271;
  void * D.34273;
  int D.34274;
  char * D.34275;
  unsigned int D.34276;
  int D.34278;
  unsigned int D.34283;
  void * D.34284;
  struct MonoInternalThread * thread;
  struct DebuggerTlsData * tls;
  gsize tid;
  int res;

  thread = key;
  tls = value;
  D.34245 = thread->tid;
  tid = (gsize) D.34245;
  D.34248 = GetCurrentThreadId ();
  if (D.34248 == tid) goto <D.34246>; else goto <D.34249>;
  <D.34249>:
  D.34250 = tls->terminated;
  if (D.34250 != 0) goto <D.34246>; else goto <D.34247>;
  <D.34246>:
  return;
  <D.34247>:
  log_level.409 = log_level;
  D.34252 = log_level.409 > 0;
  D.34253 = (long int) D.34252;
  D.34254 = __builtin_expect (D.34253, 0);
  if (D.34254 != 0) goto <D.34255>; else goto <D.34256>;
  <D.34255>:
  log_file.410 = log_file;
  D.34258 = GetCurrentThreadId ();
  D.34259 = (void *) D.34258;
  tid.411 = (void *) tid;
  fprintf (log_file.410, "[%p] Interrupting %p...\n", D.34259, tid.411);
  log_file.410 = log_file;
  fflush (log_file.410);
  <D.34256>:
  D.34261 = &tls->interrupt_count;
  InterlockedIncrement (D.34261);
  D.34262 = mono_thread_info_new_interrupt_enabled ();
  if (D.34262 != 0) goto <D.34263>; else goto <D.34264>;
  <D.34263>:
  {
    struct MonoThreadInfo * info;
    struct MonoJitInfo * ji;

    D.34245 = thread->tid;
    D.34265 = (long unsigned int) D.34245;
    info = mono_thread_info_safe_suspend_sync (D.34265, 0);
    if (info == 0B) goto <D.34266>; else goto <D.34267>;
    <D.34266>:
    log_level.409 = log_level;
    D.34252 = log_level.409 > 0;
    D.34253 = (long int) D.34252;
    D.34254 = __builtin_expect (D.34253, 0);
    if (D.34254 != 0) goto <D.34268>; else goto <D.34269>;
    <D.34268>:
    log_file.410 = log_file;
    D.34270 = GetCurrentThreadId ();
    D.34271 = (void *) D.34270;
    tid.411 = (void *) tid;
    fprintf (log_file.410, "[%p] mono_thread_info_suspend_sync () failed for %p...\n", D.34271, tid.411);
    log_file.410 = log_file;
    fflush (log_file.410);
    <D.34269>:
    tls->terminated = 1;
    goto <D.34272>;
    <D.34267>:
    D.34273 = info->suspend_state.unwind_data[0];
    D.34274 = info->suspend_state.ctx.pc;
    D.34275 = (char *) D.34274;
    ji = mono_jit_info_table_find (D.34273, D.34275);
    thread_interrupt (tls, info, 0B, ji);
    D.34276 = info->node.key;
    mono_thread_info_resume (D.34276);
    <D.34272>:
  }
  goto <D.34277>;
  <D.34264>:
  D.34278 = mono_thread_get_abort_signal ();
  res = mono_thread_kill (thread, D.34278);
  if (res != 0) goto <D.34279>; else goto <D.34280>;
  <D.34279>:
  log_level.409 = log_level;
  D.34252 = log_level.409 > 0;
  D.34253 = (long int) D.34252;
  D.34254 = __builtin_expect (D.34253, 0);
  if (D.34254 != 0) goto <D.34281>; else goto <D.34282>;
  <D.34281>:
  log_file.410 = log_file;
  D.34283 = GetCurrentThreadId ();
  D.34284 = (void *) D.34283;
  tid.411 = (void *) tid;
  fprintf (log_file.410, "[%p] mono_thread_kill () failed for %p: %d...\n", D.34284, tid.411, res);
  log_file.410 = log_file;
  fflush (log_file.410);
  <D.34282>:
  tls->terminated = 1;
  <D.34280>:
  <D.34277>:
}


thread_interrupt (struct DebuggerTlsData * tls, struct MonoThreadInfo * info, void * sigctx, struct MonoJitInfo * ji)
{
  int D.34286;
  gboolean D.34289;
  gint32 * D.34290;
  int D.34296;
  int log_level.412;
  _Bool D.34304;
  long int D.34305;
  long int D.34306;
  struct FILE * log_file.413;
  void * tid.414;
  struct MonoMethod * D.34311;
  const char * D.34312;
  int D.34313;
  int D.34316;
  struct MonoInternalThread * D.34323;
  struct MonoRuntimeExceptionHandlingCallbacks * D.34331;
  void (*<T31f9>) (gboolean (*MonoInternalStackWalk) (struct MonoStackFrameInfo *, struct MonoContext *, void *), struct MonoThreadUnwindState *, MonoUnwindOptions, void *) D.34332;
  struct MonoThreadUnwindState * D.34333;
  int D.34334;
  struct StackFrameInfo * D.34337;
  struct MonoThreadUnwindState * D.34338;
  _Bool D.34339;
  long int D.34340;
  long int D.34341;
  struct MonoThreadUnwindState * D.34344;
  struct MonoContext * D.34347;
  void * D.34348;
  void * D.34349;
  gboolean res;
  void * ip;
  MonoNativeThreadId tid;

  D.34286 = tls->interrupt_count;
  if (D.34286 == 0) goto <D.34287>; else goto <D.34288>;
  <D.34287>:
  D.34289 = 0;
  return D.34289;
  <D.34288>:
  D.34290 = &tls->interrupt_count;
  InterlockedDecrement (D.34290);
  if (sigctx != 0B) goto <D.34291>; else goto <D.34292>;
  <D.34291>:
  ip = mono_arch_ip_from_context (sigctx);
  goto <D.34293>;
  <D.34292>:
  if (info != 0B) goto <D.34294>; else goto <D.34295>;
  <D.34294>:
  D.34296 = info->suspend_state.ctx.pc;
  ip = (void *) D.34296;
  goto <D.34297>;
  <D.34295>:
  ip = 0B;
  <D.34297>:
  <D.34293>:
  if (info != 0B) goto <D.34298>; else goto <D.34299>;
  <D.34298>:
  tid = info->node.key;
  goto <D.34300>;
  <D.34299>:
  tid = GetCurrentThreadId ();
  <D.34300>:
  if (ji != 0B) goto <D.34301>; else goto <D.34302>;
  <D.34301>:
  log_level.412 = log_level;
  D.34304 = log_level.412 > 0;
  D.34305 = (long int) D.34304;
  D.34306 = __builtin_expect (D.34305, 0);
  if (D.34306 != 0) goto <D.34307>; else goto <D.34308>;
  <D.34307>:
  log_file.413 = log_file;
  tid.414 = (void *) tid;
  D.34311 = jinfo_get_method (ji);
  D.34312 = D.34311->name;
  fprintf (log_file.413, "[%p] Received interrupt while at %s(%p), continuing.\n", tid.414, D.34312, ip);
  log_file.413 = log_file;
  fflush (log_file.413);
  <D.34308>:
  D.34289 = 1;
  return D.34289;
  <D.34302>:
  D.34313 = tls->suspended;
  if (D.34313 == 0) goto <D.34314>; else goto <D.34315>;
  <D.34314>:
  D.34316 = tls->suspending;
  if (D.34316 == 0) goto <D.34317>; else goto <D.34318>;
  <D.34317>:
  {
    struct MonoContext ctx;
    struct GetLastFrameUserData data;

    try
      {
        if (ip != 0B) goto <D.34319>; else goto <D.34320>;
        <D.34319>:
        log_level.412 = log_level;
        D.34304 = log_level.412 > 0;
        D.34305 = (long int) D.34304;
        D.34306 = __builtin_expect (D.34305, 0);
        if (D.34306 != 0) goto <D.34321>; else goto <D.34322>;
        <D.34321>:
        log_file.413 = log_file;
        tid.414 = (void *) tid;
        fprintf (log_file.413, "[%p] Received interrupt while at %p, treating as suspended.\n", tid.414, ip);
        log_file.413 = log_file;
        fflush (log_file.413);
        <D.34322>:
        <D.34320>:
        D.34323 = tls->thread;
        if (D.34323 == 0B) goto <D.34324>; else goto <D.34325>;
        <D.34324>:
        D.34289 = 1;
        return D.34289;
        <D.34325>:
        data.last_frame_set = 0;
        if (sigctx != 0B) goto <D.34326>; else goto <D.34327>;
        <D.34326>:
        mono_arch_sigctx_to_monoctx (sigctx, &ctx);
        mono_walk_stack_with_ctx (get_last_frame, &ctx, 0, &data);
        goto <D.34328>;
        <D.34327>:
        if (info != 0B) goto <D.34329>; else goto <D.34330>;
        <D.34329>:
        D.34331 = mono_get_eh_callbacks ();
        D.34332 = D.34331->mono_walk_stack_with_state;
        D.34333 = &info->suspend_state;
        D.34332 (get_last_frame, D.34333, 0, &data);
        <D.34330>:
        <D.34328>:
        D.34334 = data.last_frame_set;
        if (D.34334 != 0) goto <D.34335>; else goto <D.34336>;
        <D.34335>:
        D.34337 = &tls->async_last_frame;
        memcpy (D.34337, &data.last_frame, 52);
        D.34338 = &tls->async_state;
        res = mono_thread_state_init_from_monoctx (D.34338, &ctx);
        D.34339 = res == 0;
        D.34340 = (long int) D.34339;
        D.34341 = __builtin_expect (D.34340, 0);
        if (D.34341 != 0) goto <D.34342>; else goto <D.34343>;
        <D.34342>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 2519, "res");
        <D.34343>:
        D.34344 = &tls->context;
        mono_thread_state_init_from_monoctx (D.34344, &ctx);
        D.34339 = res == 0;
        D.34340 = (long int) D.34339;
        D.34341 = __builtin_expect (D.34340, 0);
        if (D.34341 != 0) goto <D.34345>; else goto <D.34346>;
        <D.34345>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 2521, "res");
        <D.34346>:
        D.34347 = &tls->async_state.ctx;
        memcpy (D.34347, &data.ctx, 208);
        D.34348 = data.lmf;
        tls->async_state.unwind_data[1] = D.34348;
        D.34323 = tls->thread;
        D.34349 = D.34323->jit_data;
        tls->async_state.unwind_data[2] = D.34349;
        goto <D.34350>;
        <D.34336>:
        tls->async_state.valid = 0;
        <D.34350>:
        mono_memory_barrier ();
        tls->suspended = 1;
        mono_sem_post (&suspend_sem);
      }
    finally
      {
        ctx = {CLOBBER};
        data = {CLOBBER};
      }
  }
  <D.34318>:
  <D.34315>:
  D.34289 = 1;
  return D.34289;
}


get_last_frame (struct StackFrameInfo * info, struct MonoContext * ctx, void * user_data)
{
  <unnamed type> D.34354;
  gboolean D.34357;
  int D.34358;
  struct StackFrameInfo * D.34361;
  struct MonoContext * D.34362;
  void * D.34363;
  struct GetLastFrameUserData * data;

  data = user_data;
  D.34354 = info->type;
  if (D.34354 == 2) goto <D.34355>; else goto <D.34356>;
  <D.34355>:
  D.34357 = 0;
  return D.34357;
  <D.34356>:
  D.34358 = data->last_frame_set;
  if (D.34358 == 0) goto <D.34359>; else goto <D.34360>;
  <D.34359>:
  D.34361 = &data->last_frame;
  memcpy (D.34361, info, 52);
  data->last_frame_set = 1;
  D.34357 = 0;
  return D.34357;
  <D.34360>:
  D.34362 = &data->ctx;
  memcpy (D.34362, ctx, 208);
  D.34363 = info->lmf;
  data->lmf = D.34363;
  D.34357 = 1;
  return D.34357;
}


mono_memory_barrier ()
{
  __sync_synchronize ();
}


get_objref (struct MonoObject * obj)
{
  struct ObjRef * D.34367;
  struct GHashTable * obj_to_objref.415;
  struct GHashTable * obj_to_objref.416;
  struct MonoGHashTable * suspended_objs.417;
  int D.34373;
  int suspend_count.418;
  struct MonoGHashTable * suspended_objs.419;
  int D.34380;
  const void * hash.420;
  unsigned int D.34386;
  struct MonoObject * D.34387;
  unsigned int obj.421;
  unsigned int D.34392;
  const void * D.34393;
  struct MonoObject * D.34396;
  int D.34399;
  unsigned int D.34400;
  struct GHashTable * objrefs.422;
  int D.34402;
  void * D.34403;
  int D.34404;
  void * hash.423;
  void * D.34409;
  struct ObjRef * ref;
  struct GSList * reflist;
  struct GSList * l;
  int hash;

  reflist = 0B;
  hash = 0;
  if (obj == 0B) goto <D.34365>; else goto <D.34366>;
  <D.34365>:
  D.34367 = 0B;
  return D.34367;
  <D.34366>:
  mono_loader_lock ();
  obj_to_objref.415 = obj_to_objref;
  if (obj_to_objref.415 == 0B) goto <D.34369>; else goto <D.34370>;
  <D.34369>:
  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.34373 = mono_gc_is_moving ();
  if (D.34373 == 0) goto <D.34374>; else goto <D.34375>;
  <D.34374>:
  mono_gc_register_root (&suspended_objs, 4, 0B);
  <D.34375>:
  <D.34370>:
  suspend_count.418 = suspend_count;
  if (suspend_count.418 != 0) goto <D.34377>; else goto <D.34378>;
  <D.34377>:
  suspended_objs.419 = suspended_objs;
  mono_g_hash_table_insert (suspended_objs.419, obj, 0B);
  <D.34378>:
  D.34380 = mono_gc_is_moving ();
  if (D.34380 != 0) goto <D.34381>; else goto <D.34382>;
  <D.34381>:
  hash = mono_object_hash (obj);
  obj_to_objref.415 = obj_to_objref;
  hash.420 = (const void *) hash;
  reflist = monoeg_g_hash_table_lookup (obj_to_objref.415, hash.420);
  l = reflist;
  goto <D.27614>;
  <D.27613>:
  ref = l->data;
  if (ref != 0B) goto <D.34384>; else goto <D.34385>;
  <D.34384>:
  D.34386 = ref->handle;
  D.34387 = mono_gchandle_get_target (D.34386);
  if (D.34387 == obj) goto <D.34388>; else goto <D.34389>;
  <D.34388>:
  mono_loader_unlock ();
  D.34367 = ref;
  return D.34367;
  <D.34389>:
  <D.34385>:
  l = l->next;
  <D.27614>:
  if (l != 0B) goto <D.27613>; else goto <D.27615>;
  <D.27615>:
  goto <D.34390>;
  <D.34382>:
  obj_to_objref.415 = obj_to_objref;
  obj.421 = (unsigned int) obj;
  D.34392 = ~obj.421;
  D.34393 = (const void *) D.34392;
  ref = monoeg_g_hash_table_lookup (obj_to_objref.415, D.34393);
  if (ref != 0B) goto <D.34394>; else goto <D.34395>;
  <D.34394>:
  D.34386 = ref->handle;
  D.34396 = mono_gchandle_get_target (D.34386);
  if (D.34396 == obj) goto <D.34397>; else goto <D.34398>;
  <D.34397>:
  mono_loader_unlock ();
  D.34367 = ref;
  return D.34367;
  <D.34398>:
  <D.34395>:
  <D.34390>:
  ref = monoeg_malloc0 (8);
  D.34399 = InterlockedIncrement (&objref_id);
  ref->id = D.34399;
  D.34400 = mono_gchandle_new_weakref (obj, 0);
  ref->handle = D.34400;
  objrefs.422 = objrefs;
  D.34402 = ref->id;
  D.34403 = (void *) D.34402;
  monoeg_g_hash_table_insert_replace (objrefs.422, D.34403, ref, 0);
  D.34404 = mono_gc_is_moving ();
  if (D.34404 != 0) goto <D.34405>; else goto <D.34406>;
  <D.34405>:
  reflist = monoeg_g_slist_append (reflist, ref);
  obj_to_objref.415 = obj_to_objref;
  hash.423 = (void *) hash;
  monoeg_g_hash_table_insert_replace (obj_to_objref.415, hash.423, reflist, 0);
  goto <D.34408>;
  <D.34406>:
  obj_to_objref.415 = obj_to_objref;
  obj.421 = (unsigned int) obj;
  D.34392 = ~obj.421;
  D.34409 = (void *) D.34392;
  monoeg_g_hash_table_insert_replace (obj_to_objref.415, D.34409, ref, 0);
  <D.34408>:
  mono_loader_unlock ();
  D.34367 = ref;
  return D.34367;
}


send_packet (int command_set, int command, struct Buffer * data)
{
  guint8 * D.34411;
  int D.34412;
  guint8 * D.34413;
  int D.34414;
  int D.34415;
  unsigned int len.424;
  unsigned int id.425;
  unsigned char D.34418;
  unsigned char D.34419;
  guint8 * D.34420;
  guint8 * D.34421;
  unsigned int D.34422;
  gboolean D.34423;
  struct Buffer buf;
  int len;
  int id;
  gboolean res;

  try
    {
      id = InterlockedIncrement (&packet_id);
      D.34411 = data->p;
      D.34412 = (int) D.34411;
      D.34413 = data->buf;
      D.34414 = (int) D.34413;
      D.34415 = D.34412 - D.34414;
      len = D.34415 + 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.34418 = (unsigned char) command_set;
      buffer_add_byte (&buf, D.34418);
      D.34419 = (unsigned char) command;
      buffer_add_byte (&buf, D.34419);
      D.34420 = buf.buf;
      D.34421 = D.34420 + 11;
      D.34413 = data->buf;
      D.34411 = data->p;
      D.34412 = (int) D.34411;
      D.34413 = data->buf;
      D.34414 = (int) D.34413;
      D.34415 = D.34412 - D.34414;
      D.34422 = (unsigned int) D.34415;
      memcpy (D.34421, D.34413, D.34422);
      D.34420 = buf.buf;
      res = transport_send (D.34420, len);
      buffer_free (&buf);
      D.34423 = res;
      return D.34423;
    }
  finally
    {
      buf = {CLOBBER};
    }
}


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

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


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

  switch (event) <default: <D.28161>, case 0: <D.28144>, case 1: <D.28145>, case 2: <D.28146>, case 3: <D.28147>, case 4: <D.28148>, case 5: <D.28149>, case 6: <D.28150>, case 7: <D.28151>, case 8: <D.28152>, case 9: <D.28153>, case 10: <D.28154>, case 11: <D.28155>, case 12: <D.28156>, case 13: <D.28157>, case 14: <D.28158>, case 15: <D.28159>, case 16: <D.28160>>
  <D.28144>:
  D.34427 = "VM_START";
  return D.34427;
  <D.28145>:
  D.34427 = "VM_DEATH";
  return D.34427;
  <D.28146>:
  D.34427 = "THREAD_START";
  return D.34427;
  <D.28147>:
  D.34427 = "THREAD_DEATH";
  return D.34427;
  <D.28148>:
  D.34427 = "APPDOMAIN_CREATE";
  return D.34427;
  <D.28149>:
  D.34427 = "APPDOMAIN_UNLOAD";
  return D.34427;
  <D.28150>:
  D.34427 = "METHOD_ENTRY";
  return D.34427;
  <D.28151>:
  D.34427 = "METHOD_EXIT";
  return D.34427;
  <D.28152>:
  D.34427 = "ASSEMBLY_LOAD";
  return D.34427;
  <D.28153>:
  D.34427 = "ASSEMBLY_UNLOAD";
  return D.34427;
  <D.28154>:
  D.34427 = "BREAKPOINT";
  return D.34427;
  <D.28155>:
  D.34427 = "STEP";
  return D.34427;
  <D.28156>:
  D.34427 = "TYPE_LOAD";
  return D.34427;
  <D.28157>:
  D.34427 = "EXCEPTION";
  return D.34427;
  <D.28158>:
  D.34427 = "KEEPALIVE";
  return D.34427;
  <D.28159>:
  D.34427 = "USER_BREAK";
  return D.34427;
  <D.28160>:
  D.34427 = "USER_LOG";
  return D.34427;
  <D.28161>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "debugger-agent.c", 3535);
  D.34427 = "";
  return D.34427;
}


suspend_current ()
{
  unsigned int D.34429;
  unsigned int debugger_thread_id.426;
  _Bool D.34431;
  long int D.34432;
  long int D.34433;
  int D.34436;
  unsigned int debugger_tls_id.427;
  _Bool D.34440;
  long int D.34441;
  long int D.34442;
  int D.34445;
  int log_level.428;
  _Bool D.34449;
  long int D.34450;
  long int D.34451;
  struct FILE * log_file.429;
  unsigned int D.34455;
  void * D.34456;
  _Bool D.34457;
  long int D.34458;
  long int D.34459;
  int suspend_count.430;
  unsigned int suspend_count.431;
  unsigned int D.34464;
  int threads_suspend_count.432;
  int threads_suspend_count.433;
  unsigned int D.34469;
  void * D.34470;
  struct InvokeData * D.34471;
  int err;
  struct DebuggerTlsData * tls;

  D.34429 = GetCurrentThreadId ();
  debugger_thread_id.426 = debugger_thread_id;
  D.34431 = D.34429 == debugger_thread_id.426;
  D.34432 = (long int) D.34431;
  D.34433 = __builtin_expect (D.34432, 0);
  if (D.34433 != 0) goto <D.34434>; else goto <D.34435>;
  <D.34434>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 2855, "debugger_thread_id != GetCurrentThreadId ()");
  <D.34435>:
  D.34436 = mono_loader_lock_is_owned_by_self ();
  if (D.34436 != 0) goto <D.34437>; else goto <D.34438>;
  <D.34437>:
  return;
  <D.34438>:
  debugger_tls_id.427 = debugger_tls_id;
  tls = pthread_getspecific (debugger_tls_id.427);
  D.34440 = tls == 0B;
  D.34441 = (long int) D.34440;
  D.34442 = __builtin_expect (D.34441, 0);
  if (D.34442 != 0) goto <D.34443>; else goto <D.34444>;
  <D.34443>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 2866, "tls");
  <D.34444>:
  pthread_mutex_lock (&suspend_mutex);
  tls->suspending = 0;
  tls->really_suspended = 1;
  D.34445 = tls->suspended;
  if (D.34445 == 0) goto <D.34446>; else goto <D.34447>;
  <D.34446>:
  tls->suspended = 1;
  mono_sem_post (&suspend_sem);
  <D.34447>:
  log_level.428 = log_level;
  D.34449 = log_level.428 > 0;
  D.34450 = (long int) D.34449;
  D.34451 = __builtin_expect (D.34450, 0);
  if (D.34451 != 0) goto <D.34452>; else goto <D.34453>;
  <D.34452>:
  log_file.429 = log_file;
  D.34455 = GetCurrentThreadId ();
  D.34456 = (void *) D.34455;
  fprintf (log_file.429, "[%p] Suspended.\n", D.34456);
  log_file.429 = log_file;
  fflush (log_file.429);
  <D.34453>:
  goto <D.27948>;
  <D.27947>:
  err = pthread_cond_wait (&suspend_cond, &suspend_mutex);
  D.34457 = err != 0;
  D.34458 = (long int) D.34457;
  D.34459 = __builtin_expect (D.34458, 0);
  if (D.34459 != 0) goto <D.34460>; else goto <D.34461>;
  <D.34460>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 2893, "err == 0");
  <D.34461>:
  <D.27948>:
  suspend_count.430 = suspend_count;
  suspend_count.431 = (unsigned int) suspend_count.430;
  D.34464 = tls->resume_count;
  if (suspend_count.431 != D.34464) goto <D.27947>; else goto <D.27949>;
  <D.27949>:
  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.34449 = log_level.428 > 0;
  D.34450 = (long int) D.34449;
  D.34451 = __builtin_expect (D.34450, 0);
  if (D.34451 != 0) goto <D.34467>; else goto <D.34468>;
  <D.34467>:
  log_file.429 = log_file;
  D.34469 = GetCurrentThreadId ();
  D.34470 = (void *) D.34469;
  fprintf (log_file.429, "[%p] Resumed.\n", D.34470);
  log_file.429 = log_file;
  fflush (log_file.429);
  <D.34468>:
  D.34471 = tls->pending_invoke;
  if (D.34471 != 0B) goto <D.34472>; else goto <D.34473>;
  <D.34472>:
  D.34471 = tls->pending_invoke;
  D.34471->has_ctx = 1;
  D.34471 = tls->pending_invoke;
  D.34471->ctx = tls->context.ctx;
  invoke_method ();
  <D.34473>:
  tls->context.valid = 0;
  tls->async_state.valid = 0;
  invalidate_frames (tls);
}


invoke_method ()
{
  unsigned int debugger_tls_id.434;
  _Bool D.34476;
  long int D.34477;
  long int D.34478;
  _Bool D.34481;
  long int D.34482;
  long int D.34483;
  struct InvokeData * D.34486;
  guint8 * p.435;
  guint8 * p.436;
  <unnamed type> D.34492;
  int D.34493;
  int D.34494;
  int D.34497;
  int D.34498;
  unsigned int i.437;
  unsigned int D.34502;
  struct MonoContext * D.34503;
  int D.34504;
  unsigned int D.34509;
  _Bool D.34510;
  long int D.34511;
  long int D.34512;
  unsigned int D.34515;
  int log_level.438;
  _Bool D.34517;
  long int D.34518;
  long int D.34519;
  struct FILE * log_file.439;
  unsigned int D.34523;
  void * D.34524;
  int D.34525;
  struct MonoInternalThread * D.34528;
  struct InvokeData * D.34529;
  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.34476 = tls == 0B;
      D.34477 = (long int) D.34476;
      D.34478 = __builtin_expect (D.34477, 0);
      if (D.34478 != 0) goto <D.34479>; else goto <D.34480>;
      <D.34479>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 6421, "tls");
      <D.34480>:
      mono_loader_lock ();
      invoke = tls->pending_invoke;
      D.34481 = invoke == 0B;
      D.34482 = (long int) D.34481;
      D.34483 = __builtin_expect (D.34482, 0);
      if (D.34483 != 0) goto <D.34484>; else goto <D.34485>;
      <D.34484>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 6431, "invoke");
      <D.34485>:
      tls->pending_invoke = 0B;
      D.34486 = tls->invoke;
      invoke->last_invoke = D.34486;
      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.29077>;
      <D.29076>:
      buffer_init (&buf, 128);
      if (err != 0) goto <D.34488>; else goto <D.34489>;
      <D.34488>:
      goto <D.34490>;
      <D.34489>:
      p.436 = p;
      D.34492 = do_invoke_method (tls, &buf, invoke, p.436, &p);
      err = (int) D.34492;
      <D.34490>:
      D.34493 = invoke->nmethods;
      D.34494 = D.34493 + -1;
      if (D.34494 == mindex) goto <D.34495>; else goto <D.34496>;
      <D.34495>:
      D.34497 = invoke->flags;
      D.34498 = D.34497 & 2;
      if (D.34498 == 0) goto <D.34499>; else goto <D.34500>;
      <D.34499>:
      i = 0;
      goto <D.29074>;
      <D.29073>:
      suspend_vm ();
      i = i + 1;
      <D.29074>:
      i.437 = (unsigned int) i;
      D.34502 = invoke->suspend_count;
      if (i.437 < D.34502) goto <D.29073>; else goto <D.29075>;
      <D.29075>:
      <D.34500>:
      <D.34496>:
      send_reply_packet (id, err, &buf);
      buffer_free (&buf);
      mindex = mindex + 1;
      <D.29077>:
      D.34493 = invoke->nmethods;
      if (D.34493 > mindex) goto <D.29076>; else goto <D.29078>;
      <D.29078>:
      D.34503 = &invoke->ctx;
      memcpy (&restore_ctx, D.34503, 208);
      D.34504 = invoke->has_ctx;
      if (D.34504 != 0) goto <D.34505>; else goto <D.34506>;
      <D.34505>:
      save_thread_context (&restore_ctx);
      <D.34506>:
      D.34497 = invoke->flags;
      D.34498 = D.34497 & 2;
      if (D.34498 != 0) goto <D.34507>; else goto <D.34508>;
      <D.34507>:
      D.34509 = tls->resume_count;
      D.34510 = D.34509 == 0;
      D.34511 = (long int) D.34510;
      D.34512 = __builtin_expect (D.34511, 0);
      if (D.34512 != 0) goto <D.34513>; else goto <D.34514>;
      <D.34513>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 6473, "tls->resume_count");
      <D.34514>:
      D.34509 = tls->resume_count;
      D.34502 = invoke->suspend_count;
      D.34515 = D.34509 - D.34502;
      tls->resume_count = D.34515;
      <D.34508>:
      log_level.438 = log_level;
      D.34517 = log_level.438 > 0;
      D.34518 = (long int) D.34517;
      D.34519 = __builtin_expect (D.34518, 0);
      if (D.34519 != 0) goto <D.34520>; else goto <D.34521>;
      <D.34520>:
      log_file.439 = log_file;
      D.34523 = GetCurrentThreadId ();
      D.34524 = (void *) D.34523;
      D.34509 = tls->resume_count;
      fprintf (log_file.439, "[%p] Invoke finished (%d), resume_count = %d.\n", D.34524, err, D.34509);
      log_file.439 = log_file;
      fflush (log_file.439);
      <D.34521>:
      mono_loader_lock ();
      D.34525 = tls->abort_requested;
      if (D.34525 != 0) goto <D.34526>; else goto <D.34527>;
      <D.34526>:
      D.34528 = tls->thread;
      mono_thread_internal_reset_abort (D.34528);
      <D.34527>:
      D.34486 = tls->invoke;
      D.34529 = D.34486->last_invoke;
      tls->invoke = D.34529;
      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.34530;
  int log_level.440;
  _Bool D.34534;
  long int D.34535;
  long int D.34536;
  struct FILE * log_file.441;
  unsigned int D.34540;
  void * D.34541;
  char * D.34542;
  const char * iftmp.442;
  struct MonoObject * this.443;
  struct MonoVTable * D.34547;
  struct MonoClass * D.34548;
  void * * D.34550;
  guint8 * p.444;
  int err.445;
  ErrorCode D.34555;
  struct MonoClass * D.34556;
  unsigned char D.34557;
  unsigned char D.34558;
  int D.34561;
  unsigned int D.34562;
  short unsigned int D.34567;
  int D.34568;
  int D.34569;
  unsigned int D.34575;
  void * D.34576;
  int D.34577;
  unsigned int D.34578;
  struct MonoType * D.34579;
  struct MonoDomain * domain.446;
  <unnamed type> D.34581;
  int err.447;
  struct MonoObject * this.448;
  unsigned int D.34591;
  unsigned int D.34592;
  unsigned char D.34594;
  unsigned int D.34600;
  void * D.34601;
  unsigned int D.34604;
  void * D.34605;
  char * D.34606;
  const char * iftmp.449;
  struct MonoDomain * D.34613;
  int D.29045;
  int iftmp.450;
  int D.29044;
  const char[6] * D.34625;
  unsigned char D.34626;
  int D.34627;
  unsigned char D.34628;
  int D.34629;
  _Bool D.34630;
  _Bool D.34631;
  _Bool D.34632;
  const unsigned char * D.34635;
  unsigned char D.34636;
  int D.34637;
  const unsigned char * D.34638;
  unsigned char D.34639;
  int D.34640;
  _Bool D.34641;
  _Bool D.34642;
  const unsigned char * D.34645;
  unsigned char D.34646;
  int D.34647;
  const unsigned char * D.34648;
  unsigned char D.34649;
  int D.34650;
  _Bool D.34651;
  _Bool D.34652;
  const unsigned char * D.34655;
  unsigned char D.34656;
  int D.34657;
  const unsigned char * D.34658;
  unsigned char D.34659;
  int D.34660;
  const char * D.34662;
  unsigned int D.34665;
  struct MonoObject * this.451;
  int D.34672;
  short unsigned int D.34675;
  int D.34676;
  unsigned int nargs.452;
  unsigned int D.34680;
  struct MonoType * D.34681;
  int D.34682;
  unsigned int i.453;
  unsigned int D.34686;
  guint8 * D.34687;
  <unnamed type> D.34688;
  int err.454;
  void * * D.34691;
  void * D.34692;
  struct MonoVTable * D.34695;
  struct MonoDomain * D.34696;
  guint8 * * D.34700;
  struct MonoClass * D.34701;
  int D.34702;
  unsigned int D.34703;
  void * D.34704;
  guint8 * D.34705;
  <unnamed type> D.34706;
  int err.455;
  int D.34711;
  int D.34712;
  int D.34716;
  struct MonoLMF * D.34719;
  struct MonoContext * D.34720;
  struct MonoObject * res.456;
  struct MonoObject * res.457;
  unsigned int D.34728;
  void * D.34729;
  struct MonoObject * res.458;
  const char * iftmp.459;
  struct MonoObject * exc.460;
  struct MonoVTable * D.34735;
  struct MonoClass * D.34736;
  long long unsigned int D.34738;
  long int D.34739;
  struct MonoClass * D.34742;
  struct MonoType * D.34743;
  struct MonoType * D.34745;
  unsigned char D.34746;
  int D.29058;
  int iftmp.461;
  int D.29057;
  unsigned char D.34754;
  int D.34755;
  _Bool D.34756;
  _Bool D.34757;
  _Bool D.34758;
  const unsigned char * D.34761;
  unsigned char D.34762;
  int D.34763;
  _Bool D.34764;
  _Bool D.34765;
  const unsigned char * D.34768;
  unsigned char D.34769;
  int D.34770;
  _Bool D.34771;
  _Bool D.34772;
  const unsigned char * D.34775;
  unsigned char D.34776;
  int D.34777;
  struct MonoClass * D.34781;
  struct MonoType * D.34782;
  int D.34784;
  struct MonoClass * D.34791;
  unsigned char D.34792;
  unsigned char D.34793;
  struct MonoClass * D.34796;
  int D.34797;
  int D.34800;
  unsigned int D.34801;
  _Bool D.34802;
  long int D.34803;
  long int D.34804;
  _Bool D.34808;
  long int D.34809;
  long int D.34810;
  void * D.34813;
  void * D.34816;
  int D.34817;
  int D.34818;
  struct MonoLMF * D.34819;
  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.34530 = invoke->method;
      if (D.34530 != 0B) goto <D.34531>; else goto <D.34532>;
      <D.34531>:
      this = 0B;
      log_level.440 = log_level;
      D.34534 = log_level.440 > 0;
      D.34535 = (long int) D.34534;
      D.34536 = __builtin_expect (D.34535, 0);
      if (D.34536 != 0) goto <D.34537>; else goto <D.34538>;
      <D.34537>:
      log_file.441 = log_file;
      D.34540 = GetCurrentThreadId ();
      D.34541 = (void *) D.34540;
      D.34530 = invoke->method;
      D.34542 = mono_method_full_name (D.34530, 1);
      this.443 = this;
      if (this.443 != 0B) goto <D.34545>; else goto <D.34546>;
      <D.34545>:
      this.443 = this;
      D.34547 = this.443->vtable;
      D.34548 = D.34547->klass;
      iftmp.442 = D.34548->name;
      goto <D.34549>;
      <D.34546>:
      iftmp.442 = "<null>";
      <D.34549>:
      fprintf (log_file.441, "[%p] Invoking method \'%s\' on receiver \'%s\'.\n", D.34541, D.34542, iftmp.442);
      log_file.441 = log_file;
      fflush (log_file.441);
      <D.34538>:
      D.34530 = invoke->method;
      D.34550 = invoke->args;
      mono_runtime_invoke (D.34530, 0B, D.34550, &exc);
      monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "debugger-agent.c", 6243);
      <D.34532>:
      p.444 = p;
      m = decode_methodid (p.444, &p, end, &domain, &err);
      err.445 = err;
      if (err.445 != 0) goto <D.34553>; else goto <D.34554>;
      <D.34553>:
      err.445 = err;
      D.34555 = (ErrorCode) err.445;
      return D.34555;
      <D.34554>:
      sig = mono_method_signature (m);
      D.34556 = m->klass;
      D.34557 = BIT_FIELD_REF <*D.34556, 8, 160>;
      D.34558 = D.34557 & 8;
      if (D.34558 != 0) goto <D.34559>; else goto <D.34560>;
      <D.34559>:
      D.34556 = m->klass;
      D.34561 = mono_class_instance_size (D.34556);
      D.34562 = (unsigned int) D.34561;
      this_buf = __builtin_alloca (D.34562);
      goto <D.34563>;
      <D.34560>:
      this_buf = __builtin_alloca (4);
      <D.34563>:
      D.34556 = m->klass;
      D.34557 = BIT_FIELD_REF <*D.34556, 8, 160>;
      D.34558 = D.34557 & 8;
      if (D.34558 != 0) goto <D.34566>; else goto <D.34564>;
      <D.34566>:
      D.34567 = m->flags;
      D.34568 = (int) D.34567;
      D.34569 = D.34568 & 16;
      if (D.34569 != 0) goto <D.34570>; else goto <D.34564>;
      <D.34570>:
      {
        int type;

        p.444 = p;
        type = decode_byte (p.444, &p, end);
        if (type != 240) goto <D.34571>; else goto <D.34572>;
        <D.34571>:
        log_level.440 = log_level;
        D.34534 = log_level.440 > 0;
        D.34535 = (long int) D.34534;
        D.34536 = __builtin_expect (D.34535, 0);
        if (D.34536 != 0) goto <D.34573>; else goto <D.34574>;
        <D.34573>:
        log_file.441 = log_file;
        D.34575 = GetCurrentThreadId ();
        D.34576 = (void *) D.34575;
        fprintf (log_file.441, "[%p] Error: Static vtype method invoked with this argument.\n", D.34576);
        log_file.441 = log_file;
        fflush (log_file.441);
        <D.34574>:
        D.34555 = 102;
        return D.34555;
        <D.34572>:
        D.34556 = m->klass;
        D.34577 = mono_class_instance_size (D.34556);
        D.34578 = (unsigned int) D.34577;
        memset (this_buf, 0, D.34578);
      }
      goto <D.34565>;
      <D.34564>:
      D.34556 = m->klass;
      D.34579 = &D.34556->byval_arg;
      domain.446 = domain;
      p.444 = p;
      D.34581 = decode_value (D.34579, domain.446, this_buf, p.444, &p, end);
      err.447 = (int) D.34581;
      err = err.447;
      err.445 = err;
      if (err.445 != 0) goto <D.34583>; else goto <D.34584>;
      <D.34583>:
      err.445 = err;
      D.34555 = (ErrorCode) err.445;
      return D.34555;
      <D.34584>:
      <D.34565>:
      D.34556 = m->klass;
      D.34557 = BIT_FIELD_REF <*D.34556, 8, 160>;
      D.34558 = D.34557 & 8;
      if (D.34558 == 0) goto <D.34585>; else goto <D.34586>;
      <D.34585>:
      this.448 = MEM[(struct MonoObject * *)this_buf];
      this = this.448;
      goto <D.34588>;
      <D.34586>:
      this = 0B;
      <D.34588>:
      D.34556 = m->klass;
      D.34591 = D.34556->flags;
      D.34592 = D.34591 & 32;
      if (D.34592 != 0) goto <D.34589>; else goto <D.34593>;
      <D.34593>:
      D.34556 = m->klass;
      D.34594 = D.34556->byval_arg.type;
      if (D.34594 == 19) goto <D.34589>; else goto <D.34595>;
      <D.34595>:
      D.34556 = m->klass;
      D.34594 = D.34556->byval_arg.type;
      if (D.34594 == 30) goto <D.34589>; else goto <D.34590>;
      <D.34589>:
      this.443 = this;
      if (this.443 == 0B) goto <D.34596>; else goto <D.34597>;
      <D.34596>:
      log_level.440 = log_level;
      D.34534 = log_level.440 > 0;
      D.34535 = (long int) D.34534;
      D.34536 = __builtin_expect (D.34535, 0);
      if (D.34536 != 0) goto <D.34598>; else goto <D.34599>;
      <D.34598>:
      log_file.441 = log_file;
      D.34600 = GetCurrentThreadId ();
      D.34601 = (void *) D.34600;
      fprintf (log_file.441, "[%p] Error: Interface method invoked without this argument.\n", D.34601);
      log_file.441 = log_file;
      fflush (log_file.441);
      <D.34599>:
      D.34555 = 102;
      return D.34555;
      <D.34597>:
      this.443 = this;
      m = mono_object_get_virtual_method (this.443, m);
      <D.34590>:
      log_level.440 = log_level;
      D.34534 = log_level.440 > 0;
      D.34535 = (long int) D.34534;
      D.34536 = __builtin_expect (D.34535, 0);
      if (D.34536 != 0) goto <D.34602>; else goto <D.34603>;
      <D.34602>:
      log_file.441 = log_file;
      D.34604 = GetCurrentThreadId ();
      D.34605 = (void *) D.34604;
      D.34606 = mono_method_full_name (m, 1);
      this.443 = this;
      if (this.443 != 0B) goto <D.34608>; else goto <D.34609>;
      <D.34608>:
      this.443 = this;
      D.34547 = this.443->vtable;
      D.34548 = D.34547->klass;
      iftmp.449 = D.34548->name;
      goto <D.34610>;
      <D.34609>:
      iftmp.449 = "<null>";
      <D.34610>:
      fprintf (log_file.441, "[%p] Invoking method \'%s\' on receiver \'%s\'.\n", D.34605, D.34606, iftmp.449);
      log_file.441 = log_file;
      fflush (log_file.441);
      <D.34603>:
      this.443 = this;
      if (this.443 != 0B) goto <D.34611>; else goto <D.34612>;
      <D.34611>:
      this.443 = this;
      D.34547 = this.443->vtable;
      D.34613 = D.34547->domain;
      domain.446 = domain;
      if (D.34613 != domain.446) goto <D.34614>; else goto <D.34615>;
      <D.34614>:
      monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "debugger-agent.c", 6285);
      <D.34615>:
      <D.34612>:
      D.34556 = m->klass;
      D.34557 = BIT_FIELD_REF <*D.34556, 8, 160>;
      D.34558 = D.34557 & 8;
      if (D.34558 == 0) goto <D.34616>; else goto <D.34617>;
      <D.34616>:
      D.34567 = m->flags;
      D.34568 = (int) D.34567;
      D.34569 = D.34568 & 16;
      if (D.34569 == 0) goto <D.34618>; else goto <D.34619>;
      <D.34618>:
      this.443 = this;
      if (this.443 == 0B) goto <D.34620>; else goto <D.34621>;
      <D.34620>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          __s2 = m->name;
          D.34625 = ".ctor";
          D.34626 = MEM[(const unsigned char *)D.34625];
          D.34627 = (int) D.34626;
          D.34628 = *__s2;
          D.34629 = (int) D.34628;
          __result = D.34627 - D.34629;
          {
            D.34630 = __s2_len != 0;
            D.34631 = __result == 0;
            D.34632 = D.34630 & D.34631;
            if (D.34632 != 0) goto <D.34633>; else goto <D.34634>;
            <D.34633>:
            D.34635 = &MEM[(void *)".ctor" + 1B];
            D.34636 = *D.34635;
            D.34637 = (int) D.34636;
            D.34638 = __s2 + 1;
            D.34639 = *D.34638;
            D.34640 = (int) D.34639;
            __result = D.34637 - D.34640;
            D.34641 = __s2_len > 1;
            D.34631 = __result == 0;
            D.34642 = D.34641 & D.34631;
            if (D.34642 != 0) goto <D.34643>; else goto <D.34644>;
            <D.34643>:
            D.34645 = &MEM[(void *)".ctor" + 2B];
            D.34646 = *D.34645;
            D.34647 = (int) D.34646;
            D.34648 = __s2 + 2;
            D.34649 = *D.34648;
            D.34650 = (int) D.34649;
            __result = D.34647 - D.34650;
            D.34651 = __s2_len > 2;
            D.34631 = __result == 0;
            D.34652 = D.34651 & D.34631;
            if (D.34652 != 0) goto <D.34653>; else goto <D.34654>;
            <D.34653>:
            D.34655 = &MEM[(void *)".ctor" + 3B];
            D.34656 = *D.34655;
            D.34657 = (int) D.34656;
            D.34658 = __s2 + 3;
            D.34659 = *D.34658;
            D.34660 = (int) D.34659;
            __result = D.34657 - D.34660;
            <D.34654>:
            <D.34644>:
            <D.34634>:
          }
          D.29044 = __result;
        }
        iftmp.450 = -D.29044;
        goto <D.34661>;
        <D.34624>:
        D.34662 = m->name;
        iftmp.450 = __builtin_strcmp (D.34662, ".ctor");
        <D.34661>:
        D.29045 = iftmp.450;
      }
      if (D.29045 == 0) goto <D.34663>; else goto <D.34664>;
      <D.34663>:
      D.34556 = m->klass;
      D.34591 = D.34556->flags;
      D.34665 = D.34591 & 128;
      if (D.34665 != 0) goto <D.34666>; else goto <D.34667>;
      <D.34666>:
      D.34555 = 102;
      return D.34555;
      <D.34667>:
      domain.446 = domain;
      D.34556 = m->klass;
      this.451 = mono_object_new (domain.446, D.34556);
      this = this.451;
      goto <D.34669>;
      <D.34664>:
      D.34555 = 102;
      return D.34555;
      <D.34669>:
      <D.34621>:
      <D.34619>:
      <D.34617>:
      this.443 = this;
      if (this.443 != 0B) goto <D.34670>; else goto <D.34671>;
      <D.34670>:
      this.443 = this;
      D.34556 = m->klass;
      D.34579 = &D.34556->byval_arg;
      D.34672 = obj_is_of_type (this.443, D.34579);
      if (D.34672 == 0) goto <D.34673>; else goto <D.34674>;
      <D.34673>:
      D.34555 = 102;
      return D.34555;
      <D.34674>:
      <D.34671>:
      p.444 = p;
      nargs = decode_int (p.444, &p, end);
      D.34675 = sig->param_count;
      D.34676 = (int) D.34675;
      if (D.34676 != nargs) goto <D.34677>; else goto <D.34678>;
      <D.34677>:
      D.34555 = 102;
      return D.34555;
      <D.34678>:
      nargs.452 = (unsigned int) nargs;
      D.34680 = nargs.452 * 4;
      arg_buf = __builtin_alloca (D.34680);
      nargs.452 = (unsigned int) nargs;
      D.34680 = nargs.452 * 4;
      memset (arg_buf, 0, D.34680);
      nargs.452 = (unsigned int) nargs;
      D.34680 = nargs.452 * 4;
      args = __builtin_alloca (D.34680);
      i = 0;
      goto <D.29048>;
      <D.29047>:
      D.34681 = sig->params[i];
      D.34682 = mono_type_is_reference (D.34681);
      if (D.34682 != 0) goto <D.34683>; else goto <D.34684>;
      <D.34683>:
      D.34681 = sig->params[i];
      domain.446 = domain;
      i.453 = (unsigned int) i;
      D.34686 = i.453 * 4;
      D.34687 = args + D.34686;
      p.444 = p;
      D.34688 = decode_value (D.34681, domain.446, D.34687, p.444, &p, end);
      err.454 = (int) D.34688;
      err = err.454;
      err.445 = err;
      if (err.445 != 0) goto <D.29046>; else goto <D.34690>;
      <D.34690>:
      i.453 = (unsigned int) i;
      D.34686 = i.453 * 4;
      D.34691 = args + D.34686;
      D.34692 = *D.34691;
      if (D.34692 != 0B) goto <D.34693>; else goto <D.34694>;
      <D.34693>:
      i.453 = (unsigned int) i;
      D.34686 = i.453 * 4;
      D.34691 = args + D.34686;
      D.34692 = *D.34691;
      D.34695 = MEM[(struct MonoObject *)D.34692].vtable;
      D.34696 = D.34695->domain;
      domain.446 = domain;
      if (D.34696 != domain.446) goto <D.34697>; else goto <D.34698>;
      <D.34697>:
      monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "debugger-agent.c", 6315);
      <D.34698>:
      <D.34694>:
      goto <D.34699>;
      <D.34684>:
      i.453 = (unsigned int) i;
      D.34686 = i.453 * 4;
      D.34700 = arg_buf + D.34686;
      D.34681 = sig->params[i];
      D.34701 = mono_class_from_mono_type (D.34681);
      D.34702 = mono_class_instance_size (D.34701);
      D.34703 = (unsigned int) D.34702;
      D.34704 = __builtin_alloca (D.34703);
      *D.34700 = D.34704;
      D.34681 = sig->params[i];
      domain.446 = domain;
      i.453 = (unsigned int) i;
      D.34686 = i.453 * 4;
      D.34700 = arg_buf + D.34686;
      D.34705 = *D.34700;
      p.444 = p;
      D.34706 = decode_value (D.34681, domain.446, D.34705, p.444, &p, end);
      err.455 = (int) D.34706;
      err = err.455;
      err.445 = err;
      if (err.445 != 0) goto <D.29046>; else goto <D.34708>;
      <D.34708>:
      i.453 = (unsigned int) i;
      D.34686 = i.453 * 4;
      D.34691 = args + D.34686;
      i.453 = (unsigned int) i;
      D.34686 = i.453 * 4;
      D.34700 = arg_buf + D.34686;
      D.34705 = *D.34700;
      *D.34691 = D.34705;
      <D.34699>:
      i = i + 1;
      <D.29048>:
      if (i < nargs) goto <D.29047>; else goto <D.29046>;
      <D.29046>:
      if (i < nargs) goto <D.34709>; else goto <D.34710>;
      <D.34709>:
      err.445 = err;
      D.34555 = (ErrorCode) err.445;
      return D.34555;
      <D.34710>:
      D.34711 = invoke->flags;
      D.34712 = D.34711 & 1;
      if (D.34712 != 0) goto <D.34713>; else goto <D.34714>;
      <D.34713>:
      tls->disable_breakpoints = 1;
      goto <D.34715>;
      <D.34714>:
      tls->disable_breakpoints = 0;
      <D.34715>:
      D.34716 = invoke->has_ctx;
      if (D.34716 != 0) goto <D.34717>; else goto <D.34718>;
      <D.34717>:
      {
        struct MonoLMF * * lmf_addr;

        lmf_addr = mono_get_lmf_addr ();
        memset (&ext, 0, 424);
        D.34719 = *lmf_addr;
        mono_arch_init_lmf_ext (&ext, D.34719);
        ext.debugger_invoke = 1;
        D.34720 = &invoke->ctx;
        memcpy (&ext.ctx, D.34720, 208);
        mono_set_lmf (&ext);
      }
      <D.34718>:
      mono_stopwatch_start (&watch);
      D.34556 = m->klass;
      D.34557 = BIT_FIELD_REF <*D.34556, 8, 160>;
      D.34558 = D.34557 & 8;
      if (D.34558 != 0) goto <D.34721>; else goto <D.34722>;
      <D.34721>:
      res.456 = mono_runtime_invoke (m, this_buf, args, &exc);
      res = res.456;
      goto <D.34724>;
      <D.34722>:
      this.443 = this;
      res.457 = mono_runtime_invoke (m, this.443, args, &exc);
      res = res.457;
      <D.34724>:
      mono_stopwatch_stop (&watch);
      log_level.440 = log_level;
      D.34534 = log_level.440 > 0;
      D.34535 = (long int) D.34534;
      D.34536 = __builtin_expect (D.34535, 0);
      if (D.34536 != 0) goto <D.34726>; else goto <D.34727>;
      <D.34726>:
      log_file.441 = log_file;
      D.34728 = GetCurrentThreadId ();
      D.34729 = (void *) D.34728;
      res.458 = res;
      exc.460 = exc;
      if (exc.460 != 0B) goto <D.34733>; else goto <D.34734>;
      <D.34733>:
      exc.460 = exc;
      D.34735 = exc.460->vtable;
      D.34736 = D.34735->klass;
      iftmp.459 = D.34736->name;
      goto <D.34737>;
      <D.34734>:
      iftmp.459 = 0B;
      <D.34737>:
      D.34738 = mono_stopwatch_elapsed_ms (&watch);
      D.34739 = (long int) D.34738;
      fprintf (log_file.441, "[%p] Invoke result: %p, exc: %s, time: %ld ms.\n", D.34729, res.458, iftmp.459, D.34739);
      log_file.441 = log_file;
      fflush (log_file.441);
      <D.34727>:
      exc.460 = exc;
      if (exc.460 != 0B) goto <D.34740>; else goto <D.34741>;
      <D.34740>:
      buffer_add_byte (buf, 0);
      D.34742 = mono_defaults.object_class;
      D.34743 = &D.34742->byval_arg;
      domain.446 = domain;
      buffer_add_value (buf, D.34743, &exc, domain.446);
      goto <D.34744>;
      <D.34741>:
      buffer_add_byte (buf, 1);
      D.34745 = sig->ret;
      D.34746 = D.34745->type;
      if (D.34746 == 1) goto <D.34747>; else goto <D.34748>;
      <D.34747>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          __s2 = m->name;
          D.34625 = ".ctor";
          D.34626 = MEM[(const unsigned char *)D.34625];
          D.34627 = (int) D.34626;
          D.34754 = *__s2;
          D.34755 = (int) D.34754;
          __result = D.34627 - D.34755;
          {
            D.34756 = __s2_len != 0;
            D.34757 = __result == 0;
            D.34758 = D.34756 & D.34757;
            if (D.34758 != 0) goto <D.34759>; else goto <D.34760>;
            <D.34759>:
            D.34635 = &MEM[(void *)".ctor" + 1B];
            D.34636 = *D.34635;
            D.34637 = (int) D.34636;
            D.34761 = __s2 + 1;
            D.34762 = *D.34761;
            D.34763 = (int) D.34762;
            __result = D.34637 - D.34763;
            D.34764 = __s2_len > 1;
            D.34757 = __result == 0;
            D.34765 = D.34764 & D.34757;
            if (D.34765 != 0) goto <D.34766>; else goto <D.34767>;
            <D.34766>:
            D.34645 = &MEM[(void *)".ctor" + 2B];
            D.34646 = *D.34645;
            D.34647 = (int) D.34646;
            D.34768 = __s2 + 2;
            D.34769 = *D.34768;
            D.34770 = (int) D.34769;
            __result = D.34647 - D.34770;
            D.34771 = __s2_len > 2;
            D.34757 = __result == 0;
            D.34772 = D.34771 & D.34757;
            if (D.34772 != 0) goto <D.34773>; else goto <D.34774>;
            <D.34773>:
            D.34655 = &MEM[(void *)".ctor" + 3B];
            D.34656 = *D.34655;
            D.34657 = (int) D.34656;
            D.34775 = __s2 + 3;
            D.34776 = *D.34775;
            D.34777 = (int) D.34776;
            __result = D.34657 - D.34777;
            <D.34774>:
            <D.34767>:
            <D.34760>:
          }
          D.29057 = __result;
        }
        iftmp.461 = -D.29057;
        goto <D.34778>;
        <D.34753>:
        D.34662 = m->name;
        iftmp.461 = __builtin_strcmp (D.34662, ".ctor");
        <D.34778>:
        D.29058 = iftmp.461;
      }
      if (D.29058 == 0) goto <D.34779>; else goto <D.34749>;
      <D.34779>:
      D.34556 = m->klass;
      D.34557 = BIT_FIELD_REF <*D.34556, 8, 160>;
      D.34558 = D.34557 & 8;
      if (D.34558 == 0) goto <D.34780>; else goto <D.34749>;
      <D.34780>:
      D.34742 = mono_defaults.object_class;
      D.34743 = &D.34742->byval_arg;
      domain.446 = domain;
      buffer_add_value (buf, D.34743, &this, domain.446);
      goto <D.34750>;
      <D.34749>:
      D.34781 = mono_defaults.void_class;
      D.34782 = &D.34781->byval_arg;
      domain.446 = domain;
      buffer_add_value (buf, D.34782, 0B, domain.446);
      <D.34750>:
      goto <D.34783>;
      <D.34748>:
      D.34745 = sig->ret;
      D.34784 = mono_type_is_reference (D.34745);
      if (D.34784 != 0) goto <D.34785>; else goto <D.34786>;
      <D.34785>:
      D.34745 = sig->ret;
      domain.446 = domain;
      buffer_add_value (buf, D.34745, &res, domain.446);
      goto <D.34787>;
      <D.34786>:
      D.34745 = sig->ret;
      D.34791 = mono_class_from_mono_type (D.34745);
      D.34792 = BIT_FIELD_REF <*D.34791, 8, 160>;
      D.34793 = D.34792 & 8;
      if (D.34793 != 0) goto <D.34788>; else goto <D.34794>;
      <D.34794>:
      D.34745 = sig->ret;
      D.34746 = D.34745->type;
      if (D.34746 == 15) goto <D.34788>; else goto <D.34795>;
      <D.34795>:
      D.34745 = sig->ret;
      D.34746 = D.34745->type;
      if (D.34746 == 27) goto <D.34788>; else goto <D.34789>;
      <D.34788>:
      D.34745 = sig->ret;
      D.34796 = mono_class_from_mono_type (D.34745);
      D.34797 = mono_class_is_nullable (D.34796);
      if (D.34797 != 0) goto <D.34798>; else goto <D.34799>;
      <D.34798>:
      {
        struct MonoClass * k;
        guint8 * nullable_buf;

        D.34745 = sig->ret;
        k = mono_class_from_mono_type (D.34745);
        D.34800 = mono_class_value_size (k, 0B);
        D.34801 = (unsigned int) D.34800;
        nullable_buf = __builtin_alloca (D.34801);
        D.34802 = nullable_buf == 0B;
        D.34803 = (long int) D.34802;
        D.34804 = __builtin_expect (D.34803, 0);
        if (D.34804 != 0) goto <D.34805>; else goto <D.34806>;
        <D.34805>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 6379, "nullable_buf");
        <D.34806>:
        res.458 = res;
        mono_nullable_init (nullable_buf, res.458, k);
        D.34745 = sig->ret;
        domain.446 = domain;
        buffer_add_value (buf, D.34745, nullable_buf, domain.446);
      }
      goto <D.34807>;
      <D.34799>:
      res.458 = res;
      D.34808 = res.458 == 0B;
      D.34809 = (long int) D.34808;
      D.34810 = __builtin_expect (D.34809, 0);
      if (D.34810 != 0) goto <D.34811>; else goto <D.34812>;
      <D.34811>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 6383, "res");
      <D.34812>:
      D.34745 = sig->ret;
      res.458 = res;
      D.34813 = mono_object_unbox (res.458);
      domain.446 = domain;
      buffer_add_value (buf, D.34745, D.34813, domain.446);
      <D.34807>:
      goto <D.34790>;
      <D.34789>:
      monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "debugger-agent.c", 6387);
      <D.34790>:
      <D.34787>:
      <D.34783>:
      <D.34744>:
      tls->disable_breakpoints = 0;
      D.34716 = invoke->has_ctx;
      if (D.34716 != 0) goto <D.34814>; else goto <D.34815>;
      <D.34814>:
      D.34816 = ext.lmf.previous_lmf;
      D.34817 = (int) D.34816;
      D.34818 = D.34817 & -4;
      D.34819 = (struct MonoLMF *) D.34818;
      mono_set_lmf (D.34819);
      <D.34815>:
      p.444 = p;
      *endp = p.444;
      D.34555 = 0;
      return D.34555;
    }
  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.34824;
  int D.34829;
  void * D.34831;
  unsigned int D.34832;

  D.34824 = __builtin_constant_p (__len);
  if (D.34824 != 0) goto <D.34825>; else goto <D.34826>;
  <D.34825>:
  if (__len == 0) goto <D.34827>; else goto <D.34828>;
  <D.34827>:
  D.34829 = __builtin_constant_p (__ch);
  if (D.34829 == 0) goto <D.34822>; else goto <D.34830>;
  <D.34830>:
  if (__ch != 0) goto <D.34822>; else goto <D.34823>;
  <D.34822>:
  __warn_memset_zero_len ();
  D.34831 = __dest;
  return D.34831;
  <D.34823>:
  <D.34828>:
  <D.34826>:
  D.34832 = __builtin_object_size (__dest, 0);
  D.34831 = __builtin___memset_chk (__dest, __ch, __len, D.34832);
  return D.34831;
}


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

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


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

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


mono_stopwatch_elapsed_ms (struct MonoStopwatch * w)
{
  guint64 D.34836;
  long long unsigned int D.34837;
  long long unsigned int D.34838;

  D.34837 = mono_stopwatch_elapsed (w);
  D.34838 = D.34837 + 500;
  D.34836 = D.34838 / 1000;
  return D.34836;
}


mono_stopwatch_elapsed (struct MonoStopwatch * w)
{
  guint64 D.34840;
  long long int D.34841;
  long long int D.34842;
  long long int D.34843;
  long long int D.34844;

  D.34841 = w->stop;
  D.34842 = w->start;
  D.34843 = D.34841 - D.34842;
  D.34844 = D.34843 / 10;
  D.34840 = (guint64) D.34844;
  return D.34840;
}


send_type_load (struct MonoClass * klass)
{
  union mono_mutex_t * D.34846;
  _Bool D.34849;
  long int D.34850;
  long int D.34851;
  struct GHashTable * D.34854;
  void * D.34855;
  _Bool D.34860;
  long int D.34861;
  long int D.34862;
  gboolean type_load;
  struct MonoDomain * domain;
  struct AgentDomainInfo * info;

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

    D.34846 = &domain->lock.mutex;
    ret = pthread_mutex_lock (D.34846);
    if (ret != 0) goto <D.34847>; else goto <D.34848>;
    <D.34847>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.34848>:
    D.34849 = ret != 0;
    D.34850 = (long int) D.34849;
    D.34851 = __builtin_expect (D.34850, 0);
    if (D.34851 != 0) goto <D.34852>; else goto <D.34853>;
    <D.34852>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 3983, "ret == 0");
    <D.34853>:
  }
  info = get_agent_domain_info (domain);
  D.34854 = info->loaded_classes;
  D.34855 = monoeg_g_hash_table_lookup (D.34854, klass);
  if (D.34855 == 0B) goto <D.34856>; else goto <D.34857>;
  <D.34856>:
  type_load = 1;
  D.34854 = info->loaded_classes;
  monoeg_g_hash_table_insert_replace (D.34854, klass, klass, 0);
  <D.34857>:
  {
    int ret;

    D.34846 = &domain->lock.mutex;
    ret = pthread_mutex_unlock (D.34846);
    if (ret != 0) goto <D.34858>; else goto <D.34859>;
    <D.34858>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.34859>:
    D.34860 = ret != 0;
    D.34861 = (long int) D.34860;
    D.34862 = __builtin_expect (D.34861, 0);
    if (D.34862 != 0) goto <D.34863>; else goto <D.34864>;
    <D.34863>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 3992, "ret == 0");
    <D.34864>:
  }
  mono_loader_unlock ();
  if (type_load != 0) goto <D.34865>; else goto <D.34866>;
  <D.34865>:
  emit_type_load (klass, klass, 0B);
  <D.34866>:
}


add_pending_breakpoints (struct MonoMethod * method, struct MonoJitInfo * ji)
{
  struct GPtrArray * breakpoints.462;
  void * * D.34870;
  unsigned int i.463;
  unsigned int D.34872;
  void * * D.34873;
  int D.34874;
  struct GPtrArray * D.34877;
  void * * D.34878;
  unsigned int j.464;
  unsigned int D.34880;
  void * * D.34881;
  struct MonoJitInfo * D.34882;
  unsigned int j.465;
  unsigned int D.34886;
  union mono_mutex_t * D.34889;
  _Bool D.34892;
  long int D.34893;
  long int D.34894;
  void * D.34897;
  struct GHashTable * D.34898;
  unsigned char D.34901;
  unsigned char D.34902;
  struct MonoMethod * D.34905;
  _Bool D.34908;
  long int D.34909;
  long int D.34910;
  _Bool D.34915;
  long int D.34916;
  long int D.34917;
  unsigned int i.466;
  unsigned int D.34921;
  int i;
  int j;
  struct MonoSeqPointInfo * seq_points;
  struct MonoDomain * domain;
  struct MonoMethod * jmethod;

  breakpoints.462 = breakpoints;
  if (breakpoints.462 == 0B) goto <D.34868>; else goto <D.34869>;
  <D.34868>:
  return;
  <D.34869>:
  domain = mono_domain_get ();
  mono_loader_lock ();
  i = 0;
  goto <D.28374>;
  <D.28373>:
  {
    struct MonoBreakpoint * bp;
    gboolean found;

    breakpoints.462 = breakpoints;
    D.34870 = breakpoints.462->pdata;
    i.463 = (unsigned int) i;
    D.34872 = i.463 * 4;
    D.34873 = D.34870 + D.34872;
    bp = *D.34873;
    found = 0;
    D.34874 = bp_matches_method (bp, method);
    if (D.34874 == 0) goto <D.34875>; else goto <D.34876>;
    <D.34875>:
    // predicted unlikely by continue predictor.
    goto <D.28366>;
    <D.34876>:
    j = 0;
    goto <D.28369>;
    <D.28368>:
    {
      struct BreakpointInstance * inst;

      D.34877 = bp->children;
      D.34878 = D.34877->pdata;
      j.464 = (unsigned int) j;
      D.34880 = j.464 * 4;
      D.34881 = D.34878 + D.34880;
      inst = *D.34881;
      D.34882 = inst->ji;
      if (D.34882 == ji) goto <D.34883>; else goto <D.34884>;
      <D.34883>:
      found = 1;
      <D.34884>:
    }
    j = j + 1;
    <D.28369>:
    j.465 = (unsigned int) j;
    D.34877 = bp->children;
    D.34886 = D.34877->len;
    if (j.465 < D.34886) goto <D.28368>; else goto <D.28370>;
    <D.28370>:
    if (found == 0) goto <D.34887>; else goto <D.34888>;
    <D.34887>:
    jmethod = jinfo_get_method (ji);
    {
      int ret;

      D.34889 = &domain->lock.mutex;
      ret = pthread_mutex_lock (D.34889);
      if (ret != 0) goto <D.34890>; else goto <D.34891>;
      <D.34890>:
      monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
      <D.34891>:
      D.34892 = ret != 0;
      D.34893 = (long int) D.34892;
      D.34894 = __builtin_expect (D.34893, 0);
      if (D.34894 != 0) goto <D.34895>; else goto <D.34896>;
      <D.34895>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 4271, "ret == 0");
      <D.34896>:
    }
    D.34897 = domain->runtime_info;
    D.34898 = MEM[(struct MonoJitDomainInfo *)D.34897].seq_points;
    seq_points = monoeg_g_hash_table_lookup (D.34898, jmethod);
    if (seq_points == 0B) goto <D.34899>; else goto <D.34900>;
    <D.34899>:
    D.34901 = BIT_FIELD_REF <*jmethod, 8, 168>;
    D.34902 = D.34901 & 16;
    if (D.34902 != 0) goto <D.34903>; else goto <D.34904>;
    <D.34903>:
    D.34897 = domain->runtime_info;
    D.34898 = MEM[(struct MonoJitDomainInfo *)D.34897].seq_points;
    D.34905 = mono_method_get_declaring_generic_method (jmethod);
    seq_points = monoeg_g_hash_table_lookup (D.34898, D.34905);
    <D.34904>:
    <D.34900>:
    {
      int ret;

      D.34889 = &domain->lock.mutex;
      ret = pthread_mutex_unlock (D.34889);
      if (ret != 0) goto <D.34906>; else goto <D.34907>;
      <D.34906>:
      monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
      <D.34907>:
      D.34908 = ret != 0;
      D.34909 = (long int) D.34908;
      D.34910 = __builtin_expect (D.34909, 0);
      if (D.34910 != 0) goto <D.34911>; else goto <D.34912>;
      <D.34911>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 4275, "ret == 0");
      <D.34912>:
    }
    if (seq_points == 0B) goto <D.34913>; else goto <D.34914>;
    <D.34913>:
    // predicted unlikely by continue predictor.
    goto <D.28366>;
    <D.34914>:
    D.34915 = seq_points == 0B;
    D.34916 = (long int) D.34915;
    D.34917 = __builtin_expect (D.34916, 0);
    if (D.34917 != 0) goto <D.34918>; else goto <D.34919>;
    <D.34918>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 4279, "seq_points");
    <D.34919>:
    insert_breakpoint (seq_points, domain, ji, bp, 0B);
    <D.34888>:
  }
  <D.28366>:
  i = i + 1;
  <D.28374>:
  i.466 = (unsigned int) i;
  breakpoints.462 = breakpoints;
  D.34921 = breakpoints.462->len;
  if (i.466 < D.34921) goto <D.28373>; else goto <D.28375>;
  <D.28375>:
  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.34924;
  unsigned int i.468;
  unsigned int D.34926;
  void * * D.34927;
  int D.34928;
  int D.34931;
  int D.34932;
  unsigned int i.469;
  unsigned int D.34934;
  int i;
  gboolean found;

  mono_loader_lock ();
  found = 1;
  goto <D.28995>;
  <D.28994>:
  found = 0;
  i = 0;
  goto <D.28993>;
  <D.28992>:
  {
    struct EventRequest * req;

    event_requests.467 = event_requests;
    D.34924 = event_requests.467->pdata;
    i.468 = (unsigned int) i;
    D.34926 = i.468 * 4;
    D.34927 = D.34924 + D.34926;
    req = *D.34927;
    D.34928 = event_req_matches_assembly (req, assembly);
    if (D.34928 != 0) goto <D.34929>; else goto <D.34930>;
    <D.34929>:
    D.34931 = req->id;
    D.34932 = req->event_kind;
    clear_event_request (D.34931, D.34932);
    found = 1;
    goto <D.28991>;
    <D.34930>:
  }
  i = i + 1;
  <D.28993>:
  i.469 = (unsigned int) i;
  event_requests.467 = event_requests;
  D.34934 = event_requests.467->len;
  if (i.469 < D.34934) goto <D.28992>; else goto <D.28991>;
  <D.28991>:
  <D.28995>:
  if (found != 0) goto <D.28994>; else goto <D.28996>;
  <D.28996>:
  mono_loader_unlock ();
}


event_req_matches_assembly (struct EventRequest * req, struct MonoAssembly * assembly)
{
  int D.34935;
  gboolean D.34938;
  void * D.34939;
  <unnamed type> D.34940;
  struct MonoClass * D.34943;
  struct MonoImage * D.34946;
  struct MonoAssembly * D.34947;
  struct MonoAssembly * * D.34952;
  unsigned int j.470;
  unsigned int D.34956;
  struct MonoAssembly * * D.34957;
  struct MonoAssembly * D.34958;
  int D.34961;

  D.34935 = req->event_kind;
  if (D.34935 == 10) goto <D.34936>; else goto <D.34937>;
  <D.34936>:
  D.34939 = req->info;
  D.34938 = breakpoint_matches_assembly (D.34939, assembly);
  return D.34938;
  <D.34937>:
  {
    int i;
    int j;

    i = 0;
    goto <D.28983>;
    <D.28982>:
    {
      struct Modifier * m;

      m = &req->modifiers[i];
      D.34940 = m->kind;
      if (D.34940 == 8) goto <D.34941>; else goto <D.34942>;
      <D.34941>:
      D.34943 = m->data.exc_class;
      if (D.34943 != 0B) goto <D.34944>; else goto <D.34945>;
      <D.34944>:
      D.34943 = m->data.exc_class;
      D.34946 = D.34943->image;
      D.34947 = D.34946->assembly;
      if (D.34947 == assembly) goto <D.34948>; else goto <D.34949>;
      <D.34948>:
      D.34938 = 1;
      return D.34938;
      <D.34949>:
      <D.34945>:
      <D.34942>:
      D.34940 = m->kind;
      if (D.34940 == 11) goto <D.34950>; else goto <D.34951>;
      <D.34950>:
      D.34952 = m->data.assemblies;
      if (D.34952 != 0B) goto <D.34953>; else goto <D.34954>;
      <D.34953>:
      j = 0;
      goto <D.28980>;
      <D.28979>:
      D.34952 = m->data.assemblies;
      j.470 = (unsigned int) j;
      D.34956 = j.470 * 4;
      D.34957 = D.34952 + D.34956;
      D.34958 = *D.34957;
      if (D.34958 == assembly) goto <D.34959>; else goto <D.34960>;
      <D.34959>:
      D.34938 = 1;
      return D.34938;
      <D.34960>:
      j = j + 1;
      <D.28980>:
      D.34952 = m->data.assemblies;
      j.470 = (unsigned int) j;
      D.34956 = j.470 * 4;
      D.34957 = D.34952 + D.34956;
      D.34958 = *D.34957;
      if (D.34958 != 0B) goto <D.28979>; else goto <D.28981>;
      <D.28981>:
      <D.34954>:
      <D.34951>:
    }
    i = i + 1;
    <D.28983>:
    D.34961 = req->nmodifiers;
    if (D.34961 > i) goto <D.28982>; else goto <D.28984>;
    <D.28984>:
  }
  D.34938 = 0;
  return D.34938;
}


breakpoint_matches_assembly (struct MonoBreakpoint * bp, struct MonoAssembly * assembly)
{
  gboolean D.34963;
  int iftmp.471;
  struct MonoMethod * D.34967;
  struct MonoClass * D.34969;
  struct MonoImage * D.34970;
  struct MonoAssembly * D.34971;

  D.34967 = bp->method;
  if (D.34967 != 0B) goto <D.34968>; else goto <D.34965>;
  <D.34968>:
  D.34967 = bp->method;
  D.34969 = D.34967->klass;
  D.34970 = D.34969->image;
  D.34971 = D.34970->assembly;
  if (D.34971 == assembly) goto <D.34972>; else goto <D.34965>;
  <D.34972>:
  iftmp.471 = 1;
  goto <D.34966>;
  <D.34965>:
  iftmp.471 = 0;
  <D.34966>:
  D.34963 = iftmp.471;
  return D.34963;
}


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

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


type_comes_from_assembly (void * klass, void * also_klass, void * assembly)
{
  gboolean D.34975;
  struct MonoImage * D.34976;
  struct MonoImage * D.34977;
  _Bool D.34978;

  D.34976 = mono_class_get_image (klass);
  D.34977 = mono_assembly_get_image (assembly);
  D.34978 = D.34976 == D.34977;
  D.34975 = (gboolean) D.34978;
  return D.34975;
}


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)
{
  struct MonoGHashTable * tid_to_thread.473;
  const void * tid.474;
  struct MonoGHashTable * tid_to_thread_obj.475;
  struct MonoGHashTable * thread_to_tls.476;
  struct MonoInternalThread * * D.34989;
  int log_level.477;
  _Bool D.34993;
  long int D.34994;
  long int D.34995;
  struct FILE * log_file.478;
  void * tid.479;
  struct MonoInternalThread * thread;
  struct DebuggerTlsData * tls;

  tls = 0B;
  mono_loader_lock ();
  tid_to_thread.473 = tid_to_thread;
  tid.474 = (const void *) tid;
  thread = mono_g_hash_table_lookup (tid_to_thread.473, tid.474);
  if (thread != 0B) goto <D.34983>; else goto <D.34984>;
  <D.34983>:
  tid_to_thread_obj.475 = tid_to_thread_obj;
  tid.474 = (const void *) tid;
  mono_g_hash_table_remove (tid_to_thread_obj.475, tid.474);
  thread_to_tls.476 = thread_to_tls;
  tls = mono_g_hash_table_lookup (thread_to_tls.476, thread);
  if (tls != 0B) goto <D.34987>; else goto <D.34988>;
  <D.34987>:
  tls->terminated = 1;
  D.34989 = &tls->thread;
  mono_gc_deregister_root (D.34989);
  tls->thread = 0B;
  <D.34988>:
  <D.34984>:
  mono_loader_unlock ();
  if (thread != 0B) goto <D.34990>; else goto <D.34991>;
  <D.34990>:
  log_level.477 = log_level;
  D.34993 = log_level.477 > 0;
  D.34994 = (long int) D.34993;
  D.34995 = __builtin_expect (D.34994, 0);
  if (D.34995 != 0) goto <D.34996>; else goto <D.34997>;
  <D.34996>:
  log_file.478 = log_file;
  tid.479 = (void *) tid;
  fprintf (log_file.478, "[%p] Thread terminated, obj=%p, tls=%p.\n", tid.479, thread, tls);
  log_file.478 = log_file;
  fflush (log_file.478);
  <D.34997>:
  process_profiler_event (3, thread);
  <D.34991>:
}


thread_startup (struct MonoProfiler * prof, uintptr_t tid)
{
  unsigned int debugger_thread_id.480;
  long long unsigned int D.35003;
  long long unsigned int D.35004;
  _Bool D.35005;
  long int D.35006;
  long int D.35007;
  struct MonoGHashTable * tid_to_thread.481;
  const void * tid.482;
  int log_level.483;
  _Bool D.35017;
  long int D.35018;
  long int D.35019;
  struct FILE * log_file.484;
  void * tid.485;
  struct MonoGHashTable * thread_to_tls.486;
  struct MonoGHashTable * tid_to_thread_obj.487;
  unsigned int debugger_tls_id.488;
  _Bool D.35029;
  long int D.35030;
  long int D.35031;
  struct MonoInternalThread * * D.35036;
  void * D.35037;
  struct MonoThread * D.35040;
  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.35001>; else goto <D.35002>;
  <D.35001>:
  return;
  <D.35002>:
  D.35003 = thread->tid;
  D.35004 = (long long unsigned int) tid;
  D.35005 = D.35003 != D.35004;
  D.35006 = (long int) D.35005;
  D.35007 = __builtin_expect (D.35006, 0);
  if (D.35007 != 0) goto <D.35008>; else goto <D.35009>;
  <D.35008>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 3789, "thread->tid == tid");
  <D.35009>:
  mono_loader_lock ();
  tid_to_thread.481 = tid_to_thread;
  tid.482 = (const void *) tid;
  old_thread = mono_g_hash_table_lookup (tid_to_thread.481, tid.482);
  mono_loader_unlock ();
  if (old_thread != 0B) goto <D.35012>; else goto <D.35013>;
  <D.35012>:
  if (thread == old_thread) goto <D.35014>; else goto <D.35015>;
  <D.35014>:
  log_level.483 = log_level;
  D.35017 = log_level.483 > 0;
  D.35018 = (long int) D.35017;
  D.35019 = __builtin_expect (D.35018, 0);
  if (D.35019 != 0) goto <D.35020>; else goto <D.35021>;
  <D.35020>:
  log_file.484 = log_file;
  tid.485 = (void *) tid;
  tid.485 = (void *) tid;
  fprintf (log_file.484, "[%p] thread_start () called multiple times for %p, ignored.\n", tid.485, tid.485);
  log_file.484 = log_file;
  fflush (log_file.484);
  <D.35021>:
  return;
  <D.35015>:
  log_level.483 = log_level;
  D.35017 = log_level.483 > 0;
  D.35018 = (long int) D.35017;
  D.35019 = __builtin_expect (D.35018, 0);
  if (D.35019 != 0) goto <D.35024>; else goto <D.35025>;
  <D.35024>:
  log_file.484 = log_file;
  tid.485 = (void *) tid;
  tid.485 = (void *) tid;
  fprintf (log_file.484, "[%p] Removing stale data for tid %p.\n", tid.485, tid.485);
  log_file.484 = log_file;
  fflush (log_file.484);
  <D.35025>:
  mono_loader_lock ();
  thread_to_tls.486 = thread_to_tls;
  mono_g_hash_table_remove (thread_to_tls.486, old_thread);
  tid_to_thread.481 = tid_to_thread;
  tid.482 = (const void *) tid;
  mono_g_hash_table_remove (tid_to_thread.481, tid.482);
  tid_to_thread_obj.487 = tid_to_thread_obj;
  tid.482 = (const void *) tid;
  mono_g_hash_table_remove (tid_to_thread_obj.487, tid.482);
  mono_loader_unlock ();
  <D.35013>:
  debugger_tls_id.488 = debugger_tls_id;
  tls = pthread_getspecific (debugger_tls_id.488);
  D.35029 = tls != 0B;
  D.35030 = (long int) D.35029;
  D.35031 = __builtin_expect (D.35030, 0);
  if (D.35031 != 0) goto <D.35032>; else goto <D.35033>;
  <D.35032>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 3817, "!tls");
  <D.35033>:
  tls = monoeg_malloc0 (1432);
  if (0 != 0) goto <D.35034>; else goto <D.35035>;
  <D.35034>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 3820, "sizeof (tls->thread) == sizeof (MonoObject*)");
  <D.35035>:
  D.35036 = &tls->thread;
  D.35037 = mono_gc_make_root_descr_all_refs (1);
  mono_gc_register_root (D.35036, 4, D.35037);
  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.35017 = log_level.483 > 0;
  D.35018 = (long int) D.35017;
  D.35019 = __builtin_expect (D.35018, 0);
  if (D.35019 != 0) goto <D.35038>; else goto <D.35039>;
  <D.35038>:
  log_file.484 = log_file;
  tid.485 = (void *) tid;
  fprintf (log_file.484, "[%p] Thread started, obj=%p, tls=%p.\n", tid.485, thread, tls);
  log_file.484 = log_file;
  fflush (log_file.484);
  <D.35039>:
  mono_loader_lock ();
  thread_to_tls.486 = thread_to_tls;
  mono_g_hash_table_insert (thread_to_tls.486, thread, tls);
  tid_to_thread.481 = tid_to_thread;
  tid.485 = (void *) tid;
  mono_g_hash_table_insert (tid_to_thread.481, tid.485, thread);
  tid_to_thread_obj.487 = tid_to_thread_obj;
  tid.485 = (void *) tid;
  D.35040 = mono_thread_current ();
  mono_g_hash_table_insert (tid_to_thread_obj.487, tid.485, D.35040);
  mono_loader_unlock ();
  process_profiler_event (2, thread);
  suspend_current ();
}


mono_native_tls_set_value (pthread_key_t key, void * value)
{
  int D.35042;
  int D.35043;
  _Bool D.35044;

  D.35043 = pthread_setspecific (key, value);
  D.35044 = D.35043 == 0;
  D.35042 = (int) D.35044;
  return D.35042;
}


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.35050;
  unsigned int i.491;
  unsigned int D.35052;
  void * * D.35053;
  struct GPtrArray * D.35054;
  void * * D.35055;
  unsigned int j.492;
  unsigned int D.35057;
  void * * D.35058;
  struct MonoDomain * D.35059;
  unsigned int j.493;
  unsigned int D.35064;
  unsigned int i.494;
  unsigned int D.35066;
  int i;
  int j;

  breakpoints.490 = breakpoints;
  if (breakpoints.490 == 0B) goto <D.35048>; else goto <D.35049>;
  <D.35048>:
  return;
  <D.35049>:
  mono_loader_lock ();
  i = 0;
  goto <D.28437>;
  <D.28436>:
  {
    struct MonoBreakpoint * bp;

    breakpoints.490 = breakpoints;
    D.35050 = breakpoints.490->pdata;
    i.491 = (unsigned int) i;
    D.35052 = i.491 * 4;
    D.35053 = D.35050 + D.35052;
    bp = *D.35053;
    j = 0;
    goto <D.28434>;
    <D.28433>:
    {
      struct BreakpointInstance * inst;

      D.35054 = bp->children;
      D.35055 = D.35054->pdata;
      j.492 = (unsigned int) j;
      D.35057 = j.492 * 4;
      D.35058 = D.35055 + D.35057;
      inst = *D.35058;
      D.35059 = inst->domain;
      if (D.35059 == domain) goto <D.35060>; else goto <D.35061>;
      <D.35060>:
      remove_breakpoint (inst);
      monoeg_g_free (inst);
      D.35054 = bp->children;
      j.493 = (unsigned int) j;
      monoeg_g_ptr_array_remove_index_fast (D.35054, j.493);
      goto <D.35063>;
      <D.35061>:
      j = j + 1;
      <D.35063>:
    }
    <D.28434>:
    j.493 = (unsigned int) j;
    D.35054 = bp->children;
    D.35064 = D.35054->len;
    if (j.493 < D.35064) goto <D.28433>; else goto <D.28435>;
    <D.28435>:
  }
  i = i + 1;
  <D.28437>:
  i.494 = (unsigned int) i;
  breakpoints.490 = breakpoints;
  D.35066 = breakpoints.490->len;
  if (i.494 < D.35066) goto <D.28436>; else goto <D.28438>;
  <D.28438>:
  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.35069;
  int D.35070;

  D.35069 = mono_thread_current ();
  process_profiler_event (0, D.35069);
  D.35070 = agent_config.defer;
  if (D.35070 != 0) goto <D.35071>; else goto <D.35072>;
  <D.35071>:
  start_debugger_thread ();
  <D.35072>:
}


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

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


mono_debugger_agent_cleanup ()
{
  int inited.496;

  inited.496 = inited;
  if (inited.496 == 0) goto <D.35075>; else goto <D.35076>;
  <D.35075>:
  return;
  <D.35076>:
  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.35081;
  unsigned int debugger_thread_id.498;
  int debugger_thread_exited.499;

  inited.497 = inited;
  if (inited.497 == 0) goto <D.35079>; else goto <D.35080>;
  <D.35079>:
  return;
  <D.35080>:
  transport_close1 ();
  D.35081 = GetCurrentThreadId ();
  debugger_thread_id.498 = debugger_thread_id;
  if (D.35081 != debugger_thread_id.498) goto <D.35083>; else goto <D.35084>;
  <D.35083>:
  <D.27490>:
  pthread_mutex_lock (&debugger_thread_exited_mutex);
  debugger_thread_exited.499 = debugger_thread_exited;
  if (debugger_thread_exited.499 == 0) goto <D.35086>; else goto <D.35087>;
  <D.35086>:
  pthread_cond_wait (&debugger_thread_exited_cond, &debugger_thread_exited_mutex);
  <D.35087>:
  pthread_mutex_unlock (&debugger_thread_exited_mutex);
  debugger_thread_exited.499 = debugger_thread_exited;
  if (debugger_thread_exited.499 == 0) goto <D.27490>; else goto <D.27491>;
  <D.27491>:
  <D.35084>:
  transport_close2 ();
}


transport_close1 ()
{
  struct DebuggerTransport * transport.500;
  void (*<T1268>) (void) D.35090;

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


breakpoints_cleanup ()
{
  struct GPtrArray * event_requests.501;
  void * * D.35092;
  unsigned int i.502;
  unsigned int D.35094;
  void * * D.35095;
  int D.35096;
  void * D.35099;
  unsigned int i.503;
  unsigned int D.35102;
  struct GPtrArray * breakpoints.504;
  void * * D.35104;
  void * * D.35105;
  void * D.35106;
  unsigned int D.35107;
  struct GHashTable * bp_locs.505;
  int i;

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

    event_requests.501 = event_requests;
    D.35092 = event_requests.501->pdata;
    i.502 = (unsigned int) i;
    D.35094 = i.502 * 4;
    D.35095 = D.35092 + D.35094;
    req = *D.35095;
    D.35096 = req->event_kind;
    if (D.35096 == 10) goto <D.35097>; else goto <D.35098>;
    <D.35097>:
    D.35099 = req->info;
    clear_breakpoint (D.35099);
    event_requests.501 = event_requests;
    i.503 = (unsigned int) i;
    monoeg_g_ptr_array_remove_index_fast (event_requests.501, i.503);
    monoeg_g_free (req);
    goto <D.35101>;
    <D.35098>:
    i = i + 1;
    <D.35101>:
  }
  <D.28421>:
  i.503 = (unsigned int) i;
  event_requests.501 = event_requests;
  D.35102 = event_requests.501->len;
  if (i.503 < D.35102) goto <D.28420>; else goto <D.28422>;
  <D.28422>:
  i = 0;
  goto <D.28424>;
  <D.28423>:
  breakpoints.504 = breakpoints;
  D.35104 = breakpoints.504->pdata;
  i.502 = (unsigned int) i;
  D.35094 = i.502 * 4;
  D.35105 = D.35104 + D.35094;
  D.35106 = *D.35105;
  monoeg_g_free (D.35106);
  i = i + 1;
  <D.28424>:
  i.503 = (unsigned int) i;
  breakpoints.504 = breakpoints;
  D.35107 = breakpoints.504->len;
  if (i.503 < D.35107) goto <D.28423>; else goto <D.28425>;
  <D.28425>:
  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.35110;
  void * * D.35113;
  unsigned int j.507;
  unsigned int D.35115;
  void * * D.35116;
  void * D.35117;
  unsigned int j.508;
  unsigned int D.35119;
  int i;
  int j;

  i = 0;
  goto <D.27694>;
  <D.27693>:
  D.35110 = ids[i];
  if (D.35110 != 0B) goto <D.35111>; else goto <D.35112>;
  <D.35111>:
  j = 0;
  goto <D.27691>;
  <D.27690>:
  D.35110 = ids[i];
  D.35113 = D.35110->pdata;
  j.507 = (unsigned int) j;
  D.35115 = j.507 * 4;
  D.35116 = D.35113 + D.35115;
  D.35117 = *D.35116;
  monoeg_g_free (D.35117);
  j = j + 1;
  <D.27691>:
  j.508 = (unsigned int) j;
  D.35110 = ids[i];
  D.35119 = D.35110->len;
  if (j.508 < D.35119) goto <D.27690>; else goto <D.27692>;
  <D.27692>:
  D.35110 = ids[i];
  monoeg_g_ptr_array_free (D.35110, 1);
  <D.35112>:
  ids[i] = 0B;
  i = i + 1;
  <D.27694>:
  if (i <= 6) goto <D.27693>; else goto <D.27695>;
  <D.27695>:
}


transport_init ()
{
  int D.27450;
  char * D.35120;
  const char * D.35121;
  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.27453>;
  <D.27452>:
  {
    size_t __s1_len;
    size_t __s2_len;

    D.35120 = agent_config.transport;
    D.35121 = transports[i].name;
    D.27450 = __builtin_strcmp (D.35120, D.35121);
  }
  if (D.27450 == 0) goto <D.27451>; else goto <D.35122>;
  <D.35122>:
  i = i + 1;
  <D.27453>:
  ntransports.509 = ntransports;
  if (i < ntransports.509) goto <D.27452>; else goto <D.27451>;
  <D.27451>:
  ntransports.509 = ntransports;
  if (i == ntransports.509) goto <D.35124>; else goto <D.35125>;
  <D.35124>:
  stderr.510 = stderr;
  fprintf (stderr.510, "debugger-agent: The supported values for the \'transport\' option are: ");
  i = 0;
  goto <D.27455>;
  <D.27454>:
  stderr.510 = stderr;
  if (i > 0) goto <D.35128>; else goto <D.35129>;
  <D.35128>:
  iftmp.511 = ", ";
  goto <D.35130>;
  <D.35129>:
  iftmp.511 = "";
  <D.35130>:
  D.35121 = transports[i].name;
  fprintf (stderr.510, "%s\'%s\'", iftmp.511, D.35121);
  i = i + 1;
  <D.27455>:
  ntransports.509 = ntransports;
  if (i < ntransports.509) goto <D.27454>; else goto <D.27456>;
  <D.27456>:
  stderr.510 = stderr;
  fprintf (stderr.510, "\n");
  exit (1);
  <D.35125>:
  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)
{
  sizetype total.513;
  void * D.35133;
  int D.35134;
  unsigned int D.35135;
  int D.35138;
  int * D.35144;
  int D.35145;
  unsigned int D.35149;
  int last_keepalive.514;
  int D.35151;
  _Bool D.35156;
  _Bool D.35157;
  _Bool D.35158;
  int D.35161;
  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.27366>:
  again:
  total.513 = (sizetype) total;
  D.35133 = buf + total.513;
  D.35134 = len - total;
  D.35135 = (unsigned int) D.35134;
  res = recv (fd, D.35133, D.35135, flags);
  if (res > 0) goto <D.35136>; else goto <D.35137>;
  <D.35136>:
  total = total + res;
  <D.35137>:
  D.35138 = agent_config.keepalive;
  if (D.35138 != 0) goto <D.35139>; else goto <D.35140>;
  <D.35139>:
  {
    gboolean need_keepalive;

    need_keepalive = 0;
    if (res == -1) goto <D.35143>; else goto <D.35141>;
    <D.35143>:
    D.35144 = __errno_location ();
    D.35145 = *D.35144;
    if (D.35145 == 11) goto <D.35146>; else goto <D.35141>;
    <D.35146>:
    need_keepalive = 1;
    goto <D.35142>;
    <D.35141>:
    if (res == -1) goto <D.35147>; else goto <D.35148>;
    <D.35147>:
    D.35149 = mono_msec_ticks ();
    msecs = (gint32) D.35149;
    last_keepalive.514 = last_keepalive;
    D.35151 = msecs - last_keepalive.514;
    D.35138 = agent_config.keepalive;
    if (D.35151 >= D.35138) goto <D.35152>; else goto <D.35153>;
    <D.35152>:
    need_keepalive = 1;
    last_keepalive = msecs;
    <D.35153>:
    <D.35148>:
    <D.35142>:
    if (need_keepalive != 0) goto <D.35154>; else goto <D.35155>;
    <D.35154>:
    process_profiler_event (14, 0B);
    goto again;
    <D.35155>:
  }
  <D.35140>:
  D.35156 = res > 0;
  D.35157 = total < len;
  D.35158 = D.35156 & D.35157;
  if (D.35158 != 0) goto <D.27366>; else goto <D.35159>;
  <D.35159>:
  if (res == -1) goto <D.35160>; else goto <D.27367>;
  <D.35160>:
  D.35144 = __errno_location ();
  D.35145 = *D.35144;
  if (D.35145 == 4) goto <D.27366>; else goto <D.27367>;
  <D.27367>:
  D.35161 = total;
  return D.35161;
}


recv (int __fd, void * __buf, size_t __n, int __flags)
{
  unsigned int D.35163;
  int D.35166;
  ssize_t D.35169;
  unsigned int D.35170;
  unsigned int D.35171;
  unsigned int D.35174;

  D.35163 = __builtin_object_size (__buf, 0);
  if (D.35163 != 4294967295) goto <D.35164>; else goto <D.35165>;
  <D.35164>:
  D.35166 = __builtin_constant_p (__n);
  if (D.35166 == 0) goto <D.35167>; else goto <D.35168>;
  <D.35167>:
  D.35170 = __builtin_object_size (__buf, 0);
  D.35169 = __recv_chk (__fd, __buf, __n, D.35170, __flags);
  return D.35169;
  <D.35168>:
  D.35171 = __builtin_object_size (__buf, 0);
  if (D.35171 < __n) goto <D.35172>; else goto <D.35173>;
  <D.35172>:
  D.35174 = __builtin_object_size (__buf, 0);
  D.35169 = __recv_chk_warn (__fd, __buf, __n, D.35174, __flags);
  return D.35169;
  <D.35173>:
  <D.35165>:
  D.35169 = __recv_alias (__fd, __buf, __n, __flags);
  return D.35169;
}


socket_transport_send (void * data, int len)
{
  int conn_fd.515;
  unsigned int len.516;
  int * D.35179;
  int D.35180;
  gboolean D.35183;
  int res;

  <D.27381>:
  conn_fd.515 = conn_fd;
  len.516 = (unsigned int) len;
  res = send (conn_fd.515, data, len.516, 0);
  if (res == -1) goto <D.35178>; else goto <D.27382>;
  <D.35178>:
  D.35179 = __errno_location ();
  D.35180 = *D.35179;
  if (D.35180 == 4) goto <D.27381>; else goto <D.27382>;
  <D.27382>:
  if (res != len) goto <D.35181>; else goto <D.35182>;
  <D.35181>:
  D.35183 = 0;
  return D.35183;
  <D.35182>:
  D.35183 = 1;
  return D.35183;
}


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.35188;
  _Bool D.35191;
  long int D.35192;
  long int D.35193;
  char * host.520;
  int port.521;
  struct _IO_FILE * stderr.522;
  const char * D.35204;
  int D.35205;
  _Bool D.35210;
  long int D.35211;
  long int D.35212;
  int * D.35217;
  int D.35218;
  char * D.35219;
  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.35220;
  short unsigned int D.27398;
  int port.523;
  int D.35225;
  int D.35226;
  int D.35227;
  int D.35230;
  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.35233;
  struct sockaddr * D.35234;
  unsigned int D.35235;
  struct addrinfo * result.524;
  int D.35241;
  int log_level.525;
  _Bool D.35245;
  long int D.35246;
  long int D.35247;
  struct FILE * log_file.526;
  int D.35251;
  int D.35254;
  long int D.27412;
  long int iftmp.527;
  int D.35256;
  long int iftmp.528;
  unsigned int __d.529;
  long int D.35265;
  long int D.35266;
  int D.35267;
  long unsigned int D.35268;
  long int D.35269;
  long int D.35270;
  int D.35271;
  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.35283;
  int D.35284;
  int D.35288;
  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.35188 = agent_config.address;
      if (D.35188 != 0B) goto <D.35189>; else goto <D.35190>;
      <D.35189>:
      D.35188 = agent_config.address;
      res = parse_address (D.35188, &host, &port);
      D.35191 = res != 0;
      D.35192 = (long int) D.35191;
      D.35193 = __builtin_expect (D.35192, 0);
      if (D.35193 != 0) goto <D.35194>; else goto <D.35195>;
      <D.35194>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 1177, "res == 0");
      <D.35195>:
      goto <D.35196>;
      <D.35190>:
      host = 0B;
      port = 0;
      <D.35196>:
      conn_fd = -1;
      listen_fd = -1;
      host.520 = host;
      if (host.520 != 0B) goto <D.35198>; else goto <D.35199>;
      <D.35198>:
      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.35201>; else goto <D.35202>;
      <D.35201>:
      stderr.522 = stderr;
      host.520 = host;
      port.521 = port;
      D.35204 = gai_strerror (s);
      fprintf (stderr.522, "debugger-agent: Unable to resolve %s:%d: %s\n", host.520, port.521, D.35204);
      exit (1);
      <D.35202>:
      <D.35199>:
      D.35205 = agent_config.server;
      if (D.35205 != 0) goto <D.35206>; else goto <D.35207>;
      <D.35206>:
      host.520 = host;
      if (host.520 == 0B) goto <D.35208>; else goto <D.35209>;
      <D.35208>:
      {
        struct sockaddr_in addr;
        socklen_t addrlen;

        try
          {
            sfd = socket (2, 1, 0);
            D.35210 = sfd == 0;
            D.35211 = (long int) D.35210;
            D.35212 = __builtin_expect (D.35211, 0);
            if (D.35212 != 0) goto <D.35213>; else goto <D.35214>;
            <D.35213>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 1222, "sfd");
            <D.35214>:
            res = listen (sfd, 16);
            if (res == -1) goto <D.35215>; else goto <D.35216>;
            <D.35215>:
            stderr.522 = stderr;
            D.35217 = __errno_location ();
            D.35218 = *D.35217;
            D.35219 = strerror (D.35218);
            fprintf (stderr.522, "debugger-agent: Unable to setup listening socket: %s\n", D.35219);
            exit (1);
            <D.35216>:
            listen_fd = sfd;
            addrlen = 16;
            memset (&addr, 0, 16);
            D.35220.__sockaddr__ = &addr;
            res = getsockname (sfd, D.35220, &addrlen);
            D.35191 = res != 0;
            D.35192 = (long int) D.35191;
            D.35193 = __builtin_expect (D.35192, 0);
            if (D.35193 != 0) goto <D.35221>; else goto <D.35222>;
            <D.35221>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 1235, "res == 0");
            <D.35222>:
            host = "127.0.0.1";
            {
              short unsigned int __bsx;

              __bsx = addr.sin_port;
              D.27398 = __bsx r>> 8;
            }
            port.523 = (int) D.27398;
            port = port.523;
            host.520 = host;
            port.521 = port;
            printf ("%s:%d\n", host.520, port.521);
          }
        finally
          {
            addr = {CLOBBER};
            addrlen = {CLOBBER};
          }
      }
      goto <D.35224>;
      <D.35209>:
      rp = result;
      goto <D.27403>;
      <D.27402>:
      {
        int n;

        try
          {
            n = 1;
            D.35225 = rp->ai_family;
            D.35226 = rp->ai_socktype;
            D.35227 = rp->ai_protocol;
            sfd = socket (D.35225, D.35226, D.35227);
            if (sfd == -1) goto <D.35228>; else goto <D.35229>;
            <D.35228>:
            // predicted unlikely by continue predictor.
            goto <D.27400>;
            <D.35229>:
            D.35230 = setsockopt (sfd, 1, 2, &n, 4);
            if (D.35230 == -1) goto <D.35231>; else goto <D.35232>;
            <D.35231>:
            // predicted unlikely by continue predictor.
            goto <D.27400>;
            <D.35232>:
            D.35234 = rp->ai_addr;
            D.35233.__sockaddr__ = D.35234;
            D.35235 = rp->ai_addrlen;
            res = bind (sfd, D.35233, D.35235);
            if (res == -1) goto <D.35236>; else goto <D.35237>;
            <D.35236>:
            // predicted unlikely by continue predictor.
            goto <D.27400>;
            <D.35237>:
            res = listen (sfd, 16);
            if (res == -1) goto <D.35238>; else goto <D.35239>;
            <D.35238>:
            // predicted unlikely by continue predictor.
            goto <D.27400>;
            <D.35239>:
            listen_fd = sfd;
            goto <D.27401>;
          }
        finally
          {
            n = {CLOBBER};
          }
      }
      <D.27400>:
      rp = rp->ai_next;
      <D.27403>:
      if (rp != 0B) goto <D.27402>; else goto <D.27401>;
      <D.27401>:
      result.524 = result;
      freeaddrinfo (result.524);
      <D.35224>:
      D.35241 = agent_config.defer;
      if (D.35241 != 0) goto <D.35242>; else goto <D.35243>;
      <D.35242>:
      return;
      <D.35243>:
      log_level.525 = log_level;
      D.35245 = log_level.525 > 0;
      D.35246 = (long int) D.35245;
      D.35247 = __builtin_expect (D.35246, 0);
      if (D.35247 != 0) goto <D.35248>; else goto <D.35249>;
      <D.35248>:
      log_file.526 = log_file;
      host.520 = host;
      port.521 = port;
      D.35251 = agent_config.timeout;
      fprintf (log_file.526, "Listening on %s:%d (timeout=%d ms)...\n", host.520, port.521, D.35251);
      log_file.526 = log_file;
      fflush (log_file.526);
      <D.35249>:
      D.35251 = agent_config.timeout;
      if (D.35251 != 0) goto <D.35252>; else goto <D.35253>;
      <D.35252>:
      {
        struct fd_set readfds;
        struct timeval tv;

        try
          {
            tv.tv_sec = 0;
            D.35251 = agent_config.timeout;
            D.35254 = D.35251 * 1000;
            tv.tv_usec = D.35254;
            {
              unsigned int __i;
              struct fd_set * __arr;

              __arr = &readfds;
              __i = 0;
              goto <D.27409>;
              <D.27408>:
              __arr->fds_bits[__i] = 0;
              __i = __i + 1;
              <D.27409>:
              if (__i <= 31) goto <D.27408>; else goto <D.27410>;
              <D.27410>:
            }
            {
              long int __d;

              __d = sfd;
              D.35256 = __builtin_constant_p (__d);
              if (D.35256 != 0) goto <D.35257>; else goto <D.35258>;
              <D.35257>:
              __d.529 = (unsigned int) __d;
              if (__d.529 <= 1023) goto <D.35261>; else goto <D.35262>;
              <D.35261>:
              iftmp.528 = __d / 32;
              goto <D.35263>;
              <D.35262>:
              iftmp.528 = __fdelt_warn (__d);
              <D.35263>:
              iftmp.527 = iftmp.528;
              goto <D.35264>;
              <D.35258>:
              iftmp.527 = __fdelt_chk (__d);
              <D.35264>:
              D.27412 = iftmp.527;
            }
            D.35265 = D.27412;
            D.35266 = readfds.fds_bits[D.35265];
            D.35267 = sfd % 32;
            D.35268 = 1 << D.35267;
            D.35269 = (long int) D.35268;
            D.35270 = D.35266 | D.35269;
            readfds.fds_bits[D.35265] = D.35270;
            D.35271 = sfd + 1;
            res = select (D.35271, &readfds, 0B, 0B, &tv);
            if (res == 0) goto <D.35272>; else goto <D.35273>;
            <D.35272>:
            stderr.522 = stderr;
            fprintf (stderr.522, "debugger-agent: Timed out waiting to connect.\n");
            exit (1);
            <D.35273>:
          }
        finally
          {
            readfds = {CLOBBER};
            tv = {CLOBBER};
          }
      }
      <D.35253>:
      conn_fd.530 = socket_transport_accept (sfd);
      conn_fd = conn_fd.530;
      conn_fd.531 = conn_fd;
      if (conn_fd.531 == -1) goto <D.35276>; else goto <D.35277>;
      <D.35276>:
      exit (1);
      <D.35277>:
      log_level.525 = log_level;
      D.35245 = log_level.525 > 0;
      D.35246 = (long int) D.35245;
      D.35247 = __builtin_expect (D.35246, 0);
      if (D.35247 != 0) goto <D.35278>; else goto <D.35279>;
      <D.35278>:
      log_file.526 = log_file;
      conn_fd.531 = conn_fd;
      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.35279>:
      goto <D.35280>;
      <D.35207>:
      rp = result;
      goto <D.27416>;
      <D.27415>:
      D.35225 = rp->ai_family;
      D.35226 = rp->ai_socktype;
      D.35227 = rp->ai_protocol;
      sfd = socket (D.35225, D.35226, D.35227);
      if (sfd == -1) goto <D.35281>; else goto <D.35282>;
      <D.35281>:
      // predicted unlikely by continue predictor.
      goto <D.27413>;
      <D.35282>:
      D.35234 = rp->ai_addr;
      D.35283.__sockaddr__ = D.35234;
      D.35235 = rp->ai_addrlen;
      D.35284 = connect (sfd, D.35283, D.35235);
      if (D.35284 != -1) goto <D.27414>; else goto <D.35285>;
      <D.35285>:
      close (sfd);
      <D.27413>:
      rp = rp->ai_next;
      <D.27416>:
      if (rp != 0B) goto <D.27415>; else goto <D.27414>;
      <D.27414>:
      if (rp == 0B) goto <D.35286>; else goto <D.35287>;
      <D.35286>:
      stderr.522 = stderr;
      host.520 = host;
      port.521 = port;
      fprintf (stderr.522, "debugger-agent: Unable to connect to %s:%d\n", host.520, port.521);
      exit (1);
      <D.35287>:
      conn_fd = sfd;
      result.524 = result;
      freeaddrinfo (result.524);
      <D.35280>:
      D.35288 = transport_handshake ();
      if (D.35288 == 0) goto <D.35289>; else goto <D.35290>;
      <D.35289>:
      exit (1);
      <D.35290>:
    }
  finally
    {
      hints = {CLOBBER};
      result = {CLOBBER};
      port_string = {CLOBBER};
      host = {CLOBBER};
      port = {CLOBBER};
    }
}


register_transport (struct DebuggerTransport * trans)
{
  int ntransports.532;
  _Bool D.35297;
  long int D.35298;
  long int D.35299;
  struct DebuggerTransport * D.35302;
  int ntransports.533;

  ntransports.532 = ntransports;
  D.35297 = ntransports.532 > 15;
  D.35298 = (long int) D.35297;
  D.35299 = __builtin_expect (D.35298, 0);
  if (D.35299 != 0) goto <D.35300>; else goto <D.35301>;
  <D.35300>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 1419, "ntransports < MAX_TRANSPORTS");
  <D.35301>:
  ntransports.532 = ntransports;
  D.35302 = &transports[ntransports.532];
  memcpy (D.35302, 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.35304;
  void (*<Tc1>) (void *) destructor.534;
  int D.35306;
  _Bool D.35307;

  destructor.534 = (void (*<Tc1>) (void *)) destructor;
  D.35306 = pthread_key_create (key, destructor.534);
  D.35307 = D.35306 == 0;
  D.35304 = (int) D.35307;
  return D.35304;
}


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

  i = 0;
  goto <D.27683>;
  <D.27682>:
  D.35309 = monoeg_g_ptr_array_new ();
  ids[i] = D.35309;
  i = i + 1;
  <D.27683>:
  if (i <= 6) goto <D.27682>; else goto <D.27684>;
  <D.27684>:
}


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.35311;
  struct ObjRef * o;

  o = value;
  D.35311 = o->handle;
  mono_gchandle_free (D.35311);
  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.35314;
  char * D.35317;
  char * D.35320;
  char * D.35321;
  struct _IO_FILE * stderr.538;
  int res;

  D.35314 = InterlockedCompareExchange (&inited, 1, 0);
  if (D.35314 == 1) goto <D.35315>; else goto <D.35316>;
  <D.35315>:
  return;
  <D.35316>:
  D.35317 = agent_config.launch;
  if (D.35317 != 0B) goto <D.35318>; else goto <D.35319>;
  <D.35318>:
  {
    char * argv[16];

    try
      {
        D.35317 = agent_config.launch;
        argv[0] = D.35317;
        D.35320 = agent_config.transport;
        argv[1] = D.35320;
        D.35321 = agent_config.address;
        argv[2] = D.35321;
        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.35322>; else goto <D.35323>;
        <D.35322>:
        stderr.538 = stderr;
        D.35317 = agent_config.launch;
        fprintf (stderr.538, "Failed to execute \'%s\'.\n", D.35317);
        exit (1);
        <D.35323>:
      }
    finally
      {
        argv = {CLOBBER};
      }
  }
  <D.35319>:
  D.35321 = agent_config.address;
  transport_connect (D.35321);
  if (on_startup == 0) goto <D.35325>; else goto <D.35326>;
  <D.35325>:
  vm_start_event_sent = 1;
  start_debugger_thread ();
  <D.35326>:
}


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

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


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

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


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


mono_debugger_agent_transport_handshake ()
{
  gboolean D.35335;

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


mono_debugger_agent_free_domain_info (struct MonoDomain * domain)
{
  void * D.35337;
  struct GHashTable * D.35340;
  struct GHashTable * D.35343;
  struct GHashTable * D.35344;
  struct GPtrArray * file_names.542;
  void * * D.35346;
  unsigned int i.543;
  unsigned int D.35348;
  void * * D.35349;
  void * D.35350;
  unsigned int i.544;
  unsigned int D.35352;
  int D.35353;
  struct GHashTable * D.35354;
  char * basename.545;
  struct GSList * l.546;
  int D.35357;
  struct GHashTable * D.35358;
  int D.35359;
  struct GPtrArray * D.35360;
  void * * D.35363;
  unsigned int j.547;
  unsigned int D.35365;
  void * * D.35366;
  struct MonoDomain * D.35367;
  unsigned int j.548;
  unsigned int D.35371;
  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.35337 = domain->runtime_info;
      info = MEM[(struct MonoJitDomainInfo *)D.35337].agent_info;
      if (info != 0B) goto <D.35338>; else goto <D.35339>;
      <D.35338>:
      i = 0;
      goto <D.27707>;
      <D.27706>:
      D.35340 = info->val_to_id[i];
      if (D.35340 != 0B) goto <D.35341>; else goto <D.35342>;
      <D.35341>:
      D.35340 = info->val_to_id[i];
      monoeg_g_hash_table_destroy (D.35340);
      <D.35342>:
      i = i + 1;
      <D.27707>:
      if (i <= 6) goto <D.27706>; else goto <D.27708>;
      <D.27708>:
      D.35343 = info->loaded_classes;
      monoeg_g_hash_table_destroy (D.35343);
      D.35344 = info->source_files;
      monoeg_g_hash_table_iter_init (&iter, D.35344);
      goto <D.27713>;
      <D.27712>:
      i = 0;
      goto <D.27710>;
      <D.27709>:
      file_names.542 = file_names;
      D.35346 = file_names.542->pdata;
      i.543 = (unsigned int) i;
      D.35348 = i.543 * 4;
      D.35349 = D.35346 + D.35348;
      D.35350 = *D.35349;
      monoeg_g_free (D.35350);
      i = i + 1;
      <D.27710>:
      i.544 = (unsigned int) i;
      file_names.542 = file_names;
      D.35352 = file_names.542->len;
      if (i.544 < D.35352) goto <D.27709>; else goto <D.27711>;
      <D.27711>:
      file_names.542 = file_names;
      monoeg_g_ptr_array_free (file_names.542, 1);
      <D.27713>:
      D.35353 = monoeg_g_hash_table_iter_next (&iter, 0B, &file_names);
      if (D.35353 != 0) goto <D.27712>; else goto <D.27714>;
      <D.27714>:
      D.35354 = info->source_file_to_class;
      monoeg_g_hash_table_iter_init (&iter, D.35354);
      goto <D.27716>;
      <D.27715>:
      basename.545 = basename;
      monoeg_g_free (basename.545);
      l.546 = l;
      monoeg_g_slist_free (l.546);
      <D.27716>:
      D.35357 = monoeg_g_hash_table_iter_next (&iter, &basename, &l);
      if (D.35357 != 0) goto <D.27715>; else goto <D.27717>;
      <D.27717>:
      D.35358 = info->source_file_to_class_ignorecase;
      monoeg_g_hash_table_iter_init (&iter, D.35358);
      goto <D.27719>;
      <D.27718>:
      basename.545 = basename;
      monoeg_g_free (basename.545);
      l.546 = l;
      monoeg_g_slist_free (l.546);
      <D.27719>:
      D.35359 = monoeg_g_hash_table_iter_next (&iter, &basename, &l);
      if (D.35359 != 0) goto <D.27718>; else goto <D.27720>;
      <D.27720>:
      monoeg_g_free (info);
      <D.35339>:
      D.35337 = domain->runtime_info;
      MEM[(struct MonoJitDomainInfo *)D.35337].agent_info = 0B;
      i = 0;
      goto <D.27726>;
      <D.27725>:
      D.35360 = ids[i];
      if (D.35360 != 0B) goto <D.35361>; else goto <D.35362>;
      <D.35361>:
      j = 0;
      goto <D.27723>;
      <D.27722>:
      {
        struct Id * id;

        D.35360 = ids[i];
        D.35363 = D.35360->pdata;
        j.547 = (unsigned int) j;
        D.35365 = j.547 * 4;
        D.35366 = D.35363 + D.35365;
        id = *D.35366;
        D.35367 = id->domain;
        if (D.35367 == domain) goto <D.35368>; else goto <D.35369>;
        <D.35368>:
        id->domain = 0B;
        <D.35369>:
      }
      j = j + 1;
      <D.27723>:
      j.548 = (unsigned int) j;
      D.35360 = ids[i];
      D.35371 = D.35360->len;
      if (j.548 < D.35371) goto <D.27722>; else goto <D.27724>;
      <D.27724>:
      <D.35362>:
      i = i + 1;
      <D.27726>:
      if (i <= 6) goto <D.27725>; else goto <D.27727>;
      <D.27727>:
      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.35376;
  unsigned int debugger_tls_id.551;
  int log_level.552;
  _Bool D.35381;
  long int D.35382;
  long int D.35383;
  struct FILE * log_file.553;
  unsigned int D.35387;
  void * D.35388;
  struct DebuggerTlsData * tls;

  inited.550 = inited;
  if (inited.550 == 0) goto <D.35374>; else goto <D.35375>;
  <D.35374>:
  D.35376 = 0;
  return D.35376;
  <D.35375>:
  debugger_tls_id.551 = debugger_tls_id;
  tls = pthread_getspecific (debugger_tls_id.551);
  if (tls == 0B) goto <D.35378>; else goto <D.35379>;
  <D.35378>:
  log_level.552 = log_level;
  D.35381 = log_level.552 > 0;
  D.35382 = (long int) D.35381;
  D.35383 = __builtin_expect (D.35382, 0);
  if (D.35383 != 0) goto <D.35384>; else goto <D.35385>;
  <D.35384>:
  log_file.553 = log_file;
  D.35387 = GetCurrentThreadId ();
  D.35388 = (void *) D.35387;
  fprintf (log_file.553, "[%p] Received interrupt with no TLS, continuing.\n", D.35388);
  log_file.553 = log_file;
  fflush (log_file.553);
  <D.35385>:
  D.35376 = 0;
  return D.35376;
  <D.35379>:
  D.35376 = thread_interrupt (tls, 0B, sigctx, ji);
  return D.35376;
}


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.35390;
  struct MonoDomain * D.35391;
  _Bool D.35392;
  long int D.35393;
  long int D.35394;
  int ip.554;
  void * D.35398;
  int D.35399;
  int D.35400;
  unsigned char D.35403;
  unsigned char D.35404;
  int D.35406;
  struct MonoDomain * D.35407;
  int native_offset.555;
  _Bool D.35411;
  long int D.35412;
  long int D.35413;
  int log_level.556;
  _Bool D.35417;
  long int D.35418;
  long int D.35419;
  struct FILE * log_file.557;
  unsigned int D.35423;
  void * D.35424;
  const char * D.35425;
  int iftmp.558;
  struct GPtrArray * breakpoints.559;
  void * * D.35431;
  unsigned int i.560;
  unsigned int D.35433;
  void * * D.35434;
  struct MonoMethod * D.35435;
  struct GPtrArray * D.35438;
  void * * D.35439;
  unsigned int j.561;
  unsigned int D.35441;
  void * * D.35442;
  struct MonoJitInfo * D.35443;
  struct SeqPoint * D.35446;
  struct EventRequest * D.35449;
  int D.35450;
  unsigned int j.562;
  unsigned int D.35455;
  unsigned int i.563;
  unsigned int D.35457;
  unsigned int D.35458;
  unsigned int D.35461;
  int D.35464;
  void * * D.35470;
  void * * D.35471;
  struct MonoInternalThread * D.35472;
  struct MonoInternalThread * D.35473;
  struct MonoSeqPointInfo * info.564;
  unsigned int D.35479;
  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.35390 = ctx->pc;
      ip = (guint8 *) D.35390;
      D.35391 = mono_domain_get ();
      ji = mini_jit_info_table_find (D.35391, ip, 0B);
      D.35392 = ji == 0B;
      D.35393 = (long int) D.35392;
      D.35394 = __builtin_expect (D.35393, 0);
      if (D.35394 != 0) goto <D.35395>; else goto <D.35396>;
      <D.35395>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 4554, "ji");
      <D.35396>:
      method = jinfo_get_method (ji);
      ip.554 = (int) ip;
      D.35398 = ji->code_start;
      D.35399 = (int) D.35398;
      D.35400 = ip.554 - D.35399;
      native_offset = (guint32) D.35400;
      mono_arch_skip_breakpoint (ctx, ji);
      D.35403 = BIT_FIELD_REF <*method, 8, 160>;
      D.35404 = D.35403 & 124;
      if (D.35404 != 0) goto <D.35401>; else goto <D.35405>;
      <D.35405>:
      D.35406 = tls->disable_breakpoints;
      if (D.35406 != 0) goto <D.35401>; else goto <D.35402>;
      <D.35401>:
      return;
      <D.35402>:
      bp_reqs = monoeg_g_ptr_array_new ();
      ss_reqs = monoeg_g_ptr_array_new ();
      ss_reqs_orig = monoeg_g_ptr_array_new ();
      mono_loader_lock ();
      D.35407 = mono_domain_get ();
      native_offset.555 = (int) native_offset;
      sp = find_prev_seq_point_for_native_offset (D.35407, method, native_offset.555, &info);
      if (sp == 0B) goto <D.35409>; else goto <D.35410>;
      <D.35409>:
      no_seq_points_found (method);
      <D.35410>:
      D.35411 = sp == 0B;
      D.35412 = (long int) D.35411;
      D.35413 = __builtin_expect (D.35412, 0);
      if (D.35413 != 0) goto <D.35414>; else goto <D.35415>;
      <D.35414>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 4581, "sp");
      <D.35415>:
      log_level.556 = log_level;
      D.35417 = log_level.556 > 0;
      D.35418 = (long int) D.35417;
      D.35419 = __builtin_expect (D.35418, 0);
      if (D.35419 != 0) goto <D.35420>; else goto <D.35421>;
      <D.35420>:
      log_file.557 = log_file;
      D.35423 = GetCurrentThreadId ();
      D.35424 = (void *) D.35423;
      D.35425 = method->name;
      if (sp != 0B) goto <D.35427>; else goto <D.35428>;
      <D.35427>:
      iftmp.558 = sp->il_offset;
      goto <D.35429>;
      <D.35428>:
      iftmp.558 = -1;
      <D.35429>:
      fprintf (log_file.557, "[%p] Breakpoint hit, method=%s, ip=%p, offset=0x%x, sp il offset=0x%x.\n", D.35424, D.35425, ip, native_offset, iftmp.558);
      log_file.557 = log_file;
      fflush (log_file.557);
      <D.35421>:
      bp = 0B;
      i = 0;
      goto <D.28481>;
      <D.28480>:
      breakpoints.559 = breakpoints;
      D.35431 = breakpoints.559->pdata;
      i.560 = (unsigned int) i;
      D.35433 = i.560 * 4;
      D.35434 = D.35431 + D.35433;
      bp = *D.35434;
      D.35435 = bp->method;
      if (D.35435 == 0B) goto <D.35436>; else goto <D.35437>;
      <D.35436>:
      // predicted unlikely by continue predictor.
      goto <D.28476>;
      <D.35437>:
      j = 0;
      goto <D.28478>;
      <D.28477>:
      D.35438 = bp->children;
      D.35439 = D.35438->pdata;
      j.561 = (unsigned int) j;
      D.35441 = j.561 * 4;
      D.35442 = D.35439 + D.35441;
      inst = *D.35442;
      D.35443 = inst->ji;
      if (D.35443 == ji) goto <D.35444>; else goto <D.35445>;
      <D.35444>:
      D.35446 = inst->sp;
      if (D.35446 == sp) goto <D.35447>; else goto <D.35448>;
      <D.35447>:
      D.35449 = bp->req;
      D.35450 = D.35449->event_kind;
      if (D.35450 == 11) goto <D.35451>; else goto <D.35452>;
      <D.35451>:
      D.35449 = bp->req;
      monoeg_g_ptr_array_add (ss_reqs_orig, D.35449);
      goto <D.35453>;
      <D.35452>:
      D.35449 = bp->req;
      monoeg_g_ptr_array_add (bp_reqs, D.35449);
      <D.35453>:
      <D.35448>:
      <D.35445>:
      j = j + 1;
      <D.28478>:
      j.562 = (unsigned int) j;
      D.35438 = bp->children;
      D.35455 = D.35438->len;
      if (j.562 < D.35455) goto <D.28477>; else goto <D.28479>;
      <D.28479>:
      <D.28476>:
      i = i + 1;
      <D.28481>:
      i.563 = (unsigned int) i;
      breakpoints.559 = breakpoints;
      D.35457 = breakpoints.559->len;
      if (i.563 < D.35457) goto <D.28480>; else goto <D.28482>;
      <D.28482>:
      D.35458 = bp_reqs->len;
      if (D.35458 == 0) goto <D.35459>; else goto <D.35460>;
      <D.35459>:
      D.35461 = ss_reqs_orig->len;
      if (D.35461 == 0) goto <D.35462>; else goto <D.35463>;
      <D.35462>:
      D.35464 = sp->il_offset;
      if (D.35464 == -1) goto <D.35465>; else goto <D.35466>;
      <D.35465>:
      kind = 6;
      goto <D.35467>;
      <D.35466>:
      D.35464 = sp->il_offset;
      if (D.35464 == 16777215) goto <D.35468>; else goto <D.35469>;
      <D.35468>:
      kind = 7;
      <D.35469>:
      <D.35467>:
      <D.35463>:
      <D.35460>:
      i = 0;
      goto <D.28488>;
      <D.28487>:
      {
        struct EventRequest * req;
        struct SingleStepReq * ss_req;
        gboolean hit;

        D.35470 = ss_reqs_orig->pdata;
        i.560 = (unsigned int) i;
        D.35433 = i.560 * 4;
        D.35471 = D.35470 + D.35433;
        req = *D.35471;
        ss_req = req->info;
        D.35472 = mono_thread_internal_current ();
        D.35473 = ss_req->thread;
        if (D.35472 != D.35473) goto <D.35474>; else goto <D.35475>;
        <D.35474>:
        // predicted unlikely by continue predictor.
        goto <D.28486>;
        <D.35475>:
        hit = ss_update (ss_req, ji, sp, tls, ctx);
        if (hit != 0) goto <D.35476>; else goto <D.35477>;
        <D.35476>:
        monoeg_g_ptr_array_add (ss_reqs, req);
        <D.35477>:
        info.564 = info;
        ss_start (ss_req, method, sp, info.564, ctx, tls, 0);
      }
      <D.28486>:
      i = i + 1;
      <D.28488>:
      i.563 = (unsigned int) i;
      D.35461 = ss_reqs_orig->len;
      if (i.563 < D.35461) goto <D.28487>; else goto <D.28489>;
      <D.28489>:
      D.35479 = ss_reqs->len;
      if (D.35479 != 0) goto <D.35480>; else goto <D.35481>;
      <D.35480>:
      ss_events = create_event_list (11, ss_reqs, ji, 0B, &suspend_policy);
      <D.35481>:
      D.35458 = bp_reqs->len;
      if (D.35458 != 0) goto <D.35482>; else goto <D.35483>;
      <D.35482>:
      bp_events = create_event_list (10, bp_reqs, ji, 0B, &suspend_policy);
      <D.35483>:
      if (kind != 10) goto <D.35484>; else goto <D.35485>;
      <D.35484>:
      enter_leave_events = create_event_list (kind, 0B, ji, 0B, &suspend_policy);
      <D.35485>:
      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.35486>; else goto <D.35487>;
      <D.35486>:
      suspend_policy.565 = suspend_policy;
      process_event (11, method, 0, ctx, ss_events, suspend_policy.565);
      <D.35487>:
      if (bp_events != 0B) goto <D.35489>; else goto <D.35490>;
      <D.35489>:
      suspend_policy.565 = suspend_policy;
      process_event (kind, method, 0, ctx, bp_events, suspend_policy.565);
      <D.35490>:
      if (enter_leave_events != 0B) goto <D.35491>; else goto <D.35492>;
      <D.35491>:
      suspend_policy.565 = suspend_policy;
      process_event (kind, method, 0, ctx, enter_leave_events, suspend_policy.565);
      <D.35492>:
    }
  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.35496;
  int D.35499;
  int D.35500;
  int log_level.566;
  _Bool D.35504;
  long int D.35505;
  long int D.35506;
  struct FILE * log_file.567;
  unsigned int D.35510;
  void * D.35511;
  int D.35512;
  gboolean D.35513;
  int D.35518;
  struct MonoThreadUnwindState * D.35521;
  struct MonoInternalThread * D.35522;
  int D.35523;
  int D.35526;
  unsigned int D.35533;
  void * D.35534;
  <unnamed type> D.35535;
  unsigned int D.35540;
  struct SingleStepReq * ss_req.568;
  struct MonoMethod * D.35545;
  unsigned int D.35547;
  int D.35548;
  unsigned int D.35549;
  unsigned int D.35554;
  void * D.35555;
  unsigned int D.35559;
  void * D.35560;
  int D.35563;
  struct MonoDebugMethodInfo * minfo;
  struct MonoDebugSourceLocation * loc;
  gboolean hit;
  struct MonoMethod * method;

  loc = 0B;
  hit = 1;
  D.35496 = req->depth;
  if (D.35496 == 1) goto <D.35497>; else goto <D.35498>;
  <D.35497>:
  D.35499 = sp->flags;
  D.35500 = D.35499 & 1;
  if (D.35500 != 0) goto <D.35501>; else goto <D.35502>;
  <D.35501>:
  log_level.566 = log_level;
  D.35504 = log_level.566 > 0;
  D.35505 = (long int) D.35504;
  D.35506 = __builtin_expect (D.35505, 0);
  if (D.35506 != 0) goto <D.35507>; else goto <D.35508>;
  <D.35507>:
  log_file.567 = log_file;
  D.35510 = GetCurrentThreadId ();
  D.35511 = (void *) D.35510;
  D.35512 = sp->il_offset;
  fprintf (log_file.567, "[%p] Seq point at nonempty stack %x while stepping over, continuing single stepping.\n", D.35511, D.35512);
  log_file.567 = log_file;
  fflush (log_file.567);
  <D.35508>:
  D.35513 = 0;
  return D.35513;
  <D.35502>:
  <D.35498>:
  D.35496 = req->depth;
  if (D.35496 == 1) goto <D.35514>; else goto <D.35515>;
  <D.35514>:
  if (hit != 0) goto <D.35516>; else goto <D.35517>;
  <D.35516>:
  D.35518 = tls->context.valid;
  if (D.35518 == 0) goto <D.35519>; else goto <D.35520>;
  <D.35519>:
  D.35521 = &tls->context;
  mono_thread_state_init_from_monoctx (D.35521, ctx);
  <D.35520>:
  D.35522 = tls->thread;
  compute_frame_info (D.35522, tls);
  D.35523 = req->nframes;
  if (D.35523 != 0) goto <D.35524>; else goto <D.35525>;
  <D.35524>:
  D.35526 = tls->frame_count;
  if (D.35526 != 0) goto <D.35527>; else goto <D.35528>;
  <D.35527>:
  D.35526 = tls->frame_count;
  D.35523 = req->nframes;
  if (D.35526 > D.35523) goto <D.35529>; else goto <D.35530>;
  <D.35529>:
  log_level.566 = log_level;
  D.35504 = log_level.566 > 0;
  D.35505 = (long int) D.35504;
  D.35506 = __builtin_expect (D.35505, 0);
  if (D.35506 != 0) goto <D.35531>; else goto <D.35532>;
  <D.35531>:
  log_file.567 = log_file;
  D.35533 = GetCurrentThreadId ();
  D.35534 = (void *) D.35533;
  fprintf (log_file.567, "[%p] Breakpoint at lower frame while stepping over, continuing single stepping.\n", D.35534);
  log_file.567 = log_file;
  fflush (log_file.567);
  <D.35532>:
  D.35513 = 0;
  return D.35513;
  <D.35530>:
  <D.35528>:
  <D.35525>:
  <D.35517>:
  <D.35515>:
  D.35535 = req->size;
  if (D.35535 != 1) goto <D.35536>; else goto <D.35537>;
  <D.35536>:
  D.35513 = 1;
  return D.35513;
  <D.35537>:
  method = jinfo_get_method (ji);
  minfo = mono_debug_lookup_method (method);
  if (minfo != 0B) goto <D.35538>; else goto <D.35539>;
  <D.35538>:
  D.35512 = sp->il_offset;
  D.35540 = (unsigned int) D.35512;
  loc = mono_debug_symfile_lookup_location (minfo, D.35540);
  <D.35539>:
  if (loc == 0B) goto <D.35541>; else goto <D.35543>;
  <D.35543>:
  ss_req.568 = ss_req;
  D.35545 = ss_req.568->last_method;
  if (D.35545 == method) goto <D.35546>; else goto <D.35542>;
  <D.35546>:
  D.35547 = loc->row;
  ss_req.568 = ss_req;
  D.35548 = ss_req.568->last_line;
  D.35549 = (unsigned int) D.35548;
  if (D.35547 == D.35549) goto <D.35541>; else goto <D.35542>;
  <D.35541>:
  if (loc == 0B) goto <D.35550>; else goto <D.35551>;
  <D.35550>:
  log_level.566 = log_level;
  D.35504 = log_level.566 > 0;
  D.35505 = (long int) D.35504;
  D.35506 = __builtin_expect (D.35505, 0);
  if (D.35506 != 0) goto <D.35552>; else goto <D.35553>;
  <D.35552>:
  log_file.567 = log_file;
  D.35554 = GetCurrentThreadId ();
  D.35555 = (void *) D.35554;
  D.35512 = sp->il_offset;
  fprintf (log_file.567, "[%p] No line number info for il offset %x, continuing single stepping.\n", D.35555, D.35512);
  log_file.567 = log_file;
  fflush (log_file.567);
  <D.35553>:
  goto <D.35556>;
  <D.35551>:
  log_level.566 = log_level;
  D.35504 = log_level.566 > 0;
  D.35505 = (long int) D.35504;
  D.35506 = __builtin_expect (D.35505, 0);
  if (D.35506 != 0) goto <D.35557>; else goto <D.35558>;
  <D.35557>:
  log_file.567 = log_file;
  D.35559 = GetCurrentThreadId ();
  D.35560 = (void *) D.35559;
  D.35547 = loc->row;
  fprintf (log_file.567, "[%p] Same source line (%d), continuing single stepping.\n", D.35560, D.35547);
  log_file.567 = log_file;
  fflush (log_file.567);
  <D.35558>:
  <D.35556>:
  hit = 0;
  <D.35542>:
  if (loc != 0B) goto <D.35561>; else goto <D.35562>;
  <D.35561>:
  ss_req.568 = ss_req;
  ss_req.568->last_method = method;
  ss_req.568 = ss_req;
  D.35547 = loc->row;
  D.35563 = (int) D.35547;
  ss_req.568->last_line = D.35563;
  mono_debug_free_source_location (loc);
  <D.35562>:
  D.35513 = hit;
  return D.35513;
}


process_signal_event (void (*<T4fc9>) (struct DebuggerTlsData *) func)
{
  unsigned int debugger_tls_id.569;
  struct MonoContext * D.35566;
  struct MonoContext * D.35567;
  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.35566 = &tls->restore_ctx;
      memcpy (&orig_restore_ctx, D.35566, 208);
      D.35566 = &tls->restore_ctx;
      D.35567 = &tls->handler_ctx;
      memcpy (D.35566, D.35567, 208);
      func (tls);
      D.35566 = &tls->restore_ctx;
      memcpy (&ctx, D.35566, 208);
      D.35566 = &tls->restore_ctx;
      memcpy (D.35566, &orig_restore_ctx, 208);
      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;
  struct _IO_FILE * stderr.571;
  unsigned int D.35572;
  void * D.35573;
  _Bool D.35574;
  long int D.35575;
  long int D.35576;
  struct MonoContext * D.35579;
  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.35569>; else goto <D.35570>;
      <D.35569>:
      stderr.571 = stderr;
      D.35572 = GetCurrentThreadId ();
      D.35573 = (void *) D.35572;
      fprintf (stderr.571, "Thread %p is not attached to the JIT.\n", D.35573);
      <D.35570>:
      D.35574 = tls == 0B;
      D.35575 = (long int) D.35574;
      D.35576 = __builtin_expect (D.35575, 0);
      if (D.35576 != 0) goto <D.35577>; else goto <D.35578>;
      <D.35577>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 4690, "tls");
      <D.35578>:
      mono_arch_sigctx_to_monoctx (sigctx, &ctx);
      D.35579 = &tls->handler_ctx;
      memcpy (D.35579, &ctx, 208);
      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.35580;
  int D.35583;
  void * D.35584;
  _Bool D.35585;
  long int D.35586;
  long int D.35587;
  int suspend_policy.572;

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

    try
      {
        ctx.pc = 0;
        mono_walk_stack_with_ctx (user_break_cb, 0B, 0, &ctx);
        D.35583 = ctx.pc;
        D.35584 = (void *) D.35583;
        D.35585 = D.35584 == 0B;
        D.35586 = (long int) D.35585;
        D.35587 = __builtin_expect (D.35586, 0);
        if (D.35587 != 0) goto <D.35588>; else goto <D.35589>;
        <D.35588>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 4747, "MONO_CONTEXT_GET_IP (&ctx) != NULL");
        <D.35589>:
        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.35591>;
  <D.35582>:
  raise (5);
  <D.35591>:
}


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

  D.35592 = frame->managed;
  if (D.35592 != 0) goto <D.35593>; else goto <D.35594>;
  <D.35593>:
  MEM[(struct MonoContext *)data] = *ctx;
  D.35595 = 1;
  return D.35595;
  <D.35594>:
  D.35595 = 0;
  return D.35595;
}


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

  D.35597 = GetCurrentThreadId ();
  debugger_thread_id.573 = debugger_thread_id;
  if (D.35597 == debugger_thread_id.573) goto <D.35599>; else goto <D.35600>;
  <D.35599>:
  {
    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.35600>:
  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.35603;
  int suspend_count.574;
  struct SingleStepReq * ss_req.575;
  struct MonoInternalThread * D.35610;
  struct MonoInternalThread * D.35611;
  int log_level.576;
  struct MonoDomain * D.35617;
  _Bool D.35618;
  long int D.35619;
  long int D.35620;
  struct FILE * log_file.577;
  unsigned int D.35624;
  void * D.35625;
  <unnamed type> D.35626;
  const char * D.35627;
  struct MonoMethod * D.35628;
  char * D.35629;
  void * D.35630;
  int D.35631;
  void * D.35632;
  void * D.35633;
  struct MonoDomain * D.35634;
  _Bool D.35635;
  long int D.35636;
  long int D.35637;
  _Bool D.35640;
  long int D.35641;
  long int D.35642;
  unsigned char D.35645;
  unsigned char D.35646;
  _Bool D.35647;
  _Bool D.35648;
  _Bool D.35649;
  struct MonoClass * D.35654;
  struct MonoClass * D.35655;
  int D.28549;
  int iftmp.578;
  int D.28548;
  const char[7] * D.35661;
  unsigned char D.35662;
  int D.35663;
  unsigned char D.35664;
  int D.35665;
  _Bool D.35666;
  _Bool D.35667;
  _Bool D.35668;
  const unsigned char * D.35671;
  unsigned char D.35672;
  int D.35673;
  const unsigned char * D.35674;
  unsigned char D.35675;
  int D.35676;
  _Bool D.35677;
  _Bool D.35678;
  const unsigned char * D.35681;
  unsigned char D.35682;
  int D.35683;
  const unsigned char * D.35684;
  unsigned char D.35685;
  int D.35686;
  _Bool D.35687;
  _Bool D.35688;
  const unsigned char * D.35691;
  unsigned char D.35692;
  int D.35693;
  const unsigned char * D.35694;
  unsigned char D.35695;
  int D.35696;
  const char * D.35698;
  char * D.35700;
  struct MonoDomain * domain.579;
  int ip.580;
  void * D.35703;
  int D.35704;
  int D.35705;
  int D.35708;
  struct MonoSeqPointInfo * info.581;
  <unnamed type> D.35712;
  unsigned int D.35713;
  short unsigned int D.35716;
  int D.35717;
  int D.35718;
  int D.28558;
  int iftmp.582;
  int D.28557;
  const char[7] * D.35724;
  unsigned char D.35725;
  int D.35726;
  unsigned char D.35727;
  int D.35728;
  _Bool D.35729;
  _Bool D.35730;
  _Bool D.35731;
  const unsigned char * D.35734;
  unsigned char D.35735;
  int D.35736;
  const unsigned char * D.35737;
  unsigned char D.35738;
  int D.35739;
  _Bool D.35740;
  _Bool D.35741;
  const unsigned char * D.35744;
  unsigned char D.35745;
  int D.35746;
  const unsigned char * D.35747;
  unsigned char D.35748;
  int D.35749;
  _Bool D.35750;
  _Bool D.35751;
  const unsigned char * D.35754;
  unsigned char D.35755;
  int D.35756;
  const unsigned char * D.35757;
  unsigned char D.35758;
  int D.35759;
  struct EventRequest * D.35763;
  struct MonoMethod * D.35764;
  int suspend_policy.583;
  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.35603 = ctx->pc;
      ip = (guint8 *) D.35603;
      mono_arch_skip_single_step (ctx);
      suspend_count.574 = suspend_count;
      if (suspend_count.574 > 0) goto <D.35605>; else goto <D.35606>;
      <D.35605>:
      process_suspend (tls, ctx);
      return;
      <D.35606>:
      ss_req.575 = ss_req;
      if (ss_req.575 == 0B) goto <D.35608>; else goto <D.35609>;
      <D.35608>:
      return;
      <D.35609>:
      D.35610 = mono_thread_internal_current ();
      ss_req.575 = ss_req;
      D.35611 = ss_req.575->thread;
      if (D.35610 != D.35611) goto <D.35612>; else goto <D.35613>;
      <D.35612>:
      return;
      <D.35613>:
      log_level.576 = log_level;
      if (log_level.576 > 0) goto <D.35615>; else goto <D.35616>;
      <D.35615>:
      D.35617 = mono_domain_get ();
      ji = mini_jit_info_table_find (D.35617, ip, &domain);
      log_level.576 = log_level;
      D.35618 = log_level.576 > 0;
      D.35619 = (long int) D.35618;
      D.35620 = __builtin_expect (D.35619, 0);
      if (D.35620 != 0) goto <D.35621>; else goto <D.35622>;
      <D.35621>:
      log_file.577 = log_file;
      D.35624 = GetCurrentThreadId ();
      D.35625 = (void *) D.35624;
      ss_req.575 = ss_req;
      D.35626 = ss_req.575->depth;
      D.35627 = ss_depth_to_string (D.35626);
      D.35628 = jinfo_get_method (ji);
      D.35629 = mono_method_full_name (D.35628, 1);
      D.35603 = ctx->pc;
      D.35630 = (void *) D.35603;
      D.35631 = ctx->regs[13];
      D.35632 = (void *) D.35631;
      ss_req.575 = ss_req;
      D.35633 = ss_req.575->last_sp;
      fprintf (log_file.577, "[%p] Single step event (depth=%s) at %s (%p), sp %p, last sp %p\n", D.35625, D.35627, D.35629, D.35630, D.35632, D.35633);
      log_file.577 = log_file;
      fflush (log_file.577);
      <D.35622>:
      <D.35616>:
      D.35634 = mono_domain_get ();
      ji = mini_jit_info_table_find (D.35634, ip, &domain);
      D.35635 = ji == 0B;
      D.35636 = (long int) D.35635;
      D.35637 = __builtin_expect (D.35636, 0);
      if (D.35637 != 0) goto <D.35638>; else goto <D.35639>;
      <D.35638>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 4813, "ji");
      <D.35639>:
      method = jinfo_get_method (ji);
      D.35640 = method == 0B;
      D.35641 = (long int) D.35640;
      D.35642 = __builtin_expect (D.35641, 0);
      if (D.35642 != 0) goto <D.35643>; else goto <D.35644>;
      <D.35643>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 4815, "method");
      <D.35644>:
      D.35645 = BIT_FIELD_REF <*method, 8, 160>;
      D.35646 = D.35645 & 124;
      D.35647 = D.35646 != 0;
      D.35648 = D.35646 != 68;
      D.35649 = D.35647 & D.35648;
      if (D.35649 != 0) goto <D.35650>; else goto <D.35651>;
      <D.35650>:
      return;
      <D.35651>:
      D.35654 = method->klass;
      D.35655 = mono_defaults.string_class;
      if (D.35654 == D.35655) goto <D.35656>; else goto <D.35657>;
      <D.35656>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          __s2 = method->name;
          D.35661 = "memset";
          D.35662 = MEM[(const unsigned char *)D.35661];
          D.35663 = (int) D.35662;
          D.35664 = *__s2;
          D.35665 = (int) D.35664;
          __result = D.35663 - D.35665;
          {
            D.35666 = __s2_len != 0;
            D.35667 = __result == 0;
            D.35668 = D.35666 & D.35667;
            if (D.35668 != 0) goto <D.35669>; else goto <D.35670>;
            <D.35669>:
            D.35671 = &MEM[(void *)"memset" + 1B];
            D.35672 = *D.35671;
            D.35673 = (int) D.35672;
            D.35674 = __s2 + 1;
            D.35675 = *D.35674;
            D.35676 = (int) D.35675;
            __result = D.35673 - D.35676;
            D.35677 = __s2_len > 1;
            D.35667 = __result == 0;
            D.35678 = D.35677 & D.35667;
            if (D.35678 != 0) goto <D.35679>; else goto <D.35680>;
            <D.35679>:
            D.35681 = &MEM[(void *)"memset" + 2B];
            D.35682 = *D.35681;
            D.35683 = (int) D.35682;
            D.35684 = __s2 + 2;
            D.35685 = *D.35684;
            D.35686 = (int) D.35685;
            __result = D.35683 - D.35686;
            D.35687 = __s2_len > 2;
            D.35667 = __result == 0;
            D.35688 = D.35687 & D.35667;
            if (D.35688 != 0) goto <D.35689>; else goto <D.35690>;
            <D.35689>:
            D.35691 = &MEM[(void *)"memset" + 3B];
            D.35692 = *D.35691;
            D.35693 = (int) D.35692;
            D.35694 = __s2 + 3;
            D.35695 = *D.35694;
            D.35696 = (int) D.35695;
            __result = D.35693 - D.35696;
            <D.35690>:
            <D.35680>:
            <D.35670>:
          }
          D.28548 = __result;
        }
        iftmp.578 = -D.28548;
        goto <D.35697>;
        <D.35660>:
        D.35698 = method->name;
        iftmp.578 = __builtin_strcmp (D.35698, "memset");
        <D.35697>:
        D.28549 = iftmp.578;
      }
      if (D.28549 == 0) goto <D.35652>; else goto <D.35699>;
      <D.35699>:
      D.35698 = method->name;
      D.35700 = strstr (D.35698, "memcpy");
      if (D.35700 != 0B) goto <D.35652>; else goto <D.35653>;
      <D.35652>:
      return;
      <D.35653>:
      <D.35657>:
      domain.579 = domain;
      ip.580 = (int) ip;
      D.35703 = ji->code_start;
      D.35704 = (int) D.35703;
      D.35705 = ip.580 - D.35704;
      sp = find_next_seq_point_for_native_offset (domain.579, method, D.35705, &info);
      if (sp == 0B) goto <D.35706>; else goto <D.35707>;
      <D.35706>:
      return;
      <D.35707>:
      il_offset = sp->il_offset;
      ss_req.575 = ss_req;
      D.35708 = ss_update (ss_req.575, ji, sp, tls, ctx);
      if (D.35708 == 0) goto <D.35709>; else goto <D.35710>;
      <D.35709>:
      return;
      <D.35710>:
      ss_req.575 = ss_req;
      info.581 = info;
      ss_start (ss_req.575, method, sp, info.581, ctx, tls, 0);
      ss_req.575 = ss_req;
      D.35712 = ss_req.575->filter;
      D.35713 = D.35712 & 1;
      if (D.35713 != 0) goto <D.35714>; else goto <D.35715>;
      <D.35714>:
      D.35716 = method->flags;
      D.35717 = (int) D.35716;
      D.35718 = D.35717 & 2048;
      if (D.35718 != 0) goto <D.35719>; else goto <D.35720>;
      <D.35719>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          __s2 = method->name;
          D.35724 = ".cctor";
          D.35725 = MEM[(const unsigned char *)D.35724];
          D.35726 = (int) D.35725;
          D.35727 = *__s2;
          D.35728 = (int) D.35727;
          __result = D.35726 - D.35728;
          {
            D.35729 = __s2_len != 0;
            D.35730 = __result == 0;
            D.35731 = D.35729 & D.35730;
            if (D.35731 != 0) goto <D.35732>; else goto <D.35733>;
            <D.35732>:
            D.35734 = &MEM[(void *)".cctor" + 1B];
            D.35735 = *D.35734;
            D.35736 = (int) D.35735;
            D.35737 = __s2 + 1;
            D.35738 = *D.35737;
            D.35739 = (int) D.35738;
            __result = D.35736 - D.35739;
            D.35740 = __s2_len > 1;
            D.35730 = __result == 0;
            D.35741 = D.35740 & D.35730;
            if (D.35741 != 0) goto <D.35742>; else goto <D.35743>;
            <D.35742>:
            D.35744 = &MEM[(void *)".cctor" + 2B];
            D.35745 = *D.35744;
            D.35746 = (int) D.35745;
            D.35747 = __s2 + 2;
            D.35748 = *D.35747;
            D.35749 = (int) D.35748;
            __result = D.35746 - D.35749;
            D.35750 = __s2_len > 2;
            D.35730 = __result == 0;
            D.35751 = D.35750 & D.35730;
            if (D.35751 != 0) goto <D.35752>; else goto <D.35753>;
            <D.35752>:
            D.35754 = &MEM[(void *)".cctor" + 3B];
            D.35755 = *D.35754;
            D.35756 = (int) D.35755;
            D.35757 = __s2 + 3;
            D.35758 = *D.35757;
            D.35759 = (int) D.35758;
            __result = D.35756 - D.35759;
            <D.35753>:
            <D.35743>:
            <D.35733>:
          }
          D.28557 = __result;
        }
        iftmp.582 = -D.28557;
        goto <D.35760>;
        <D.35723>:
        D.35698 = method->name;
        iftmp.582 = __builtin_strcmp (D.35698, ".cctor");
        <D.35760>:
        D.28558 = iftmp.582;
      }
      if (D.28558 == 0) goto <D.35761>; else goto <D.35762>;
      <D.35761>:
      return;
      <D.35762>:
      <D.35720>:
      <D.35715>:
      reqs = monoeg_g_ptr_array_new ();
      mono_loader_lock ();
      ss_req.575 = ss_req;
      D.35763 = ss_req.575->req;
      monoeg_g_ptr_array_add (reqs, D.35763);
      events = create_event_list (11, reqs, ji, 0B, &suspend_policy);
      monoeg_g_ptr_array_free (reqs, 1);
      mono_loader_unlock ();
      D.35764 = jinfo_get_method (ji);
      suspend_policy.583 = suspend_policy;
      process_event (11, D.35764, 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.35769;
  int D.35770;
  unsigned int D.35773;
  unsigned int debugger_thread_id.584;
  int suspend_count.585;
  unsigned int suspend_count.586;
  unsigned int D.35779;
  int log_level.587;
  _Bool D.35783;
  long int D.35784;
  long int D.35785;
  struct FILE * log_file.588;
  unsigned int D.35789;
  void * D.35790;
  unsigned int D.35795;
  void * D.35796;
  struct MonoDomain * D.35797;
  struct MonoClass * D.35800;
  struct MonoClass * D.35801;
  int D.27922;
  int iftmp.589;
  int D.27921;
  const char[7] * D.35807;
  unsigned char D.35808;
  int D.35809;
  unsigned char D.35810;
  int D.35811;
  _Bool D.35812;
  _Bool D.35813;
  _Bool D.35814;
  const unsigned char * D.35817;
  unsigned char D.35818;
  int D.35819;
  const unsigned char * D.35820;
  unsigned char D.35821;
  int D.35822;
  _Bool D.35823;
  _Bool D.35824;
  const unsigned char * D.35827;
  unsigned char D.35828;
  int D.35829;
  const unsigned char * D.35830;
  unsigned char D.35831;
  int D.35832;
  _Bool D.35833;
  _Bool D.35834;
  const unsigned char * D.35837;
  unsigned char D.35838;
  int D.35839;
  const unsigned char * D.35840;
  unsigned char D.35841;
  int D.35842;
  const char * D.35844;
  char * D.35846;
  guint8 * ip;
  struct MonoJitInfo * ji;
  struct MonoMethod * method;

  D.35769 = ctx->pc;
  ip = (guint8 *) D.35769;
  D.35770 = mono_loader_lock_is_owned_by_self ();
  if (D.35770 != 0) goto <D.35771>; else goto <D.35772>;
  <D.35771>:
  return;
  <D.35772>:
  D.35773 = GetCurrentThreadId ();
  debugger_thread_id.584 = debugger_thread_id;
  if (D.35773 == debugger_thread_id.584) goto <D.35775>; else goto <D.35776>;
  <D.35775>:
  return;
  <D.35776>:
  suspend_count.585 = suspend_count;
  suspend_count.586 = (unsigned int) suspend_count.585;
  D.35779 = tls->resume_count;
  if (suspend_count.586 != D.35779) goto <D.35780>; else goto <D.35781>;
  <D.35780>:
  tls->suspending = 1;
  <D.35781>:
  log_level.587 = log_level;
  D.35783 = log_level.587 > 0;
  D.35784 = (long int) D.35783;
  D.35785 = __builtin_expect (D.35784, 0);
  if (D.35785 != 0) goto <D.35786>; else goto <D.35787>;
  <D.35786>:
  log_file.588 = log_file;
  D.35789 = GetCurrentThreadId ();
  D.35790 = (void *) D.35789;
  fprintf (log_file.588, "[%p] Received single step event for suspending.\n", D.35790);
  log_file.588 = log_file;
  fflush (log_file.588);
  <D.35787>:
  suspend_count.585 = suspend_count;
  suspend_count.586 = (unsigned int) suspend_count.585;
  D.35779 = tls->resume_count;
  if (suspend_count.586 == D.35779) goto <D.35791>; else goto <D.35792>;
  <D.35791>:
  log_level.587 = log_level;
  D.35783 = log_level.587 > 0;
  D.35784 = (long int) D.35783;
  D.35785 = __builtin_expect (D.35784, 0);
  if (D.35785 != 0) goto <D.35793>; else goto <D.35794>;
  <D.35793>:
  log_file.588 = log_file;
  D.35795 = GetCurrentThreadId ();
  D.35796 = (void *) D.35795;
  fprintf (log_file.588, "[%p] Ignored during single threaded invoke.\n", D.35796);
  log_file.588 = log_file;
  fflush (log_file.588);
  <D.35794>:
  return;
  <D.35792>:
  D.35797 = mono_domain_get ();
  ji = mini_jit_info_table_find (D.35797, ip, 0B);
  method = jinfo_get_method (ji);
  D.35800 = method->klass;
  D.35801 = mono_defaults.string_class;
  if (D.35800 == D.35801) goto <D.35802>; else goto <D.35803>;
  <D.35802>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = method->name;
      D.35807 = "memset";
      D.35808 = MEM[(const unsigned char *)D.35807];
      D.35809 = (int) D.35808;
      D.35810 = *__s2;
      D.35811 = (int) D.35810;
      __result = D.35809 - D.35811;
      {
        D.35812 = __s2_len != 0;
        D.35813 = __result == 0;
        D.35814 = D.35812 & D.35813;
        if (D.35814 != 0) goto <D.35815>; else goto <D.35816>;
        <D.35815>:
        D.35817 = &MEM[(void *)"memset" + 1B];
        D.35818 = *D.35817;
        D.35819 = (int) D.35818;
        D.35820 = __s2 + 1;
        D.35821 = *D.35820;
        D.35822 = (int) D.35821;
        __result = D.35819 - D.35822;
        D.35823 = __s2_len > 1;
        D.35813 = __result == 0;
        D.35824 = D.35823 & D.35813;
        if (D.35824 != 0) goto <D.35825>; else goto <D.35826>;
        <D.35825>:
        D.35827 = &MEM[(void *)"memset" + 2B];
        D.35828 = *D.35827;
        D.35829 = (int) D.35828;
        D.35830 = __s2 + 2;
        D.35831 = *D.35830;
        D.35832 = (int) D.35831;
        __result = D.35829 - D.35832;
        D.35833 = __s2_len > 2;
        D.35813 = __result == 0;
        D.35834 = D.35833 & D.35813;
        if (D.35834 != 0) goto <D.35835>; else goto <D.35836>;
        <D.35835>:
        D.35837 = &MEM[(void *)"memset" + 3B];
        D.35838 = *D.35837;
        D.35839 = (int) D.35838;
        D.35840 = __s2 + 3;
        D.35841 = *D.35840;
        D.35842 = (int) D.35841;
        __result = D.35839 - D.35842;
        <D.35836>:
        <D.35826>:
        <D.35816>:
      }
      D.27921 = __result;
    }
    iftmp.589 = -D.27921;
    goto <D.35843>;
    <D.35806>:
    D.35844 = method->name;
    iftmp.589 = __builtin_strcmp (D.35844, "memset");
    <D.35843>:
    D.27922 = iftmp.589;
  }
  if (D.27922 == 0) goto <D.35798>; else goto <D.35845>;
  <D.35845>:
  D.35844 = method->name;
  D.35846 = strstr (D.35844, "memcpy");
  if (D.35846 != 0B) goto <D.35798>; else goto <D.35799>;
  <D.35798>:
  return;
  <D.35799>:
  <D.35803>:
  save_thread_context (ctx);
  suspend_current ();
}


debugger_agent_single_step_from_context (struct MonoContext * ctx)
{
  unsigned int debugger_tls_id.590;
  _Bool D.35849;
  long int D.35850;
  long int D.35851;
  struct MonoContext * D.35854;
  struct DebuggerTlsData * tls;
  struct MonoContext orig_restore_ctx;

  try
    {
      debugger_tls_id.590 = debugger_tls_id;
      tls = pthread_getspecific (debugger_tls_id.590);
      D.35849 = tls == 0B;
      D.35850 = (long int) D.35849;
      D.35851 = __builtin_expect (D.35850, 0);
      if (D.35851 != 0) goto <D.35852>; else goto <D.35853>;
      <D.35852>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 4909, "tls");
      <D.35853>:
      D.35854 = &tls->restore_ctx;
      memcpy (&orig_restore_ctx, D.35854, 208);
      D.35854 = &tls->restore_ctx;
      memcpy (D.35854, ctx, 208);
      process_single_step_inner (tls);
      D.35854 = &tls->restore_ctx;
      memcpy (ctx, D.35854, 208);
      D.35854 = &tls->restore_ctx;
      memcpy (D.35854, &orig_restore_ctx, 208);
    }
  finally
    {
      orig_restore_ctx = {CLOBBER};
    }
}


debugger_agent_breakpoint_from_context (struct MonoContext * ctx)
{
  unsigned int debugger_tls_id.591;
  _Bool D.35856;
  long int D.35857;
  long int D.35858;
  struct MonoContext * D.35861;
  struct DebuggerTlsData * tls;
  struct MonoContext orig_restore_ctx;

  try
    {
      debugger_tls_id.591 = debugger_tls_id;
      tls = pthread_getspecific (debugger_tls_id.591);
      D.35856 = tls == 0B;
      D.35857 = (long int) D.35856;
      D.35858 = __builtin_expect (D.35857, 0);
      if (D.35858 != 0) goto <D.35859>; else goto <D.35860>;
      <D.35859>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 4928, "tls");
      <D.35860>:
      D.35861 = &tls->restore_ctx;
      memcpy (&orig_restore_ctx, D.35861, 208);
      D.35861 = &tls->restore_ctx;
      memcpy (D.35861, ctx, 208);
      process_breakpoint_inner (tls);
      D.35861 = &tls->restore_ctx;
      memcpy (ctx, D.35861, 208);
      D.35861 = &tls->restore_ctx;
      memcpy (D.35861, &orig_restore_ctx, 208);
    }
  finally
    {
      orig_restore_ctx = {CLOBBER};
    }
}


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

  try
    {
      D.35862 = agent_config.enabled;
      if (D.35862 == 0) goto <D.35863>; else goto <D.35864>;
      <D.35863>:
      return;
      <D.35864>:
      mono_loader_lock ();
      events = create_event_list (16, 0B, 0B, 0B, &suspend_policy);
      mono_loader_unlock ();
      ei.level = level;
      if (category != 0B) goto <D.35866>; else goto <D.35867>;
      <D.35866>:
      iftmp.592 = mono_string_to_utf8 (category);
      goto <D.35868>;
      <D.35867>:
      iftmp.592 = 0B;
      <D.35868>:
      ei.category = iftmp.592;
      if (message != 0B) goto <D.35870>; else goto <D.35871>;
      <D.35870>:
      iftmp.593 = mono_string_to_utf8 (message);
      goto <D.35872>;
      <D.35871>:
      iftmp.593 = 0B;
      <D.35872>:
      ei.message = iftmp.593;
      suspend_policy.594 = suspend_policy;
      process_event (16, &ei, 0, 0B, events, suspend_policy.594);
      D.35874 = ei.category;
      monoeg_g_free (D.35874);
      D.35875 = ei.message;
      monoeg_g_free (D.35875);
    }
  finally
    {
      suspend_policy = {CLOBBER};
      ei = {CLOBBER};
    }
}


mono_debugger_agent_debug_log_is_enabled ()
{
  gboolean D.35879;

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


mono_debugger_agent_handle_exception (struct MonoException * exc, struct MonoContext * throw_ctx, struct MonoContext * catch_ctx)
{
  struct MonoGHashTable * thread_to_tls.595;
  int D.35886;
  int D.35891;
  int D.35896;
  int inited.596;
  struct GSList * D.35903;
  struct MonoVTable * D.35908;
  struct MonoClass * D.35909;
  struct MonoType * D.35910;
  int D.28686;
  int iftmp.597;
  int D.28685;
  const char[1] * D.35916;
  unsigned char D.35917;
  int D.35918;
  unsigned char D.35919;
  int D.35920;
  _Bool D.35921;
  _Bool D.35922;
  _Bool D.35923;
  const unsigned char * D.35926;
  unsigned char D.35927;
  int D.35928;
  const unsigned char * D.35929;
  unsigned char D.35930;
  int D.35931;
  _Bool D.35932;
  _Bool D.35933;
  const unsigned char * D.35936;
  unsigned char D.35937;
  int D.35938;
  const unsigned char * D.35939;
  unsigned char D.35940;
  int D.35941;
  _Bool D.35942;
  _Bool D.35943;
  const unsigned char * D.35946;
  unsigned char D.35947;
  int D.35948;
  const unsigned char * D.35949;
  unsigned char D.35950;
  int D.35951;
  unsigned char D.35953;
  int D.28695;
  struct MonoDomain * D.35959;
  int D.35960;
  char * D.35961;
  struct MonoDomain * D.35964;
  int D.35965;
  char * D.35966;
  _Bool D.35968;
  int D.35969;
  struct GPtrArray * event_requests.598;
  void * * D.35971;
  unsigned int i.599;
  unsigned int D.35973;
  void * * D.35974;
  int D.35975;
  <unnamed type> D.35978;
  unsigned int k.600;
  unsigned int D.35986;
  struct MonoAssembly * * D.35987;
  struct MonoAssembly * D.35988;
  struct MonoMethod * D.35989;
  struct MonoClass * D.35990;
  struct MonoImage * D.35991;
  struct MonoAssembly * D.35992;
  int D.35997;
  unsigned int i.601;
  unsigned int D.35999;
  int D.36002;
  struct MonoThreadUnwindState * D.36007;
  struct MonoDomain * D.36008;
  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.35882>; else goto <D.35883>;
      <D.35882>:
      {
        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.35884>; else goto <D.35885>;
        <D.35884>:
        D.35886 = tls->abort_requested;
        if (D.35886 != 0) goto <D.35887>; else goto <D.35888>;
        <D.35887>:
        return;
        <D.35888>:
        <D.35885>:
        if (tls != 0B) goto <D.35889>; else goto <D.35890>;
        <D.35889>:
        D.35891 = tls->disable_breakpoints;
        if (D.35891 != 0) goto <D.35892>; else goto <D.35893>;
        <D.35892>:
        return;
        <D.35893>:
        <D.35890>:
      }
      <D.35883>:
      memset (&ei, 0, 240);
      if (catch_ctx == 0B) goto <D.35894>; else goto <D.35895>;
      <D.35894>:
      D.35896 = agent_config.onuncaught;
      if (D.35896 != 0) goto <D.35897>; else goto <D.35898>;
      <D.35897>:
      inited.596 = inited;
      if (inited.596 == 0) goto <D.35900>; else goto <D.35901>;
      <D.35900>:
      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.35901>:
      <D.35898>:
      goto <D.35902>;
      <D.35895>:
      D.35903 = agent_config.onthrow;
      if (D.35903 != 0B) goto <D.35904>; else goto <D.35905>;
      <D.35904>:
      inited.596 = inited;
      if (inited.596 == 0) goto <D.35906>; else goto <D.35907>;
      <D.35906>:
      {
        struct GSList * l;
        gboolean found;

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

          ex_type = l->data;
          D.35908 = exc->object.vtable;
          D.35909 = D.35908->klass;
          D.35910 = &D.35909->byval_arg;
          f = mono_type_full_name (D.35910);
          {
            size_t __s1_len;
            size_t __s2_len;

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

              __s2 = ex_type;
              D.35916 = "";
              D.35917 = MEM[(const unsigned char *)D.35916];
              D.35918 = (int) D.35917;
              D.35919 = *__s2;
              D.35920 = (int) D.35919;
              __result = D.35918 - D.35920;
              {
                D.35921 = __s2_len != 0;
                D.35922 = __result == 0;
                D.35923 = D.35921 & D.35922;
                if (D.35923 != 0) goto <D.35924>; else goto <D.35925>;
                <D.35924>:
                D.35926 = &MEM[(void *)"" + 1B];
                D.35927 = *D.35926;
                D.35928 = (int) D.35927;
                D.35929 = __s2 + 1;
                D.35930 = *D.35929;
                D.35931 = (int) D.35930;
                __result = D.35928 - D.35931;
                D.35932 = __s2_len > 1;
                D.35922 = __result == 0;
                D.35933 = D.35932 & D.35922;
                if (D.35933 != 0) goto <D.35934>; else goto <D.35935>;
                <D.35934>:
                D.35936 = &MEM[(void *)"" + 2B];
                D.35937 = *D.35936;
                D.35938 = (int) D.35937;
                D.35939 = __s2 + 2;
                D.35940 = *D.35939;
                D.35941 = (int) D.35940;
                __result = D.35938 - D.35941;
                D.35942 = __s2_len > 2;
                D.35922 = __result == 0;
                D.35943 = D.35942 & D.35922;
                if (D.35943 != 0) goto <D.35944>; else goto <D.35945>;
                <D.35944>:
                D.35946 = &MEM[(void *)"" + 3B];
                D.35947 = *D.35946;
                D.35948 = (int) D.35947;
                D.35949 = __s2 + 3;
                D.35950 = *D.35949;
                D.35951 = (int) D.35950;
                __result = D.35948 - D.35951;
                <D.35945>:
                <D.35935>:
                <D.35925>:
              }
              D.28685 = __result;
            }
            iftmp.597 = -D.28685;
            goto <D.35952>;
            <D.35915>:
            D.35953 = MEM[(const unsigned char * {ref-all})ex_type];
            iftmp.597 = (int) D.35953;
            <D.35952>:
            D.28686 = iftmp.597;
          }
          if (D.28686 == 0) goto <D.35911>; else goto <D.35954>;
          <D.35954>:
          {
            size_t __s1_len;
            size_t __s2_len;

            D.28695 = __builtin_strcmp (ex_type, f);
          }
          if (D.28695 == 0) goto <D.35911>; else goto <D.35912>;
          <D.35911>:
          found = 1;
          <D.35912>:
          monoeg_g_free (f);
        }
        l = l->next;
        <D.28697>:
        if (l != 0B) goto <D.28696>; else goto <D.28698>;
        <D.28698>:
        if (found != 0) goto <D.35955>; else goto <D.35956>;
        <D.35955>:
        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.35956>:
      }
      <D.35907>:
      <D.35905>:
      <D.35902>:
      inited.596 = inited;
      if (inited.596 == 0) goto <D.35957>; else goto <D.35958>;
      <D.35957>:
      return;
      <D.35958>:
      D.35959 = mono_domain_get ();
      D.35960 = throw_ctx->pc;
      D.35961 = (char *) D.35960;
      ji = mini_jit_info_table_find (D.35959, D.35961, 0B);
      if (catch_ctx != 0B) goto <D.35962>; else goto <D.35963>;
      <D.35962>:
      D.35964 = mono_domain_get ();
      D.35965 = catch_ctx->pc;
      D.35966 = (char *) D.35965;
      catch_ji = mini_jit_info_table_find (D.35964, D.35966, 0B);
      goto <D.35967>;
      <D.35963>:
      catch_ji = 0B;
      <D.35967>:
      ei.exc = exc;
      D.35968 = catch_ctx != 0B;
      D.35969 = (int) D.35968;
      ei.caught = D.35969;
      mono_loader_lock ();
      i = 0;
      goto <D.28712>;
      <D.28711>:
      {
        struct EventRequest * req;

        event_requests.598 = event_requests;
        D.35971 = event_requests.598->pdata;
        i.599 = (unsigned int) i;
        D.35973 = i.599 * 4;
        D.35974 = D.35971 + D.35973;
        req = *D.35974;
        D.35975 = req->event_kind;
        if (D.35975 != 13) goto <D.35976>; else goto <D.35977>;
        <D.35976>:
        // predicted unlikely by continue predictor.
        goto <D.28700>;
        <D.35977>:
        j = 0;
        goto <D.28709>;
        <D.28708>:
        {
          struct Modifier * mod;

          mod = &req->modifiers[j];
          D.35978 = mod->kind;
          if (D.35978 == 11) goto <D.35979>; else goto <D.35980>;
          <D.35979>:
          if (catch_ji != 0B) goto <D.35981>; else goto <D.35982>;
          <D.35981>:
          {
            int k;
            gboolean found;
            struct MonoAssembly * * assemblies;

            found = 0;
            assemblies = mod->data.assemblies;
            if (assemblies != 0B) goto <D.35983>; else goto <D.35984>;
            <D.35983>:
            k = 0;
            goto <D.28706>;
            <D.28705>:
            k.600 = (unsigned int) k;
            D.35986 = k.600 * 4;
            D.35987 = assemblies + D.35986;
            D.35988 = *D.35987;
            D.35989 = jinfo_get_method (catch_ji);
            D.35990 = D.35989->klass;
            D.35991 = D.35990->image;
            D.35992 = D.35991->assembly;
            if (D.35988 == D.35992) goto <D.35993>; else goto <D.35994>;
            <D.35993>:
            found = 1;
            <D.35994>:
            k = k + 1;
            <D.28706>:
            k.600 = (unsigned int) k;
            D.35986 = k.600 * 4;
            D.35987 = assemblies + D.35986;
            D.35988 = *D.35987;
            if (D.35988 != 0B) goto <D.28705>; else goto <D.28707>;
            <D.28707>:
            <D.35984>:
            if (found == 0) goto <D.35995>; else goto <D.35996>;
            <D.35995>:
            ei.caught = 0;
            <D.35996>:
          }
          <D.35982>:
          <D.35980>:
        }
        j = j + 1;
        <D.28709>:
        D.35997 = req->nmodifiers;
        if (D.35997 > j) goto <D.28708>; else goto <D.28710>;
        <D.28710>:
      }
      <D.28700>:
      i = i + 1;
      <D.28712>:
      i.601 = (unsigned int) i;
      event_requests.598 = event_requests;
      D.35999 = event_requests.598->len;
      if (i.601 < D.35999) goto <D.28711>; else goto <D.28713>;
      <D.28713>:
      events = create_event_list (13, 0B, ji, &ei, &suspend_policy);
      mono_loader_unlock ();
      if (tls != 0B) goto <D.36000>; else goto <D.36001>;
      <D.36000>:
      D.36002 = ei.caught;
      if (D.36002 != 0) goto <D.36003>; else goto <D.36004>;
      <D.36003>:
      if (catch_ctx != 0B) goto <D.36005>; else goto <D.36006>;
      <D.36005>:
      D.36007 = &tls->catch_state;
      memset (D.36007, 0, 224);
      tls->catch_state.ctx = *catch_ctx;
      D.36008 = mono_domain_get ();
      tls->catch_state.unwind_data[0] = D.36008;
      tls->catch_state.valid = 1;
      <D.36006>:
      <D.36004>:
      <D.36001>:
      suspend_policy.602 = suspend_policy;
      process_event (13, &ei, 0, throw_ctx, events, suspend_policy.602);
      if (tls != 0B) goto <D.36010>; else goto <D.36011>;
      <D.36010>:
      tls->catch_state.valid = 0;
      <D.36011>:
    }
  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.36021;
  int D.36022;
  _Bool D.36023;
  long int D.36024;
  long int D.36025;
  struct DebuggerTlsData * tls;

  inited.603 = inited;
  if (inited.603 == 0) goto <D.36016>; else goto <D.36017>;
  <D.36016>:
  return;
  <D.36017>:
  debugger_tls_id.604 = debugger_tls_id;
  tls = pthread_getspecific (debugger_tls_id.604);
  if (tls == 0B) goto <D.36019>; else goto <D.36020>;
  <D.36019>:
  return;
  <D.36020>:
  D.36021 = &tls->filter_state;
  D.36022 = mono_thread_state_init_from_monoctx (D.36021, orig_ctx);
  D.36023 = D.36022 == 0;
  D.36024 = (long int) D.36023;
  D.36025 = __builtin_expect (D.36024, 0);
  if (D.36025 != 0) goto <D.36026>; else goto <D.36027>;
  <D.36026>:
  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.36027>:
}


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.36030>; else goto <D.36031>;
  <D.36030>:
  return;
  <D.36031>:
  debugger_tls_id.606 = debugger_tls_id;
  tls = pthread_getspecific (debugger_tls_id.606);
  if (tls == 0B) goto <D.36033>; else goto <D.36034>;
  <D.36033>:
  return;
  <D.36034>:
  tls->filter_state.valid = 0;
}