mono_debugger_agent_parse_options (char * options)
{
  int D.27111;
  const gchar * D.27114;
  gchar * D.27115;
  int D.27117;
  const gchar * D.27120;
  gchar * D.27121;
  int D.27123;
  const char * D.27126;
  int D.27127;
  int D.27129;
  gchar * D.27132;
  int D.27134;
  char * D.27137;
  int D.27138;
  int D.27140;
  char * D.27143;
  int D.27144;
  int D.27146;
  char * D.27149;
  int D.27150;
  int D.27152;
  struct GSList * D.27155;
  gchar * D.27156;
  struct GSList * D.27157;
  int D.27159;
  gchar * D.27162;
  struct GSList * D.27163;
  int D.27165;
  int D.27168;
  const char * D.27171;
  int D.27172;
  int D.27174;
  const gchar * D.27177;
  gchar * D.27178;
  int D.27180;
  const char * D.27183;
  int D.27184;
  _Bool D.27185;
  int D.27186;
  int D.27188;
  int D.27191;
  int D.27193;
  int D.27196;
  char * D.27199;
  int D.27200;
  int D.27203;
  char * D.27206;
  unsigned int D.27209;
  unsigned int D.27210;
  unsigned int D.27211;
  gchar * D.27212;
  char * D.27213;
  struct _IO_FILE * stderr.0;
  int D.24489;
  int iftmp.1;
  int D.24488;
  const char[10] * D.27224;
  unsigned char D.27225;
  int D.27226;
  unsigned char D.27227;
  int D.27228;
  const unsigned char * D.27233;
  unsigned char D.27234;
  int D.27235;
  const unsigned char * D.27236;
  unsigned char D.27237;
  int D.27238;
  const unsigned char * D.27243;
  unsigned char D.27244;
  int D.27245;
  const unsigned char * D.27246;
  unsigned char D.27247;
  int D.27248;
  const unsigned char * D.27253;
  unsigned char D.27254;
  int D.27255;
  const unsigned char * D.27256;
  unsigned char D.27257;
  int D.27258;
  int D.27264;
  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.27109>; else goto <D.27110>;
      <D.27109>:
      options = monoeg_g_strdup_printf ("%s,%s", options, extra);
      <D.27110>:
      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.24479>;
      <D.24478>:
      {
        char * arg;

        arg = *ptr;
        D.27111 = strncmp (arg, "transport=", 10);
        if (D.27111 == 0) goto <D.27112>; else goto <D.27113>;
        <D.27112>:
        D.27114 = arg + 10;
        D.27115 = monoeg_strdup (D.27114);
        agent_config.transport = D.27115;
        goto <D.27116>;
        <D.27113>:
        D.27117 = strncmp (arg, "address=", 8);
        if (D.27117 == 0) goto <D.27118>; else goto <D.27119>;
        <D.27118>:
        D.27120 = arg + 8;
        D.27121 = monoeg_strdup (D.27120);
        agent_config.address = D.27121;
        goto <D.27122>;
        <D.27119>:
        D.27123 = strncmp (arg, "loglevel=", 9);
        if (D.27123 == 0) goto <D.27124>; else goto <D.27125>;
        <D.27124>:
        D.27126 = arg + 9;
        D.27127 = atoi (D.27126);
        agent_config.log_level = D.27127;
        goto <D.27128>;
        <D.27125>:
        D.27129 = strncmp (arg, "logfile=", 8);
        if (D.27129 == 0) goto <D.27130>; else goto <D.27131>;
        <D.27130>:
        D.27120 = arg + 8;
        D.27132 = monoeg_strdup (D.27120);
        agent_config.log_file = D.27132;
        goto <D.27133>;
        <D.27131>:
        D.27134 = strncmp (arg, "suspend=", 8);
        if (D.27134 == 0) goto <D.27135>; else goto <D.27136>;
        <D.27135>:
        D.27137 = arg + 8;
        D.27138 = parse_flag ("suspend", D.27137);
        agent_config.suspend = D.27138;
        goto <D.27139>;
        <D.27136>:
        D.27140 = strncmp (arg, "server=", 7);
        if (D.27140 == 0) goto <D.27141>; else goto <D.27142>;
        <D.27141>:
        D.27143 = arg + 7;
        D.27144 = parse_flag ("server", D.27143);
        agent_config.server = D.27144;
        goto <D.27145>;
        <D.27142>:
        D.27146 = strncmp (arg, "onuncaught=", 11);
        if (D.27146 == 0) goto <D.27147>; else goto <D.27148>;
        <D.27147>:
        D.27149 = arg + 11;
        D.27150 = parse_flag ("onuncaught", D.27149);
        agent_config.onuncaught = D.27150;
        goto <D.27151>;
        <D.27148>:
        D.27152 = strncmp (arg, "onthrow=", 8);
        if (D.27152 == 0) goto <D.27153>; else goto <D.27154>;
        <D.27153>:
        D.27155 = agent_config.onthrow;
        D.27120 = arg + 8;
        D.27156 = monoeg_strdup (D.27120);
        D.27157 = monoeg_g_slist_append (D.27155, D.27156);
        agent_config.onthrow = D.27157;
        goto <D.27158>;
        <D.27154>:
        D.27159 = strncmp (arg, "onthrow", 7);
        if (D.27159 == 0) goto <D.27160>; else goto <D.27161>;
        <D.27160>:
        D.27155 = agent_config.onthrow;
        D.27162 = monoeg_strdup ("");
        D.27163 = monoeg_g_slist_append (D.27155, D.27162);
        agent_config.onthrow = D.27163;
        goto <D.27164>;
        <D.27161>:
        D.27165 = strncmp (arg, "help", 4);
        if (D.27165 == 0) goto <D.27166>; else goto <D.27167>;
        <D.27166>:
        print_usage ();
        exit (0);
        <D.27167>:
        D.27168 = strncmp (arg, "timeout=", 8);
        if (D.27168 == 0) goto <D.27169>; else goto <D.27170>;
        <D.27169>:
        D.27171 = arg + 8;
        D.27172 = atoi (D.27171);
        agent_config.timeout = D.27172;
        goto <D.27173>;
        <D.27170>:
        D.27174 = strncmp (arg, "launch=", 7);
        if (D.27174 == 0) goto <D.27175>; else goto <D.27176>;
        <D.27175>:
        D.27177 = arg + 7;
        D.27178 = monoeg_strdup (D.27177);
        agent_config.launch = D.27178;
        goto <D.27179>;
        <D.27176>:
        D.27180 = strncmp (arg, "embedding=", 10);
        if (D.27180 == 0) goto <D.27181>; else goto <D.27182>;
        <D.27181>:
        D.27183 = arg + 10;
        D.27184 = atoi (D.27183);
        D.27185 = D.27184 == 1;
        D.27186 = (int) D.27185;
        agent_config.embedding = D.27186;
        goto <D.27187>;
        <D.27182>:
        D.27188 = strncmp (arg, "keepalive=", 10);
        if (D.27188 == 0) goto <D.27189>; else goto <D.27190>;
        <D.27189>:
        D.27183 = arg + 10;
        D.27191 = atoi (D.27183);
        agent_config.keepalive = D.27191;
        goto <D.27192>;
        <D.27190>:
        D.27193 = strncmp (arg, "setpgid=", 8);
        if (D.27193 == 0) goto <D.27194>; else goto <D.27195>;
        <D.27194>:
        D.27137 = arg + 8;
        D.27196 = parse_flag ("setpgid", D.27137);
        agent_config.setpgid = D.27196;
        goto <D.27197>;
        <D.27195>:
        print_usage ();
        exit (1);
        <D.27197>:
        <D.27192>:
        <D.27187>:
        <D.27179>:
        <D.27173>:
        <D.27164>:
        <D.27158>:
        <D.27151>:
        <D.27145>:
        <D.27139>:
        <D.27133>:
        <D.27128>:
        <D.27122>:
        <D.27116>:
      }
      ptr = ptr + 4;
      <D.24479>:
      if (ptr != 0B) goto <D.27198>; else goto <D.24480>;
      <D.27198>:
      D.27199 = *ptr;
      if (D.27199 != 0B) goto <D.24478>; else goto <D.24480>;
      <D.24480>:
      D.27200 = agent_config.server;
      if (D.27200 != 0) goto <D.27201>; else goto <D.27202>;
      <D.27201>:
      D.27203 = agent_config.suspend;
      if (D.27203 == 0) goto <D.27204>; else goto <D.27205>;
      <D.27204>:
      agent_config.defer = 1;
      D.27206 = agent_config.address;
      if (D.27206 == 0B) goto <D.27207>; else goto <D.27208>;
      <D.27207>:
      D.27209 = GetCurrentProcessId ();
      D.27210 = D.27209 % 1000;
      D.27211 = D.27210 + 56000;
      D.27212 = monoeg_g_strdup_printf ("0.0.0.0:%u", D.27211);
      agent_config.address = D.27212;
      <D.27208>:
      <D.27205>:
      <D.27202>:
      D.27213 = agent_config.transport;
      if (D.27213 == 0B) goto <D.27214>; else goto <D.27215>;
      <D.27214>:
      stderr.0 = stderr;
      fprintf (stderr.0, "debugger-agent: The \'transport\' option is mandatory.\n");
      exit (1);
      <D.27215>:
      D.27206 = agent_config.address;
      if (D.27206 == 0B) goto <D.27217>; else goto <D.27218>;
      <D.27217>:
      D.27200 = agent_config.server;
      if (D.27200 == 0) goto <D.27219>; else goto <D.27220>;
      <D.27219>:
      stderr.0 = stderr;
      fprintf (stderr.0, "debugger-agent: The \'address\' option is mandatory.\n");
      exit (1);
      <D.27220>:
      <D.27218>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          __s2 = agent_config.transport;
          D.27224 = "dt_socket";
          D.27225 = MEM[(const unsigned char *)D.27224];
          D.27226 = (int) D.27225;
          D.27227 = *__s2;
          D.27228 = (int) D.27227;
          __result = D.27226 - D.27228;
          {
            if (__s2_len != 0) goto <D.27229>; else goto <D.27230>;
            <D.27229>:
            if (__result == 0) goto <D.27231>; else goto <D.27232>;
            <D.27231>:
            D.27233 = &MEM[(void *)"dt_socket" + 1B];
            D.27234 = *D.27233;
            D.27235 = (int) D.27234;
            D.27236 = __s2 + 1;
            D.27237 = *D.27236;
            D.27238 = (int) D.27237;
            __result = D.27235 - D.27238;
            if (__s2_len > 1) goto <D.27239>; else goto <D.27240>;
            <D.27239>:
            if (__result == 0) goto <D.27241>; else goto <D.27242>;
            <D.27241>:
            D.27243 = &MEM[(void *)"dt_socket" + 2B];
            D.27244 = *D.27243;
            D.27245 = (int) D.27244;
            D.27246 = __s2 + 2;
            D.27247 = *D.27246;
            D.27248 = (int) D.27247;
            __result = D.27245 - D.27248;
            if (__s2_len > 2) goto <D.27249>; else goto <D.27250>;
            <D.27249>:
            if (__result == 0) goto <D.27251>; else goto <D.27252>;
            <D.27251>:
            D.27253 = &MEM[(void *)"dt_socket" + 3B];
            D.27254 = *D.27253;
            D.27255 = (int) D.27254;
            D.27256 = __s2 + 3;
            D.27257 = *D.27256;
            D.27258 = (int) D.27257;
            __result = D.27255 - D.27258;
            <D.27252>:
            <D.27250>:
            <D.27242>:
            <D.27240>:
            <D.27232>:
            <D.27230>:
          }
          D.24488 = __result;
        }
        iftmp.1 = -D.24488;
        goto <D.27259>;
        <D.27223>:
        D.27213 = agent_config.transport;
        iftmp.1 = __builtin_strcmp (D.27213, "dt_socket");
        <D.27259>:
        D.24489 = iftmp.1;
      }
      if (D.24489 == 0) goto <D.27260>; else goto <D.27261>;
      <D.27260>:
      D.27206 = agent_config.address;
      if (D.27206 != 0B) goto <D.27262>; else goto <D.27263>;
      <D.27262>:
      D.27206 = agent_config.address;
      D.27264 = parse_address (D.27206, &host, &port);
      if (D.27264 != 0) goto <D.27265>; else goto <D.27266>;
      <D.27265>:
      stderr.0 = stderr;
      fprintf (stderr.0, "debugger-agent: The format of the \'address\' options is \'<host>:<port>\'\n");
      exit (1);
      <D.27266>:
      <D.27263>:
      <D.27261>:
    }
  finally
    {
      host = {CLOBBER};
      port = {CLOBBER};
    }
}


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

  if (str != 0B) goto <D.27267>; else goto <D.27268>;
  <D.27267>:
  D.27269 = __strdup (str);
  return D.27269;
  <D.27268>:
  D.27269 = 0B;
  return D.27269;
}


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

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


parse_flag (const char * option, char * flag)
{
  int D.24324;
  int iftmp.2;
  int D.24323;
  const char[2] * D.27276;
  unsigned char D.27277;
  int D.27278;
  unsigned char D.27279;
  int D.27280;
  const unsigned char * D.27285;
  unsigned char D.27286;
  int D.27287;
  const unsigned char * D.27288;
  unsigned char D.27289;
  int D.27290;
  const unsigned char * D.27295;
  unsigned char D.27296;
  int D.27297;
  const unsigned char * D.27298;
  unsigned char D.27299;
  int D.27300;
  const unsigned char * D.27305;
  unsigned char D.27306;
  int D.27307;
  const unsigned char * D.27308;
  unsigned char D.27309;
  int D.27310;
  gboolean D.27314;
  int D.24333;
  int iftmp.3;
  int D.24332;
  const char[2] * D.27318;
  unsigned char D.27319;
  int D.27320;
  unsigned char D.27321;
  int D.27322;
  const unsigned char * D.27327;
  unsigned char D.27328;
  int D.27329;
  const unsigned char * D.27330;
  unsigned char D.27331;
  int D.27332;
  const unsigned char * D.27337;
  unsigned char D.27338;
  int D.27339;
  const unsigned char * D.27340;
  unsigned char D.27341;
  int D.27342;
  const unsigned char * D.27347;
  unsigned char D.27348;
  int D.27349;
  const unsigned char * D.27350;
  unsigned char D.27351;
  int D.27352;
  struct _IO_FILE * stderr.4;

  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = flag;
      D.27276 = "y";
      D.27277 = MEM[(const unsigned char *)D.27276];
      D.27278 = (int) D.27277;
      D.27279 = *__s2;
      D.27280 = (int) D.27279;
      __result = D.27278 - D.27280;
      {
        if (__s2_len != 0) goto <D.27281>; else goto <D.27282>;
        <D.27281>:
        if (__result == 0) goto <D.27283>; else goto <D.27284>;
        <D.27283>:
        D.27285 = &MEM[(void *)"y" + 1B];
        D.27286 = *D.27285;
        D.27287 = (int) D.27286;
        D.27288 = __s2 + 1;
        D.27289 = *D.27288;
        D.27290 = (int) D.27289;
        __result = D.27287 - D.27290;
        if (__s2_len > 1) goto <D.27291>; else goto <D.27292>;
        <D.27291>:
        if (__result == 0) goto <D.27293>; else goto <D.27294>;
        <D.27293>:
        D.27295 = &MEM[(void *)"y" + 2B];
        D.27296 = *D.27295;
        D.27297 = (int) D.27296;
        D.27298 = __s2 + 2;
        D.27299 = *D.27298;
        D.27300 = (int) D.27299;
        __result = D.27297 - D.27300;
        if (__s2_len > 2) goto <D.27301>; else goto <D.27302>;
        <D.27301>:
        if (__result == 0) goto <D.27303>; else goto <D.27304>;
        <D.27303>:
        D.27305 = &MEM[(void *)"y" + 3B];
        D.27306 = *D.27305;
        D.27307 = (int) D.27306;
        D.27308 = __s2 + 3;
        D.27309 = *D.27308;
        D.27310 = (int) D.27309;
        __result = D.27307 - D.27310;
        <D.27304>:
        <D.27302>:
        <D.27294>:
        <D.27292>:
        <D.27284>:
        <D.27282>:
      }
      D.24323 = __result;
    }
    iftmp.2 = -D.24323;
    goto <D.27311>;
    <D.27275>:
    iftmp.2 = __builtin_strcmp (flag, "y");
    <D.27311>:
    D.24324 = iftmp.2;
  }
  if (D.24324 == 0) goto <D.27312>; else goto <D.27313>;
  <D.27312>:
  D.27314 = 1;
  return D.27314;
  <D.27313>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = flag;
      D.27318 = "n";
      D.27319 = MEM[(const unsigned char *)D.27318];
      D.27320 = (int) D.27319;
      D.27321 = *__s2;
      D.27322 = (int) D.27321;
      __result = D.27320 - D.27322;
      {
        if (__s2_len != 0) goto <D.27323>; else goto <D.27324>;
        <D.27323>:
        if (__result == 0) goto <D.27325>; else goto <D.27326>;
        <D.27325>:
        D.27327 = &MEM[(void *)"n" + 1B];
        D.27328 = *D.27327;
        D.27329 = (int) D.27328;
        D.27330 = __s2 + 1;
        D.27331 = *D.27330;
        D.27332 = (int) D.27331;
        __result = D.27329 - D.27332;
        if (__s2_len > 1) goto <D.27333>; else goto <D.27334>;
        <D.27333>:
        if (__result == 0) goto <D.27335>; else goto <D.27336>;
        <D.27335>:
        D.27337 = &MEM[(void *)"n" + 2B];
        D.27338 = *D.27337;
        D.27339 = (int) D.27338;
        D.27340 = __s2 + 2;
        D.27341 = *D.27340;
        D.27342 = (int) D.27341;
        __result = D.27339 - D.27342;
        if (__s2_len > 2) goto <D.27343>; else goto <D.27344>;
        <D.27343>:
        if (__result == 0) goto <D.27345>; else goto <D.27346>;
        <D.27345>:
        D.27347 = &MEM[(void *)"n" + 3B];
        D.27348 = *D.27347;
        D.27349 = (int) D.27348;
        D.27350 = __s2 + 3;
        D.27351 = *D.27350;
        D.27352 = (int) D.27351;
        __result = D.27349 - D.27352;
        <D.27346>:
        <D.27344>:
        <D.27336>:
        <D.27334>:
        <D.27326>:
        <D.27324>:
      }
      D.24332 = __result;
    }
    iftmp.3 = -D.24332;
    goto <D.27353>;
    <D.27317>:
    iftmp.3 = __builtin_strcmp (flag, "n");
    <D.27353>:
    D.24333 = iftmp.3;
  }
  if (D.24333 == 0) goto <D.27354>; else goto <D.27355>;
  <D.27354>:
  D.27314 = 0;
  return D.27314;
  <D.27355>:
  stderr.4 = stderr;
  fprintf (stderr.4, "debugger-agent: The valid values for the \'%s\' option are \'y\' and \'n\'.\n", option);
  exit (1);
  D.27314 = 0;
  return D.27314;
}


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)
{
  int D.27362;
  int pos.6;
  int address.7;
  int D.27365;
  int D.27366;
  unsigned int D.27367;
  void * D.27368;
  char * D.27369;
  unsigned int D.27370;
  sizetype D.27371;
  char * D.27372;
  const char * D.27373;
  int D.27374;
  char * pos;

  pos = __builtin_strchr (address, 58);
  if (pos == 0B) goto <D.27359>; else goto <D.27361>;
  <D.27361>:
  if (pos == address) goto <D.27359>; else goto <D.27360>;
  <D.27359>:
  D.27362 = 1;
  return D.27362;
  <D.27360>:
  pos.6 = (int) pos;
  address.7 = (int) address;
  D.27365 = pos.6 - address.7;
  D.27366 = D.27365 + 1;
  D.27367 = (unsigned int) D.27366;
  D.27368 = monoeg_malloc (D.27367);
  *host = D.27368;
  D.27369 = *host;
  pos.6 = (int) pos;
  address.7 = (int) address;
  D.27365 = pos.6 - address.7;
  D.27370 = (unsigned int) D.27365;
  strncpy (D.27369, address, D.27370);
  D.27369 = *host;
  pos.6 = (int) pos;
  address.7 = (int) address;
  D.27365 = pos.6 - address.7;
  D.27371 = (sizetype) D.27365;
  D.27372 = D.27369 + D.27371;
  *D.27372 = 0;
  D.27373 = pos + 1;
  D.27374 = atoi (D.27373);
  *port = D.27374;
  D.27362 = 0;
  return D.27362;
}


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

  D.27377 = __builtin_object_size (__dest, 1);
  D.27376 = __builtin___strncpy_chk (__dest, __src, __len, D.27377);
  return D.27376;
}


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

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


mono_debugger_agent_init ()
{
  int D.27381;
  struct GPtrArray * event_requests.8;
  struct MonoGHashTable * thread_to_tls.9;
  int D.27386;
  struct MonoGHashTable * tid_to_thread.10;
  int D.27390;
  struct MonoGHashTable * tid_to_thread_obj.11;
  int D.27394;
  struct GPtrArray * pending_assembly_loads.12;
  struct GHashTable * domains.13;
  int log_level.14;
  int embedding.15;
  char * D.27401;
  struct FILE * log_file.16;
  struct FILE * log_file.17;
  struct _IO_FILE * stderr.18;
  int * D.27409;
  int D.27410;
  char * D.27411;
  struct _IO_FILE * stdout.19;
  struct MonoDebugOptions * D.27414;
  struct MonoDebugOptions * D.27415;
  struct MonoDebugOptions * D.27416;
  int D.27417;
  int D.27420;
  struct GSList * D.27423;

  D.27381 = agent_config.enabled;
  if (D.27381 == 0) goto <D.27382>; else goto <D.27383>;
  <D.27382>:
  return;
  <D.27383>:
  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.27386 = mono_gc_is_moving ();
  if (D.27386 == 0) goto <D.27387>; else goto <D.27388>;
  <D.27387>:
  mono_gc_register_root (&thread_to_tls, 4, 0B);
  <D.27388>:
  tid_to_thread.10 = mono_g_hash_table_new_type (0B, 0B, 2);
  tid_to_thread = tid_to_thread.10;
  D.27390 = mono_gc_is_moving ();
  if (D.27390 == 0) goto <D.27391>; else goto <D.27392>;
  <D.27391>:
  mono_gc_register_root (&tid_to_thread, 4, 0B);
  <D.27392>:
  tid_to_thread_obj.11 = mono_g_hash_table_new_type (0B, 0B, 2);
  tid_to_thread_obj = tid_to_thread_obj.11;
  D.27394 = mono_gc_is_moving ();
  if (D.27394 == 0) goto <D.27395>; else goto <D.27396>;
  <D.27395>:
  mono_gc_register_root (&tid_to_thread_obj, 4, 0B);
  <D.27396>:
  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.27401 = agent_config.log_file;
  if (D.27401 != 0B) goto <D.27402>; else goto <D.27403>;
  <D.27402>:
  D.27401 = agent_config.log_file;
  log_file.16 = fopen (D.27401, "w+");
  log_file = log_file.16;
  log_file.17 = log_file;
  if (log_file.17 == 0B) goto <D.27406>; else goto <D.27407>;
  <D.27406>:
  stderr.18 = stderr;
  D.27401 = agent_config.log_file;
  D.27409 = __errno_location ();
  D.27410 = *D.27409;
  D.27411 = strerror (D.27410);
  fprintf (stderr.18, "Unable to create log file \'%s\': %s.\n", D.27401, D.27411);
  exit (1);
  <D.27407>:
  goto <D.27412>;
  <D.27403>:
  stdout.19 = stdout;
  log_file = stdout.19;
  <D.27412>:
  ids_init ();
  objrefs_init ();
  breakpoints_init ();
  suspend_init ();
  D.27414 = mini_get_debug_options ();
  D.27414->gen_seq_points = 1;
  D.27415 = mini_get_debug_options ();
  D.27415->mdb_optimizations = 1;
  mono_disable_optimizations (128);
  D.27416 = mini_get_debug_options ();
  D.27416->load_aot_jit_info_eagerly = 1;
  D.27417 = agent_config.setpgid;
  if (D.27417 != 0) goto <D.27418>; else goto <D.27419>;
  <D.27418>:
  setpgid (0, 0);
  <D.27419>:
  D.27420 = agent_config.onuncaught;
  if (D.27420 == 0) goto <D.27421>; else goto <D.27422>;
  <D.27421>:
  D.27423 = agent_config.onthrow;
  if (D.27423 == 0B) goto <D.27424>; else goto <D.27425>;
  <D.27424>:
  finish_agent_init (1);
  <D.27425>:
  <D.27422>:
}


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.27435;
  struct MonoInternalThread * D.27436;
  struct GPtrArray * event_requests.23;
  void * * D.27438;
  unsigned int i.24;
  unsigned int D.27440;
  void * * D.27441;
  int D.27442;
  void * D.27445;
  unsigned int i.25;
  unsigned int D.27447;
  int i;
  void * stackptr;

  stackptr = __builtin_frame_address (1);
  embedding.20 = embedding;
  if (embedding.20 == 0) goto <D.27427>; else goto <D.27430>;
  <D.27430>:
  ss_req.21 = ss_req;
  if (ss_req.21 == 0B) goto <D.27427>; else goto <D.27432>;
  <D.27432>:
  ss_invoke_addr.22 = ss_invoke_addr;
  if (stackptr != ss_invoke_addr.22) goto <D.27427>; else goto <D.27434>;
  <D.27434>:
  ss_req.21 = ss_req;
  D.27435 = ss_req.21->thread;
  D.27436 = mono_thread_internal_current ();
  if (D.27435 != D.27436) goto <D.27427>; else goto <D.27428>;
  <D.27427>:
  return;
  <D.27428>:
  mono_loader_lock ();
  ss_invoke_addr = 0B;
  i = 0;
  goto <D.25420>;
  <D.25419>:
  {
    struct EventRequest * req;

    event_requests.23 = event_requests;
    D.27438 = event_requests.23->pdata;
    i.24 = (unsigned int) i;
    D.27440 = i.24 * 4;
    D.27441 = D.27438 + D.27440;
    req = *D.27441;
    D.27442 = req->event_kind;
    if (D.27442 == 11) goto <D.27443>; else goto <D.27444>;
    <D.27443>:
    D.27445 = req->info;
    ss_destroy (D.27445);
    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.25418>;
    <D.27444>:
  }
  i = i + 1;
  <D.25420>:
  i.25 = (unsigned int) i;
  event_requests.23 = event_requests;
  D.27447 = event_requests.23->len;
  if (i.25 < D.27447) goto <D.25419>; else goto <D.25418>;
  <D.25418>:
  mono_loader_unlock ();
}


ss_destroy (struct SingleStepReq * req)
{
  struct SingleStepReq * ss_req.26;
  _Bool D.27450;
  long int D.27451;
  long int D.27452;

  ss_req.26 = ss_req;
  D.27450 = ss_req.26 != req;
  D.27451 = (long int) D.27450;
  D.27452 = __builtin_expect (D.27451, 0);
  if (D.27452 != 0) goto <D.27453>; else goto <D.27454>;
  <D.27453>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 5255, "ss_req == req");
  <D.27454>:
  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.27455;
  void * D.27458;
  int D.27459;

  D.27455 = ss_req->bps;
  if (D.27455 != 0B) goto <D.27456>; else goto <D.27457>;
  <D.27456>:
  {
    struct GSList * l;

    l = ss_req->bps;
    goto <D.25737>;
    <D.25736>:
    D.27458 = l->data;
    clear_breakpoint (D.27458);
    l = l->next;
    <D.25737>:
    if (l != 0B) goto <D.25736>; else goto <D.25738>;
    <D.25738>:
    D.27455 = ss_req->bps;
    monoeg_g_slist_free (D.27455);
    ss_req->bps = 0B;
  }
  <D.27457>:
  D.27459 = ss_req->global;
  if (D.27459 != 0) goto <D.27460>; else goto <D.27461>;
  <D.27460>:
  stop_single_stepping ();
  ss_req->global = 0;
  <D.27461>:
}


clear_breakpoint (struct MonoBreakpoint * bp)
{
  struct GPtrArray * D.27462;
  void * * D.27463;
  unsigned int i.27;
  unsigned int D.27465;
  void * * D.27466;
  unsigned int i.28;
  unsigned int D.27468;
  struct GPtrArray * breakpoints.29;
  int i;

  i = 0;
  goto <D.25560>;
  <D.25559>:
  {
    struct BreakpointInstance * inst;

    D.27462 = bp->children;
    D.27463 = D.27462->pdata;
    i.27 = (unsigned int) i;
    D.27465 = i.27 * 4;
    D.27466 = D.27463 + D.27465;
    inst = *D.27466;
    remove_breakpoint (inst);
    monoeg_g_free (inst);
  }
  i = i + 1;
  <D.25560>:
  i.28 = (unsigned int) i;
  D.27462 = bp->children;
  D.27468 = D.27462->len;
  if (i.28 < D.27468) goto <D.25559>; else goto <D.25561>;
  <D.25561>:
  mono_loader_lock ();
  breakpoints.29 = breakpoints;
  monoeg_g_ptr_array_remove (breakpoints.29, bp);
  mono_loader_unlock ();
  D.27462 = bp->children;
  monoeg_g_ptr_array_free (D.27462, 1);
  monoeg_g_free (bp);
}


remove_breakpoint (struct BreakpointInstance * inst)
{
  struct GHashTable * bp_locs.30;
  void * D.27471;
  int D.27472;
  void * D.27473;
  _Bool D.27474;
  long int D.27475;
  long int D.27476;
  long int D.27481;
  int count;
  struct MonoJitInfo * ji;
  guint8 * ip;

  ji = inst->ji;
  ip = inst->ip;
  mono_loader_lock ();
  bp_locs.30 = bp_locs;
  D.27471 = monoeg_g_hash_table_lookup (bp_locs.30, ip);
  count = (int) D.27471;
  bp_locs.30 = bp_locs;
  D.27472 = count + -1;
  D.27473 = (void *) D.27472;
  monoeg_g_hash_table_insert_replace (bp_locs.30, ip, D.27473, 0);
  mono_loader_unlock ();
  D.27474 = count <= 0;
  D.27475 = (long int) D.27474;
  D.27476 = __builtin_expect (D.27475, 0);
  if (D.27476 != 0) goto <D.27477>; else goto <D.27478>;
  <D.27477>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 4193, "count > 0");
  <D.27478>:
  if (count == 1) goto <D.27479>; else goto <D.27480>;
  <D.27479>:
  D.27481 = inst->native_offset;
  if (D.27481 != -1) goto <D.27482>; else goto <D.27483>;
  <D.27482>:
  mono_arch_clear_breakpoint (ji, ip);
  <D.27483>:
  <D.27480>:
}


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

  val = InterlockedDecrement (&ss_count);
  if (val == 0) goto <D.27484>; else goto <D.27485>;
  <D.27484>:
  mono_arch_stop_single_stepping ();
  <D.27485>:
  ss_req.31 = ss_req;
  if (ss_req.31 != 0B) goto <D.27487>; else goto <D.27488>;
  <D.27487>:
  ss_invoke_addr = 0B;
  <D.27488>:
}


InterlockedDecrement (volatile gint32 * val)
{
  gint32 D.27489;
  unsigned int D.27490;

  D.27490 = __sync_sub_and_fetch_4 (val, 1);
  D.27489 = (gint32) D.27490;
  return D.27489;
}


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.27493>; else goto <D.27494>;
  <D.27493>:
  tls->invoke_addr = stackptr;
  <D.27494>:
  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.27496;
  void * * D.27499;
  struct MonoClass * D.27501;

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

    assembly = 0B;
    mono_loader_lock ();
    pending_assembly_loads.33 = pending_assembly_loads;
    D.27496 = pending_assembly_loads.33->len;
    if (D.27496 != 0) goto <D.27497>; else goto <D.27498>;
    <D.27497>:
    pending_assembly_loads.33 = pending_assembly_loads;
    D.27499 = pending_assembly_loads.33->pdata;
    assembly = *D.27499;
    pending_assembly_loads.33 = pending_assembly_loads;
    monoeg_g_ptr_array_remove_index (pending_assembly_loads.33, 0);
    <D.27498>:
    mono_loader_unlock ();
    if (assembly != 0B) goto <D.27500>; else goto <D.25443>;
    <D.27500>:
    process_profiler_event (8, assembly);
  }
  goto <D.25444>;
  <D.25443>:
  D.27501 = method->klass;
  send_type_load (D.27501);
  if (result == 0) goto <D.27502>; else goto <D.27503>;
  <D.27502>:
  add_pending_breakpoints (method, jinfo);
  <D.27503>:
}


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.27504>; else goto <D.27505>;
      <D.27504>:
      ei.klass = arg;
      ei_arg = &ei;
      <D.27505>:
      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.27511;
  void * * D.27512;
  unsigned int i.35;
  unsigned int D.27514;
  void * * D.27515;
  int D.27516;
  unsigned int D.27517;
  <unnamed type> D.27520;
  int D.27523;
  int D.27528;
  struct MonoInternalThread * D.27534;
  struct MonoInternalThread * D.27535;
  struct MonoClass * D.27543;
  int D.27546;
  struct MonoObject * D.27549;
  struct MonoVTable * D.27550;
  struct MonoClass * D.27551;
  int D.27552;
  int D.27561;
  int D.27564;
  int D.27569;
  unsigned int k.36;
  unsigned int D.27579;
  struct MonoAssembly * * D.27580;
  struct MonoAssembly * D.27581;
  struct MonoMethod * D.27582;
  struct MonoClass * D.27583;
  struct MonoImage * D.27584;
  struct MonoAssembly * D.27585;
  struct MonoClass * D.27594;
  struct GPtrArray * source_file_list.37;
  void * * D.27599;
  unsigned int i.38;
  unsigned int D.27601;
  void * * D.27602;
  char * D.27603;
  struct GHashTable * D.27604;
  void * D.27605;
  void * D.27609;
  unsigned int i.39;
  unsigned int D.27613;
  struct MonoType * D.27621;
  struct GHashTable * D.27622;
  void * D.27623;
  <unnamed type> D.27628;
  unsigned int D.27629;
  struct MonoMethod * D.27634;
  short unsigned int D.27635;
  int D.27636;
  int D.27637;
  int D.25277;
  int iftmp.40;
  int D.25276;
  struct MonoMethod * D.27643;
  const char[7] * D.27644;
  unsigned char D.27645;
  int D.27646;
  unsigned char D.27647;
  int D.27648;
  const unsigned char * D.27653;
  unsigned char D.27654;
  int D.27655;
  const unsigned char * D.27656;
  unsigned char D.27657;
  int D.27658;
  const unsigned char * D.27663;
  unsigned char D.27664;
  int D.27665;
  const unsigned char * D.27666;
  unsigned char D.27667;
  int D.27668;
  const unsigned char * D.27673;
  unsigned char D.27674;
  int D.27675;
  const unsigned char * D.27676;
  unsigned char D.27677;
  int D.27678;
  struct MonoMethod * D.27680;
  const char * D.27681;
  unsigned int D.27684;
  struct MonoClass * klass.41;
  struct MonoImage * D.27692;
  struct MonoClass * klass.42;
  _Bool D.27694;
  long int D.27695;
  long int D.27696;
  unsigned int D.27699;
  unsigned int D.27700;
  struct MonoMethod * D.27703;
  int D.27706;
  unsigned int D.27709;
  unsigned int D.27712;
  struct MonoClass * klass.43;
  struct MonoClass * klass.44;
  _Bool D.27721;
  long int D.27722;
  long int D.27723;
  unsigned int D.27726;
  struct MonoMethod * D.27729;
  int D.27732;
  struct MonoMethod * D.27735;
  struct MonoClass * D.27736;
  int D.27739;
  unsigned int D.27742;
  int D.27745;
  int D.27748;
  int D.27749;
  int D.27750;
  int D.27751;
  void * D.27752;
  unsigned int i.45;
  unsigned int D.27754;
  int i;
  int j;
  struct GSList * events;

  events = 0B;
  *suspend_policy = 0;
  if (reqs == 0B) goto <D.27507>; else goto <D.27508>;
  <D.27507>:
  reqs = event_requests;
  <D.27508>:
  if (reqs == 0B) goto <D.27509>; else goto <D.27510>;
  <D.27509>:
  D.27511 = 0B;
  return D.27511;
  <D.27510>:
  i = 0;
  goto <D.25286>;
  <D.25285>:
  {
    struct EventRequest * req;

    D.27512 = reqs->pdata;
    i.35 = (unsigned int) i;
    D.27514 = i.35 * 4;
    D.27515 = D.27512 + D.27514;
    req = *D.27515;
    D.27516 = req->event_kind;
    D.27517 = (unsigned int) D.27516;
    if (D.27517 == event) goto <D.27518>; else goto <D.27519>;
    <D.27518>:
    {
      gboolean filtered;

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

        mod = &req->modifiers[j];
        D.27520 = mod->kind;
        if (D.27520 == 1) goto <D.27521>; else goto <D.27522>;
        <D.27521>:
        filtered = 1;
        D.27523 = mod->data.count;
        if (D.27523 > 0) goto <D.27524>; else goto <D.27525>;
        <D.27524>:
        D.27523 = mod->data.count;
        if (D.27523 > 0) goto <D.27526>; else goto <D.27527>;
        <D.27526>:
        D.27523 = mod->data.count;
        D.27528 = D.27523 + -1;
        mod->data.count = D.27528;
        D.27523 = mod->data.count;
        if (D.27523 == 0) goto <D.27529>; else goto <D.27530>;
        <D.27529>:
        filtered = 0;
        <D.27530>:
        <D.27527>:
        <D.27525>:
        goto <D.27531>;
        <D.27522>:
        D.27520 = mod->kind;
        if (D.27520 == 3) goto <D.27532>; else goto <D.27533>;
        <D.27532>:
        D.27534 = mod->data.thread;
        D.27535 = mono_thread_internal_current ();
        if (D.27534 != D.27535) goto <D.27536>; else goto <D.27537>;
        <D.27536>:
        filtered = 1;
        <D.27537>:
        goto <D.27538>;
        <D.27533>:
        D.27520 = mod->kind;
        if (D.27520 == 8) goto <D.27541>; else goto <D.27539>;
        <D.27541>:
        if (ei != 0B) goto <D.27542>; else goto <D.27539>;
        <D.27542>:
        D.27543 = mod->data.exc_class;
        if (D.27543 != 0B) goto <D.27544>; else goto <D.27545>;
        <D.27544>:
        D.27546 = mod->subclasses;
        if (D.27546 != 0) goto <D.27547>; else goto <D.27548>;
        <D.27547>:
        D.27543 = mod->data.exc_class;
        D.27549 = ei->exc;
        D.27550 = D.27549->vtable;
        D.27551 = D.27550->klass;
        D.27552 = mono_class_is_assignable_from (D.27543, D.27551);
        if (D.27552 == 0) goto <D.27553>; else goto <D.27554>;
        <D.27553>:
        filtered = 1;
        <D.27554>:
        <D.27548>:
        <D.27545>:
        D.27543 = mod->data.exc_class;
        if (D.27543 != 0B) goto <D.27555>; else goto <D.27556>;
        <D.27555>:
        D.27546 = mod->subclasses;
        if (D.27546 == 0) goto <D.27557>; else goto <D.27558>;
        <D.27557>:
        D.27543 = mod->data.exc_class;
        D.27549 = ei->exc;
        D.27550 = D.27549->vtable;
        D.27551 = D.27550->klass;
        if (D.27543 != D.27551) goto <D.27559>; else goto <D.27560>;
        <D.27559>:
        filtered = 1;
        <D.27560>:
        <D.27558>:
        <D.27556>:
        D.27561 = ei->caught;
        if (D.27561 != 0) goto <D.27562>; else goto <D.27563>;
        <D.27562>:
        D.27564 = mod->caught;
        if (D.27564 == 0) goto <D.27565>; else goto <D.27566>;
        <D.27565>:
        filtered = 1;
        <D.27566>:
        <D.27563>:
        D.27561 = ei->caught;
        if (D.27561 == 0) goto <D.27567>; else goto <D.27568>;
        <D.27567>:
        D.27569 = mod->uncaught;
        if (D.27569 == 0) goto <D.27570>; else goto <D.27571>;
        <D.27570>:
        filtered = 1;
        <D.27571>:
        <D.27568>:
        goto <D.27540>;
        <D.27539>:
        D.27520 = mod->kind;
        if (D.27520 == 11) goto <D.27574>; else goto <D.27572>;
        <D.27574>:
        if (ji != 0B) goto <D.27575>; else goto <D.27572>;
        <D.27575>:
        {
          int k;
          gboolean found;
          struct MonoAssembly * * assemblies;

          found = 0;
          assemblies = mod->data.assemblies;
          if (assemblies != 0B) goto <D.27576>; else goto <D.27577>;
          <D.27576>:
          k = 0;
          goto <D.25249>;
          <D.25248>:
          k.36 = (unsigned int) k;
          D.27579 = k.36 * 4;
          D.27580 = assemblies + D.27579;
          D.27581 = *D.27580;
          D.27582 = jinfo_get_method (ji);
          D.27583 = D.27582->klass;
          D.27584 = D.27583->image;
          D.27585 = D.27584->assembly;
          if (D.27581 == D.27585) goto <D.27586>; else goto <D.27587>;
          <D.27586>:
          found = 1;
          <D.27587>:
          k = k + 1;
          <D.25249>:
          k.36 = (unsigned int) k;
          D.27579 = k.36 * 4;
          D.27580 = assemblies + D.27579;
          D.27581 = *D.27580;
          if (D.27581 != 0B) goto <D.25248>; else goto <D.25250>;
          <D.25250>:
          <D.27577>:
          if (found == 0) goto <D.27588>; else goto <D.27589>;
          <D.27588>:
          filtered = 1;
          <D.27589>:
        }
        goto <D.27573>;
        <D.27572>:
        D.27520 = mod->kind;
        if (D.27520 == 12) goto <D.27592>; else goto <D.27590>;
        <D.27592>:
        if (ei != 0B) goto <D.27593>; else goto <D.27590>;
        <D.27593>:
        D.27594 = ei->klass;
        if (D.27594 != 0B) goto <D.27595>; else goto <D.27590>;
        <D.27595>:
        {
          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.25266>;
              <D.25265>:
              {
                struct MonoDebugMethodInfo * minfo;

                minfo = mono_debug_lookup_method (method);
                if (minfo != 0B) goto <D.27596>; else goto <D.27597>;
                <D.27596>:
                mono_debug_symfile_get_line_numbers_full (minfo, &source_file, &source_file_list, 0B, 0B, 0B, 0B, 0B);
                i = 0;
                goto <D.25263>;
                <D.25262>:
                source_file_list.37 = source_file_list;
                D.27599 = source_file_list.37->pdata;
                i.38 = (unsigned int) i;
                D.27601 = i.38 * 4;
                D.27602 = D.27599 + D.27601;
                sinfo = *D.27602;
                D.27603 = sinfo->source_file;
                s = strdup_tolower (D.27603);
                D.27604 = mod->data.source_files;
                D.27605 = monoeg_g_hash_table_lookup (D.27604, s);
                if (D.27605 != 0B) goto <D.27606>; else goto <D.27607>;
                <D.27606>:
                found = 1;
                goto <D.27608>;
                <D.27607>:
                {
                  char * s2;
                  char * s3;

                  D.27603 = sinfo->source_file;
                  s2 = monoeg_g_path_get_basename (D.27603);
                  s3 = strdup_tolower (s2);
                  D.27604 = mod->data.source_files;
                  D.27609 = monoeg_g_hash_table_lookup (D.27604, s3);
                  if (D.27609 != 0B) goto <D.27610>; else goto <D.27611>;
                  <D.27610>:
                  found = 1;
                  <D.27611>:
                  monoeg_g_free (s2);
                  monoeg_g_free (s3);
                }
                <D.27608>:
                monoeg_g_free (s);
                i = i + 1;
                <D.25263>:
                i.39 = (unsigned int) i;
                source_file_list.37 = source_file_list;
                D.27613 = source_file_list.37->len;
                if (i.39 < D.27613) goto <D.25262>; else goto <D.25264>;
                <D.25264>:
                source_file_list.37 = source_file_list;
                monoeg_g_ptr_array_free (source_file_list.37, 1);
                <D.27597>:
              }
              <D.25266>:
              D.27594 = ei->klass;
              method = mono_class_get_methods (D.27594, &iter);
              if (method != 0B) goto <D.25265>; else goto <D.25267>;
              <D.25267>:
              if (found == 0) goto <D.27614>; else goto <D.27615>;
              <D.27614>:
              filtered = 1;
              <D.27615>:
            }
          finally
            {
              iter = {CLOBBER};
              source_file = {CLOBBER};
              source_file_list = {CLOBBER};
            }
        }
        goto <D.27591>;
        <D.27590>:
        D.27520 = mod->kind;
        if (D.27520 == 13) goto <D.27618>; else goto <D.27616>;
        <D.27618>:
        if (ei != 0B) goto <D.27619>; else goto <D.27616>;
        <D.27619>:
        D.27594 = ei->klass;
        if (D.27594 != 0B) goto <D.27620>; else goto <D.27616>;
        <D.27620>:
        {
          char * s;

          D.27594 = ei->klass;
          D.27621 = &D.27594->byval_arg;
          s = mono_type_full_name (D.27621);
          D.27622 = mod->data.type_names;
          D.27623 = monoeg_g_hash_table_lookup (D.27622, s);
          if (D.27623 == 0B) goto <D.27624>; else goto <D.27625>;
          <D.27624>:
          filtered = 1;
          <D.27625>:
          monoeg_g_free (s);
        }
        goto <D.27617>;
        <D.27616>:
        D.27520 = mod->kind;
        if (D.27520 == 10) goto <D.27626>; else goto <D.27627>;
        <D.27626>:
        D.27628 = mod->data.filter;
        D.27629 = D.27628 & 1;
        if (D.27629 != 0) goto <D.27630>; else goto <D.27631>;
        <D.27630>:
        if (ji != 0B) goto <D.27632>; else goto <D.27633>;
        <D.27632>:
        D.27634 = jinfo_get_method (ji);
        D.27635 = D.27634->flags;
        D.27636 = (int) D.27635;
        D.27637 = D.27636 & 2048;
        if (D.27637 != 0) goto <D.27638>; else goto <D.27639>;
        <D.27638>:
        {
          size_t __s1_len;
          size_t __s2_len;

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

            D.27643 = jinfo_get_method (ji);
            __s2 = D.27643->name;
            D.27644 = ".cctor";
            D.27645 = MEM[(const unsigned char *)D.27644];
            D.27646 = (int) D.27645;
            D.27647 = *__s2;
            D.27648 = (int) D.27647;
            __result = D.27646 - D.27648;
            {
              if (__s2_len != 0) goto <D.27649>; else goto <D.27650>;
              <D.27649>:
              if (__result == 0) goto <D.27651>; else goto <D.27652>;
              <D.27651>:
              D.27653 = &MEM[(void *)".cctor" + 1B];
              D.27654 = *D.27653;
              D.27655 = (int) D.27654;
              D.27656 = __s2 + 1;
              D.27657 = *D.27656;
              D.27658 = (int) D.27657;
              __result = D.27655 - D.27658;
              if (__s2_len > 1) goto <D.27659>; else goto <D.27660>;
              <D.27659>:
              if (__result == 0) goto <D.27661>; else goto <D.27662>;
              <D.27661>:
              D.27663 = &MEM[(void *)".cctor" + 2B];
              D.27664 = *D.27663;
              D.27665 = (int) D.27664;
              D.27666 = __s2 + 2;
              D.27667 = *D.27666;
              D.27668 = (int) D.27667;
              __result = D.27665 - D.27668;
              if (__s2_len > 2) goto <D.27669>; else goto <D.27670>;
              <D.27669>:
              if (__result == 0) goto <D.27671>; else goto <D.27672>;
              <D.27671>:
              D.27673 = &MEM[(void *)".cctor" + 3B];
              D.27674 = *D.27673;
              D.27675 = (int) D.27674;
              D.27676 = __s2 + 3;
              D.27677 = *D.27676;
              D.27678 = (int) D.27677;
              __result = D.27675 - D.27678;
              <D.27672>:
              <D.27670>:
              <D.27662>:
              <D.27660>:
              <D.27652>:
              <D.27650>:
            }
            D.25276 = __result;
          }
          iftmp.40 = -D.25276;
          goto <D.27679>;
          <D.27642>:
          D.27680 = jinfo_get_method (ji);
          D.27681 = D.27680->name;
          iftmp.40 = __builtin_strcmp (D.27681, ".cctor");
          <D.27679>:
          D.25277 = iftmp.40;
        }
        if (D.25277 == 0) goto <D.27682>; else goto <D.27683>;
        <D.27682>:
        filtered = 1;
        <D.27683>:
        <D.27639>:
        <D.27633>:
        <D.27631>:
        D.27628 = mod->data.filter;
        D.27684 = D.27628 & 2;
        if (D.27684 != 0) goto <D.27685>; else goto <D.27686>;
        <D.27685>:
        if (ji != 0B) goto <D.27687>; else goto <D.27688>;
        <D.27687>:
        {
          struct MonoCustomAttrInfo * ainfo;
          static struct MonoClass * klass;

          klass.41 = klass;
          if (klass.41 == 0B) goto <D.27690>; else goto <D.27691>;
          <D.27690>:
          D.27692 = mono_defaults.corlib;
          klass.42 = mono_class_from_name (D.27692, "System.Diagnostics", "DebuggerHiddenAttribute");
          klass = klass.42;
          klass.41 = klass;
          D.27694 = klass.41 == 0B;
          D.27695 = (long int) D.27694;
          D.27696 = __builtin_expect (D.27695, 0);
          if (D.27696 != 0) goto <D.27697>; else goto <D.27698>;
          <D.27697>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 3454, "klass");
          <D.27698>:
          <D.27691>:
          D.27699 = BIT_FIELD_REF <*ji, 32, 160>;
          D.27700 = D.27699 & 4194304;
          if (D.27700 == 0) goto <D.27701>; else goto <D.27702>;
          <D.27701>:
          D.27703 = jinfo_get_method (ji);
          ainfo = mono_custom_attrs_from_method (D.27703);
          if (ainfo != 0B) goto <D.27704>; else goto <D.27705>;
          <D.27704>:
          klass.41 = klass;
          D.27706 = mono_custom_attrs_has_attr (ainfo, klass.41);
          if (D.27706 != 0) goto <D.27707>; else goto <D.27708>;
          <D.27707>:
          ji->dbg_hidden = -1;
          <D.27708>:
          mono_custom_attrs_free (ainfo);
          <D.27705>:
          ji->dbg_hidden_inited = -1;
          <D.27702>:
          D.27699 = BIT_FIELD_REF <*ji, 32, 160>;
          D.27709 = D.27699 & 8388608;
          if (D.27709 != 0) goto <D.27710>; else goto <D.27711>;
          <D.27710>:
          filtered = 1;
          <D.27711>:
        }
        <D.27688>:
        <D.27686>:
        D.27628 = mod->data.filter;
        D.27712 = D.27628 & 4;
        if (D.27712 != 0) goto <D.27713>; else goto <D.27714>;
        <D.27713>:
        if (ji != 0B) goto <D.27715>; else goto <D.27716>;
        <D.27715>:
        {
          struct MonoCustomAttrInfo * ainfo;
          static struct MonoClass * klass;

          klass.43 = klass;
          if (klass.43 == 0B) goto <D.27718>; else goto <D.27719>;
          <D.27718>:
          D.27692 = mono_defaults.corlib;
          klass.44 = mono_class_from_name (D.27692, "System.Diagnostics", "DebuggerStepThroughAttribute");
          klass = klass.44;
          klass.43 = klass;
          D.27721 = klass.43 == 0B;
          D.27722 = (long int) D.27721;
          D.27723 = __builtin_expect (D.27722, 0);
          if (D.27723 != 0) goto <D.27724>; else goto <D.27725>;
          <D.27724>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 3474, "klass");
          <D.27725>:
          <D.27719>:
          D.27699 = BIT_FIELD_REF <*ji, 32, 160>;
          D.27726 = D.27699 & 33554432;
          if (D.27726 == 0) goto <D.27727>; else goto <D.27728>;
          <D.27727>:
          D.27729 = jinfo_get_method (ji);
          ainfo = mono_custom_attrs_from_method (D.27729);
          if (ainfo != 0B) goto <D.27730>; else goto <D.27731>;
          <D.27730>:
          klass.43 = klass;
          D.27732 = mono_custom_attrs_has_attr (ainfo, klass.43);
          if (D.27732 != 0) goto <D.27733>; else goto <D.27734>;
          <D.27733>:
          ji->dbg_step_through = -1;
          <D.27734>:
          mono_custom_attrs_free (ainfo);
          <D.27731>:
          D.27735 = jinfo_get_method (ji);
          D.27736 = D.27735->klass;
          ainfo = mono_custom_attrs_from_class (D.27736);
          if (ainfo != 0B) goto <D.27737>; else goto <D.27738>;
          <D.27737>:
          klass.43 = klass;
          D.27739 = mono_custom_attrs_has_attr (ainfo, klass.43);
          if (D.27739 != 0) goto <D.27740>; else goto <D.27741>;
          <D.27740>:
          ji->dbg_step_through = -1;
          <D.27741>:
          mono_custom_attrs_free (ainfo);
          <D.27738>:
          ji->dbg_step_through_inited = -1;
          <D.27728>:
          D.27699 = BIT_FIELD_REF <*ji, 32, 160>;
          D.27742 = D.27699 & 67108864;
          if (D.27742 != 0) goto <D.27743>; else goto <D.27744>;
          <D.27743>:
          filtered = 1;
          <D.27744>:
        }
        <D.27716>:
        <D.27714>:
        <D.27627>:
        <D.27617>:
        <D.27591>:
        <D.27573>:
        <D.27540>:
        <D.27538>:
        <D.27531>:
      }
      j = j + 1;
      <D.25283>:
      D.27745 = req->nmodifiers;
      if (D.27745 > j) goto <D.25282>; else goto <D.25284>;
      <D.25284>:
      if (filtered == 0) goto <D.27746>; else goto <D.27747>;
      <D.27746>:
      D.27748 = req->suspend_policy;
      D.27749 = *suspend_policy;
      D.27750 = MAX_EXPR <D.27748, D.27749>;
      *suspend_policy = D.27750;
      D.27751 = req->id;
      D.27752 = (void *) D.27751;
      events = monoeg_g_slist_append (events, D.27752);
      <D.27747>:
    }
    <D.27519>:
  }
  i = i + 1;
  <D.25286>:
  i.45 = (unsigned int) i;
  D.27754 = reqs->len;
  if (i.45 < D.27754) goto <D.25285>; else goto <D.25287>;
  <D.25287>:
  if (event == 0) goto <D.27755>; else goto <D.27756>;
  <D.27755>:
  events = monoeg_g_slist_append (events, 0B);
  <D.27756>:
  if (event == 1) goto <D.27757>; else goto <D.27758>;
  <D.27757>:
  events = monoeg_g_slist_append (events, 0B);
  <D.27758>:
  D.27511 = events;
  return D.27511;
}


strdup_tolower (char * s)
{
  int D.25228;
  char D.27762;
  int D.27763;
  int D.27764;
  const int iftmp.46;
  unsigned int __c.47;
  unsigned int D.27769;
  const __int32_t * * D.27772;
  const __int32_t * D.27773;
  unsigned int __c.48;
  unsigned int D.27775;
  const __int32_t * D.27776;
  unsigned int D.27780;
  unsigned int D.27781;
  const __int32_t * D.27782;
  char D.27783;
  char * D.27784;
  char * s2;
  char * p;

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

    {
      if (0 != 0) goto <D.27760>; else goto <D.27761>;
      <D.27760>:
      D.27762 = *p;
      D.27763 = (int) D.27762;
      D.27764 = __builtin_constant_p (D.27763);
      if (D.27764 != 0) goto <D.27765>; else goto <D.27766>;
      <D.27765>:
      {
        int __c;

        D.27762 = *p;
        __c = (int) D.27762;
        __c.47 = (unsigned int) __c;
        D.27769 = __c.47 + 128;
        if (D.27769 <= 383) goto <D.27770>; else goto <D.27771>;
        <D.27770>:
        D.27772 = __ctype_tolower_loc ();
        D.27773 = *D.27772;
        __c.48 = (unsigned int) __c;
        D.27775 = __c.48 * 4;
        D.27776 = D.27773 + D.27775;
        iftmp.46 = *D.27776;
        goto <D.27777>;
        <D.27771>:
        iftmp.46 = __c;
        <D.27777>:
        __res = iftmp.46;
      }
      goto <D.27778>;
      <D.27766>:
      D.27762 = *p;
      D.27763 = (int) D.27762;
      __res = tolower (D.27763);
      <D.27778>:
      goto <D.27779>;
      <D.27761>:
      D.27772 = __ctype_tolower_loc ();
      D.27773 = *D.27772;
      D.27762 = *p;
      D.27780 = (unsigned int) D.27762;
      D.27781 = D.27780 * 4;
      D.27782 = D.27773 + D.27781;
      __res = *D.27782;
      <D.27779>:
    }
    D.25228 = __res;
  }
  D.27783 = (char) D.25228;
  *p = D.27783;
  p = p + 1;
  <D.25230>:
  D.27762 = *p;
  if (D.27762 != 0) goto <D.25229>; else goto <D.25231>;
  <D.25231>:
  D.27784 = s2;
  return D.27784;
}


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

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


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.27792;
  long int D.27793;
  long int D.27794;
  struct FILE * log_file.51;
  const char * D.27798;
  int vm_start_event_sent.52;
  const char * D.27806;
  int vm_death_event_sent.53;
  const char * D.27812;
  int D.27813;
  const char * D.27820;
  int disconnected.54;
  const char * D.27826;
  int D.27832;
  unsigned int D.27835;
  unsigned int debugger_thread_id.55;
  unsigned int D.27841;
  unsigned int D.27846;
  unsigned char D.27847;
  int D.27848;
  unsigned int nevents.56;
  unsigned char D.27850;
  int D.27851;
  void * D.27852;
  unsigned int D.27853;
  int ecount.57;
  int ecount.58;
  long long unsigned int D.27862;
  struct MonoDomain * D.27863;
  int protocol_version_set.59;
  int major_version.60;
  int minor_version.61;
  int D.27873;
  unsigned int D.27874;
  struct MonoObject * D.27875;
  int D.27876;
  unsigned int D.27877;
  const char * iftmp.62;
  char * D.27879;
  const char * iftmp.63;
  char * D.27884;
  int iftmp.64;
  int D.27891;
  int D.27899;
  const char * D.27910;
  _Bool D.27913;
  long int D.27914;
  long int D.27915;
  unsigned int D.27918;
  void * D.27919;
  const char * D.27920;
  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.27789>; else goto <D.27790>;
      <D.27789>:
      log_level.50 = log_level;
      D.27792 = log_level.50 > 1;
      D.27793 = (long int) D.27792;
      D.27794 = __builtin_expect (D.27793, 0);
      if (D.27794 != 0) goto <D.27795>; else goto <D.27796>;
      <D.27795>:
      log_file.51 = log_file;
      D.27798 = event_to_string (event);
      fprintf (log_file.51, "Debugger agent not initialized yet: dropping %s\n", D.27798);
      log_file.51 = log_file;
      fflush (log_file.51);
      <D.27796>:
      return;
      <D.27790>:
      vm_start_event_sent.52 = vm_start_event_sent;
      if (vm_start_event_sent.52 == 0) goto <D.27800>; else goto <D.27801>;
      <D.27800>:
      if (event != 0) goto <D.27802>; else goto <D.27803>;
      <D.27802>:
      log_level.50 = log_level;
      D.27792 = log_level.50 > 1;
      D.27793 = (long int) D.27792;
      D.27794 = __builtin_expect (D.27793, 0);
      if (D.27794 != 0) goto <D.27804>; else goto <D.27805>;
      <D.27804>:
      log_file.51 = log_file;
      D.27806 = event_to_string (event);
      fprintf (log_file.51, "VM start event not sent yet: dropping %s\n", D.27806);
      log_file.51 = log_file;
      fflush (log_file.51);
      <D.27805>:
      return;
      <D.27803>:
      <D.27801>:
      vm_death_event_sent.53 = vm_death_event_sent;
      if (vm_death_event_sent.53 != 0) goto <D.27808>; else goto <D.27809>;
      <D.27808>:
      log_level.50 = log_level;
      D.27792 = log_level.50 > 1;
      D.27793 = (long int) D.27792;
      D.27794 = __builtin_expect (D.27793, 0);
      if (D.27794 != 0) goto <D.27810>; else goto <D.27811>;
      <D.27810>:
      log_file.51 = log_file;
      D.27812 = event_to_string (event);
      fprintf (log_file.51, "VM death event has been sent: dropping %s\n", D.27812);
      log_file.51 = log_file;
      fflush (log_file.51);
      <D.27811>:
      return;
      <D.27809>:
      D.27813 = mono_runtime_is_shutting_down ();
      if (D.27813 != 0) goto <D.27814>; else goto <D.27815>;
      <D.27814>:
      if (event != 1) goto <D.27816>; else goto <D.27817>;
      <D.27816>:
      log_level.50 = log_level;
      D.27792 = log_level.50 > 1;
      D.27793 = (long int) D.27792;
      D.27794 = __builtin_expect (D.27793, 0);
      if (D.27794 != 0) goto <D.27818>; else goto <D.27819>;
      <D.27818>:
      log_file.51 = log_file;
      D.27820 = event_to_string (event);
      fprintf (log_file.51, "Mono runtime is shutting down: dropping %s\n", D.27820);
      log_file.51 = log_file;
      fflush (log_file.51);
      <D.27819>:
      return;
      <D.27817>:
      <D.27815>:
      disconnected.54 = disconnected;
      if (disconnected.54 != 0) goto <D.27822>; else goto <D.27823>;
      <D.27822>:
      log_level.50 = log_level;
      D.27792 = log_level.50 > 1;
      D.27793 = (long int) D.27792;
      D.27794 = __builtin_expect (D.27793, 0);
      if (D.27794 != 0) goto <D.27824>; else goto <D.27825>;
      <D.27824>:
      log_file.51 = log_file;
      D.27826 = event_to_string (event);
      fprintf (log_file.51, "Debugger client is not connected: dropping %s\n", D.27826);
      log_file.51 = log_file;
      fflush (log_file.51);
      <D.27825>:
      return;
      <D.27823>:
      if (event == 14) goto <D.27827>; else goto <D.27828>;
      <D.27827>:
      suspend_policy = 0;
      goto <D.27829>;
      <D.27828>:
      if (events == 0B) goto <D.27830>; else goto <D.27831>;
      <D.27830>:
      return;
      <D.27831>:
      D.27832 = agent_config.defer;
      if (D.27832 != 0) goto <D.27833>; else goto <D.27834>;
      <D.27833>:
      D.27835 = GetCurrentThreadId ();
      debugger_thread_id.55 = debugger_thread_id;
      if (D.27835 == debugger_thread_id.55) goto <D.27837>; else goto <D.27838>;
      <D.27837>:
      suspend_policy = 0;
      thread = mono_thread_get_main ();
      goto <D.27839>;
      <D.27838>:
      thread = mono_thread_current ();
      <D.27839>:
      goto <D.27840>;
      <D.27834>:
      D.27841 = GetCurrentThreadId ();
      debugger_thread_id.55 = debugger_thread_id;
      if (D.27841 == debugger_thread_id.55) goto <D.27842>; else goto <D.27843>;
      <D.27842>:
      if (event != 1) goto <D.27844>; else goto <D.27845>;
      <D.27844>:
      return;
      <D.27845>:
      <D.27843>:
      <D.27840>:
      <D.27829>:
      D.27846 = monoeg_g_slist_length (events);
      nevents = (int) D.27846;
      buffer_init (&buf, 128);
      D.27847 = (unsigned char) suspend_policy;
      D.27848 = (int) D.27847;
      buffer_add_byte (&buf, D.27848);
      nevents.56 = (unsigned int) nevents;
      buffer_add_int (&buf, nevents.56);
      l = events;
      goto <D.25347>;
      <D.25346>:
      D.27850 = (unsigned char) event;
      D.27851 = (int) D.27850;
      buffer_add_byte (&buf, D.27851);
      D.27852 = l->data;
      D.27853 = (unsigned int) D.27852;
      buffer_add_int (&buf, D.27853);
      ecount.57 = ecount;
      ecount.58 = ecount.57 + 1;
      ecount = ecount.58;
      if (thread == 0B) goto <D.27856>; else goto <D.27857>;
      <D.27856>:
      thread = mono_thread_current ();
      <D.27857>:
      if (event == 0) goto <D.27858>; else goto <D.27859>;
      <D.27858>:
      if (arg != 0B) goto <D.27860>; else goto <D.27861>;
      <D.27860>:
      thread = arg;
      <D.27861>:
      <D.27859>:
      buffer_add_objid (&buf, thread);
      switch (event) <default: <D.25345>, case 0: <D.25337>, case 1: <D.25338>, case 2: <D.25325>, case 3: <D.25326>, case 4: <D.25328>, case 5: <D.25329>, case 6: <D.25330>, case 7: <D.25331>, case 8: <D.25332>, case 9: <D.25333>, case 10: <D.25335>, case 11: <D.25336>, case 12: <D.25334>, case 13: <D.25339>, case 14: <D.25344>, case 15: <D.25341>, case 16: <D.25342>>
      <D.25325>:
      <D.25326>:
      goto <D.25327>;
      <D.25328>:
      <D.25329>:
      buffer_add_domainid (&buf, arg);
      goto <D.25327>;
      <D.25330>:
      <D.25331>:
      buffer_add_methodid (&buf, domain, arg);
      goto <D.25327>;
      <D.25332>:
      <D.25333>:
      buffer_add_assemblyid (&buf, domain, arg);
      goto <D.25327>;
      <D.25334>:
      buffer_add_typeid (&buf, domain, arg);
      goto <D.25327>;
      <D.25335>:
      <D.25336>:
      buffer_add_methodid (&buf, domain, arg);
      D.27862 = (long long unsigned int) il_offset;
      buffer_add_long (&buf, D.27862);
      goto <D.25327>;
      <D.25337>:
      D.27863 = mono_get_root_domain ();
      buffer_add_domainid (&buf, D.27863);
      goto <D.25327>;
      <D.25338>:
      protocol_version_set.59 = protocol_version_set;
      if (protocol_version_set.59 != 0) goto <D.27867>; else goto <D.27868>;
      <D.27867>:
      major_version.60 = major_version;
      if (major_version.60 > 2) goto <D.27864>; else goto <D.27870>;
      <D.27870>:
      major_version.60 = major_version;
      if (major_version.60 == 2) goto <D.27871>; else goto <D.27865>;
      <D.27871>:
      minor_version.61 = minor_version;
      if (minor_version.61 > 26) goto <D.27864>; else goto <D.27865>;
      <D.27864>:
      D.27873 = mono_environment_exitcode_get ();
      D.27874 = (unsigned int) D.27873;
      buffer_add_int (&buf, D.27874);
      <D.27865>:
      <D.27868>:
      goto <D.25327>;
      <D.25339>:
      {
        struct EventInfo * ei;

        ei = arg;
        D.27875 = ei->exc;
        buffer_add_objid (&buf, D.27875);
        keepalive_obj = ei->exc;
        goto <D.25327>;
      }
      <D.25341>:
      goto <D.25327>;
      <D.25342>:
      {
        struct EventInfo * ei;

        ei = arg;
        D.27876 = ei->level;
        D.27877 = (unsigned int) D.27876;
        buffer_add_int (&buf, D.27877);
        D.27879 = ei->category;
        if (D.27879 != 0B) goto <D.27880>; else goto <D.27881>;
        <D.27880>:
        iftmp.62 = ei->category;
        goto <D.27882>;
        <D.27881>:
        iftmp.62 = "";
        <D.27882>:
        buffer_add_string (&buf, iftmp.62);
        D.27884 = ei->message;
        if (D.27884 != 0B) goto <D.27885>; else goto <D.27886>;
        <D.27885>:
        iftmp.63 = ei->message;
        goto <D.27887>;
        <D.27886>:
        iftmp.63 = "";
        <D.27887>:
        buffer_add_string (&buf, iftmp.63);
        goto <D.25327>;
      }
      <D.25344>:
      suspend_policy = 0;
      goto <D.25327>;
      <D.25345>:
      monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "debugger-agent.c", 3680);
      <D.25327>:
      l = l->next;
      <D.25347>:
      if (l != 0B) goto <D.25346>; else goto <D.25348>;
      <D.25348>:
      if (event == 0) goto <D.27888>; else goto <D.27889>;
      <D.27888>:
      D.27891 = agent_config.suspend;
      if (D.27891 != 0) goto <D.27892>; else goto <D.27893>;
      <D.27892>:
      iftmp.64 = 2;
      goto <D.27894>;
      <D.27893>:
      iftmp.64 = 0;
      <D.27894>:
      suspend_policy = iftmp.64;
      D.27832 = agent_config.defer;
      if (D.27832 == 0) goto <D.27895>; else goto <D.27896>;
      <D.27895>:
      start_debugger_thread ();
      <D.27896>:
      <D.27889>:
      if (event == 1) goto <D.27897>; else goto <D.27898>;
      <D.27897>:
      vm_death_event_sent = 1;
      suspend_policy = 0;
      <D.27898>:
      D.27899 = mono_runtime_is_shutting_down ();
      if (D.27899 != 0) goto <D.27900>; else goto <D.27901>;
      <D.27900>:
      suspend_policy = 0;
      <D.27901>:
      if (suspend_policy != 0) goto <D.27902>; else goto <D.27903>;
      <D.27902>:
      save_thread_context (ctx);
      suspend_vm ();
      if (keepalive_obj != 0B) goto <D.27904>; else goto <D.27905>;
      <D.27904>:
      get_objref (keepalive_obj);
      <D.27905>:
      <D.27903>:
      send_success = send_packet (64, 100, &buf);
      buffer_free (&buf);
      monoeg_g_slist_free (events);
      events = 0B;
      if (send_success == 0) goto <D.27906>; else goto <D.27907>;
      <D.27906>:
      log_level.50 = log_level;
      D.27792 = log_level.50 > 1;
      D.27793 = (long int) D.27792;
      D.27794 = __builtin_expect (D.27793, 0);
      if (D.27794 != 0) goto <D.27908>; else goto <D.27909>;
      <D.27908>:
      log_file.51 = log_file;
      D.27910 = event_to_string (event);
      fprintf (log_file.51, "Sending command %s failed.\n", D.27910);
      log_file.51 = log_file;
      fflush (log_file.51);
      <D.27909>:
      return;
      <D.27907>:
      if (event == 0) goto <D.27911>; else goto <D.27912>;
      <D.27911>:
      vm_start_event_sent = 1;
      <D.27912>:
      log_level.50 = log_level;
      D.27913 = log_level.50 > 0;
      D.27914 = (long int) D.27913;
      D.27915 = __builtin_expect (D.27914, 0);
      if (D.27915 != 0) goto <D.27916>; else goto <D.27917>;
      <D.27916>:
      log_file.51 = log_file;
      D.27918 = GetCurrentThreadId ();
      D.27919 = (void *) D.27918;
      D.27920 = event_to_string (event);
      ecount.57 = ecount;
      fprintf (log_file.51, "[%p] Sent %d events %s(%d), suspend=%d.\n", D.27919, nevents, D.27920, ecount.57, suspend_policy);
      log_file.51 = log_file;
      fflush (log_file.51);
      <D.27917>:
      switch (suspend_policy) <default: <D.25353>, case 0: <D.25349>, case 1: <D.25352>, case 2: <D.25351>>
      <D.25349>:
      goto <D.25350>;
      <D.25351>:
      suspend_current ();
      goto <D.25350>;
      <D.25352>:
      monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "debugger-agent.c", 3737);
      <D.25353>:
      monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "debugger-agent.c", 3740);
      <D.25350>:
    }
  finally
    {
      buf = {CLOBBER};
    }
}


buffer_init (struct Buffer * buf, int size)
{
  unsigned int size.65;
  void * D.27927;
  guint8 * D.27928;
  sizetype size.66;
  guint8 * D.27930;

  size.65 = (unsigned int) size;
  D.27927 = monoeg_malloc (size.65);
  buf->buf = D.27927;
  D.27928 = buf->buf;
  buf->p = D.27928;
  D.27928 = buf->buf;
  size.66 = (sizetype) size;
  D.27930 = D.27928 + size.66;
  buf->end = D.27930;
}


buffer_add_byte (struct Buffer * buf, guint8 val)
{
  guint8 * D.27931;
  guint8 * D.27932;

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


buffer_make_room (struct Buffer * buf, int size)
{
  guint8 * D.27933;
  int D.27934;
  guint8 * D.27935;
  int D.27936;
  int D.27937;
  guint8 * D.27940;
  int D.27941;
  int D.27942;
  int D.27943;
  unsigned int new_size.67;
  sizetype size.68;
  guint8 * D.27946;
  sizetype new_size.69;
  guint8 * D.27948;

  D.27933 = buf->end;
  D.27934 = (int) D.27933;
  D.27935 = buf->p;
  D.27936 = (int) D.27935;
  D.27937 = D.27934 - D.27936;
  if (D.27937 < size) goto <D.27938>; else goto <D.27939>;
  <D.27938>:
  {
    int new_size;
    guint8 * p;

    D.27933 = buf->end;
    D.27934 = (int) D.27933;
    D.27940 = buf->buf;
    D.27941 = (int) D.27940;
    D.27942 = D.27934 - D.27941;
    D.27943 = D.27942 + size;
    new_size = D.27943 + 32;
    D.27940 = buf->buf;
    new_size.67 = (unsigned int) new_size;
    p = monoeg_realloc (D.27940, new_size.67);
    D.27935 = buf->p;
    D.27936 = (int) D.27935;
    D.27940 = buf->buf;
    D.27941 = (int) D.27940;
    size = D.27936 - D.27941;
    buf->buf = p;
    size.68 = (sizetype) size;
    D.27946 = p + size.68;
    buf->p = D.27946;
    D.27940 = buf->buf;
    new_size.69 = (sizetype) new_size;
    D.27948 = D.27940 + new_size.69;
    buf->end = D.27948;
  }
  <D.27939>:
}


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

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


get_id (struct MonoDomain * domain, IdType type, void * val)
{
  int D.27952;
  union mono_mutex_t * D.27953;
  _Bool D.27956;
  long int D.27957;
  long int D.27958;
  struct GHashTable * D.27961;
  struct GHashTable * D.27964;
  _Bool D.27969;
  long int D.27970;
  long int D.27971;
  struct GPtrArray * D.27974;
  unsigned int D.27975;
  unsigned int D.27976;
  int D.27977;
  _Bool D.27980;
  long int D.27981;
  long int D.27982;
  struct Id * id;
  struct AgentDomainInfo * info;

  if (val == 0B) goto <D.27950>; else goto <D.27951>;
  <D.27950>:
  D.27952 = 0;
  return D.27952;
  <D.27951>:
  mono_loader_lock ();
  {
    int ret;

    D.27953 = &domain->lock.mutex;
    ret = pthread_mutex_lock (D.27953);
    if (ret != 0) goto <D.27954>; else goto <D.27955>;
    <D.27954>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.27955>:
    D.27956 = ret != 0;
    D.27957 = (long int) D.27956;
    D.27958 = __builtin_expect (D.27957, 0);
    if (D.27958 != 0) goto <D.27959>; else goto <D.27960>;
    <D.27959>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 2149, "ret == 0");
    <D.27960>:
  }
  info = get_agent_domain_info (domain);
  D.27961 = info->val_to_id[type];
  if (D.27961 == 0B) goto <D.27962>; else goto <D.27963>;
  <D.27962>:
  D.27964 = monoeg_g_hash_table_new (mono_aligned_addr_hash, 0B);
  info->val_to_id[type] = D.27964;
  <D.27963>:
  D.27961 = info->val_to_id[type];
  id = monoeg_g_hash_table_lookup (D.27961, val);
  if (id != 0B) goto <D.27965>; else goto <D.27966>;
  <D.27965>:
  {
    int ret;

    D.27953 = &domain->lock.mutex;
    ret = pthread_mutex_unlock (D.27953);
    if (ret != 0) goto <D.27967>; else goto <D.27968>;
    <D.27967>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.27968>:
    D.27969 = ret != 0;
    D.27970 = (long int) D.27969;
    D.27971 = __builtin_expect (D.27970, 0);
    if (D.27971 != 0) goto <D.27972>; else goto <D.27973>;
    <D.27972>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 2158, "ret == 0");
    <D.27973>:
  }
  mono_loader_unlock ();
  D.27952 = id->id;
  return D.27952;
  <D.27966>:
  id = monoeg_malloc0 (12);
  D.27974 = ids[type];
  D.27975 = D.27974->len;
  D.27976 = D.27975 + 1;
  D.27977 = (int) D.27976;
  id->id = D.27977;
  id->domain = domain;
  id->data.val = val;
  D.27961 = info->val_to_id[type];
  monoeg_g_hash_table_insert_replace (D.27961, val, id, 0);
  {
    int ret;

    D.27953 = &domain->lock.mutex;
    ret = pthread_mutex_unlock (D.27953);
    if (ret != 0) goto <D.27978>; else goto <D.27979>;
    <D.27978>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.27979>:
    D.27980 = ret != 0;
    D.27981 = (long int) D.27980;
    D.27982 = __builtin_expect (D.27981, 0);
    if (D.27982 != 0) goto <D.27983>; else goto <D.27984>;
    <D.27983>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 2171, "ret == 0");
    <D.27984>:
  }
  D.27974 = ids[type];
  monoeg_g_ptr_array_add (D.27974, id);
  mono_loader_unlock ();
  D.27952 = id->id;
  return D.27952;
}


get_agent_domain_info (struct MonoDomain * domain)
{
  union mono_mutex_t * D.27986;
  _Bool D.27989;
  long int D.27990;
  long int D.27991;
  void * D.27994;
  void * D.27997;
  struct GHashTable * D.27998;
  struct GHashTable * D.27999;
  struct GHashTable * D.28000;
  struct GHashTable * D.28001;
  _Bool D.28004;
  long int D.28005;
  long int D.28006;
  struct AgentDomainInfo * D.28009;
  struct AgentDomainInfo * info;

  info = 0B;
  {
    int ret;

    D.27986 = &domain->lock.mutex;
    ret = pthread_mutex_lock (D.27986);
    if (ret != 0) goto <D.27987>; else goto <D.27988>;
    <D.27987>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.27988>:
    D.27989 = ret != 0;
    D.27990 = (long int) D.27989;
    D.27991 = __builtin_expect (D.27990, 0);
    if (D.27991 != 0) goto <D.27992>; else goto <D.27993>;
    <D.27992>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 2122, "ret == 0");
    <D.27993>:
  }
  D.27994 = domain->runtime_info;
  info = MEM[(struct MonoJitDomainInfo *)D.27994].agent_info;
  if (info == 0B) goto <D.27995>; else goto <D.27996>;
  <D.27995>:
  D.27994 = domain->runtime_info;
  D.27997 = monoeg_malloc0 (44);
  MEM[(struct MonoJitDomainInfo *)D.27994].agent_info = D.27997;
  info = MEM[(struct MonoJitDomainInfo *)D.27994].agent_info;
  D.27998 = monoeg_g_hash_table_new (mono_aligned_addr_hash, 0B);
  info->loaded_classes = D.27998;
  D.27999 = monoeg_g_hash_table_new (mono_aligned_addr_hash, 0B);
  info->source_files = D.27999;
  D.28000 = monoeg_g_hash_table_new (monoeg_g_str_hash, monoeg_g_str_equal);
  info->source_file_to_class = D.28000;
  D.28001 = monoeg_g_hash_table_new (monoeg_g_str_hash, monoeg_g_str_equal);
  info->source_file_to_class_ignorecase = D.28001;
  <D.27996>:
  {
    int ret;

    D.27986 = &domain->lock.mutex;
    ret = pthread_mutex_unlock (D.27986);
    if (ret != 0) goto <D.28002>; else goto <D.28003>;
    <D.28002>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.28003>:
    D.28004 = ret != 0;
    D.28005 = (long int) D.28004;
    D.28006 = __builtin_expect (D.28005, 0);
    if (D.28006 != 0) goto <D.28007>; else goto <D.28008>;
    <D.28007>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 2133, "ret == 0");
    <D.28008>:
  }
  D.28009 = info;
  return D.28009;
}


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.28013;
  long int D.28014;
  long int D.28015;
  struct MonoType * D.28020;
  unsigned int D.28021;
  unsigned int debugger_thread_id.72;
  struct FILE * log_file.73;
  unsigned int D.28031;
  void * D.28032;

  buffer_add_ptr_id (buf, domain, 2, klass);
  log_level.71 = log_level;
  D.28013 = log_level.71 > 1;
  D.28014 = (long int) D.28013;
  D.28015 = __builtin_expect (D.28014, 0);
  if (D.28015 != 0) goto <D.28016>; else goto <D.28017>;
  <D.28016>:
  if (klass != 0B) goto <D.28018>; else goto <D.28019>;
  <D.28018>:
  {
    char * s;

    D.28020 = &klass->byval_arg;
    s = mono_type_full_name (D.28020);
    D.28021 = GetCurrentThreadId ();
    debugger_thread_id.72 = debugger_thread_id;
    if (D.28021 == debugger_thread_id.72) goto <D.28023>; else goto <D.28024>;
    <D.28023>:
    log_level.71 = log_level;
    D.28013 = log_level.71 > 1;
    D.28014 = (long int) D.28013;
    D.28015 = __builtin_expect (D.28014, 0);
    if (D.28015 != 0) goto <D.28025>; else goto <D.28026>;
    <D.28025>:
    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.28026>:
    goto <D.28028>;
    <D.28024>:
    log_level.71 = log_level;
    D.28013 = log_level.71 > 1;
    D.28014 = (long int) D.28013;
    D.28015 = __builtin_expect (D.28014, 0);
    if (D.28015 != 0) goto <D.28029>; else goto <D.28030>;
    <D.28029>:
    log_file.73 = log_file;
    D.28031 = GetCurrentThreadId ();
    D.28032 = (void *) D.28031;
    fprintf (log_file.73, "[%p]   send class [%s]\n", D.28032, s);
    log_file.73 = log_file;
    fflush (log_file.73);
    <D.28030>:
    <D.28028>:
    monoeg_g_free (s);
  }
  <D.28019>:
  <D.28017>:
}


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

  buffer_add_ptr_id (buf, domain, 3, method);
  log_level.74 = log_level;
  D.28034 = log_level.74 > 1;
  D.28035 = (long int) D.28034;
  D.28036 = __builtin_expect (D.28035, 0);
  if (D.28036 != 0) goto <D.28037>; else goto <D.28038>;
  <D.28037>:
  if (method != 0B) goto <D.28039>; else goto <D.28040>;
  <D.28039>:
  {
    char * s;

    s = mono_method_full_name (method, 1);
    log_level.74 = log_level;
    D.28034 = log_level.74 > 1;
    D.28035 = (long int) D.28034;
    D.28036 = __builtin_expect (D.28035, 0);
    if (D.28036 != 0) goto <D.28041>; else goto <D.28042>;
    <D.28041>:
    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.28042>:
    monoeg_g_free (s);
  }
  <D.28040>:
  <D.28038>:
}


buffer_add_long (struct Buffer * buf, guint64 l)
{
  long long unsigned int D.28044;
  unsigned int D.28045;
  unsigned int D.28046;

  D.28044 = l >> 32;
  D.28045 = (unsigned int) D.28044;
  buffer_add_int (buf, D.28045);
  D.28046 = (unsigned int) l;
  buffer_add_int (buf, D.28046);
}


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

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


get_objid (struct MonoObject * obj)
{
  int D.28048;
  struct ObjRef * D.28049;

  D.28049 = get_objref (obj);
  D.28048 = D.28049->id;
  return D.28048;
}


buffer_add_int (struct Buffer * buf, guint32 val)
{
  guint8 * D.28051;
  unsigned int D.28052;
  unsigned char D.28053;
  guint8 * D.28054;
  unsigned int D.28055;
  unsigned char D.28056;
  guint8 * D.28057;
  unsigned int D.28058;
  unsigned char D.28059;
  guint8 * D.28060;
  unsigned char D.28061;
  guint8 * D.28062;

  buffer_make_room (buf, 4);
  D.28051 = buf->p;
  D.28052 = val >> 24;
  D.28053 = (unsigned char) D.28052;
  *D.28051 = D.28053;
  D.28051 = buf->p;
  D.28054 = D.28051 + 1;
  D.28055 = val >> 16;
  D.28056 = (unsigned char) D.28055;
  *D.28054 = D.28056;
  D.28051 = buf->p;
  D.28057 = D.28051 + 2;
  D.28058 = val >> 8;
  D.28059 = (unsigned char) D.28058;
  *D.28057 = D.28059;
  D.28051 = buf->p;
  D.28060 = D.28051 + 3;
  D.28061 = (unsigned char) val;
  *D.28060 = D.28061;
  D.28051 = buf->p;
  D.28062 = D.28051 + 4;
  buf->p = D.28062;
}


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

  if (str == 0B) goto <D.28063>; else goto <D.28064>;
  <D.28063>:
  buffer_add_int (buf, 0);
  goto <D.28065>;
  <D.28064>:
  D.28066 = strlen (str);
  len = (int) D.28066;
  len.76 = (unsigned int) len;
  buffer_add_int (buf, len.76);
  buffer_add_data (buf, str, len);
  <D.28065>:
}


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

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


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

  D.28073 = __builtin_object_size (__dest, 0);
  D.28072 = __builtin___memcpy_chk (__dest, __src, __len, D.28073);
  return D.28072;
}


start_debugger_thread ()
{
  void * debugger_thread_handle.79;
  void * debugger_thread_handle.80;
  _Bool D.28077;
  long int D.28078;
  long int D.28079;

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


debugger_thread (void * arg)
{
  int log_level.81;
  _Bool D.28083;
  long int D.28084;
  long int D.28085;
  struct FILE * log_file.82;
  unsigned int D.28089;
  void * D.28090;
  unsigned int debugger_thread_id.83;
  struct MonoDomain * D.28092;
  struct MonoInternalThread * D.28093;
  unsigned int D.28094;
  unsigned int D.28095;
  int D.28096;
  int D.28099;
  struct MonoThread * D.28105;
  guint8 * p.84;
  _Bool D.28111;
  long int D.28112;
  long int D.28113;
  <unnamed type> command_set.85;
  const char * D.28123;
  int D.28124;
  unsigned int D.28125;
  sizetype len.86;
  sizetype D.28133;
  int err.87;
  unsigned int command.88;
  unsigned int D.28144;
  int vm_death_event_sent.89;
  int D.28157;
  _Bool D.28160;
  long int D.28161;
  long int D.28162;
  guint32 D.28165;
  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.28083 = log_level.81 > 0;
      D.28084 = (long int) D.28083;
      D.28085 = __builtin_expect (D.28084, 0);
      if (D.28085 != 0) goto <D.28086>; else goto <D.28087>;
      <D.28086>:
      log_file.82 = log_file;
      D.28089 = GetCurrentThreadId ();
      D.28090 = (void *) D.28089;
      fprintf (log_file.82, "[dbg] Agent thread started, pid=%p\n", D.28090);
      log_file.82 = log_file;
      fflush (log_file.82);
      <D.28087>:
      debugger_thread_id.83 = GetCurrentThreadId ();
      debugger_thread_id = debugger_thread_id.83;
      D.28092 = mono_get_root_domain ();
      mono_jit_thread_attach (D.28092);
      D.28093 = mono_thread_internal_current ();
      D.28094 = D.28093->flags;
      D.28095 = D.28094 | 1;
      D.28093->flags = D.28095;
      mono_set_is_debugger_attached (1);
      D.28096 = agent_config.defer;
      if (D.28096 != 0) goto <D.28097>; else goto <D.28098>;
      <D.28097>:
      D.28099 = wait_for_attach ();
      if (D.28099 == 0) goto <D.28100>; else goto <D.28101>;
      <D.28100>:
      log_level.81 = log_level;
      D.28083 = log_level.81 > 0;
      D.28084 = (long int) D.28083;
      D.28085 = __builtin_expect (D.28084, 0);
      if (D.28085 != 0) goto <D.28102>; else goto <D.28103>;
      <D.28102>:
      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.28103>:
      attach_failed = 1;
      goto <D.28104>;
      <D.28101>:
      D.28105 = mono_thread_get_main ();
      process_profiler_event (0, D.28105);
      <D.28104>:
      <D.28098>:
      goto <D.27107>;
      <D.27106>:
      res = transport_recv (&header, 11);
      if (res != 11) goto <D.28106>; else goto <D.28107>;
      <D.28106>:
      log_level.81 = log_level;
      D.28083 = log_level.81 > 0;
      D.28084 = (long int) D.28083;
      D.28085 = __builtin_expect (D.28084, 0);
      if (D.28085 != 0) goto <D.28108>; else goto <D.28109>;
      <D.28108>:
      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.28109>:
      goto <D.27089>;
      <D.28107>:
      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.28111 = flags != 0;
      D.28112 = (long int) D.28111;
      D.28113 = __builtin_expect (D.28112, 0);
      if (D.28113 != 0) goto <D.28114>; else goto <D.28115>;
      <D.28114>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 9156, "flags == 0");
      <D.28115>:
      log_level.81 = log_level;
      if (log_level.81 != 0) goto <D.28116>; else goto <D.28117>;
      <D.28116>:
      {
        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.28119>; else goto <D.28120>;
            <D.28119>:
            sprintf (&cmd_num, "%d", command);
            cmd_str = &cmd_num;
            <D.28120>:
            log_level.81 = log_level;
            D.28083 = log_level.81 > 0;
            D.28084 = (long int) D.28083;
            D.28085 = __builtin_expect (D.28084, 0);
            if (D.28085 != 0) goto <D.28121>; else goto <D.28122>;
            <D.28121>:
            log_file.82 = log_file;
            command_set.85 = (<unnamed type>) command_set;
            D.28123 = command_set_to_string (command_set.85);
            fprintf (log_file.82, "[dbg] Command %s(%s) [%d].\n", D.28123, cmd_str, id);
            log_file.82 = log_file;
            fflush (log_file.82);
            <D.28122>:
          }
        finally
          {
            cmd_num = {CLOBBER};
          }
      }
      <D.28117>:
      D.28124 = len + -11;
      D.28125 = (unsigned int) D.28124;
      data = monoeg_malloc (D.28125);
      if (len > 11) goto <D.28126>; else goto <D.28127>;
      <D.28126>:
      D.28124 = len + -11;
      res = transport_recv (data, D.28124);
      D.28124 = len + -11;
      if (D.28124 != res) goto <D.28128>; else goto <D.28129>;
      <D.28128>:
      log_level.81 = log_level;
      D.28083 = log_level.81 > 0;
      D.28084 = (long int) D.28083;
      D.28085 = __builtin_expect (D.28084, 0);
      if (D.28085 != 0) goto <D.28130>; else goto <D.28131>;
      <D.28130>:
      log_file.82 = log_file;
      D.28124 = len + -11;
      fprintf (log_file.82, "[dbg] transport_recv () returned %d, expected %d.\n", res, D.28124);
      log_file.82 = log_file;
      fflush (log_file.82);
      <D.28131>:
      goto <D.27089>;
      <D.28129>:
      <D.28127>:
      p = data;
      len.86 = (sizetype) len;
      D.28133 = len.86 + 4294967285;
      end = data + D.28133;
      buffer_init (&buf, 128);
      err = 0;
      no_reply = 0;
      switch (command_set) <default: <D.27105>, case 1: <D.27092>, case 9: <D.27104>, case 10: <D.27103>, case 11: <D.27100>, case 13: <D.27102>, case 15: <D.27094>, case 16: <D.27101>, case 20: <D.27095>, case 21: <D.27096>, case 22: <D.27099>, case 23: <D.27098>, case 24: <D.27097>>
      <D.27092>:
      p.84 = p;
      err = vm_commands (command, id, p.84, end, &buf);
      if (err == 0) goto <D.28134>; else goto <D.28135>;
      <D.28134>:
      if (command == 7) goto <D.28136>; else goto <D.28137>;
      <D.28136>:
      no_reply = 1;
      <D.28137>:
      <D.28135>:
      goto <D.27093>;
      <D.27094>:
      p.84 = p;
      err = event_commands (command, p.84, end, &buf);
      goto <D.27093>;
      <D.27095>:
      p.84 = p;
      err = domain_commands (command, p.84, end, &buf);
      goto <D.27093>;
      <D.27096>:
      p.84 = p;
      err = assembly_commands (command, p.84, end, &buf);
      goto <D.27093>;
      <D.27097>:
      p.84 = p;
      err = module_commands (command, p.84, end, &buf);
      goto <D.27093>;
      <D.27098>:
      p.84 = p;
      err = type_commands (command, p.84, end, &buf);
      goto <D.27093>;
      <D.27099>:
      p.84 = p;
      err = method_commands (command, p.84, end, &buf);
      goto <D.27093>;
      <D.27100>:
      p.84 = p;
      err = thread_commands (command, p.84, end, &buf);
      goto <D.27093>;
      <D.27101>:
      p.84 = p;
      err = frame_commands (command, p.84, end, &buf);
      goto <D.27093>;
      <D.27102>:
      p.84 = p;
      err = array_commands (command, p.84, end, &buf);
      goto <D.27093>;
      <D.27103>:
      p.84 = p;
      err = string_commands (command, p.84, end, &buf);
      goto <D.27093>;
      <D.27104>:
      p.84 = p;
      err = object_commands (command, p.84, end, &buf);
      goto <D.27093>;
      <D.27105>:
      err = 100;
      <D.27093>:
      if (no_reply == 0) goto <D.28138>; else goto <D.28139>;
      <D.28138>:
      err.87 = (int) err;
      send_reply_packet (id, err.87, &buf);
      <D.28139>:
      monoeg_g_free (data);
      buffer_free (&buf);
      if (command_set == 1) goto <D.28141>; else goto <D.28142>;
      <D.28141>:
      command.88 = (unsigned int) command;
      D.28144 = command.88 + 4294967291;
      if (D.28144 <= 1) goto <D.27089>; else goto <D.28145>;
      <D.28145>:
      <D.28142>:
      <D.27107>:
      if (attach_failed == 0) goto <D.27106>; else goto <D.27089>;
      <D.27089>:
      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.28083 = log_level.81 > 0;
      D.28084 = (long int) D.28083;
      D.28085 = __builtin_expect (D.28084, 0);
      if (D.28085 != 0) goto <D.28146>; else goto <D.28147>;
      <D.28146>:
      log_file.82 = log_file;
      fprintf (log_file.82, "[dbg] Debugger thread exited.\n");
      log_file.82 = log_file;
      fflush (log_file.82);
      <D.28147>:
      if (attach_failed == 0) goto <D.28148>; else goto <D.28149>;
      <D.28148>:
      if (command_set == 1) goto <D.28150>; else goto <D.28151>;
      <D.28150>:
      if (command == 6) goto <D.28152>; else goto <D.28153>;
      <D.28152>:
      vm_death_event_sent.89 = vm_death_event_sent;
      if (vm_death_event_sent.89 == 0) goto <D.28155>; else goto <D.28156>;
      <D.28155>:
      D.28157 = mono_runtime_is_shutting_down ();
      if (D.28157 == 0) goto <D.28158>; else goto <D.28159>;
      <D.28158>:
      log_level.81 = log_level;
      D.28160 = log_level.81 > 1;
      D.28161 = (long int) D.28160;
      D.28162 = __builtin_expect (D.28161, 0);
      if (D.28162 != 0) goto <D.28163>; else goto <D.28164>;
      <D.28163>:
      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.28164>:
      start_debugger_thread ();
      <D.28159>:
      <D.28156>:
      <D.28153>:
      <D.28151>:
      <D.28149>:
      D.28165 = 0;
      return D.28165;
    }
  finally
    {
      header = {CLOBBER};
      p = {CLOBBER};
      buf = {CLOBBER};
    }
}


wait_for_attach ()
{
  int listen_fd.90;
  int log_level.91;
  _Bool D.28172;
  long int D.28173;
  long int D.28174;
  struct FILE * log_file.92;
  gboolean D.28178;
  int conn_fd.93;
  int conn_fd.94;
  int D.28187;
  _Bool D.28188;
  int disconnected.95;
  int disconnected.96;

  listen_fd.90 = listen_fd;
  if (listen_fd.90 == -1) goto <D.28169>; else goto <D.28170>;
  <D.28169>:
  log_level.91 = log_level;
  D.28172 = log_level.91 > 0;
  D.28173 = (long int) D.28172;
  D.28174 = __builtin_expect (D.28173, 0);
  if (D.28174 != 0) goto <D.28175>; else goto <D.28176>;
  <D.28175>:
  log_file.92 = log_file;
  fprintf (log_file.92, "[dbg] Invalid listening socket\n");
  log_file.92 = log_file;
  fflush (log_file.92);
  <D.28176>:
  D.28178 = 0;
  return D.28178;
  <D.28170>:
  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.28172 = log_level.91 > 0;
  D.28173 = (long int) D.28172;
  D.28174 = __builtin_expect (D.28173, 0);
  if (D.28174 != 0) goto <D.28180>; else goto <D.28181>;
  <D.28180>:
  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.28181>:
  conn_fd.94 = conn_fd;
  if (conn_fd.94 == -1) goto <D.28183>; else goto <D.28184>;
  <D.28183>:
  log_level.91 = log_level;
  D.28172 = log_level.91 > 0;
  D.28173 = (long int) D.28172;
  D.28174 = __builtin_expect (D.28173, 0);
  if (D.28174 != 0) goto <D.28185>; else goto <D.28186>;
  <D.28185>:
  log_file.92 = log_file;
  fprintf (log_file.92, "[dbg] Bad client connection\n");
  log_file.92 = log_file;
  fflush (log_file.92);
  <D.28186>:
  D.28178 = 0;
  return D.28178;
  <D.28184>:
  D.28187 = transport_handshake ();
  D.28188 = D.28187 == 0;
  disconnected.95 = (int) D.28188;
  disconnected = disconnected.95;
  disconnected.96 = disconnected;
  if (disconnected.96 != 0) goto <D.28191>; else goto <D.28192>;
  <D.28191>:
  log_level.91 = log_level;
  D.28172 = log_level.91 > 0;
  D.28173 = (long int) D.28172;
  D.28174 = __builtin_expect (D.28173, 0);
  if (D.28174 != 0) goto <D.28193>; else goto <D.28194>;
  <D.28193>:
  log_file.92 = log_file;
  fprintf (log_file.92, "Transport handshake failed!\n");
  log_file.92 = log_file;
  fflush (log_file.92);
  <D.28194>:
  D.28178 = 0;
  return D.28178;
  <D.28192>:
  D.28178 = 1;
  return D.28178;
}


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.28196;
  int conn_fd.97;
  int conn_fd.98;
  struct _IO_FILE * stderr.99;
  int log_level.100;
  _Bool D.28204;
  long int D.28205;
  long int D.28206;
  struct FILE * log_file.101;
  int D.28210;

  D.28196.__sockaddr__ = 0B;
  conn_fd.97 = accept (socket_fd, D.28196, 0B);
  conn_fd = conn_fd.97;
  conn_fd.98 = conn_fd;
  if (conn_fd.98 == -1) goto <D.28199>; else goto <D.28200>;
  <D.28199>:
  stderr.99 = stderr;
  fprintf (stderr.99, "debugger-agent: Unable to listen on %d\n", socket_fd);
  goto <D.28202>;
  <D.28200>:
  log_level.100 = log_level;
  D.28204 = log_level.100 > 0;
  D.28205 = (long int) D.28204;
  D.28206 = __builtin_expect (D.28205, 0);
  if (D.28206 != 0) goto <D.28207>; else goto <D.28208>;
  <D.28207>:
  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.28208>:
  <D.28202>:
  D.28210 = conn_fd;
  return D.28210;
}


transport_handshake ()
{
  unsigned int D.28212;
  int D.28213;
  int * D.28215;
  int D.28216;
  _Bool D.28217;
  long int D.28218;
  long int D.28219;
  unsigned int D.28222;
  int D.28223;
  unsigned int res.102;
  unsigned int D.28227;
  char[128] * handshake_msg.103;
  char D.28230;
  _Bool D.28231;
  unsigned int D.28232;
  int D.28233;
  struct _IO_FILE * stderr.104;
  gboolean D.28235;
  int conn_fd.105;
  _Bool D.28239;
  long int D.28240;
  long int D.28241;
  char handshake_msg[128];
  guint8 buf[128];
  int res;

  try
    {
      disconnected = 1;
      sprintf (&handshake_msg, "DWP-Handshake");
      <D.24630>:
      D.28212 = strlen (&handshake_msg);
      D.28213 = (int) D.28212;
      res = transport_send (&handshake_msg, D.28213);
      if (res == -1) goto <D.28214>; else goto <D.24631>;
      <D.28214>:
      D.28215 = __errno_location ();
      D.28216 = *D.28215;
      if (D.28216 == 4) goto <D.24630>; else goto <D.24631>;
      <D.24631>:
      D.28217 = res == -1;
      D.28218 = (long int) D.28217;
      D.28219 = __builtin_expect (D.28218, 0);
      if (D.28219 != 0) goto <D.28220>; else goto <D.28221>;
      <D.28220>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 1498, "res != -1");
      <D.28221>:
      D.28222 = strlen (&handshake_msg);
      D.28223 = (int) D.28222;
      res = transport_recv (&buf, D.28223);
      res.102 = (unsigned int) res;
      D.28227 = strlen (&handshake_msg);
      if (res.102 != D.28227) goto <D.28224>; else goto <D.28228>;
      <D.28228>:
      handshake_msg.103 = &handshake_msg;
      D.28230 = MEM[(const char *)handshake_msg.103];
      D.28231 = D.28230 != 0;
      D.28232 = (unsigned int) D.28231;
      D.28233 = memcmp (&buf, &handshake_msg, D.28232);
      if (D.28233 != 0) goto <D.28224>; else goto <D.28225>;
      <D.28224>:
      stderr.104 = stderr;
      fprintf (stderr.104, "debugger-agent: DWP handshake failed.\n");
      D.28235 = 0;
      return D.28235;
      <D.28225>:
      major_version = 2;
      minor_version = 27;
      protocol_version_set = 0;
      conn_fd.105 = conn_fd;
      if (conn_fd.105 != 0) goto <D.28237>; else goto <D.28238>;
      <D.28237>:
      {
        int flag;
        int result;

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


transport_send (void * buf, int len)
{
  int D.28246;
  struct DebuggerTransport * transport.106;
  gboolean (*<T3e60>) (void *, int) D.28248;

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


set_keepalive ()
{
  int D.28252;
  int conn_fd.107;
  int D.28255;
  int D.28256;
  int D.28257;
  _Bool D.28258;
  long int D.28259;
  long int D.28260;
  struct timeval tv;
  int result;

  try
    {
      D.28252 = agent_config.keepalive;
      if (D.28252 == 0) goto <D.28250>; else goto <D.28253>;
      <D.28253>:
      conn_fd.107 = conn_fd;
      if (conn_fd.107 == 0) goto <D.28250>; else goto <D.28251>;
      <D.28250>:
      return;
      <D.28251>:
      D.28252 = agent_config.keepalive;
      D.28255 = D.28252 / 1000;
      tv.tv_sec = D.28255;
      D.28252 = agent_config.keepalive;
      D.28256 = D.28252 % 1000;
      D.28257 = D.28256 * 1000;
      tv.tv_usec = D.28257;
      conn_fd.107 = conn_fd;
      result = setsockopt (conn_fd.107, 65535, 4102, &tv, 8);
      D.28258 = result < 0;
      D.28259 = (long int) D.28258;
      D.28260 = __builtin_expect (D.28259, 0);
      if (D.28260 != 0) goto <D.28261>; else goto <D.28262>;
      <D.28261>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 1126, "result >= 0");
      <D.28262>:
    }
  finally
    {
      tv = {CLOBBER};
    }
}


decode_int (guint8 * buf, guint8 * * endbuf, guint8 * limit)
{
  guint8 * D.28266;
  guint8 * D.28267;
  _Bool D.28268;
  long int D.28269;
  long int D.28270;
  int D.28273;
  unsigned char D.28274;
  int D.28275;
  int D.28276;
  guint8 * D.28277;
  unsigned char D.28278;
  int D.28279;
  int D.28280;
  int D.28281;
  guint8 * D.28282;
  unsigned char D.28283;
  int D.28284;
  int D.28285;
  int D.28286;
  guint8 * D.28287;
  unsigned char D.28288;
  int D.28289;

  D.28266 = buf + 4;
  *endbuf = D.28266;
  D.28267 = *endbuf;
  D.28268 = D.28267 > limit;
  D.28269 = (long int) D.28268;
  D.28270 = __builtin_expect (D.28269, 0);
  if (D.28270 != 0) goto <D.28271>; else goto <D.28272>;
  <D.28271>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 1599, "*endbuf <= limit");
  <D.28272>:
  D.28274 = *buf;
  D.28275 = (int) D.28274;
  D.28276 = D.28275 << 24;
  D.28277 = buf + 1;
  D.28278 = *D.28277;
  D.28279 = (int) D.28278;
  D.28280 = D.28279 << 16;
  D.28281 = D.28276 | D.28280;
  D.28282 = buf + 2;
  D.28283 = *D.28282;
  D.28284 = (int) D.28283;
  D.28285 = D.28284 << 8;
  D.28286 = D.28281 | D.28285;
  D.28287 = buf + 3;
  D.28288 = *D.28287;
  D.28289 = (int) D.28288;
  D.28273 = D.28286 | D.28289;
  return D.28273;
}


decode_byte (guint8 * buf, guint8 * * endbuf, guint8 * limit)
{
  guint8 * D.28291;
  guint8 * D.28292;
  _Bool D.28293;
  long int D.28294;
  long int D.28295;
  int D.28298;
  unsigned char D.28299;

  D.28291 = buf + 1;
  *endbuf = D.28291;
  D.28292 = *endbuf;
  D.28293 = D.28292 > limit;
  D.28294 = (long int) D.28293;
  D.28295 = __builtin_expect (D.28294, 0);
  if (D.28295 != 0) goto <D.28296>; else goto <D.28297>;
  <D.28296>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 1591, "*endbuf <= limit");
  <D.28297>:
  D.28299 = *buf;
  D.28298 = (int) D.28299;
  return D.28298;
}


cmd_to_string (CommandSet set, int command)
{
  const char * D.28301;
  sizetype command.108;
  sizetype D.28306;
  sizetype D.28307;
  const char * * D.28308;
  const char * * cmds;
  int cmds_len;

  cmds_len = 0;
  switch (set) <default: <D.27068>, case 1: <D.27054>, case 9: <D.27056>, case 10: <D.27057>, case 11: <D.27058>, case 13: <D.27059>, case 15: <D.27060>, case 16: <D.27061>, case 20: <D.27062>, case 21: <D.27063>, case 22: <D.27064>, case 23: <D.27065>, case 24: <D.27066>, case 64: <D.27067>>
  <D.27054>:
  cmds = &vm_cmds_str;
  cmds_len = 12;
  goto <D.27055>;
  <D.27056>:
  cmds = &object_cmds_str;
  cmds_len = 7;
  goto <D.27055>;
  <D.27057>:
  cmds = &string_cmds_str;
  cmds_len = 3;
  goto <D.27055>;
  <D.27058>:
  cmds = &thread_cmds_str;
  cmds_len = 6;
  goto <D.27055>;
  <D.27059>:
  cmds = &array_cmds_str;
  cmds_len = 3;
  goto <D.27055>;
  <D.27060>:
  cmds = &event_cmds_str;
  cmds_len = 3;
  goto <D.27055>;
  <D.27061>:
  cmds = &stack_frame_cmds_str;
  cmds_len = 3;
  goto <D.27055>;
  <D.27062>:
  cmds = &appdomain_cmds_str;
  cmds_len = 7;
  goto <D.27055>;
  <D.27063>:
  cmds = &assembly_cmds_str;
  cmds_len = 6;
  goto <D.27055>;
  <D.27064>:
  cmds = &method_cmds_str;
  cmds_len = 10;
  goto <D.27055>;
  <D.27065>:
  cmds = &type_cmds_str;
  cmds_len = 18;
  goto <D.27055>;
  <D.27066>:
  cmds = &module_cmds_str;
  cmds_len = 1;
  goto <D.27055>;
  <D.27067>:
  cmds = &event_cmds_str;
  cmds_len = 3;
  goto <D.27055>;
  <D.27068>:
  D.28301 = 0B;
  return D.28301;
  <D.27055>:
  if (command > 0) goto <D.28303>; else goto <D.28302>;
  <D.28303>:
  if (command <= cmds_len) goto <D.28304>; else goto <D.28302>;
  <D.28304>:
  command.108 = (sizetype) command;
  D.28306 = command.108 + 1073741823;
  D.28307 = D.28306 * 4;
  D.28308 = cmds + D.28307;
  D.28301 = *D.28308;
  return D.28301;
  <D.28302>:
  D.28301 = 0B;
  return D.28301;
}


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

  D.28311 = __builtin_object_size (__s, 1);
  D.28310 = __builtin___sprintf_chk (__s, 1, D.28311, __fmt, __builtin_va_arg_pack ());
  return D.28310;
}


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

  switch (command_set) <default: <D.27035>, case 1: <D.27022>, case 9: <D.27023>, case 10: <D.27024>, case 11: <D.27025>, case 13: <D.27026>, case 15: <D.27027>, case 16: <D.27028>, case 20: <D.27029>, case 21: <D.27030>, case 22: <D.27031>, case 23: <D.27032>, case 24: <D.27033>, case 64: <D.27034>>
  <D.27022>:
  D.28313 = "VM";
  return D.28313;
  <D.27023>:
  D.28313 = "OBJECT_REF";
  return D.28313;
  <D.27024>:
  D.28313 = "STRING_REF";
  return D.28313;
  <D.27025>:
  D.28313 = "THREAD";
  return D.28313;
  <D.27026>:
  D.28313 = "ARRAY_REF";
  return D.28313;
  <D.27027>:
  D.28313 = "EVENT_REQUEST";
  return D.28313;
  <D.27028>:
  D.28313 = "STACK_FRAME";
  return D.28313;
  <D.27029>:
  D.28313 = "APPDOMAIN";
  return D.28313;
  <D.27030>:
  D.28313 = "ASSEMBLY";
  return D.28313;
  <D.27031>:
  D.28313 = "METHOD";
  return D.28313;
  <D.27032>:
  D.28313 = "TYPE";
  return D.28313;
  <D.27033>:
  D.28313 = "MODULE";
  return D.28313;
  <D.27034>:
  D.28313 = "EVENT";
  return D.28313;
  <D.27035>:
  D.28313 = "";
  return D.28313;
}


transport_recv (void * buf, int len)
{
  int D.28315;
  struct DebuggerTransport * transport.109;
  int (*<T3e61>) (void *, int) D.28317;

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


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.28323;
  long int D.28324;
  long int D.28325;
  struct FILE * log_file.114;
  int major_version.115;
  int minor_version.116;
  struct MonoGHashTable * tid_to_thread_obj.117;
  unsigned int D.28332;
  int suspend_count.118;
  ErrorCode D.28336;
  struct GPtrArray * event_requests.119;
  void * * D.28338;
  int D.28339;
  int D.28340;
  unsigned int D.28341;
  int D.28342;
  int D.28343;
  struct MonoImage * D.28344;
  struct MonoGHashTable * tid_to_thread.120;
  struct MonoGHashTable * thread_to_tls.121;
  void * D.28353;
  void * D.28354;
  void * D.28355;
  struct InvokeData * D.28356;
  int D.28357;
  <unnamed type> D.28365;
  int D.28373;
  struct MonoThread * thread.122;
  struct _MonoInternalThread * D.28377;
  _Bool D.28378;
  long int D.28379;
  long int D.28380;
  int D.28383;
  struct InvokeData * D.28386;
  void * D.28389;
  int end.123;
  int p.124;
  int D.28392;
  unsigned int D.28393;
  void * D.28394;
  guint8 * D.28395;
  unsigned int D.28396;
  sizetype D.28397;
  guint8 * D.28398;
  unsigned int suspend_count.125;
  int D.28400;
  <unnamed type> D.28404;
  struct MonoThread * thread.126;
  struct _MonoInternalThread * D.28408;
  _Bool D.28409;
  long int D.28410;
  long int D.28411;
  int D.28414;
  struct InvokeData * D.28419;
  int D.28421;
  struct GHashTable * domains.127;
  struct MonoDomain * domain.128;
  void * D.28424;
  struct GHashTable * D.28425;
  struct GHashTable * D.28426;
  struct MonoClass * klass.129;
  void * D.28428;
  void * * D.28431;
  unsigned int i.130;
  unsigned int D.28433;
  void * * D.28434;
  struct GHashTable * D.28435;
  gchar * D.28438;
  struct GHashTable * D.28440;
  gchar * D.28443;
  unsigned int i.131;
  unsigned int D.28446;
  int D.28447;
  void * klass.132;
  int D.28452;
  unsigned int D.28453;
  void * * D.28454;
  void * * D.28455;
  void * D.28456;
  void * * D.28457;
  void * * D.28458;
  void * D.28459;
  int D.28460;
  struct MonoDomain * domain.133;
  union mono_mutex_t * D.28464;
  _Bool D.28467;
  long int D.28468;
  long int D.28469;
  struct MonoImage * D.28472;
  struct MonoClass * D.28477;
  _Bool D.28480;
  long int D.28481;
  long int D.28482;
  int D.28485;
  unsigned int D.28486;
  void * * D.28487;
  unsigned int i.134;
  unsigned int D.28489;
  void * * D.28490;
  void * D.28491;
  void * * D.28492;
  void * * D.28493;
  void * D.28494;
  unsigned int i.135;

  switch (command) <default: <D.26374>, case 1: <D.26262>, case 2: <D.26267>, case 3: <D.26268>, case 4: <D.26269>, case 5: <D.26278>, case 6: <D.26270>, case 7: <D.26295>, case 8: <D.26266>, case 9: <D.26308>, case 10: <D.26314>, case 11: <D.26316>, case 12: <D.26350>, case 13: <D.26296>>
  <D.26262>:
  {
    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.26265>;
  }
  <D.26266>:
  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.28323 = log_level.113 > 0;
  D.28324 = (long int) D.28323;
  D.28325 = __builtin_expect (D.28324, 0);
  if (D.28325 != 0) goto <D.28326>; else goto <D.28327>;
  <D.28326>:
  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.28327>:
  goto <D.26265>;
  <D.26267>:
  mono_loader_lock ();
  tid_to_thread_obj.117 = tid_to_thread_obj;
  D.28332 = mono_g_hash_table_size (tid_to_thread_obj.117);
  buffer_add_int (buf, D.28332);
  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.26265>;
  <D.26268>:
  suspend_vm ();
  wait_for_suspend ();
  goto <D.26265>;
  <D.26269>:
  suspend_count.118 = suspend_count;
  if (suspend_count.118 == 0) goto <D.28334>; else goto <D.28335>;
  <D.28334>:
  D.28336 = 101;
  return D.28336;
  <D.28335>:
  resume_vm ();
  clear_suspended_objs ();
  goto <D.26265>;
  <D.26270>:
  mono_loader_lock ();
  goto <D.26273>;
  <D.26272>:
  {
    struct EventRequest * req;

    event_requests.119 = event_requests;
    D.28338 = event_requests.119->pdata;
    req = *D.28338;
    D.28339 = req->id;
    D.28340 = req->event_kind;
    clear_event_request (D.28339, D.28340);
  }
  <D.26273>:
  event_requests.119 = event_requests;
  D.28341 = event_requests.119->len;
  if (D.28341 != 0) goto <D.26272>; else goto <D.26274>;
  <D.26274>:
  mono_loader_unlock ();
  goto <D.26276>;
  <D.26275>:
  resume_vm ();
  <D.26276>:
  suspend_count.118 = suspend_count;
  if (suspend_count.118 > 0) goto <D.26275>; else goto <D.26277>;
  <D.26277>:
  disconnected = 1;
  vm_start_event_sent = 0;
  goto <D.26265>;
  <D.26278>:
  {
    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.26287>;
    <D.26286>:
    {
      struct EventRequest * req;

      event_requests.119 = event_requests;
      D.28338 = event_requests.119->pdata;
      req = *D.28338;
      D.28342 = req->id;
      D.28343 = req->event_kind;
      clear_event_request (D.28342, D.28343);
    }
    <D.26287>:
    event_requests.119 = event_requests;
    D.28341 = event_requests.119->len;
    if (D.28341 != 0) goto <D.26286>; else goto <D.26288>;
    <D.26288>:
    mono_loader_unlock ();
    suspend_vm ();
    wait_for_suspend ();
    D.28344 = mono_defaults.corlib;
    env_class = mono_class_from_name (D.28344, "System", "Environment");
    if (env_class != 0B) goto <D.28345>; else goto <D.28346>;
    <D.28345>:
    exit_method = mono_class_get_method_from_name (env_class, "Exit", 1);
    <D.28346>:
    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 ();
    if (thread != 0B) goto <D.28350>; else goto <D.28348>;
    <D.28350>:
    if (exit_method != 0B) goto <D.28351>; else goto <D.28348>;
    <D.28351>:
    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.28353 = monoeg_malloc (4);
    *args = D.28353;
    D.28354 = *args;
    MEM[(int *)D.28354] = exit_code;
    D.28355 = monoeg_malloc0 (300);
    tls->pending_invoke = D.28355;
    D.28356 = tls->pending_invoke;
    D.28356->method = exit_method;
    D.28356 = tls->pending_invoke;
    D.28356->args = args;
    D.28356 = tls->pending_invoke;
    D.28356->nmethods = 1;
    goto <D.26290>;
    <D.26289>:
    resume_vm ();
    <D.26290>:
    suspend_count.118 = suspend_count;
    if (suspend_count.118 > 0) goto <D.26289>; else goto <D.26291>;
    <D.26291>:
    goto <D.28349>;
    <D.28348>:
    goto <D.26293>;
    <D.26292>:
    resume_vm ();
    <D.26293>:
    suspend_count.118 = suspend_count;
    if (suspend_count.118 > 0) goto <D.26292>; else goto <D.26294>;
    <D.26294>:
    D.28357 = mono_runtime_try_shutdown ();
    if (D.28357 == 0) goto <D.26265>; else goto <D.28358>;
    <D.28358>:
    mono_environment_exitcode_set (exit_code);
    log_level.113 = log_level;
    D.28323 = log_level.113 > 0;
    D.28324 = (long int) D.28323;
    D.28325 = __builtin_expect (D.28324, 0);
    if (D.28325 != 0) goto <D.28359>; else goto <D.28360>;
    <D.28359>:
    log_file.114 = log_file;
    fprintf (log_file.114, "Suspending all threads...\n");
    log_file.114 = log_file;
    fflush (log_file.114);
    <D.28360>:
    mono_thread_suspend_all_other_threads ();
    log_level.113 = log_level;
    D.28323 = log_level.113 > 0;
    D.28324 = (long int) D.28323;
    D.28325 = __builtin_expect (D.28324, 0);
    if (D.28325 != 0) goto <D.28361>; else goto <D.28362>;
    <D.28361>:
    log_file.114 = log_file;
    fprintf (log_file.114, "Shutting down the runtime...\n");
    log_file.114 = log_file;
    fflush (log_file.114);
    <D.28362>:
    mono_runtime_quit ();
    transport_close2 ();
    log_level.113 = log_level;
    D.28323 = log_level.113 > 0;
    D.28324 = (long int) D.28323;
    D.28325 = __builtin_expect (D.28324, 0);
    if (D.28325 != 0) goto <D.28363>; else goto <D.28364>;
    <D.28363>:
    log_file.114 = log_file;
    fprintf (log_file.114, "Exiting...\n");
    log_file.114 = log_file;
    fflush (log_file.114);
    <D.28364>:
    exit (exit_code);
    <D.28349>:
    goto <D.26265>;
  }
  <D.26295>:
  <D.26296>:
  {
    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.28365 = get_object (objid, &thread);
        err = (int) D.28365;
        if (err != 0) goto <D.28366>; else goto <D.28367>;
        <D.28366>:
        D.28336 = (ErrorCode) err;
        return D.28336;
        <D.28367>:
        p.110 = p;
        flags = decode_int (p.110, &p, end);
        if (command == 13) goto <D.28368>; else goto <D.28369>;
        <D.28368>:
        p.110 = p;
        nmethods = decode_int (p.110, &p, end);
        goto <D.28370>;
        <D.28369>:
        nmethods = 1;
        <D.28370>:
        suspend_count.118 = suspend_count;
        if (suspend_count.118 != 0) goto <D.28371>; else goto <D.28372>;
        <D.28371>:
        wait_for_suspend ();
        <D.28372>:
        D.28373 = is_suspended ();
        if (D.28373 == 0) goto <D.28374>; else goto <D.28375>;
        <D.28374>:
        D.28336 = 101;
        return D.28336;
        <D.28375>:
        mono_loader_lock ();
        thread_to_tls.121 = thread_to_tls;
        thread.122 = thread;
        D.28377 = thread.122->internal_thread;
        tls = mono_g_hash_table_lookup (thread_to_tls.121, D.28377);
        mono_loader_unlock ();
        D.28378 = tls == 0B;
        D.28379 = (long int) D.28378;
        D.28380 = __builtin_expect (D.28379, 0);
        if (D.28380 != 0) goto <D.28381>; else goto <D.28382>;
        <D.28381>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 6722, "tls");
        <D.28382>:
        D.28383 = tls->really_suspended;
        if (D.28383 == 0) goto <D.28384>; else goto <D.28385>;
        <D.28384>:
        D.28336 = 101;
        return D.28336;
        <D.28385>:
        D.28386 = tls->pending_invoke;
        if (D.28386 != 0B) goto <D.28387>; else goto <D.28388>;
        <D.28387>:
        D.28336 = 101;
        return D.28336;
        <D.28388>:
        D.28389 = monoeg_malloc0 (300);
        tls->pending_invoke = D.28389;
        D.28386 = tls->pending_invoke;
        D.28386->id = id;
        D.28386 = tls->pending_invoke;
        D.28386->flags = flags;
        D.28386 = tls->pending_invoke;
        end.123 = (int) end;
        p.110 = p;
        p.124 = (int) p.110;
        D.28392 = end.123 - p.124;
        D.28393 = (unsigned int) D.28392;
        D.28394 = monoeg_malloc (D.28393);
        D.28386->p = D.28394;
        D.28386 = tls->pending_invoke;
        D.28395 = D.28386->p;
        p.110 = p;
        end.123 = (int) end;
        p.110 = p;
        p.124 = (int) p.110;
        D.28392 = end.123 - p.124;
        D.28396 = (unsigned int) D.28392;
        memcpy (D.28395, p.110, D.28396);
        D.28386 = tls->pending_invoke;
        D.28386 = tls->pending_invoke;
        D.28395 = D.28386->p;
        end.123 = (int) end;
        p.110 = p;
        p.124 = (int) p.110;
        D.28392 = end.123 - p.124;
        D.28397 = (sizetype) D.28392;
        D.28398 = D.28395 + D.28397;
        D.28386->endp = D.28398;
        D.28386 = tls->pending_invoke;
        suspend_count.118 = suspend_count;
        suspend_count.125 = (unsigned int) suspend_count.118;
        D.28386->suspend_count = suspend_count.125;
        D.28386 = tls->pending_invoke;
        D.28386->nmethods = nmethods;
        D.28400 = flags & 2;
        if (D.28400 != 0) goto <D.28401>; else goto <D.28402>;
        <D.28401>:
        thread.122 = thread;
        D.28377 = thread.122->internal_thread;
        resume_thread (D.28377);
        goto <D.28403>;
        <D.28402>:
        count = suspend_count;
        i = 0;
        goto <D.26306>;
        <D.26305>:
        resume_vm ();
        i = i + 1;
        <D.26306>:
        if (i < count) goto <D.26305>; else goto <D.26307>;
        <D.26307>:
        <D.28403>:
        goto <D.26265>;
      }
    finally
      {
        thread = {CLOBBER};
      }
  }
  <D.26308>:
  {
    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.28404 = get_object (objid, &thread);
        err = (int) D.28404;
        if (err != 0) goto <D.28405>; else goto <D.28406>;
        <D.28405>:
        D.28336 = (ErrorCode) err;
        return D.28336;
        <D.28406>:
        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.28408 = thread.126->internal_thread;
        tls = mono_g_hash_table_lookup (thread_to_tls.121, D.28408);
        D.28409 = tls == 0B;
        D.28410 = (long int) D.28409;
        D.28411 = __builtin_expect (D.28410, 0);
        if (D.28411 != 0) goto <D.28412>; else goto <D.28413>;
        <D.28412>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 6767, "tls");
        <D.28413>:
        D.28414 = tls->abort_requested;
        if (D.28414 != 0) goto <D.28415>; else goto <D.28416>;
        <D.28415>:
        mono_loader_unlock ();
        goto <D.26265>;
        <D.28416>:
        D.28419 = tls->invoke;
        if (D.28419 == 0B) goto <D.28417>; else goto <D.28420>;
        <D.28420>:
        D.28419 = tls->invoke;
        D.28421 = D.28419->id;
        if (D.28421 != invoke_id) goto <D.28417>; else goto <D.28418>;
        <D.28417>:
        mono_loader_unlock ();
        D.28336 = 104;
        return D.28336;
        <D.28418>:
        tls->abort_requested = 1;
        thread.126 = thread;
        D.28408 = thread.126->internal_thread;
        ves_icall_System_Threading_Thread_Abort (D.28408, 0B);
        mono_loader_unlock ();
        goto <D.26265>;
      }
    finally
      {
        thread = {CLOBBER};
      }
  }
  <D.26314>:
  {
    int timeout;

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

          domain.128 = domain;
          D.28424 = domain.128->runtime_info;
          info = MEM[(struct MonoJitDomainInfo *)D.28424].agent_info;
          D.28425 = info->loaded_classes;
          monoeg_g_hash_table_iter_init (&kiter, D.28425);
          goto <D.26338>;
          <D.26337>:
          D.28426 = info->source_files;
          klass.129 = klass;
          D.28428 = monoeg_g_hash_table_lookup (D.28426, klass.129);
          if (D.28428 == 0B) goto <D.28429>; else goto <D.28430>;
          <D.28429>:
          klass.129 = klass;
          files = get_source_files_for_type (klass.129);
          D.28426 = info->source_files;
          klass.129 = klass;
          monoeg_g_hash_table_insert_replace (D.28426, klass.129, files, 0);
          i = 0;
          goto <D.26335>;
          <D.26334>:
          {
            char * s;
            char * s2;
            char * s3;

            D.28431 = files->pdata;
            i.130 = (unsigned int) i;
            D.28433 = i.130 * 4;
            D.28434 = D.28431 + D.28433;
            s = *D.28434;
            s2 = monoeg_g_path_get_basename (s);
            D.28435 = info->source_file_to_class;
            class_list = monoeg_g_hash_table_lookup (D.28435, s2);
            if (class_list == 0B) goto <D.28436>; else goto <D.28437>;
            <D.28436>:
            klass.129 = klass;
            class_list = monoeg_g_slist_prepend (class_list, klass.129);
            D.28435 = info->source_file_to_class;
            D.28438 = monoeg_strdup (s2);
            monoeg_g_hash_table_insert_replace (D.28435, D.28438, class_list, 0);
            goto <D.28439>;
            <D.28437>:
            klass.129 = klass;
            class_list = monoeg_g_slist_prepend (class_list, klass.129);
            D.28435 = info->source_file_to_class;
            monoeg_g_hash_table_insert_replace (D.28435, s2, class_list, 0);
            <D.28439>:
            s3 = strdup_tolower (s2);
            D.28440 = info->source_file_to_class_ignorecase;
            class_list = monoeg_g_hash_table_lookup (D.28440, s3);
            if (class_list == 0B) goto <D.28441>; else goto <D.28442>;
            <D.28441>:
            klass.129 = klass;
            class_list = monoeg_g_slist_prepend (class_list, klass.129);
            D.28440 = info->source_file_to_class_ignorecase;
            D.28443 = monoeg_strdup (s3);
            monoeg_g_hash_table_insert_replace (D.28440, D.28443, class_list, 0);
            goto <D.28444>;
            <D.28442>:
            klass.129 = klass;
            class_list = monoeg_g_slist_prepend (class_list, klass.129);
            D.28440 = info->source_file_to_class_ignorecase;
            monoeg_g_hash_table_insert_replace (D.28440, s3, class_list, 0);
            <D.28444>:
            monoeg_g_free (s2);
            monoeg_g_free (s3);
          }
          i = i + 1;
          <D.26335>:
          i.131 = (unsigned int) i;
          D.28446 = files->len;
          if (i.131 < D.28446) goto <D.26334>; else goto <D.26336>;
          <D.26336>:
          <D.28430>:
          <D.26338>:
          D.28447 = monoeg_g_hash_table_iter_next (&kiter, 0B, &klass);
          if (D.28447 != 0) goto <D.26337>; else goto <D.26339>;
          <D.26339>:
          if (ignore_case != 0) goto <D.28448>; else goto <D.28449>;
          <D.28448>:
          {
            char * s;

            s = strdup_tolower (basename);
            D.28440 = info->source_file_to_class_ignorecase;
            class_list = monoeg_g_hash_table_lookup (D.28440, s);
            monoeg_g_free (s);
          }
          goto <D.28450>;
          <D.28449>:
          D.28435 = info->source_file_to_class;
          class_list = monoeg_g_hash_table_lookup (D.28435, basename);
          <D.28450>:
          l = class_list;
          goto <D.26342>;
          <D.26341>:
          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.26342>:
          if (l != 0B) goto <D.26341>; else goto <D.26343>;
          <D.26343>:
        }
        <D.26345>:
        D.28452 = monoeg_g_hash_table_iter_next (&iter, 0B, &domain);
        if (D.28452 != 0) goto <D.26344>; else goto <D.26346>;
        <D.26346>:
        mono_loader_unlock ();
        monoeg_g_free (fname);
        monoeg_g_free (basename);
        D.28453 = res_classes->len;
        buffer_add_int (buf, D.28453);
        i = 0;
        goto <D.26348>;
        <D.26347>:
        D.28454 = res_domains->pdata;
        i.130 = (unsigned int) i;
        D.28433 = i.130 * 4;
        D.28455 = D.28454 + D.28433;
        D.28456 = *D.28455;
        D.28457 = res_classes->pdata;
        i.130 = (unsigned int) i;
        D.28433 = i.130 * 4;
        D.28458 = D.28457 + D.28433;
        D.28459 = *D.28458;
        buffer_add_typeid (buf, D.28456, D.28459);
        i = i + 1;
        <D.26348>:
        i.131 = (unsigned int) i;
        D.28453 = res_classes->len;
        if (i.131 < D.28453) goto <D.26347>; else goto <D.26349>;
        <D.26349>:
        monoeg_g_ptr_array_free (res_classes, 1);
        monoeg_g_ptr_array_free (res_domains, 1);
        goto <D.26265>;
      }
    finally
      {
        iter = {CLOBBER};
        kiter = {CLOBBER};
        domain = {CLOBBER};
        klass = {CLOBBER};
      }
  }
  <D.26350>:
  {
    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.28460 = mono_reflection_parse_type (name, &info);
        if (D.28460 == 0) goto <D.28461>; else goto <D.28462>;
        <D.28461>:
        monoeg_g_free (name);
        mono_reflection_free_type_info (&info);
        D.28336 = 102;
        return D.28336;
        <D.28462>:
        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.26369>;
        <D.26368>:
        {
          struct MonoAssembly * ass;
          gboolean type_resolve;
          struct MonoType * t;
          struct GSList * tmp;

          try
            {
              {
                int ret;

                domain.133 = domain;
                D.28464 = &domain.133->assemblies_lock.mutex;
                ret = pthread_mutex_lock (D.28464);
                if (ret != 0) goto <D.28465>; else goto <D.28466>;
                <D.28465>:
                monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
                <D.28466>:
                D.28467 = ret != 0;
                D.28468 = (long int) D.28467;
                D.28469 = __builtin_expect (D.28468, 0);
                if (D.28469 != 0) goto <D.28470>; else goto <D.28471>;
                <D.28470>:
                monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 6927, "ret == 0");
                <D.28471>:
              }
              domain.133 = domain;
              tmp = domain.133->domain_assemblies;
              goto <D.26365>;
              <D.26364>:
              ass = tmp->data;
              D.28472 = ass->image;
              if (D.28472 != 0B) goto <D.28473>; else goto <D.28474>;
              <D.28473>:
              type_resolve = 1;
              D.28472 = ass->image;
              t = mono_reflection_get_type (D.28472, &info, ignore_case, &type_resolve);
              if (t != 0B) goto <D.28475>; else goto <D.28476>;
              <D.28475>:
              D.28477 = mono_type_get_class (t);
              monoeg_g_ptr_array_add (res_classes, D.28477);
              domain.133 = domain;
              monoeg_g_ptr_array_add (res_domains, domain.133);
              <D.28476>:
              <D.28474>:
              tmp = tmp->next;
              <D.26365>:
              if (tmp != 0B) goto <D.26364>; else goto <D.26366>;
              <D.26366>:
              {
                int ret;

                domain.133 = domain;
                D.28464 = &domain.133->assemblies_lock.mutex;
                ret = pthread_mutex_unlock (D.28464);
                if (ret != 0) goto <D.28478>; else goto <D.28479>;
                <D.28478>:
                monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
                <D.28479>:
                D.28480 = ret != 0;
                D.28481 = (long int) D.28480;
                D.28482 = __builtin_expect (D.28481, 0);
                if (D.28482 != 0) goto <D.28483>; else goto <D.28484>;
                <D.28483>:
                monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 6940, "ret == 0");
                <D.28484>:
              }
            }
          finally
            {
              type_resolve = {CLOBBER};
            }
        }
        <D.26369>:
        D.28485 = monoeg_g_hash_table_iter_next (&iter, 0B, &domain);
        if (D.28485 != 0) goto <D.26368>; else goto <D.26370>;
        <D.26370>:
        mono_loader_unlock ();
        monoeg_g_free (name);
        mono_reflection_free_type_info (&info);
        D.28486 = res_classes->len;
        buffer_add_int (buf, D.28486);
        i = 0;
        goto <D.26372>;
        <D.26371>:
        D.28487 = res_domains->pdata;
        i.134 = (unsigned int) i;
        D.28489 = i.134 * 4;
        D.28490 = D.28487 + D.28489;
        D.28491 = *D.28490;
        D.28492 = res_classes->pdata;
        i.134 = (unsigned int) i;
        D.28489 = i.134 * 4;
        D.28493 = D.28492 + D.28489;
        D.28494 = *D.28493;
        buffer_add_typeid (buf, D.28491, D.28494);
        i = i + 1;
        <D.26372>:
        i.135 = (unsigned int) i;
        D.28486 = res_classes->len;
        if (i.135 < D.28486) goto <D.26371>; else goto <D.26373>;
        <D.26373>:
        monoeg_g_ptr_array_free (res_classes, 1);
        monoeg_g_ptr_array_free (res_domains, 1);
        goto <D.26265>;
      }
    finally
      {
        iter = {CLOBBER};
        domain = {CLOBBER};
        info = {CLOBBER};
      }
  }
  <D.26374>:
  D.28336 = 100;
  return D.28336;
  <D.26265>:
  D.28336 = 0;
  return D.28336;
}


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


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

  D.28513 = 1;
  return D.28513;
}


clear_event_request (int req_id, int etype)
{
  struct GPtrArray * event_requests.138;
  void * * D.28516;
  unsigned int i.139;
  unsigned int D.28518;
  void * * D.28519;
  int D.28520;
  int D.28523;
  void * D.28528;
  unsigned int i.140;
  unsigned int D.28536;
  int i;

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

    event_requests.138 = event_requests;
    D.28516 = event_requests.138->pdata;
    i.139 = (unsigned int) i;
    D.28518 = i.139 * 4;
    D.28519 = D.28516 + D.28518;
    req = *D.28519;
    D.28520 = req->id;
    if (D.28520 == req_id) goto <D.28521>; else goto <D.28522>;
    <D.28521>:
    D.28523 = req->event_kind;
    if (D.28523 == etype) goto <D.28524>; else goto <D.28525>;
    <D.28524>:
    D.28523 = req->event_kind;
    if (D.28523 == 10) goto <D.28526>; else goto <D.28527>;
    <D.28526>:
    D.28528 = req->info;
    clear_breakpoint (D.28528);
    <D.28527>:
    D.28523 = req->event_kind;
    if (D.28523 == 11) goto <D.28529>; else goto <D.28530>;
    <D.28529>:
    D.28528 = req->info;
    ss_destroy (D.28528);
    <D.28530>:
    D.28523 = req->event_kind;
    if (D.28523 == 6) goto <D.28531>; else goto <D.28532>;
    <D.28531>:
    D.28528 = req->info;
    clear_breakpoint (D.28528);
    <D.28532>:
    D.28523 = req->event_kind;
    if (D.28523 == 7) goto <D.28533>; else goto <D.28534>;
    <D.28533>:
    D.28528 = req->info;
    clear_breakpoint (D.28528);
    <D.28534>:
    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.26108>;
    <D.28525>:
    <D.28522>:
  }
  i = i + 1;
  <D.26110>:
  i.140 = (unsigned int) i;
  event_requests.138 = event_requests;
  D.28536 = event_requests.138->len;
  if (i.140 < D.28536) goto <D.26109>; else goto <D.26108>;
  <D.26108>:
  mono_loader_unlock ();
}


transport_close2 ()
{
  struct DebuggerTransport * transport.141;
  void (*<T7a8>) (void) D.28538;

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


wait_for_suspend ()
{
  struct MonoGHashTable * thread_to_tls.142;
  unsigned int D.28540;
  int log_level.143;
  _Bool D.28543;
  long int D.28544;
  long int D.28545;
  struct FILE * log_file.144;
  _Bool D.28549;
  long int D.28550;
  long int D.28551;
  int nthreads;
  int nwait;
  int err;
  gboolean waited;

  waited = 0;
  mono_loader_lock ();
  thread_to_tls.142 = thread_to_tls;
  D.28540 = mono_g_hash_table_size (thread_to_tls.142);
  nthreads = (int) D.28540;
  mono_loader_unlock ();
  <D.25115>:
  nwait = count_threads_to_wait_for ();
  if (nwait != 0) goto <D.28541>; else goto <D.25114>;
  <D.28541>:
  log_level.143 = log_level;
  D.28543 = log_level.143 > 0;
  D.28544 = (long int) D.28543;
  D.28545 = __builtin_expect (D.28544, 0);
  if (D.28545 != 0) goto <D.28546>; else goto <D.28547>;
  <D.28546>:
  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.28547>:
  err = mono_sem_wait (&suspend_sem, 0);
  D.28549 = err != 0;
  D.28550 = (long int) D.28549;
  D.28551 = __builtin_expect (D.28550, 0);
  if (D.28551 != 0) goto <D.28552>; else goto <D.28553>;
  <D.28552>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 2962, "err == 0");
  <D.28553>:
  waited = 1;
  goto <D.25115>;
  <D.25114>:
  if (waited != 0) goto <D.28554>; else goto <D.28555>;
  <D.28554>:
  log_level.143 = log_level;
  D.28543 = log_level.143 > 0;
  D.28544 = (long int) D.28543;
  D.28545 = __builtin_expect (D.28544, 0);
  if (D.28545 != 0) goto <D.28556>; else goto <D.28557>;
  <D.28556>:
  log_file.144 = log_file;
  fprintf (log_file.144, "%d threads suspended.\n", nthreads);
  log_file.144 = log_file;
  fflush (log_file.144);
  <D.28557>:
  <D.28555>:
}


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


count_thread (void * key, void * value, void * user_data)
{
  int D.28562;
  int D.28565;
  int D.28568;
  int D.28569;
  struct DebuggerTlsData * tls;

  tls = value;
  D.28562 = tls->suspended;
  if (D.28562 == 0) goto <D.28563>; else goto <D.28564>;
  <D.28563>:
  D.28565 = tls->terminated;
  if (D.28565 == 0) goto <D.28566>; else goto <D.28567>;
  <D.28566>:
  D.28568 = MEM[(int *)user_data];
  D.28569 = D.28568 + 1;
  MEM[(int *)user_data] = D.28569;
  <D.28567>:
  <D.28564>:
}


is_suspended ()
{
  gboolean D.28570;
  int D.28571;
  _Bool D.28572;

  D.28571 = count_threads_to_wait_for ();
  D.28572 = D.28571 == 0;
  D.28570 = (gboolean) D.28572;
  return D.28570;
}


resume_thread (struct MonoInternalThread * thread)
{
  unsigned int D.28574;
  unsigned int debugger_thread_id.146;
  _Bool D.28576;
  long int D.28577;
  long int D.28578;
  struct MonoGHashTable * thread_to_tls.147;
  _Bool D.28582;
  long int D.28583;
  long int D.28584;
  int suspend_count.148;
  _Bool D.28588;
  long int D.28589;
  long int D.28590;
  int log_level.149;
  _Bool D.28594;
  long int D.28595;
  long int D.28596;
  struct FILE * log_file.150;
  long long unsigned int D.28600;
  int D.28601;
  void * D.28602;
  unsigned int D.28603;
  unsigned int suspend_count.151;
  unsigned int D.28605;
  _Bool D.28606;
  long int D.28607;
  long int D.28608;
  int err;
  struct DebuggerTlsData * tls;

  D.28574 = GetCurrentThreadId ();
  debugger_thread_id.146 = debugger_thread_id;
  D.28576 = D.28574 != debugger_thread_id.146;
  D.28577 = (long int) D.28576;
  D.28578 = __builtin_expect (D.28577, 0);
  if (D.28578 != 0) goto <D.28579>; else goto <D.28580>;
  <D.28579>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 2796, "debugger_thread_id == GetCurrentThreadId ()");
  <D.28580>:
  mono_loader_lock ();
  thread_to_tls.147 = thread_to_tls;
  tls = mono_g_hash_table_lookup (thread_to_tls.147, thread);
  D.28582 = tls == 0B;
  D.28583 = (long int) D.28582;
  D.28584 = __builtin_expect (D.28583, 0);
  if (D.28584 != 0) goto <D.28585>; else goto <D.28586>;
  <D.28585>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 2801, "tls");
  <D.28586>:
  pthread_mutex_lock (&suspend_mutex);
  suspend_count.148 = suspend_count;
  D.28588 = suspend_count.148 <= 0;
  D.28589 = (long int) D.28588;
  D.28590 = __builtin_expect (D.28589, 0);
  if (D.28590 != 0) goto <D.28591>; else goto <D.28592>;
  <D.28591>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 2805, "suspend_count > 0");
  <D.28592>:
  log_level.149 = log_level;
  D.28594 = log_level.149 > 0;
  D.28595 = (long int) D.28594;
  D.28596 = __builtin_expect (D.28595, 0);
  if (D.28596 != 0) goto <D.28597>; else goto <D.28598>;
  <D.28597>:
  log_file.150 = log_file;
  D.28600 = thread->tid;
  D.28601 = (int) D.28600;
  D.28602 = (void *) D.28601;
  fprintf (log_file.150, "[%p] Resuming thread...\n", D.28602);
  log_file.150 = log_file;
  fflush (log_file.150);
  <D.28598>:
  D.28603 = tls->resume_count;
  suspend_count.148 = suspend_count;
  suspend_count.151 = (unsigned int) suspend_count.148;
  D.28605 = D.28603 + suspend_count.151;
  tls->resume_count = D.28605;
  err = pthread_cond_broadcast (&suspend_cond);
  D.28606 = err != 0;
  D.28607 = (long int) D.28606;
  D.28608 = __builtin_expect (D.28607, 0);
  if (D.28608 != 0) goto <D.28609>; else goto <D.28610>;
  <D.28609>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 2816, "err == 0");
  <D.28610>:
  pthread_mutex_unlock (&suspend_mutex);
  mono_loader_unlock ();
}


resume_vm ()
{
  unsigned int D.28611;
  unsigned int debugger_thread_id.152;
  _Bool D.28613;
  long int D.28614;
  long int D.28615;
  int suspend_count.153;
  _Bool D.28619;
  long int D.28620;
  long int D.28621;
  int suspend_count.154;
  int log_level.155;
  _Bool D.28626;
  long int D.28627;
  long int D.28628;
  struct FILE * log_file.156;
  unsigned int D.28632;
  void * D.28633;
  struct MonoGHashTable * thread_to_tls.157;
  _Bool D.28637;
  long int D.28638;
  long int D.28639;
  int err;

  D.28611 = GetCurrentThreadId ();
  debugger_thread_id.152 = debugger_thread_id;
  D.28613 = D.28611 != debugger_thread_id.152;
  D.28614 = (long int) D.28613;
  D.28615 = __builtin_expect (D.28614, 0);
  if (D.28615 != 0) goto <D.28616>; else goto <D.28617>;
  <D.28616>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 2755, "debugger_thread_id == GetCurrentThreadId ()");
  <D.28617>:
  mono_loader_lock ();
  pthread_mutex_lock (&suspend_mutex);
  suspend_count.153 = suspend_count;
  D.28619 = suspend_count.153 <= 0;
  D.28620 = (long int) D.28619;
  D.28621 = __builtin_expect (D.28620, 0);
  if (D.28621 != 0) goto <D.28622>; else goto <D.28623>;
  <D.28622>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 2761, "suspend_count > 0");
  <D.28623>:
  suspend_count.153 = suspend_count;
  suspend_count.154 = suspend_count.153 + -1;
  suspend_count = suspend_count.154;
  log_level.155 = log_level;
  D.28626 = log_level.155 > 0;
  D.28627 = (long int) D.28626;
  D.28628 = __builtin_expect (D.28627, 0);
  if (D.28628 != 0) goto <D.28629>; else goto <D.28630>;
  <D.28629>:
  log_file.156 = log_file;
  D.28632 = GetCurrentThreadId ();
  D.28633 = (void *) D.28632;
  suspend_count.153 = suspend_count;
  fprintf (log_file.156, "[%p] Resuming vm, suspend count=%d...\n", D.28633, suspend_count.153);
  log_file.156 = log_file;
  fflush (log_file.156);
  <D.28630>:
  suspend_count.153 = suspend_count;
  if (suspend_count.153 == 0) goto <D.28634>; else goto <D.28635>;
  <D.28634>:
  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.28635>:
  err = pthread_cond_broadcast (&suspend_cond);
  D.28637 = err != 0;
  D.28638 = (long int) D.28637;
  D.28639 = __builtin_expect (D.28638, 0);
  if (D.28639 != 0) goto <D.28640>; else goto <D.28641>;
  <D.28640>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 2774, "err == 0");
  <D.28641>:
  pthread_mutex_unlock (&suspend_mutex);
  suspend_count.153 = suspend_count;
  if (suspend_count.153 == 0) goto <D.28642>; else goto <D.28643>;
  <D.28642>:
  mono_thread_pool_resume ();
  <D.28643>:
  mono_loader_unlock ();
}


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

  tls = value;
  D.28644 = tls->really_suspended;
  if (D.28644 == 0) goto <D.28645>; else goto <D.28646>;
  <D.28645>:
  D.28647 = tls->suspended;
  if (D.28647 != 0) goto <D.28648>; else goto <D.28649>;
  <D.28648>:
  tls->suspended = 0;
  tls->context.valid = 0;
  tls->async_state.valid = 0;
  invalidate_frames (tls);
  <D.28649>:
  <D.28646>:
}


invalidate_frames (struct DebuggerTlsData * tls)
{
  unsigned int debugger_tls_id.158;
  _Bool D.28653;
  long int D.28654;
  long int D.28655;
  struct StackFrame * * D.28658;
  unsigned int i.159;
  unsigned int D.28660;
  struct StackFrame * * D.28661;
  struct StackFrame * D.28662;
  struct MonoDebugMethodJitInfo * D.28663;
  int D.28666;
  int i;

  if (tls == 0B) goto <D.28650>; else goto <D.28651>;
  <D.28650>:
  debugger_tls_id.158 = debugger_tls_id;
  tls = pthread_getspecific (debugger_tls_id.158);
  <D.28651>:
  D.28653 = tls == 0B;
  D.28654 = (long int) D.28653;
  D.28655 = __builtin_expect (D.28654, 0);
  if (D.28655 != 0) goto <D.28656>; else goto <D.28657>;
  <D.28656>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 2831, "tls");
  <D.28657>:
  i = 0;
  goto <D.25087>;
  <D.25086>:
  D.28658 = tls->frames;
  i.159 = (unsigned int) i;
  D.28660 = i.159 * 4;
  D.28661 = D.28658 + D.28660;
  D.28662 = *D.28661;
  D.28663 = D.28662->jit;
  if (D.28663 != 0B) goto <D.28664>; else goto <D.28665>;
  <D.28664>:
  D.28658 = tls->frames;
  i.159 = (unsigned int) i;
  D.28660 = i.159 * 4;
  D.28661 = D.28658 + D.28660;
  D.28662 = *D.28661;
  D.28663 = D.28662->jit;
  mono_debug_free_method_jit_info (D.28663);
  <D.28665>:
  D.28658 = tls->frames;
  i.159 = (unsigned int) i;
  D.28660 = i.159 * 4;
  D.28661 = D.28658 + D.28660;
  D.28662 = *D.28661;
  monoeg_g_free (D.28662);
  i = i + 1;
  <D.25087>:
  D.28666 = tls->frame_count;
  if (D.28666 > i) goto <D.25086>; else goto <D.25088>;
  <D.25088>:
  D.28658 = tls->frames;
  monoeg_g_free (D.28658);
  tls->frame_count = 0;
  tls->frames = 0B;
}


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

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


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

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


get_object (int objid, struct MonoObject * * obj)
{
  <unnamed type> D.28671;
  ErrorCode D.28674;
  struct MonoObject * D.28675;
  int err;

  D.28671 = get_object_allow_null (objid, obj);
  err = (int) D.28671;
  if (err != 0) goto <D.28672>; else goto <D.28673>;
  <D.28672>:
  D.28674 = (ErrorCode) err;
  return D.28674;
  <D.28673>:
  D.28675 = *obj;
  if (D.28675 == 0B) goto <D.28676>; else goto <D.28677>;
  <D.28676>:
  D.28674 = 20;
  return D.28674;
  <D.28677>:
  D.28674 = 0;
  return D.28674;
}


get_object_allow_null (int objid, struct MonoObject * * obj)
{
  ErrorCode D.28681;
  struct GHashTable * objrefs.160;
  const void * objid.161;
  unsigned int D.28688;
  struct MonoObject * D.28689;
  struct MonoObject * D.28690;
  struct ObjRef * ref;

  if (objid == 0) goto <D.28679>; else goto <D.28680>;
  <D.28679>:
  *obj = 0B;
  D.28681 = 0;
  return D.28681;
  <D.28680>:
  objrefs.160 = objrefs;
  if (objrefs.160 == 0B) goto <D.28683>; else goto <D.28684>;
  <D.28683>:
  D.28681 = 20;
  return D.28681;
  <D.28684>:
  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.28686>; else goto <D.28687>;
  <D.28686>:
  D.28688 = ref->handle;
  D.28689 = mono_gchandle_get_target (D.28688);
  *obj = D.28689;
  mono_loader_unlock ();
  D.28690 = *obj;
  if (D.28690 == 0B) goto <D.28691>; else goto <D.28692>;
  <D.28691>:
  D.28681 = 20;
  return D.28681;
  <D.28692>:
  D.28681 = 0;
  return D.28681;
  <D.28687>:
  mono_loader_unlock ();
  D.28681 = 20;
  return D.28681;
}


get_source_files_for_type (struct MonoClass * klass)
{
  struct GPtrArray * source_file_list.162;
  void * * D.28697;
  unsigned int j.163;
  unsigned int D.28699;
  void * * D.28700;
  int D.26245;
  void * * D.28701;
  unsigned int i.164;
  unsigned int D.28703;
  void * * D.28704;
  void * D.28705;
  char * D.28706;
  unsigned int i.165;
  unsigned int D.28709;
  gchar * D.28712;
  unsigned int j.166;
  unsigned int D.28714;
  struct GPtrArray * D.28715;
  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.26253>;
      <D.26252>:
      {
        struct MonoDebugMethodInfo * minfo;
        struct GPtrArray * source_file_list;

        try
          {
            minfo = mono_debug_lookup_method (method);
            if (minfo != 0B) goto <D.28694>; else goto <D.28695>;
            <D.28694>:
            mono_debug_symfile_get_line_numbers_full (minfo, 0B, &source_file_list, 0B, 0B, 0B, 0B, 0B);
            j = 0;
            goto <D.26250>;
            <D.26249>:
            source_file_list.162 = source_file_list;
            D.28697 = source_file_list.162->pdata;
            j.163 = (unsigned int) j;
            D.28699 = j.163 * 4;
            D.28700 = D.28697 + D.28699;
            sinfo = *D.28700;
            i = 0;
            goto <D.26248>;
            <D.26247>:
            {
              size_t __s1_len;
              size_t __s2_len;

              D.28701 = files->pdata;
              i.164 = (unsigned int) i;
              D.28703 = i.164 * 4;
              D.28704 = D.28701 + D.28703;
              D.28705 = *D.28704;
              D.28706 = sinfo->source_file;
              D.26245 = __builtin_strcmp (D.28705, D.28706);
            }
            if (D.26245 == 0) goto <D.26246>; else goto <D.28707>;
            <D.28707>:
            i = i + 1;
            <D.26248>:
            i.165 = (unsigned int) i;
            D.28709 = files->len;
            if (i.165 < D.28709) goto <D.26247>; else goto <D.26246>;
            <D.26246>:
            i.165 = (unsigned int) i;
            D.28709 = files->len;
            if (i.165 == D.28709) goto <D.28710>; else goto <D.28711>;
            <D.28710>:
            D.28706 = sinfo->source_file;
            D.28712 = monoeg_strdup (D.28706);
            monoeg_g_ptr_array_add (files, D.28712);
            <D.28711>:
            j = j + 1;
            <D.26250>:
            j.166 = (unsigned int) j;
            source_file_list.162 = source_file_list;
            D.28714 = source_file_list.162->len;
            if (j.166 < D.28714) goto <D.26249>; else goto <D.26251>;
            <D.26251>:
            source_file_list.162 = source_file_list;
            monoeg_g_ptr_array_free (source_file_list.162, 1);
            <D.28695>:
          }
        finally
          {
            source_file_list = {CLOBBER};
          }
      }
      <D.26253>:
      method = mono_class_get_methods (klass, &iter);
      if (method != 0B) goto <D.26252>; else goto <D.26254>;
      <D.26254>:
      D.28715 = files;
      return D.28715;
    }
  finally
    {
      iter = {CLOBBER};
    }
}


decode_string (guint8 * buf, guint8 * * endbuf, guint8 * limit)
{
  guint8 * buf.167;
  char * D.28721;
  int D.28722;
  unsigned int D.28723;
  _Bool D.28724;
  long int D.28725;
  long int D.28726;
  unsigned int len.168;
  sizetype len.169;
  char * D.28731;
  guint8 * buf.170;
  int len;
  char * s;

  buf.167 = buf;
  len = decode_int (buf.167, &buf, limit);
  if (len < 0) goto <D.28719>; else goto <D.28720>;
  <D.28719>:
  buf.167 = buf;
  *endbuf = buf.167;
  D.28721 = 0B;
  return D.28721;
  <D.28720>:
  D.28722 = len + 1;
  D.28723 = (unsigned int) D.28722;
  s = monoeg_malloc (D.28723);
  D.28724 = s == 0B;
  D.28725 = (long int) D.28724;
  D.28726 = __builtin_expect (D.28725, 0);
  if (D.28726 != 0) goto <D.28727>; else goto <D.28728>;
  <D.28727>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 1633, "s");
  <D.28728>:
  buf.167 = buf;
  len.168 = (unsigned int) len;
  memcpy (s, buf.167, len.168);
  len.169 = (sizetype) len;
  D.28731 = s + len.169;
  *D.28731 = 0;
  buf.167 = buf;
  len.169 = (sizetype) len;
  buf.170 = buf.167 + len.169;
  buf = buf.170;
  buf.167 = buf;
  *endbuf = buf.167;
  D.28721 = s;
  return D.28721;
}


event_commands (int command, guint8 * p, guint8 * end, struct Buffer * buf)
{
  guint8 * p.171;
  unsigned int nmodifiers.172;
  unsigned int D.28736;
  unsigned int D.28737;
  int D.28738;
  <unnamed type> mod.173;
  int D.28742;
  int err.174;
  ErrorCode D.28749;
  long long int D.28750;
  int protocol_version_set.175;
  int major_version.176;
  int minor_version.177;
  <unnamed type> filter.178;
  <unnamed type> D.28769;
  unsigned int D.28770;
  unsigned int D.28773;
  struct MonoInternalThread * * D.28777;
  <unnamed type> D.28778;
  int err.179;
  int D.28787;
  int D.28788;
  int D.28795;
  int log_level.180;
  _Bool D.28797;
  long int D.28798;
  long int D.28799;
  struct FILE * log_file.181;
  const char * iftmp.182;
  const char * iftmp.183;
  int D.28808;
  const char * iftmp.184;
  int D.28813;
  const char * iftmp.185;
  int D.28818;
  struct MonoClass * D.28824;
  int D.28825;
  unsigned int n.186;
  unsigned int D.28832;
  void * D.28833;
  struct MonoAssembly * * D.28834;
  unsigned int j.187;
  unsigned int D.28836;
  struct MonoAssembly * * D.28837;
  struct MonoAssembly * D.28838;
  struct GHashTable * D.28844;
  struct GHashTable * D.28847;
  struct GHashTable * D.28851;
  struct GHashTable * D.28854;
  int D.28856;
  _Bool D.28859;
  long int D.28860;
  long int D.28861;
  struct MonoBreakpoint * D.28864;
  int D.28865;
  const char * D.28870;
  _Bool D.28874;
  long int D.28875;
  long int D.28876;
  <unnamed type> D.28879;
  int err.188;
  struct MonoThread * step_thread.189;
  struct _MonoInternalThread * D.28884;
  <unnamed type> size.190;
  <unnamed type> depth.191;
  <unnamed type> D.28887;
  int err.192;
  struct MonoBreakpoint * D.28894;
  struct MonoBreakpoint * D.28898;
  int D.28906;
  struct GPtrArray * event_requests.193;
  int D.28910;
  struct GHashTable * domains.194;
  struct MonoGHashTable * tid_to_thread.195;
  int D.28915;
  unsigned int D.28916;
  void * * D.28917;
  unsigned int i.196;
  unsigned int D.28919;
  void * * D.28920;
  int D.28921;
  void * D.28924;
  unsigned int i.197;
  unsigned int D.28927;
  int err;
  struct MonoError error;

  try
    {
      switch (command) <default: <D.26438>, case 1: <D.26383>, case 2: <D.26429>, case 3: <D.26432>>
      <D.26383>:
      {
        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.28736 = nmodifiers.172 + 1;
            D.28737 = D.28736 * 20;
            req = monoeg_malloc0 (D.28737);
            D.28738 = InterlockedIncrement (&event_request_id);
            req->id = D.28738;
            req->event_kind = event_kind;
            req->suspend_policy = suspend_policy;
            req->nmodifiers = nmodifiers;
            method = 0B;
            i = 0;
            goto <D.26420>;
            <D.26419>:
            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.28740>; else goto <D.28741>;
            <D.28740>:
            p.171 = p;
            D.28742 = decode_int (p.171, &p, end);
            req->modifiers[i].data.count = D.28742;
            goto <D.28743>;
            <D.28741>:
            if (mod == 7) goto <D.28744>; else goto <D.28745>;
            <D.28744>:
            p.171 = p;
            method = decode_methodid (p.171, &p, end, &domain, &err);
            err.174 = err;
            if (err.174 != 0) goto <D.28747>; else goto <D.28748>;
            <D.28747>:
            err.174 = err;
            D.28749 = (ErrorCode) err.174;
            return D.28749;
            <D.28748>:
            p.171 = p;
            D.28750 = decode_long (p.171, &p, end);
            location = (long int) D.28750;
            goto <D.28751>;
            <D.28745>:
            if (mod == 10) goto <D.28752>; else goto <D.28753>;
            <D.28752>:
            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.28757>; else goto <D.28758>;
            <D.28757>:
            major_version.176 = major_version;
            if (major_version.176 > 2) goto <D.28754>; else goto <D.28760>;
            <D.28760>:
            major_version.176 = major_version;
            if (major_version.176 == 2) goto <D.28761>; else goto <D.28755>;
            <D.28761>:
            minor_version.177 = minor_version;
            if (minor_version.177 > 15) goto <D.28754>; else goto <D.28755>;
            <D.28754>:
            p.171 = p;
            filter = decode_int (p.171, &p, end);
            <D.28755>:
            <D.28758>:
            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.28764>; else goto <D.28766>;
            <D.28766>:
            major_version.176 = major_version;
            if (major_version.176 <= 2) goto <D.28767>; else goto <D.28765>;
            <D.28767>:
            major_version.176 = major_version;
            if (major_version.176 != 2) goto <D.28764>; else goto <D.28768>;
            <D.28768>:
            minor_version.177 = minor_version;
            if (minor_version.177 <= 25) goto <D.28764>; else goto <D.28765>;
            <D.28764>:
            D.28769 = req->modifiers[i].data.filter;
            D.28770 = D.28769 & 2;
            if (D.28770 != 0) goto <D.28771>; else goto <D.28772>;
            <D.28771>:
            D.28769 = req->modifiers[i].data.filter;
            D.28773 = D.28769 | 4;
            req->modifiers[i].data.filter = D.28773;
            <D.28772>:
            <D.28765>:
            goto <D.28774>;
            <D.28753>:
            if (mod == 3) goto <D.28775>; else goto <D.28776>;
            <D.28775>:
            {
              int id;

              p.171 = p;
              id = decode_id (p.171, &p, end);
              D.28777 = &req->modifiers[i].data.thread;
              D.28778 = get_object (id, D.28777);
              err.179 = (int) D.28778;
              err = err.179;
              err.174 = err;
              if (err.174 != 0) goto <D.28780>; else goto <D.28781>;
              <D.28780>:
              monoeg_g_free (req);
              err.174 = err;
              D.28749 = (ErrorCode) err.174;
              return D.28749;
              <D.28781>:
            }
            goto <D.28782>;
            <D.28776>:
            if (mod == 8) goto <D.28783>; else goto <D.28784>;
            <D.28783>:
            {
              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.28785>; else goto <D.28786>;
              <D.28785>:
              err.174 = err;
              D.28749 = (ErrorCode) err.174;
              return D.28749;
              <D.28786>:
              p.171 = p;
              D.28787 = decode_byte (p.171, &p, end);
              req->modifiers[i].caught = D.28787;
              p.171 = p;
              D.28788 = decode_byte (p.171, &p, end);
              req->modifiers[i].uncaught = D.28788;
              protocol_version_set.175 = protocol_version_set;
              if (protocol_version_set.175 != 0) goto <D.28792>; else goto <D.28789>;
              <D.28792>:
              major_version.176 = major_version;
              if (major_version.176 > 2) goto <D.28790>; else goto <D.28793>;
              <D.28793>:
              major_version.176 = major_version;
              if (major_version.176 == 2) goto <D.28794>; else goto <D.28789>;
              <D.28794>:
              minor_version.177 = minor_version;
              if (minor_version.177 > 24) goto <D.28790>; else goto <D.28789>;
              <D.28790>:
              p.171 = p;
              D.28795 = decode_byte (p.171, &p, end);
              req->modifiers[i].subclasses = D.28795;
              goto <D.28791>;
              <D.28789>:
              req->modifiers[i].subclasses = 1;
              <D.28791>:
              log_level.180 = log_level;
              D.28797 = log_level.180 > 0;
              D.28798 = (long int) D.28797;
              D.28799 = __builtin_expect (D.28798, 0);
              if (D.28799 != 0) goto <D.28800>; else goto <D.28801>;
              <D.28800>:
              log_file.181 = log_file;
              if (exc_class != 0B) goto <D.28804>; else goto <D.28805>;
              <D.28804>:
              iftmp.182 = exc_class->name;
              goto <D.28806>;
              <D.28805>:
              iftmp.182 = "all";
              <D.28806>:
              D.28808 = req->modifiers[i].caught;
              if (D.28808 != 0) goto <D.28809>; else goto <D.28810>;
              <D.28809>:
              iftmp.183 = ", caught";
              goto <D.28811>;
              <D.28810>:
              iftmp.183 = "";
              <D.28811>:
              D.28813 = req->modifiers[i].uncaught;
              if (D.28813 != 0) goto <D.28814>; else goto <D.28815>;
              <D.28814>:
              iftmp.184 = ", uncaught";
              goto <D.28816>;
              <D.28815>:
              iftmp.184 = "";
              <D.28816>:
              D.28818 = req->modifiers[i].subclasses;
              if (D.28818 != 0) goto <D.28819>; else goto <D.28820>;
              <D.28819>:
              iftmp.185 = ", include-subclasses";
              goto <D.28821>;
              <D.28820>:
              iftmp.185 = "";
              <D.28821>:
              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.28801>:
              if (exc_class != 0B) goto <D.28822>; else goto <D.28823>;
              <D.28822>:
              req->modifiers[i].data.exc_class = exc_class;
              D.28824 = mono_defaults.exception_class;
              D.28825 = mono_class_is_assignable_from (D.28824, exc_class);
              if (D.28825 == 0) goto <D.28826>; else goto <D.28827>;
              <D.28826>:
              monoeg_g_free (req);
              D.28749 = 102;
              return D.28749;
              <D.28827>:
              <D.28823>:
            }
            goto <D.28828>;
            <D.28784>:
            if (mod == 11) goto <D.28829>; else goto <D.28830>;
            <D.28829>:
            {
              int n;
              int j;

              p.171 = p;
              n = decode_int (p.171, &p, end);
              n.186 = (unsigned int) n;
              D.28832 = n.186 * 4;
              D.28833 = monoeg_malloc0 (D.28832);
              req->modifiers[i].data.assemblies = D.28833;
              j = 0;
              goto <D.26404>;
              <D.26403>:
              D.28834 = req->modifiers[i].data.assemblies;
              j.187 = (unsigned int) j;
              D.28836 = j.187 * 4;
              D.28837 = D.28834 + D.28836;
              p.171 = p;
              D.28838 = decode_assemblyid (p.171, &p, end, &domain, &err);
              *D.28837 = D.28838;
              err.174 = err;
              if (err.174 != 0) goto <D.28839>; else goto <D.28840>;
              <D.28839>:
              D.28834 = req->modifiers[i].data.assemblies;
              monoeg_g_free (D.28834);
              err.174 = err;
              D.28749 = (ErrorCode) err.174;
              return D.28749;
              <D.28840>:
              j = j + 1;
              <D.26404>:
              if (j < n) goto <D.26403>; else goto <D.26405>;
              <D.26405>:
            }
            goto <D.28841>;
            <D.28830>:
            if (mod == 12) goto <D.28842>; else goto <D.28843>;
            <D.28842>:
            {
              int n;
              int j;

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

                p.171 = p;
                s = decode_string (p.171, &p, end);
                if (s != 0B) goto <D.28845>; else goto <D.28846>;
                <D.28845>:
                s2 = strdup_tolower (s);
                D.28847 = modifier->data.source_files;
                monoeg_g_hash_table_insert_replace (D.28847, s2, s2, 0);
                monoeg_g_free (s);
                <D.28846>:
              }
              j = j + 1;
              <D.26411>:
              if (j < n) goto <D.26410>; else goto <D.26412>;
              <D.26412>:
            }
            goto <D.28848>;
            <D.28843>:
            if (mod == 13) goto <D.28849>; else goto <D.28850>;
            <D.28849>:
            {
              int n;
              int j;

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

                p.171 = p;
                s = decode_string (p.171, &p, end);
                if (s != 0B) goto <D.28852>; else goto <D.28853>;
                <D.28852>:
                D.28854 = modifier->data.type_names;
                monoeg_g_hash_table_insert_replace (D.28854, s, s, 0);
                <D.28853>:
              }
              j = j + 1;
              <D.26417>:
              if (j < n) goto <D.26416>; else goto <D.26418>;
              <D.26418>:
            }
            goto <D.28855>;
            <D.28850>:
            monoeg_g_free (req);
            D.28749 = 100;
            return D.28749;
            <D.28855>:
            <D.28848>:
            <D.28841>:
            <D.28828>:
            <D.28782>:
            <D.28774>:
            <D.28751>:
            <D.28743>:
            i = i + 1;
            <D.26420>:
            if (i < nmodifiers) goto <D.26419>; else goto <D.26421>;
            <D.26421>:
            D.28856 = req->event_kind;
            if (D.28856 == 10) goto <D.28857>; else goto <D.28858>;
            <D.28857>:
            D.28859 = method == 0B;
            D.28860 = (long int) D.28859;
            D.28861 = __builtin_expect (D.28860, 0);
            if (D.28861 != 0) goto <D.28862>; else goto <D.28863>;
            <D.28862>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 7086, "method");
            <D.28863>:
            D.28864 = set_breakpoint (method, location, req, &error);
            req->info = D.28864;
            D.28865 = mono_error_ok (&error);
            if (D.28865 == 0) goto <D.28866>; else goto <D.28867>;
            <D.28866>:
            monoeg_g_free (req);
            log_level.180 = log_level;
            D.28797 = log_level.180 > 0;
            D.28798 = (long int) D.28797;
            D.28799 = __builtin_expect (D.28798, 0);
            if (D.28799 != 0) goto <D.28868>; else goto <D.28869>;
            <D.28868>:
            log_file.181 = log_file;
            D.28870 = mono_error_get_message (&error);
            fprintf (log_file.181, "[dbg] Failed to set breakpoint: %s\n", D.28870);
            log_file.181 = log_file;
            fflush (log_file.181);
            <D.28869>:
            mono_error_cleanup (&error);
            D.28749 = 106;
            return D.28749;
            <D.28867>:
            goto <D.28871>;
            <D.28858>:
            D.28856 = req->event_kind;
            if (D.28856 == 11) goto <D.28872>; else goto <D.28873>;
            <D.28872>:
            D.28874 = step_thread_id == 0;
            D.28875 = (long int) D.28874;
            D.28876 = __builtin_expect (D.28875, 0);
            if (D.28876 != 0) goto <D.28877>; else goto <D.28878>;
            <D.28877>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 7096, "step_thread_id");
            <D.28878>:
            D.28879 = get_object (step_thread_id, &step_thread);
            err.188 = (int) D.28879;
            err = err.188;
            err.174 = err;
            if (err.174 != 0) goto <D.28881>; else goto <D.28882>;
            <D.28881>:
            monoeg_g_free (req);
            err.174 = err;
            D.28749 = (ErrorCode) err.174;
            return D.28749;
            <D.28882>:
            step_thread.189 = step_thread;
            D.28884 = step_thread.189->internal_thread;
            size.190 = (<unnamed type>) size;
            depth.191 = (<unnamed type>) depth;
            D.28887 = ss_create (D.28884, size.190, depth.191, req);
            err.192 = (int) D.28887;
            err = err.192;
            err.174 = err;
            if (err.174 != 0) goto <D.28889>; else goto <D.28890>;
            <D.28889>:
            monoeg_g_free (req);
            err.174 = err;
            D.28749 = (ErrorCode) err.174;
            return D.28749;
            <D.28890>:
            goto <D.28891>;
            <D.28873>:
            D.28856 = req->event_kind;
            if (D.28856 == 6) goto <D.28892>; else goto <D.28893>;
            <D.28892>:
            D.28894 = set_breakpoint (0B, -1, req, 0B);
            req->info = D.28894;
            goto <D.28895>;
            <D.28893>:
            D.28856 = req->event_kind;
            if (D.28856 == 7) goto <D.28896>; else goto <D.28897>;
            <D.28896>:
            D.28898 = set_breakpoint (0B, 16777215, req, 0B);
            req->info = D.28898;
            goto <D.28899>;
            <D.28897>:
            D.28856 = req->event_kind;
            if (D.28856 == 13) goto <D.28900>; else goto <D.28901>;
            <D.28900>:
            goto <D.28902>;
            <D.28901>:
            D.28856 = req->event_kind;
            if (D.28856 == 12) goto <D.28903>; else goto <D.28904>;
            <D.28903>:
            goto <D.28905>;
            <D.28904>:
            D.28906 = req->nmodifiers;
            if (D.28906 != 0) goto <D.28907>; else goto <D.28908>;
            <D.28907>:
            monoeg_g_free (req);
            D.28749 = 100;
            return D.28749;
            <D.28908>:
            <D.28905>:
            <D.28902>:
            <D.28899>:
            <D.28895>:
            <D.28891>:
            <D.28871>:
            mono_loader_lock ();
            event_requests.193 = event_requests;
            monoeg_g_ptr_array_add (event_requests.193, req);
            D.28910 = agent_config.defer;
            if (D.28910 != 0) goto <D.28911>; else goto <D.28912>;
            <D.28911>:
            D.28856 = req->event_kind;
            switch (D.28856) <default: <D.26427>, case 2: <D.26425>, case 4: <D.26422>, case 8: <D.26424>, case 12: <D.26426>>
            <D.26422>:
            domains.194 = domains;
            monoeg_g_hash_table_foreach (domains.194, emit_appdomain_load, 0B);
            goto <D.26423>;
            <D.26424>:
            mono_assembly_foreach (emit_assembly_load, 0B);
            goto <D.26423>;
            <D.26425>:
            tid_to_thread.195 = tid_to_thread;
            mono_g_hash_table_foreach (tid_to_thread.195, emit_thread_start, 0B);
            goto <D.26423>;
            <D.26426>:
            mono_domain_foreach (send_types_for_domain, 0B);
            goto <D.26423>;
            <D.26427>:
            goto <D.26423>;
            <D.26423>:
            <D.28912>:
            mono_loader_unlock ();
            D.28915 = req->id;
            D.28916 = (unsigned int) D.28915;
            buffer_add_int (buf, D.28916);
            goto <D.26428>;
          }
        finally
          {
            step_thread = {CLOBBER};
            domain = {CLOBBER};
          }
      }
      <D.26429>:
      {
        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.26428>;
      }
      <D.26432>:
      {
        int i;

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

          event_requests.193 = event_requests;
          D.28917 = event_requests.193->pdata;
          i.196 = (unsigned int) i;
          D.28919 = i.196 * 4;
          D.28920 = D.28917 + D.28919;
          req = *D.28920;
          D.28921 = req->event_kind;
          if (D.28921 == 10) goto <D.28922>; else goto <D.28923>;
          <D.28922>:
          D.28924 = req->info;
          clear_breakpoint (D.28924);
          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.28926>;
          <D.28923>:
          i = i + 1;
          <D.28926>:
        }
        <D.26436>:
        i.197 = (unsigned int) i;
        event_requests.193 = event_requests;
        D.28927 = event_requests.193->len;
        if (i.197 < D.28927) goto <D.26435>; else goto <D.26437>;
        <D.26437>:
        mono_loader_unlock ();
        goto <D.26428>;
      }
      <D.26438>:
      D.28749 = 100;
      return D.28749;
      <D.26428>:
      D.28749 = 0;
      return D.28749;
    }
  finally
    {
      err = {CLOBBER};
      error = {CLOBBER};
    }
}


send_types_for_domain (struct MonoDomain * domain, void * user_data)
{
  union mono_mutex_t * D.28933;
  _Bool D.28936;
  long int D.28937;
  long int D.28938;
  _Bool D.28941;
  long int D.28942;
  long int D.28943;
  struct GHashTable * D.28946;
  _Bool D.28949;
  long int D.28950;
  long int D.28951;
  struct AgentDomainInfo * info;

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

    D.28933 = &domain->lock.mutex;
    ret = pthread_mutex_lock (D.28933);
    if (ret != 0) goto <D.28934>; else goto <D.28935>;
    <D.28934>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.28935>:
    D.28936 = ret != 0;
    D.28937 = (long int) D.28936;
    D.28938 = __builtin_expect (D.28937, 0);
    if (D.28938 != 0) goto <D.28939>; else goto <D.28940>;
    <D.28939>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 4009, "ret == 0");
    <D.28940>:
  }
  info = get_agent_domain_info (domain);
  D.28941 = info == 0B;
  D.28942 = (long int) D.28941;
  D.28943 = __builtin_expect (D.28942, 0);
  if (D.28943 != 0) goto <D.28944>; else goto <D.28945>;
  <D.28944>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 4011, "info");
  <D.28945>:
  D.28946 = info->loaded_classes;
  monoeg_g_hash_table_foreach (D.28946, emit_type_load, 0B);
  {
    int ret;

    D.28933 = &domain->lock.mutex;
    ret = pthread_mutex_unlock (D.28933);
    if (ret != 0) goto <D.28947>; else goto <D.28948>;
    <D.28947>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.28948>:
    D.28949 = ret != 0;
    D.28950 = (long int) D.28949;
    D.28951 = __builtin_expect (D.28950, 0);
    if (D.28951 != 0) goto <D.28952>; else goto <D.28953>;
    <D.28952>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 4013, "ret == 0");
    <D.28953>:
  }
  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.28956>; else goto <D.28957>;
  <D.28956>:
  process_profiler_event (2, value);
  <D.28957>:
}


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.28958;
  struct GHashTable * D.28959;

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


InterlockedIncrement (volatile gint32 * val)
{
  gint32 D.28960;
  unsigned int D.28961;

  D.28961 = __sync_add_and_fetch_4 (val, 1);
  D.28960 = (gint32) D.28961;
  return D.28960;
}


decode_methodid (guint8 * buf, guint8 * * endbuf, guint8 * limit, struct MonoDomain * * domain, int * err)
{
  int log_level.200;
  _Bool D.28964;
  long int D.28965;
  long int D.28966;
  struct FILE * log_file.201;
  struct MonoMethod * D.28974;
  struct MonoMethod * m;

  m = decode_ptr_id (buf, endbuf, limit, 3, domain, err);
  log_level.200 = log_level;
  D.28964 = log_level.200 > 1;
  D.28965 = (long int) D.28964;
  D.28966 = __builtin_expect (D.28965, 0);
  if (D.28966 != 0) goto <D.28967>; else goto <D.28968>;
  <D.28967>:
  if (m != 0B) goto <D.28969>; else goto <D.28970>;
  <D.28969>:
  {
    char * s;

    s = mono_method_full_name (m, 1);
    log_level.200 = log_level;
    D.28964 = log_level.200 > 1;
    D.28965 = (long int) D.28964;
    D.28966 = __builtin_expect (D.28965, 0);
    if (D.28966 != 0) goto <D.28971>; else goto <D.28972>;
    <D.28971>:
    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.28972>:
    monoeg_g_free (s);
  }
  <D.28970>:
  <D.28968>:
  D.28974 = m;
  return D.28974;
}


decode_ptr_id (guint8 * buf, guint8 * * endbuf, guint8 * limit, IdType type, struct MonoDomain * * domain, int * err)
{
  void * D.28980;
  int iftmp.202;
  unsigned int id.203;
  struct GPtrArray * D.28987;
  unsigned int D.28988;
  _Bool D.28989;
  long int D.28990;
  long int D.28991;
  void * * D.28994;
  sizetype id.204;
  sizetype D.28996;
  sizetype D.28997;
  void * * D.28998;
  struct MonoDomain * D.28999;
  struct Id * res;
  int id;

  id = decode_id (buf, endbuf, limit);
  *err = 0;
  if (domain != 0B) goto <D.28976>; else goto <D.28977>;
  <D.28976>:
  *domain = 0B;
  <D.28977>:
  if (id == 0) goto <D.28978>; else goto <D.28979>;
  <D.28978>:
  D.28980 = 0B;
  return D.28980;
  <D.28979>:
  mono_loader_lock ();
  if (id <= 0) goto <D.28982>; else goto <D.28985>;
  <D.28985>:
  id.203 = (unsigned int) id;
  D.28987 = ids[type];
  D.28988 = D.28987->len;
  if (id.203 > D.28988) goto <D.28982>; else goto <D.28983>;
  <D.28982>:
  iftmp.202 = 1;
  goto <D.28984>;
  <D.28983>:
  iftmp.202 = 0;
  <D.28984>:
  D.28989 = iftmp.202 != 0;
  D.28990 = (long int) D.28989;
  D.28991 = __builtin_expect (D.28990, 0);
  if (D.28991 != 0) goto <D.28992>; else goto <D.28993>;
  <D.28992>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 2196, "id > 0 && id <= ids [type]->len");
  <D.28993>:
  D.28987 = ids[type];
  D.28994 = D.28987->pdata;
  id.204 = (sizetype) id;
  D.28996 = id.204 + 1073741823;
  D.28997 = D.28996 * 4;
  D.28998 = D.28994 + D.28997;
  res = *D.28998;
  mono_loader_unlock ();
  D.28999 = res->domain;
  if (D.28999 == 0B) goto <D.29000>; else goto <D.29001>;
  <D.29000>:
  *err = 103;
  D.28980 = 0B;
  return D.28980;
  <D.29001>:
  if (domain != 0B) goto <D.29002>; else goto <D.29003>;
  <D.29002>:
  D.28999 = res->domain;
  *domain = D.28999;
  <D.29003>:
  D.28980 = res->data.val;
  return D.28980;
}


decode_long (guint8 * buf, guint8 * * endbuf, guint8 * limit)
{
  guint8 * buf.205;
  int D.29006;
  int D.29007;
  gint64 D.29008;
  long long unsigned int D.29009;
  long long unsigned int D.29010;
  long long unsigned int D.29011;
  long long unsigned int D.29012;
  guint32 high;
  guint32 low;

  buf.205 = buf;
  D.29006 = decode_int (buf.205, &buf, limit);
  high = (guint32) D.29006;
  buf.205 = buf;
  D.29007 = decode_int (buf.205, &buf, limit);
  low = (guint32) D.29007;
  buf.205 = buf;
  *endbuf = buf.205;
  D.29009 = (long long unsigned int) high;
  D.29010 = D.29009 << 32;
  D.29011 = (long long unsigned int) low;
  D.29012 = D.29010 | D.29011;
  D.29008 = (gint64) D.29012;
  return D.29008;
}


decode_typeid (guint8 * buf, guint8 * * endbuf, guint8 * limit, struct MonoDomain * * domain, int * err)
{
  int log_level.206;
  _Bool D.29015;
  long int D.29016;
  long int D.29017;
  struct MonoType * D.29022;
  struct FILE * log_file.207;
  struct MonoClass * D.29026;
  struct MonoClass * klass;

  klass = decode_ptr_id (buf, endbuf, limit, 2, domain, err);
  log_level.206 = log_level;
  D.29015 = log_level.206 > 1;
  D.29016 = (long int) D.29015;
  D.29017 = __builtin_expect (D.29016, 0);
  if (D.29017 != 0) goto <D.29018>; else goto <D.29019>;
  <D.29018>:
  if (klass != 0B) goto <D.29020>; else goto <D.29021>;
  <D.29020>:
  {
    char * s;

    D.29022 = &klass->byval_arg;
    s = mono_type_full_name (D.29022);
    log_level.206 = log_level;
    D.29015 = log_level.206 > 1;
    D.29016 = (long int) D.29015;
    D.29017 = __builtin_expect (D.29016, 0);
    if (D.29017 != 0) goto <D.29023>; else goto <D.29024>;
    <D.29023>:
    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.29024>:
    monoeg_g_free (s);
  }
  <D.29021>:
  <D.29019>:
  D.29026 = klass;
  return D.29026;
}


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

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


ss_create (struct MonoInternalThread * thread, StepSize size, StepDepth depth, struct EventRequest * req)
{
  int suspend_count.208;
  ErrorCode D.29033;
  struct SingleStepReq * ss_req.209;
  int log_level.210;
  _Bool D.29038;
  long int D.29039;
  long int D.29040;
  struct FILE * log_file.211;
  _Bool D.29044;
  long int D.29045;
  long int D.29046;
  const char * D.29049;
  void * ss_req.212;
  struct MonoGHashTable * thread_to_tls.213;
  _Bool D.29052;
  long int D.29053;
  long int D.29054;
  int D.29057;
  _Bool D.29058;
  long int D.29059;
  long int D.29060;
  int D.29063;
  void * D.29064;
  void * D.29065;
  int D.29066;
  void * D.29069;
  void * D.29070;
  struct MonoContext * D.29071;
  _Bool D.29072;
  long int D.29073;
  long int D.29074;
  <unnamed type> D.29077;
  _Bool D.29078;
  long int D.29079;
  long int D.29080;
  struct MonoDomain * D.29083;
  struct MonoMethod * D.29084;
  int D.29085;
  _Bool D.29088;
  long int D.29089;
  long int D.29090;
  <unnamed type> D.29095;
  int D.29098;
  struct StackFrame * * D.29101;
  struct MonoMethod * D.29102;
  unsigned int D.29105;
  unsigned int D.29110;
  int D.29111;
  unsigned int D.29118;
  struct MonoDomain * D.29121;
  struct MonoMethod * D.29122;
  unsigned int D.29123;
  int D.29124;
  struct MonoSeqPointInfo * info.214;
  struct MonoContext * D.29130;
  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.29031>; else goto <D.29032>;
      <D.29031>:
      D.29033 = 101;
      return D.29033;
      <D.29032>:
      wait_for_suspend ();
      ss_req.209 = ss_req;
      if (ss_req.209 != 0B) goto <D.29035>; else goto <D.29036>;
      <D.29035>:
      log_level.210 = log_level;
      D.29038 = log_level.210 >= 0;
      D.29039 = (long int) D.29038;
      D.29040 = __builtin_expect (D.29039, 0);
      if (D.29040 != 0) goto <D.29041>; else goto <D.29042>;
      <D.29041>:
      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.29042>:
      D.29033 = 100;
      return D.29033;
      <D.29036>:
      log_level.210 = log_level;
      D.29044 = log_level.210 > 0;
      D.29045 = (long int) D.29044;
      D.29046 = __builtin_expect (D.29045, 0);
      if (D.29046 != 0) goto <D.29047>; else goto <D.29048>;
      <D.29047>:
      log_file.211 = log_file;
      D.29049 = ss_depth_to_string (depth);
      fprintf (log_file.211, "[dbg] Starting single step of thread %p (depth=%s).\n", thread, D.29049);
      log_file.211 = log_file;
      fflush (log_file.211);
      <D.29048>:
      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.29052 = tls == 0B;
      D.29053 = (long int) D.29052;
      D.29054 = __builtin_expect (D.29053, 0);
      if (D.29054 != 0) goto <D.29055>; else goto <D.29056>;
      <D.29055>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 5168, "tls");
      <D.29056>:
      D.29057 = tls->context.valid;
      D.29058 = D.29057 == 0;
      D.29059 = (long int) D.29058;
      D.29060 = __builtin_expect (D.29059, 0);
      if (D.29060 != 0) goto <D.29061>; else goto <D.29062>;
      <D.29061>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 5169, "tls->context.valid");
      <D.29062>:
      ss_req.209 = ss_req;
      ss_req.209 = ss_req;
      D.29063 = tls->context.ctx.sc_regs[29];
      D.29064 = (void *) D.29063;
      ss_req.209->last_sp = D.29064;
      D.29065 = ss_req.209->last_sp;
      ss_req.209->start_sp = D.29065;
      D.29066 = tls->catch_state.valid;
      if (D.29066 != 0) goto <D.29067>; else goto <D.29068>;
      <D.29067>:
      {
        gboolean res;
        struct StackFrameInfo frame;
        struct MonoContext new_ctx;
        struct MonoLMF * lmf;

        try
          {
            lmf = 0B;
            D.29069 = tls->catch_state.unwind_data[0];
            D.29070 = thread->jit_data;
            D.29071 = &tls->catch_state.ctx;
            res = mono_find_jit_info_ext (D.29069, D.29070, 0B, D.29071, &new_ctx, 0B, &lmf, 0B, &frame);
            D.29072 = res == 0;
            D.29073 = (long int) D.29072;
            D.29074 = __builtin_expect (D.29073, 0);
            if (D.29074 != 0) goto <D.29075>; else goto <D.29076>;
            <D.29075>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 5184, "res");
            <D.29076>:
            D.29077 = frame.type;
            D.29078 = D.29077 != 0;
            D.29079 = (long int) D.29078;
            D.29080 = __builtin_expect (D.29079, 0);
            if (D.29080 != 0) goto <D.29081>; else goto <D.29082>;
            <D.29081>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 5185, "frame.type == FRAME_TYPE_MANAGED");
            <D.29082>:
            D.29083 = frame.domain;
            D.29084 = frame.method;
            D.29085 = frame.native_offset;
            sp = find_next_seq_point_for_native_offset (D.29083, D.29084, D.29085, &info);
            if (sp == 0B) goto <D.29086>; else goto <D.29087>;
            <D.29086>:
            D.29084 = frame.method;
            no_seq_points_found (D.29084);
            <D.29087>:
            D.29088 = sp == 0B;
            D.29089 = (long int) D.29088;
            D.29090 = __builtin_expect (D.29089, 0);
            if (D.29090 != 0) goto <D.29091>; else goto <D.29092>;
            <D.29091>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 5194, "sp");
            <D.29092>:
            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.29068>:
      if (step_to_catch == 0) goto <D.29093>; else goto <D.29094>;
      <D.29093>:
      ss_req.209 = ss_req;
      D.29095 = ss_req.209->size;
      if (D.29095 == 1) goto <D.29096>; else goto <D.29097>;
      <D.29096>:
      {
        struct StackFrame * frame;

        compute_frame_info (thread, tls);
        D.29098 = tls->frame_count;
        if (D.29098 != 0) goto <D.29099>; else goto <D.29100>;
        <D.29099>:
        D.29101 = tls->frames;
        frame = *D.29101;
        ss_req.209 = ss_req;
        D.29102 = frame->method;
        ss_req.209->last_method = D.29102;
        ss_req.209 = ss_req;
        ss_req.209->last_line = -1;
        D.29102 = frame->method;
        minfo = mono_debug_lookup_method (D.29102);
        if (minfo != 0B) goto <D.29103>; else goto <D.29104>;
        <D.29103>:
        D.29105 = frame->il_offset;
        if (D.29105 != 4294967295) goto <D.29106>; else goto <D.29107>;
        <D.29106>:
        {
          struct MonoDebugSourceLocation * loc;

          D.29105 = frame->il_offset;
          loc = mono_debug_symfile_lookup_location (minfo, D.29105);
          if (loc != 0B) goto <D.29108>; else goto <D.29109>;
          <D.29108>:
          ss_req.209 = ss_req;
          D.29110 = loc->row;
          D.29111 = (int) D.29110;
          ss_req.209->last_line = D.29111;
          monoeg_g_free (loc);
          <D.29109>:
        }
        <D.29107>:
        <D.29104>:
        <D.29100>:
      }
      <D.29097>:
      <D.29094>:
      if (step_to_catch == 0) goto <D.29112>; else goto <D.29113>;
      <D.29112>:
      {
        struct StackFrame * frame;

        compute_frame_info (thread, tls);
        D.29098 = tls->frame_count;
        if (D.29098 != 0) goto <D.29114>; else goto <D.29115>;
        <D.29114>:
        D.29101 = tls->frames;
        frame = *D.29101;
        if (method == 0B) goto <D.29116>; else goto <D.29117>;
        <D.29116>:
        D.29118 = frame->il_offset;
        if (D.29118 != 4294967295) goto <D.29119>; else goto <D.29120>;
        <D.29119>:
        D.29121 = frame->domain;
        D.29122 = frame->method;
        D.29123 = frame->native_offset;
        D.29124 = (int) D.29123;
        sp = find_prev_seq_point_for_native_offset (D.29121, D.29122, D.29124, &info);
        if (sp == 0B) goto <D.29125>; else goto <D.29126>;
        <D.29125>:
        D.29122 = frame->method;
        no_seq_points_found (D.29122);
        <D.29126>:
        D.29088 = sp == 0B;
        D.29089 = (long int) D.29088;
        D.29090 = __builtin_expect (D.29089, 0);
        if (D.29090 != 0) goto <D.29127>; else goto <D.29128>;
        <D.29127>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 5240, "sp");
        <D.29128>:
        method = frame->method;
        <D.29120>:
        <D.29117>:
        <D.29115>:
      }
      <D.29113>:
      ss_req.209 = ss_req;
      info.214 = info;
      D.29130 = &tls->context.ctx;
      ss_start (ss_req.209, method, sp, info.214, D.29130, tls, step_to_catch);
      D.29033 = 0;
      return D.29033;
    }
  finally
    {
      info = {CLOBBER};
    }
}


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

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


find_next_seq_point_for_native_offset (struct MonoDomain * domain, struct MonoMethod * method, gint32 native_offset, struct MonoSeqPointInfo * * info)
{
  struct SeqPoint * D.29139;
  _Bool D.29140;
  long int D.29141;
  long int D.29142;
  int D.29147;
  int D.29150;
  struct MonoSeqPointInfo * seq_points;
  int i;

  seq_points = get_seq_points (domain, method);
  if (seq_points == 0B) goto <D.29135>; else goto <D.29136>;
  <D.29135>:
  if (info != 0B) goto <D.29137>; else goto <D.29138>;
  <D.29137>:
  *info = 0B;
  <D.29138>:
  D.29139 = 0B;
  return D.29139;
  <D.29136>:
  D.29140 = seq_points == 0B;
  D.29141 = (long int) D.29140;
  D.29142 = __builtin_expect (D.29141, 0);
  if (D.29142 != 0) goto <D.29143>; else goto <D.29144>;
  <D.29143>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 3028, "seq_points");
  <D.29144>:
  if (info != 0B) goto <D.29145>; else goto <D.29146>;
  <D.29145>:
  *info = seq_points;
  <D.29146>:
  i = 0;
  goto <D.25138>;
  <D.25137>:
  D.29147 = seq_points->seq_points[i].native_offset;
  if (D.29147 >= native_offset) goto <D.29148>; else goto <D.29149>;
  <D.29148>:
  D.29139 = &seq_points->seq_points[i];
  return D.29139;
  <D.29149>:
  i = i + 1;
  <D.25138>:
  D.29150 = seq_points->len;
  if (D.29150 > i) goto <D.25137>; else goto <D.25139>;
  <D.25139>:
  D.29139 = 0B;
  return D.29139;
}


get_seq_points (struct MonoDomain * domain, struct MonoMethod * method)
{
  union mono_mutex_t * D.29152;
  _Bool D.29155;
  long int D.29156;
  long int D.29157;
  void * D.29160;
  struct GHashTable * D.29161;
  unsigned int D.29164;
  unsigned int D.29165;
  struct MonoMethod * D.29168;
  struct MonoMethod * D.29171;
  _Bool D.29174;
  long int D.29175;
  long int D.29176;
  struct MonoSeqPointInfo * D.29179;
  struct MonoSeqPointInfo * seq_points;

  {
    int ret;

    D.29152 = &domain->lock.mutex;
    ret = pthread_mutex_lock (D.29152);
    if (ret != 0) goto <D.29153>; else goto <D.29154>;
    <D.29153>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.29154>:
    D.29155 = ret != 0;
    D.29156 = (long int) D.29155;
    D.29157 = __builtin_expect (D.29156, 0);
    if (D.29157 != 0) goto <D.29158>; else goto <D.29159>;
    <D.29158>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 2989, "ret == 0");
    <D.29159>:
  }
  D.29160 = domain->runtime_info;
  D.29161 = MEM[(struct MonoJitDomainInfo *)D.29160].seq_points;
  seq_points = monoeg_g_hash_table_lookup (D.29161, method);
  if (seq_points == 0B) goto <D.29162>; else goto <D.29163>;
  <D.29162>:
  D.29164 = BIT_FIELD_REF <*method, 32, 160>;
  D.29165 = D.29164 & 4096;
  if (D.29165 != 0) goto <D.29166>; else goto <D.29167>;
  <D.29166>:
  D.29160 = domain->runtime_info;
  D.29161 = MEM[(struct MonoJitDomainInfo *)D.29160].seq_points;
  D.29168 = mono_method_get_declaring_generic_method (method);
  seq_points = monoeg_g_hash_table_lookup (D.29161, D.29168);
  if (seq_points == 0B) goto <D.29169>; else goto <D.29170>;
  <D.29169>:
  D.29160 = domain->runtime_info;
  D.29161 = MEM[(struct MonoJitDomainInfo *)D.29160].seq_points;
  D.29171 = mini_get_shared_method (method);
  seq_points = monoeg_g_hash_table_lookup (D.29161, D.29171);
  <D.29170>:
  <D.29167>:
  <D.29163>:
  {
    int ret;

    D.29152 = &domain->lock.mutex;
    ret = pthread_mutex_unlock (D.29152);
    if (ret != 0) goto <D.29172>; else goto <D.29173>;
    <D.29172>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.29173>:
    D.29174 = ret != 0;
    D.29175 = (long int) D.29174;
    D.29176 = __builtin_expect (D.29175, 0);
    if (D.29176 != 0) goto <D.29177>; else goto <D.29178>;
    <D.29177>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 2997, "ret == 0");
    <D.29178>:
  }
  D.29179 = seq_points;
  return D.29179;
}


compute_frame_info (struct MonoInternalThread * thread, struct DebuggerTlsData * tls)
{
  struct StackFrame * * D.29181;
  int D.29184;
  int log_level.215;
  _Bool D.29188;
  long int D.29189;
  long int D.29190;
  struct FILE * log_file.216;
  long long unsigned int D.29194;
  long int D.29195;
  int D.29196;
  int D.29201;
  int D.29203;
  struct StackFrameInfo * D.29205;
  struct MonoThreadUnwindState * D.29206;
  int D.29207;
  int D.29210;
  struct MonoThreadUnwindState * D.29213;
  struct MonoThreadUnwindState * D.29214;
  struct GSList * D.29219;
  unsigned int D.29220;
  unsigned int new_frame_count.217;
  unsigned int D.29222;
  unsigned int i.218;
  unsigned int D.29224;
  struct StackFrame * * D.29225;
  struct StackFrame * D.29226;
  int D.29227;
  void * D.29228;
  int D.29229;
  void * D.29230;
  int D.29233;
  int D.29234;
  int D.29237;
  int findex.219;
  unsigned int findex.220;
  unsigned int D.29240;
  struct StackFrame * * D.29241;
  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.29181 = tls->frames;
      if (D.29181 != 0B) goto <D.29182>; else goto <D.29183>;
      <D.29182>:
      D.29184 = tls->frames_up_to_date;
      if (D.29184 != 0) goto <D.29185>; else goto <D.29186>;
      <D.29185>:
      return;
      <D.29186>:
      <D.29183>:
      log_level.215 = log_level;
      D.29188 = log_level.215 > 0;
      D.29189 = (long int) D.29188;
      D.29190 = __builtin_expect (D.29189, 0);
      if (D.29190 != 0) goto <D.29191>; else goto <D.29192>;
      <D.29191>:
      log_file.216 = log_file;
      D.29194 = thread->tid;
      D.29195 = (long int) D.29194;
      fprintf (log_file.216, "Frames for %p(tid=%lx):\n", thread, D.29195);
      log_file.216 = log_file;
      fflush (log_file.216);
      <D.29192>:
      user_data.tls = tls;
      user_data.frames = 0B;
      D.29196 = tls->terminated;
      if (D.29196 != 0) goto <D.29197>; else goto <D.29198>;
      <D.29197>:
      tls->frame_count = 0;
      return;
      <D.29198>:
      D.29201 = tls->really_suspended;
      if (D.29201 == 0) goto <D.29202>; else goto <D.29199>;
      <D.29202>:
      D.29203 = tls->async_state.valid;
      if (D.29203 != 0) goto <D.29204>; else goto <D.29199>;
      <D.29204>:
      D.29205 = &tls->async_last_frame;
      process_frame (D.29205, 0B, &user_data);
      D.29206 = &tls->async_state;
      mono_walk_stack_with_state (process_frame, D.29206, opts, &user_data);
      goto <D.29200>;
      <D.29199>:
      D.29207 = tls->filter_state.valid;
      if (D.29207 != 0) goto <D.29208>; else goto <D.29209>;
      <D.29208>:
      D.29210 = tls->context.valid;
      if (D.29210 != 0) goto <D.29211>; else goto <D.29212>;
      <D.29211>:
      D.29213 = &tls->context;
      mono_walk_stack_with_state (process_filter_frame, D.29213, opts, &user_data);
      <D.29212>:
      D.29214 = &tls->filter_state;
      mono_walk_stack_with_state (process_frame, D.29214, opts, &user_data);
      goto <D.29215>;
      <D.29209>:
      D.29210 = tls->context.valid;
      if (D.29210 != 0) goto <D.29216>; else goto <D.29217>;
      <D.29216>:
      D.29213 = &tls->context;
      mono_walk_stack_with_state (process_frame, D.29213, opts, &user_data);
      goto <D.29218>;
      <D.29217>:
      tls->frame_count = 0;
      return;
      <D.29218>:
      <D.29215>:
      <D.29200>:
      D.29219 = user_data.frames;
      D.29220 = monoeg_g_slist_length (D.29219);
      new_frame_count = (int) D.29220;
      new_frame_count.217 = (unsigned int) new_frame_count;
      D.29222 = new_frame_count.217 * 4;
      new_frames = monoeg_malloc0 (D.29222);
      findex = 0;
      tmp = user_data.frames;
      goto <D.25200>;
      <D.25199>:
      f = tmp->data;
      i = 0;
      goto <D.25198>;
      <D.25197>:
      D.29181 = tls->frames;
      i.218 = (unsigned int) i;
      D.29224 = i.218 * 4;
      D.29225 = D.29181 + D.29224;
      D.29226 = *D.29225;
      D.29227 = D.29226->ctx.sc_regs[29];
      D.29228 = (void *) D.29227;
      D.29229 = f->ctx.sc_regs[29];
      D.29230 = (void *) D.29229;
      if (D.29228 == D.29230) goto <D.29231>; else goto <D.29232>;
      <D.29231>:
      D.29181 = tls->frames;
      i.218 = (unsigned int) i;
      D.29224 = i.218 * 4;
      D.29225 = D.29181 + D.29224;
      D.29226 = *D.29225;
      D.29233 = D.29226->id;
      f->id = D.29233;
      goto <D.25196>;
      <D.29232>:
      i = i + 1;
      <D.25198>:
      D.29234 = tls->frame_count;
      if (D.29234 > i) goto <D.25197>; else goto <D.25196>;
      <D.25196>:
      D.29234 = tls->frame_count;
      if (D.29234 <= i) goto <D.29235>; else goto <D.29236>;
      <D.29235>:
      D.29237 = InterlockedIncrement (&frame_id);
      f->id = D.29237;
      <D.29236>:
      findex.219 = findex;
      findex = findex.219 + 1;
      findex.220 = (unsigned int) findex.219;
      D.29240 = findex.220 * 4;
      D.29241 = new_frames + D.29240;
      *D.29241 = f;
      tmp = tmp->next;
      <D.25200>:
      if (tmp != 0B) goto <D.25199>; else goto <D.25201>;
      <D.25201>:
      D.29219 = user_data.frames;
      monoeg_g_slist_free (D.29219);
      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.29245;
  void * D.29246;
  struct DebuggerTlsData * D.29247;
  int D.29248;
  void * D.29249;
  gboolean D.29252;
  struct ComputeFramesUserData * ud;

  ud = user_data;
  D.29245 = ctx->sc_regs[29];
  D.29246 = (void *) D.29245;
  D.29247 = ud->tls;
  D.29248 = D.29247->filter_state.ctx.sc_regs[29];
  D.29249 = (void *) D.29248;
  if (D.29246 >= D.29249) goto <D.29250>; else goto <D.29251>;
  <D.29250>:
  D.29252 = 1;
  return D.29252;
  <D.29251>:
  D.29252 = process_frame (info, ctx, user_data);
  return D.29252;
}


process_frame (struct StackFrameInfo * info, struct MonoContext * ctx, void * user_data)
{
  <unnamed type> D.29254;
  struct GSList * D.29259;
  struct GSList * D.29262;
  void * D.29263;
  int D.29264;
  int D.29265;
  gboolean D.29266;
  struct MonoJitInfo * D.29267;
  unsigned int D.29276;
  unsigned int D.29277;
  int D.29280;
  struct MonoDomain * D.29285;
  int D.29286;
  int D.29289;
  unsigned int D.29292;
  int D.29293;
  int log_level.221;
  _Bool D.29295;
  long int D.29296;
  long int D.29297;
  struct FILE * log_file.222;
  char * D.29301;
  int D.29302;
  int protocol_version_set.223;
  int major_version.224;
  int minor_version.225;
  unsigned int D.29315;
  unsigned int D.29316;
  mgreg_t * * D.29317;
  mgreg_t *[32] * D.29320;
  struct GSList * D.29323;
  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.29254 = info->type;
  if (D.29254 != 0) goto <D.29255>; else goto <D.29256>;
  <D.29255>:
  D.29254 = info->type;
  if (D.29254 == 1) goto <D.29257>; else goto <D.29258>;
  <D.29257>:
  D.29259 = ud->frames;
  if (D.29259 != 0B) goto <D.29260>; else goto <D.29261>;
  <D.29260>:
  D.29259 = ud->frames;
  D.29262 = monoeg_g_slist_last (D.29259);
  D.29263 = D.29262->data;
  D.29264 = MEM[(struct StackFrame *)D.29263].flags;
  D.29265 = D.29264 | 1;
  MEM[(struct StackFrame *)D.29263].flags = D.29265;
  <D.29261>:
  <D.29258>:
  D.29266 = 0;
  return D.29266;
  <D.29256>:
  D.29267 = info->ji;
  if (D.29267 != 0B) goto <D.29268>; else goto <D.29269>;
  <D.29268>:
  D.29267 = info->ji;
  method = jinfo_get_method (D.29267);
  goto <D.29270>;
  <D.29269>:
  method = info->method;
  <D.29270>:
  actual_method = info->actual_method;
  api_method = method;
  if (method == 0B) goto <D.29271>; else goto <D.29272>;
  <D.29271>:
  D.29266 = 0;
  return D.29266;
  <D.29272>:
  if (method == 0B) goto <D.29273>; else goto <D.29275>;
  <D.29275>:
  D.29276 = BIT_FIELD_REF <*method, 32, 160>;
  D.29277 = D.29276 & 124;
  if (D.29277 != 0) goto <D.29278>; else goto <D.29274>;
  <D.29278>:
  D.29276 = BIT_FIELD_REF <*method, 32, 160>;
  D.29277 = D.29276 & 124;
  if (D.29277 != 68) goto <D.29279>; else goto <D.29274>;
  <D.29279>:
  D.29276 = BIT_FIELD_REF <*method, 32, 160>;
  D.29277 = D.29276 & 124;
  if (D.29277 != 24) goto <D.29273>; else goto <D.29274>;
  <D.29273>:
  D.29266 = 0;
  return D.29266;
  <D.29274>:
  D.29280 = info->il_offset;
  if (D.29280 == -1) goto <D.29281>; else goto <D.29282>;
  <D.29281>:
  D.29259 = ud->frames;
  if (D.29259 == 0B) goto <D.29283>; else goto <D.29284>;
  <D.29283>:
  D.29285 = info->domain;
  D.29286 = info->native_offset;
  sp = find_prev_seq_point_for_native_offset (D.29285, method, D.29286, 0B);
  if (sp != 0B) goto <D.29287>; else goto <D.29288>;
  <D.29287>:
  D.29289 = sp->il_offset;
  info->il_offset = D.29289;
  <D.29288>:
  <D.29284>:
  D.29280 = info->il_offset;
  if (D.29280 == -1) goto <D.29290>; else goto <D.29291>;
  <D.29290>:
  D.29285 = info->domain;
  D.29286 = info->native_offset;
  D.29292 = (unsigned int) D.29286;
  D.29293 = mono_debug_il_offset_from_address (method, D.29285, D.29292);
  info->il_offset = D.29293;
  <D.29291>:
  <D.29282>:
  log_level.221 = log_level;
  D.29295 = log_level.221 > 0;
  D.29296 = (long int) D.29295;
  D.29297 = __builtin_expect (D.29296, 0);
  if (D.29297 != 0) goto <D.29298>; else goto <D.29299>;
  <D.29298>:
  log_file.222 = log_file;
  D.29301 = mono_method_full_name (method, 1);
  D.29280 = info->il_offset;
  D.29286 = info->native_offset;
  D.29302 = info->managed;
  fprintf (log_file.222, "\tFrame: %s:%x(%x) %d\n", D.29301, D.29280, D.29286, D.29302);
  log_file.222 = log_file;
  fflush (log_file.222);
  <D.29299>:
  D.29276 = BIT_FIELD_REF <*method, 32, 160>;
  D.29277 = D.29276 & 124;
  if (D.29277 == 24) goto <D.29303>; else goto <D.29304>;
  <D.29303>:
  protocol_version_set.223 = protocol_version_set;
  if (protocol_version_set.223 == 0) goto <D.29305>; else goto <D.29308>;
  <D.29308>:
  major_version.224 = major_version;
  if (major_version.224 <= 2) goto <D.29310>; else goto <D.29306>;
  <D.29310>:
  major_version.224 = major_version;
  if (major_version.224 != 2) goto <D.29305>; else goto <D.29311>;
  <D.29311>:
  minor_version.225 = minor_version;
  if (minor_version.225 <= 16) goto <D.29305>; else goto <D.29306>;
  <D.29305>:
  D.29266 = 0;
  return D.29266;
  <D.29306>:
  api_method = mono_marshal_method_from_wrapper (method);
  if (api_method == 0B) goto <D.29313>; else goto <D.29314>;
  <D.29313>:
  D.29266 = 0;
  return D.29266;
  <D.29314>:
  actual_method = api_method;
  flags = flags | 2;
  <D.29304>:
  frame = monoeg_malloc0 (432);
  frame->method = method;
  frame->actual_method = actual_method;
  frame->api_method = api_method;
  D.29280 = info->il_offset;
  D.29315 = (unsigned int) D.29280;
  frame->il_offset = D.29315;
  D.29286 = info->native_offset;
  D.29316 = (unsigned int) D.29286;
  frame->native_offset = D.29316;
  frame->flags = flags;
  D.29267 = info->ji;
  frame->ji = D.29267;
  D.29317 = info->reg_locations;
  if (D.29317 != 0B) goto <D.29318>; else goto <D.29319>;
  <D.29318>:
  D.29320 = &frame->reg_locations;
  D.29317 = info->reg_locations;
  memcpy (D.29320, D.29317, 128);
  <D.29319>:
  if (ctx != 0B) goto <D.29321>; else goto <D.29322>;
  <D.29321>:
  frame->ctx = *ctx;
  frame->has_ctx = 1;
  <D.29322>:
  D.29285 = info->domain;
  frame->domain = D.29285;
  D.29259 = ud->frames;
  D.29323 = monoeg_g_slist_append (D.29259, frame);
  ud->frames = D.29323;
  D.29266 = 0;
  return D.29266;
}


find_prev_seq_point_for_native_offset (struct MonoDomain * domain, struct MonoMethod * method, gint32 native_offset, struct MonoSeqPointInfo * * info)
{
  struct SeqPoint * D.29329;
  int D.29330;
  int D.29331;
  struct MonoSeqPointInfo * seq_points;
  int i;

  seq_points = get_seq_points (domain, method);
  if (info != 0B) goto <D.29325>; else goto <D.29326>;
  <D.29325>:
  *info = seq_points;
  <D.29326>:
  if (seq_points == 0B) goto <D.29327>; else goto <D.29328>;
  <D.29327>:
  D.29329 = 0B;
  return D.29329;
  <D.29328>:
  D.29330 = seq_points->len;
  i = D.29330 + -1;
  goto <D.25149>;
  <D.25148>:
  D.29331 = seq_points->seq_points[i].native_offset;
  if (D.29331 <= native_offset) goto <D.29332>; else goto <D.29333>;
  <D.29332>:
  D.29329 = &seq_points->seq_points[i];
  return D.29329;
  <D.29333>:
  i = i + -1;
  <D.25149>:
  if (i >= 0) goto <D.25148>; else goto <D.25150>;
  <D.25150>:
  D.29329 = 0B;
  return D.29329;
}


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

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


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

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


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.29340;
  struct EventRequest * D.29341;
  struct GSList * D.29342;
  struct GSList * D.29343;
  int D.29348;
  <unnamed type> D.29350;
  int D.29354;
  struct MonoThreadUnwindState * D.29357;
  struct MonoInternalThread * D.29358;
  struct StackFrame * * D.29361;
  unsigned int frame_index.226;
  unsigned int D.29363;
  struct StackFrame * * D.29364;
  struct MonoDomain * D.29365;
  struct MonoMethod * D.29366;
  unsigned int D.29367;
  int D.29368;
  int D.29372;
  struct MonoDomain * D.29378;
  struct MonoMethod * D.29379;
  unsigned int D.29380;
  int D.29381;
  struct MonoSeqPointInfo * info.227;
  int * D.29390;
  unsigned int i.228;
  unsigned int D.29392;
  int * D.29393;
  int D.29394;
  int D.29395;
  struct GSList * D.29396;
  int D.29399;
  struct StackFrame * * D.29402;
  struct MonoJitInfo * D.29403;
  struct MonoDomain * D.29406;
  struct MonoMethod * D.29407;
  void * D.29408;
  int D.29409;
  void * D.29410;
  int D.29411;
  int D.29412;
  struct GSList * D.29415;
  <unnamed-unsigned:15> D.29416;
  int D.29417;
  int log_level.229;
  _Bool D.29423;
  long int D.29424;
  long int D.29425;
  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.29338>; else goto <D.29339>;
  <D.29338>:
  D.29340 = sp->il_offset;
  D.29341 = ss_req->req;
  bp = set_breakpoint (method, D.29340, D.29341, 0B);
  D.29342 = ss_req->bps;
  D.29343 = monoeg_g_slist_append (D.29342, bp);
  ss_req->bps = D.29343;
  goto <D.29344>;
  <D.29339>:
  frame_index = 1;
  if (sp == 0B) goto <D.29345>; else goto <D.29347>;
  <D.29347>:
  D.29348 = sp->next_len;
  if (D.29348 == 0) goto <D.29345>; else goto <D.29349>;
  <D.29349>:
  D.29350 = ss_req->depth;
  if (D.29350 == 2) goto <D.29345>; else goto <D.29351>;
  <D.29351>:
  D.29350 = ss_req->depth;
  if (D.29350 == 1) goto <D.29345>; else goto <D.29346>;
  <D.29345>:
  if (ctx != 0B) goto <D.29352>; else goto <D.29353>;
  <D.29352>:
  D.29354 = tls->context.valid;
  if (D.29354 == 0) goto <D.29355>; else goto <D.29356>;
  <D.29355>:
  D.29357 = &tls->context;
  mono_thread_state_init_from_monoctx (D.29357, ctx);
  <D.29356>:
  D.29358 = tls->thread;
  compute_frame_info (D.29358, tls);
  <D.29353>:
  <D.29346>:
  D.29350 = ss_req->depth;
  if (D.29350 == 2) goto <D.29359>; else goto <D.29360>;
  <D.29359>:
  goto <D.25757>;
  <D.25756>:
  {
    struct StackFrame * frame;

    D.29361 = tls->frames;
    frame_index.226 = (unsigned int) frame_index;
    D.29363 = frame_index.226 * 4;
    D.29364 = D.29361 + D.29363;
    frame = *D.29364;
    method = frame->method;
    D.29365 = frame->domain;
    D.29366 = frame->method;
    D.29367 = frame->native_offset;
    D.29368 = (int) D.29367;
    sp = find_prev_seq_point_for_native_offset (D.29365, D.29366, D.29368, &info);
    frame_index = frame_index + 1;
    if (sp != 0B) goto <D.29369>; else goto <D.29370>;
    <D.29369>:
    D.29348 = sp->next_len;
    if (D.29348 != 0) goto <D.25755>; else goto <D.29371>;
    <D.29371>:
    <D.29370>:
  }
  <D.25757>:
  D.29372 = tls->frame_count;
  if (D.29372 > frame_index) goto <D.25756>; else goto <D.25755>;
  <D.25755>:
  goto <D.29373>;
  <D.29360>:
  if (sp != 0B) goto <D.29374>; else goto <D.29375>;
  <D.29374>:
  D.29348 = sp->next_len;
  if (D.29348 == 0) goto <D.29376>; else goto <D.29377>;
  <D.29376>:
  sp = 0B;
  goto <D.25761>;
  <D.25760>:
  {
    struct StackFrame * frame;

    D.29361 = tls->frames;
    frame_index.226 = (unsigned int) frame_index;
    D.29363 = frame_index.226 * 4;
    D.29364 = D.29361 + D.29363;
    frame = *D.29364;
    method = frame->method;
    D.29378 = frame->domain;
    D.29379 = frame->method;
    D.29380 = frame->native_offset;
    D.29381 = (int) D.29380;
    sp = find_prev_seq_point_for_native_offset (D.29378, D.29379, D.29381, &info);
    if (sp != 0B) goto <D.29382>; else goto <D.29383>;
    <D.29382>:
    D.29348 = sp->next_len;
    if (D.29348 != 0) goto <D.25759>; else goto <D.29384>;
    <D.29384>:
    <D.29383>:
    sp = 0B;
    frame_index = frame_index + 1;
  }
  <D.25761>:
  D.29372 = tls->frame_count;
  if (D.29372 > frame_index) goto <D.25760>; else goto <D.25759>;
  <D.25759>:
  <D.29377>:
  <D.29375>:
  <D.29373>:
  if (sp != 0B) goto <D.29385>; else goto <D.29386>;
  <D.29385>:
  D.29348 = sp->next_len;
  if (D.29348 > 0) goto <D.29387>; else goto <D.29388>;
  <D.29387>:
  i = 0;
  goto <D.25763>;
  <D.25762>:
  info.227 = info;
  D.29390 = sp->next;
  i.228 = (unsigned int) i;
  D.29392 = i.228 * 4;
  D.29393 = D.29390 + D.29392;
  D.29394 = *D.29393;
  next_sp = &info.227->seq_points[D.29394];
  D.29395 = next_sp->il_offset;
  D.29341 = ss_req->req;
  bp = set_breakpoint (method, D.29395, D.29341, 0B);
  D.29342 = ss_req->bps;
  D.29396 = monoeg_g_slist_append (D.29342, bp);
  ss_req->bps = D.29396;
  i = i + 1;
  <D.25763>:
  D.29348 = sp->next_len;
  if (D.29348 > i) goto <D.25762>; else goto <D.25764>;
  <D.25764>:
  <D.29388>:
  <D.29386>:
  D.29350 = ss_req->depth;
  if (D.29350 == 1) goto <D.29397>; else goto <D.29398>;
  <D.29397>:
  D.29399 = ss_req->nframes;
  if (D.29399 == 0) goto <D.29400>; else goto <D.29401>;
  <D.29400>:
  D.29372 = tls->frame_count;
  ss_req->nframes = D.29372;
  <D.29401>:
  i = 0;
  goto <D.25772>;
  <D.25771>:
  {
    struct StackFrame * frame;

    D.29361 = tls->frames;
    i.228 = (unsigned int) i;
    D.29392 = i.228 * 4;
    D.29402 = D.29361 + D.29392;
    frame = *D.29402;
    D.29403 = frame->ji;
    if (D.29403 != 0B) goto <D.29404>; else goto <D.29405>;
    <D.29404>:
    {
      struct MonoJitInfo * jinfo;

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

        ei = &jinfo->clauses[j];
        D.29406 = frame->domain;
        D.29407 = frame->method;
        D.29408 = ei->handler_start;
        D.29409 = (int) D.29408;
        D.29410 = jinfo->code_start;
        D.29411 = (int) D.29410;
        D.29412 = D.29409 - D.29411;
        sp = find_next_seq_point_for_native_offset (D.29406, D.29407, D.29412, 0B);
        if (sp != 0B) goto <D.29413>; else goto <D.29414>;
        <D.29413>:
        D.29407 = frame->method;
        D.29340 = sp->il_offset;
        D.29341 = ss_req->req;
        bp = set_breakpoint (D.29407, D.29340, D.29341, 0B);
        D.29342 = ss_req->bps;
        D.29415 = monoeg_g_slist_append (D.29342, bp);
        ss_req->bps = D.29415;
        <D.29414>:
      }
      j = j + 1;
      <D.25769>:
      D.29416 = jinfo->num_clauses;
      D.29417 = (int) D.29416;
      if (D.29417 > j) goto <D.25768>; else goto <D.25770>;
      <D.25770>:
    }
    <D.29405>:
  }
  i = i + 1;
  <D.25772>:
  D.29372 = tls->frame_count;
  if (D.29372 > i) goto <D.25771>; else goto <D.25773>;
  <D.25773>:
  <D.29398>:
  D.29350 = ss_req->depth;
  if (D.29350 == 0) goto <D.29418>; else goto <D.29419>;
  <D.29418>:
  enable_global = 1;
  <D.29419>:
  tls->context.valid = 0;
  tls->async_state.valid = 0;
  invalidate_frames (tls);
  <D.29344>:
  if (enable_global != 0) goto <D.29420>; else goto <D.29421>;
  <D.29420>:
  log_level.229 = log_level;
  D.29423 = log_level.229 > 0;
  D.29424 = (long int) D.29423;
  D.29425 = __builtin_expect (D.29424, 0);
  if (D.29425 != 0) goto <D.29426>; else goto <D.29427>;
  <D.29426>:
  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.29427>:
  ss_req->global = 1;
  start_single_stepping ();
  goto <D.29429>;
  <D.29421>:
  D.29342 = ss_req->bps;
  if (D.29342 == 0B) goto <D.29430>; else goto <D.29431>;
  <D.29430>:
  log_level.229 = log_level;
  D.29423 = log_level.229 > 0;
  D.29424 = (long int) D.29423;
  D.29425 = __builtin_expect (D.29424, 0);
  if (D.29425 != 0) goto <D.29432>; else goto <D.29433>;
  <D.29432>:
  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.29433>:
  ss_req->global = 1;
  start_single_stepping ();
  goto <D.29434>;
  <D.29431>:
  ss_req->global = 0;
  <D.29434>:
  <D.29429>:
}


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

  val = InterlockedIncrement (&ss_count);
  if (val == 1) goto <D.29435>; else goto <D.29436>;
  <D.29435>:
  mono_arch_start_single_stepping ();
  <D.29436>:
  ss_req.231 = ss_req;
  if (ss_req.231 != 0B) goto <D.29438>; else goto <D.29439>;
  <D.29438>:
  ss_invoke_addr.232 = ss_invoke_addr;
  if (ss_invoke_addr.232 == 0B) goto <D.29441>; else goto <D.29442>;
  <D.29441>:
  {
    struct DebuggerTlsData * tls;

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


set_breakpoint (struct MonoMethod * method, long int il_offset, struct EventRequest * req, struct MonoError * error)
{
  struct GPtrArray * D.29448;
  int log_level.235;
  _Bool D.29450;
  long int D.29451;
  long int D.29452;
  struct FILE * log_file.236;
  const char * iftmp.237;
  int D.29457;
  const char * iftmp.238;
  struct GHashTable * domains.239;
  struct MonoDomain * domain.240;
  union mono_mutex_t * D.29467;
  _Bool D.29470;
  long int D.29471;
  long int D.29472;
  void * D.29475;
  struct GHashTable * D.29476;
  struct MonoMethod * m.241;
  int D.29478;
  struct MonoSeqPointInfo * seq_points.242;
  int D.29482;
  _Bool D.29485;
  long int D.29486;
  long int D.29487;
  int D.29490;
  struct GPtrArray * breakpoints.243;
  int D.29494;
  struct MonoBreakpoint * D.29497;
  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.29446>; else goto <D.29447>;
      <D.29446>:
      mono_error_init (error);
      <D.29447>:
      bp = monoeg_malloc0 (16);
      bp->method = method;
      bp->il_offset = il_offset;
      bp->req = req;
      D.29448 = monoeg_g_ptr_array_new ();
      bp->children = D.29448;
      log_level.235 = log_level;
      D.29450 = log_level.235 > 0;
      D.29451 = (long int) D.29450;
      D.29452 = __builtin_expect (D.29451, 0);
      if (D.29452 != 0) goto <D.29453>; else goto <D.29454>;
      <D.29453>:
      log_file.236 = log_file;
      D.29457 = req->event_kind;
      if (D.29457 == 11) goto <D.29458>; else goto <D.29459>;
      <D.29458>:
      iftmp.237 = "single step ";
      goto <D.29460>;
      <D.29459>:
      iftmp.237 = "";
      <D.29460>:
      if (method != 0B) goto <D.29462>; else goto <D.29463>;
      <D.29462>:
      iftmp.238 = mono_method_full_name (method, 1);
      goto <D.29464>;
      <D.29463>:
      iftmp.238 = "<all>";
      <D.29464>:
      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.29454>:
      mono_loader_lock ();
      domains.239 = domains;
      monoeg_g_hash_table_iter_init (&iter, domains.239);
      goto <D.25552>;
      <D.25551>:
      {
        int ret;

        domain.240 = domain;
        D.29467 = &domain.240->lock.mutex;
        ret = pthread_mutex_lock (D.29467);
        if (ret != 0) goto <D.29468>; else goto <D.29469>;
        <D.29468>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
        <D.29469>:
        D.29470 = ret != 0;
        D.29471 = (long int) D.29470;
        D.29472 = __builtin_expect (D.29471, 0);
        if (D.29472 != 0) goto <D.29473>; else goto <D.29474>;
        <D.29473>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 4353, "ret == 0");
        <D.29474>:
      }
      domain.240 = domain;
      D.29475 = domain.240->runtime_info;
      D.29476 = MEM[(struct MonoJitDomainInfo *)D.29475].seq_points;
      monoeg_g_hash_table_iter_init (&iter2, D.29476);
      goto <D.25548>;
      <D.25547>:
      m.241 = m;
      D.29478 = bp_matches_method (bp, m.241);
      if (D.29478 != 0) goto <D.29479>; else goto <D.29480>;
      <D.29479>:
      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.29480>:
      <D.25548>:
      D.29482 = monoeg_g_hash_table_iter_next (&iter2, &m, &seq_points);
      if (D.29482 != 0) goto <D.25547>; else goto <D.25549>;
      <D.25549>:
      {
        int ret;

        domain.240 = domain;
        D.29467 = &domain.240->lock.mutex;
        ret = pthread_mutex_unlock (D.29467);
        if (ret != 0) goto <D.29483>; else goto <D.29484>;
        <D.29483>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.29484>:
        D.29485 = ret != 0;
        D.29486 = (long int) D.29485;
        D.29487 = __builtin_expect (D.29486, 0);
        if (D.29487 != 0) goto <D.29488>; else goto <D.29489>;
        <D.29488>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 4361, "ret == 0");
        <D.29489>:
      }
      <D.25552>:
      D.29490 = monoeg_g_hash_table_iter_next (&iter, &domain, 0B);
      if (D.29490 != 0) goto <D.25551>; else goto <D.25553>;
      <D.25553>:
      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.29492>; else goto <D.29493>;
      <D.29492>:
      D.29494 = mono_error_ok (error);
      if (D.29494 == 0) goto <D.29495>; else goto <D.29496>;
      <D.29495>:
      clear_breakpoint (bp);
      D.29497 = 0B;
      return D.29497;
      <D.29496>:
      <D.29493>:
      D.29497 = bp;
      return D.29497;
    }
  finally
    {
      iter = {CLOBBER};
      iter2 = {CLOBBER};
      domain = {CLOBBER};
      m = {CLOBBER};
      seq_points = {CLOBBER};
    }
}


bp_matches_method (struct MonoBreakpoint * bp, struct MonoMethod * method)
{
  struct MonoMethod * D.29500;
  gboolean D.29503;
  unsigned int D.29506;
  unsigned int D.29507;
  struct MonoMethod * D.29510;
  unsigned int D.29513;
  unsigned int D.29514;
  struct MonoMethod * D.29519;
  struct MonoMethod * D.29520;
  struct MonoGenericInst * D.29523;
  struct MonoGenericInst * D.29524;
  struct MonoGenericInst * D.29527;
  unsigned int D.29530;
  unsigned int D.29531;
  unsigned char D.29534;
  <unnamed-unsigned:22> D.29537;
  int D.29538;
  int i;

  D.29500 = bp->method;
  if (D.29500 == 0B) goto <D.29501>; else goto <D.29502>;
  <D.29501>:
  D.29503 = 1;
  return D.29503;
  <D.29502>:
  D.29500 = bp->method;
  if (D.29500 == method) goto <D.29504>; else goto <D.29505>;
  <D.29504>:
  D.29503 = 1;
  return D.29503;
  <D.29505>:
  D.29506 = BIT_FIELD_REF <*method, 32, 160>;
  D.29507 = D.29506 & 4096;
  if (D.29507 != 0) goto <D.29508>; else goto <D.29509>;
  <D.29508>:
  D.29510 = MEM[(struct MonoMethodInflated *)method].declaring;
  D.29500 = bp->method;
  if (D.29510 == D.29500) goto <D.29511>; else goto <D.29512>;
  <D.29511>:
  D.29503 = 1;
  return D.29503;
  <D.29512>:
  <D.29509>:
  D.29500 = bp->method;
  D.29513 = BIT_FIELD_REF <*D.29500, 32, 160>;
  D.29514 = D.29513 & 4096;
  if (D.29514 != 0) goto <D.29515>; else goto <D.29516>;
  <D.29515>:
  D.29506 = BIT_FIELD_REF <*method, 32, 160>;
  D.29507 = D.29506 & 4096;
  if (D.29507 != 0) goto <D.29517>; else goto <D.29518>;
  <D.29517>:
  {
    struct MonoMethodInflated * bpimethod;
    struct MonoMethodInflated * imethod;

    bpimethod = bp->method;
    imethod = method;
    D.29519 = bpimethod->declaring;
    D.29520 = imethod->declaring;
    if (D.29519 == D.29520) goto <D.29521>; else goto <D.29522>;
    <D.29521>:
    D.29523 = bpimethod->context.class_inst;
    D.29524 = imethod->context.class_inst;
    if (D.29523 == D.29524) goto <D.29525>; else goto <D.29526>;
    <D.29525>:
    D.29527 = bpimethod->context.method_inst;
    if (D.29527 != 0B) goto <D.29528>; else goto <D.29529>;
    <D.29528>:
    D.29527 = bpimethod->context.method_inst;
    D.29530 = BIT_FIELD_REF <*D.29527, 32, 32>;
    D.29531 = D.29530 & 4194304;
    if (D.29531 != 0) goto <D.29532>; else goto <D.29533>;
    <D.29532>:
    i = 0;
    goto <D.25500>;
    <D.25499>:
    {
      struct MonoType * t1;

      D.29527 = bpimethod->context.method_inst;
      t1 = D.29527->type_argv[i];
      D.29534 = t1->type;
      if (D.29534 != 30) goto <D.29535>; else goto <D.29536>;
      <D.29535>:
      D.29503 = 0;
      return D.29503;
      <D.29536>:
    }
    i = i + 1;
    <D.25500>:
    D.29527 = bpimethod->context.method_inst;
    D.29537 = D.29527->type_argc;
    D.29538 = (int) D.29537;
    if (D.29538 > i) goto <D.25499>; else goto <D.25501>;
    <D.25501>:
    D.29503 = 1;
    return D.29503;
    <D.29533>:
    <D.29529>:
    <D.29526>:
    <D.29522>:
  }
  <D.29518>:
  <D.29516>:
  D.29503 = 0;
  return D.29503;
}


set_bp_in_method (struct MonoDomain * domain, struct MonoMethod * method, struct MonoSeqPointInfo * seq_points, struct MonoBreakpoint * bp, struct MonoError * error)
{
  _Bool D.29544;
  long int D.29545;
  long int D.29546;
  struct MonoJitInfo * ji.244;
  struct MonoJitInfo * ji.245;
  _Bool D.29551;
  long int D.29552;
  long int D.29553;
  void * code;
  struct MonoJitInfo * ji;

  try
    {
      if (error != 0B) goto <D.29540>; else goto <D.29541>;
      <D.29540>:
      mono_error_init (error);
      <D.29541>:
      code = mono_jit_find_compiled_method_with_jit_info (domain, method, &ji);
      if (code == 0B) goto <D.29542>; else goto <D.29543>;
      <D.29542>:
      code = mono_aot_get_method (domain, method);
      D.29544 = code == 0B;
      D.29545 = (long int) D.29544;
      D.29546 = __builtin_expect (D.29545, 0);
      if (D.29546 != 0) goto <D.29547>; else goto <D.29548>;
      <D.29547>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 4301, "code");
      <D.29548>:
      ji.244 = mono_jit_info_table_find (domain, code);
      ji = ji.244;
      ji.245 = ji;
      D.29551 = ji.245 == 0B;
      D.29552 = (long int) D.29551;
      D.29553 = __builtin_expect (D.29552, 0);
      if (D.29553 != 0) goto <D.29554>; else goto <D.29555>;
      <D.29554>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 4303, "ji");
      <D.29555>:
      <D.29543>:
      D.29544 = code == 0B;
      D.29545 = (long int) D.29544;
      D.29546 = __builtin_expect (D.29545, 0);
      if (D.29546 != 0) goto <D.29556>; else goto <D.29557>;
      <D.29556>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 4305, "code");
      <D.29557>:
      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.29560;
  long int D.29561;
  int D.29563;
  int D.29570;
  struct MonoMethod * D.29574;
  char * D.29575;
  int log_level.246;
  _Bool D.29577;
  long int D.29578;
  long int D.29579;
  struct FILE * log_file.247;
  int D.29583;
  int D.29586;
  void * D.29587;
  sizetype D.29588;
  guint8 * D.29589;
  struct GPtrArray * D.29590;
  struct GHashTable * bp_locs.248;
  guint8 * D.29592;
  void * D.29593;
  int D.29594;
  void * D.29595;
  struct MonoMethod * D.29605;
  char * D.29606;
  int i;
  int count;
  struct BreakpointInstance * inst;
  struct SeqPoint * sp;

  sp = 0B;
  if (error != 0B) goto <D.29558>; else goto <D.29559>;
  <D.29558>:
  mono_error_init (error);
  <D.29559>:
  i = 0;
  goto <D.25477>;
  <D.25476>:
  sp = &seq_points->seq_points[i];
  D.29560 = sp->il_offset;
  D.29561 = bp->il_offset;
  if (D.29560 == D.29561) goto <D.25475>; else goto <D.29562>;
  <D.29562>:
  i = i + 1;
  <D.25477>:
  D.29563 = seq_points->len;
  if (D.29563 > i) goto <D.25476>; else goto <D.25475>;
  <D.25475>:
  D.29563 = seq_points->len;
  if (D.29563 == i) goto <D.29564>; else goto <D.29565>;
  <D.29564>:
  i = 0;
  goto <D.25480>;
  <D.25479>:
  sp = &seq_points->seq_points[i];
  D.29560 = sp->il_offset;
  if (D.29560 != -1) goto <D.29566>; else goto <D.29567>;
  <D.29566>:
  D.29560 = sp->il_offset;
  if (D.29560 != 16777215) goto <D.29568>; else goto <D.29569>;
  <D.29568>:
  D.29560 = sp->il_offset;
  D.29570 = D.29560 + 1;
  D.29561 = bp->il_offset;
  if (D.29570 == D.29561) goto <D.25478>; else goto <D.29571>;
  <D.29571>:
  <D.29569>:
  <D.29567>:
  i = i + 1;
  <D.25480>:
  D.29563 = seq_points->len;
  if (D.29563 > i) goto <D.25479>; else goto <D.25478>;
  <D.25478>:
  <D.29565>:
  D.29563 = seq_points->len;
  if (D.29563 == i) goto <D.29572>; else goto <D.29573>;
  <D.29572>:
  {
    char * s;

    D.29574 = jinfo_get_method (ji);
    D.29575 = mono_method_full_name (D.29574, 1);
    D.29561 = bp->il_offset;
    D.29563 = seq_points->len;
    s = monoeg_g_strdup_printf ("Unable to insert breakpoint at %s:%d, seq_points=%d\n", D.29575, D.29561, D.29563);
    i = 0;
    goto <D.25483>;
    <D.25482>:
    log_level.246 = log_level;
    D.29577 = log_level.246 > 0;
    D.29578 = (long int) D.29577;
    D.29579 = __builtin_expect (D.29578, 0);
    if (D.29579 != 0) goto <D.29580>; else goto <D.29581>;
    <D.29580>:
    log_file.247 = log_file;
    D.29583 = seq_points->seq_points[i].il_offset;
    fprintf (log_file.247, "%d\n", D.29583);
    log_file.247 = log_file;
    fflush (log_file.247);
    <D.29581>:
    i = i + 1;
    <D.25483>:
    D.29563 = seq_points->len;
    if (D.29563 > i) goto <D.25482>; else goto <D.25484>;
    <D.25484>:
    if (error != 0B) goto <D.29584>; else goto <D.29585>;
    <D.29584>:
    mono_error_set_error (error, 9, "%s", s);
    monoeg_g_log (0B, 16, "%s", s);
    monoeg_g_free (s);
    return;
    <D.29585>:
    monoeg_g_log (0B, 16, "%s", s);
    monoeg_g_free (s);
    return;
  }
  <D.29573>:
  inst = monoeg_malloc0 (24);
  inst->sp = sp;
  D.29586 = sp->native_offset;
  inst->native_offset = D.29586;
  D.29587 = ji->code_start;
  D.29586 = sp->native_offset;
  D.29588 = (sizetype) D.29586;
  D.29589 = D.29587 + D.29588;
  inst->ip = D.29589;
  inst->ji = ji;
  inst->domain = domain;
  mono_loader_lock ();
  D.29590 = bp->children;
  monoeg_g_ptr_array_add (D.29590, inst);
  bp_locs.248 = bp_locs;
  D.29592 = inst->ip;
  D.29593 = monoeg_g_hash_table_lookup (bp_locs.248, D.29592);
  count = (int) D.29593;
  bp_locs.248 = bp_locs;
  D.29592 = inst->ip;
  D.29594 = count + 1;
  D.29595 = (void *) D.29594;
  monoeg_g_hash_table_insert_replace (bp_locs.248, D.29592, D.29595, 0);
  mono_loader_unlock ();
  D.29586 = sp->native_offset;
  if (D.29586 == -1) goto <D.29596>; else goto <D.29597>;
  <D.29596>:
  log_level.246 = log_level;
  D.29577 = log_level.246 > 0;
  D.29578 = (long int) D.29577;
  D.29579 = __builtin_expect (D.29578, 0);
  if (D.29579 != 0) goto <D.29598>; else goto <D.29599>;
  <D.29598>:
  log_file.247 = log_file;
  D.29561 = bp->il_offset;
  fprintf (log_file.247, "[dbg] Attempting to insert seq point at dead IL offset %d, ignoring.\n", D.29561);
  log_file.247 = log_file;
  fflush (log_file.247);
  <D.29599>:
  goto <D.29600>;
  <D.29597>:
  if (count == 0) goto <D.29601>; else goto <D.29602>;
  <D.29601>:
  D.29592 = inst->ip;
  mono_arch_set_breakpoint (ji, D.29592);
  <D.29602>:
  <D.29600>:
  log_level.246 = log_level;
  D.29577 = log_level.246 > 0;
  D.29578 = (long int) D.29577;
  D.29579 = __builtin_expect (D.29578, 0);
  if (D.29579 != 0) goto <D.29603>; else goto <D.29604>;
  <D.29603>:
  log_file.247 = log_file;
  D.29605 = jinfo_get_method (ji);
  D.29606 = mono_method_full_name (D.29605, 1);
  D.29560 = sp->il_offset;
  fprintf (log_file.247, "[dbg] Inserted breakpoint at %s:0x%x.\n", D.29606, D.29560);
  log_file.247 = log_file;
  fflush (log_file.247);
  <D.29604>:
}


domain_commands (int command, guint8 * p, guint8 * end, struct Buffer * buf)
{
  struct MonoDomain * D.29608;
  guint8 * p.249;
  int err.250;
  ErrorCode D.29613;
  char * D.29614;
  unsigned int count.251;
  struct MonoAssembly * D.29620;
  struct MonoAppDomain * D.29623;
  struct MonoVTable * D.29624;
  struct MonoClass * D.29625;
  struct MonoImage * D.29626;
  struct MonoAssembly * D.29627;
  struct MonoDomain * domain2.252;
  _Bool D.29635;
  long int D.29636;
  long int D.29637;
  struct MonoType * D.29640;
  void * D.29641;
  <unnamed type> D.29642;
  int err.253;
  int err;
  struct MonoDomain * domain;

  try
    {
      switch (command) <default: <D.26469>, case 1: <D.26447>, case 2: <D.26449>, case 3: <D.26450>, case 4: <D.26460>, case 5: <D.26462>, case 6: <D.26461>, case 7: <D.26465>>
      <D.26447>:
      D.29608 = mono_get_root_domain ();
      buffer_add_domainid (buf, D.29608);
      goto <D.26448>;
      <D.26449>:
      p.249 = p;
      domain = decode_domainid (p.249, &p, end, 0B, &err);
      err.250 = err;
      if (err.250 != 0) goto <D.29611>; else goto <D.29612>;
      <D.29611>:
      err.250 = err;
      D.29613 = (ErrorCode) err.250;
      return D.29613;
      <D.29612>:
      D.29614 = domain->friendly_name;
      buffer_add_string (buf, D.29614);
      goto <D.26448>;
      <D.26450>:
      {
        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.29615>; else goto <D.29616>;
        <D.29615>:
        err.250 = err;
        D.29613 = (ErrorCode) err.250;
        return D.29613;
        <D.29616>:
        mono_loader_lock ();
        count = 0;
        tmp = domain->domain_assemblies;
        goto <D.26455>;
        <D.26454>:
        count = count + 1;
        tmp = tmp->next;
        <D.26455>:
        if (tmp != 0B) goto <D.26454>; else goto <D.26456>;
        <D.26456>:
        count.251 = (unsigned int) count;
        buffer_add_int (buf, count.251);
        tmp = domain->domain_assemblies;
        goto <D.26458>;
        <D.26457>:
        ass = tmp->data;
        buffer_add_assemblyid (buf, domain, ass);
        tmp = tmp->next;
        <D.26458>:
        if (tmp != 0B) goto <D.26457>; else goto <D.26459>;
        <D.26459>:
        mono_loader_unlock ();
        goto <D.26448>;
      }
      <D.26460>:
      p.249 = p;
      domain = decode_domainid (p.249, &p, end, 0B, &err);
      err.250 = err;
      if (err.250 != 0) goto <D.29618>; else goto <D.29619>;
      <D.29618>:
      err.250 = err;
      D.29613 = (ErrorCode) err.250;
      return D.29613;
      <D.29619>:
      D.29620 = domain->entry_assembly;
      buffer_add_assemblyid (buf, domain, D.29620);
      goto <D.26448>;
      <D.26461>:
      p.249 = p;
      domain = decode_domainid (p.249, &p, end, 0B, &err);
      err.250 = err;
      if (err.250 != 0) goto <D.29621>; else goto <D.29622>;
      <D.29621>:
      err.250 = err;
      D.29613 = (ErrorCode) err.250;
      return D.29613;
      <D.29622>:
      D.29623 = domain->domain;
      D.29624 = D.29623->mbr.obj.vtable;
      D.29625 = D.29624->klass;
      D.29626 = D.29625->image;
      D.29627 = D.29626->assembly;
      buffer_add_assemblyid (buf, domain, D.29627);
      goto <D.26448>;
      <D.26462>:
      {
        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.29628>; else goto <D.29629>;
        <D.29628>:
        err.250 = err;
        D.29613 = (ErrorCode) err.250;
        return D.29613;
        <D.29629>:
        p.249 = p;
        s = decode_string (p.249, &p, end);
        o = mono_string_new (domain, s);
        buffer_add_objid (buf, o);
        goto <D.26448>;
      }
      <D.26465>:
      {
        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.29630>; else goto <D.29631>;
            <D.29630>:
            err.250 = err;
            D.29613 = (ErrorCode) err.250;
            return D.29613;
            <D.29631>:
            p.249 = p;
            klass = decode_typeid (p.249, &p, end, &domain2, &err);
            err.250 = err;
            if (err.250 != 0) goto <D.29632>; else goto <D.29633>;
            <D.29632>:
            err.250 = err;
            D.29613 = (ErrorCode) err.250;
            return D.29613;
            <D.29633>:
            domain2.252 = domain2;
            D.29635 = domain != domain2.252;
            D.29636 = (long int) D.29635;
            D.29637 = __builtin_expect (D.29636, 0);
            if (D.29637 != 0) goto <D.29638>; else goto <D.29639>;
            <D.29638>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 7271, "domain == domain2");
            <D.29639>:
            o = mono_object_new (domain, klass);
            D.29640 = &klass->byval_arg;
            D.29641 = mono_object_unbox (o);
            p.249 = p;
            D.29642 = decode_value (D.29640, domain, D.29641, p.249, &p, end);
            err.253 = (int) D.29642;
            err = err.253;
            err.250 = err;
            if (err.250 != 0) goto <D.29644>; else goto <D.29645>;
            <D.29644>:
            err.250 = err;
            D.29613 = (ErrorCode) err.250;
            return D.29613;
            <D.29645>:
            buffer_add_objid (buf, o);
            goto <D.26448>;
          }
        finally
          {
            domain2 = {CLOBBER};
          }
      }
      <D.26469>:
      D.29613 = 100;
      return D.29613;
      <D.26448>:
      D.29613 = 0;
      return D.29613;
    }
  finally
    {
      err = {CLOBBER};
    }
}


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

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


decode_value (struct MonoType * t, struct MonoDomain * domain, guint8 * addr, guint8 * buf, guint8 * * endbuf, guint8 * limit)
{
  guint8 * buf.254;
  unsigned char D.29653;
  struct MonoClass * D.29656;
  int D.29657;
  struct MonoGenericClass * D.29660;
  struct MonoGenericInst * D.29661;
  <unnamed type> D.29662;
  ErrorCode D.29665;
  unsigned char D.29666;
  int D.29667;
  struct MonoClass * D.29670;
  int D.29671;
  unsigned int D.29672;
  <unnamed type> D.29673;
  struct MonoClass * D.29676;
  struct MonoObject * D.29677;
  struct MonoClass * D.29678;
  struct MonoClass * D.29681;
  int err;
  int type;

  buf.254 = buf;
  type = decode_byte (buf.254, &buf, limit);
  D.29653 = t->type;
  if (D.29653 == 21) goto <D.29654>; else goto <D.29655>;
  <D.29654>:
  D.29656 = mono_class_from_mono_type (t);
  D.29657 = mono_class_is_nullable (D.29656);
  if (D.29657 != 0) goto <D.29658>; else goto <D.29659>;
  <D.29658>:
  {
    struct MonoType * targ;
    guint8 * nullable_buf;

    D.29660 = t->data.generic_class;
    D.29661 = D.29660->context.class_inst;
    targ = D.29661->type_argv[0];
    buf.254 = buf;
    D.29662 = decode_value_internal (t, type, domain, addr, buf.254, endbuf, limit);
    err = (int) D.29662;
    if (err == 0) goto <D.29663>; else goto <D.29664>;
    <D.29663>:
    D.29665 = (ErrorCode) err;
    return D.29665;
    <D.29664>:
    D.29666 = targ->type;
    D.29667 = (int) D.29666;
    if (D.29667 == type) goto <D.29668>; else goto <D.29669>;
    <D.29668>:
    D.29670 = mono_class_from_mono_type (targ);
    D.29671 = mono_class_instance_size (D.29670);
    D.29672 = (unsigned int) D.29671;
    nullable_buf = monoeg_malloc (D.29672);
    buf.254 = buf;
    D.29673 = decode_value_internal (targ, type, domain, nullable_buf, buf.254, endbuf, limit);
    err = (int) D.29673;
    if (err != 0) goto <D.29674>; else goto <D.29675>;
    <D.29674>:
    monoeg_g_free (nullable_buf);
    D.29665 = (ErrorCode) err;
    return D.29665;
    <D.29675>:
    D.29676 = mono_class_from_mono_type (targ);
    D.29677 = mono_value_box (domain, D.29676, nullable_buf);
    D.29678 = mono_class_from_mono_type (t);
    mono_nullable_init (addr, D.29677, D.29678);
    monoeg_g_free (nullable_buf);
    buf.254 = buf;
    *endbuf = buf.254;
    D.29665 = 0;
    return D.29665;
    <D.29669>:
    if (type == 240) goto <D.29679>; else goto <D.29680>;
    <D.29679>:
    D.29681 = mono_class_from_mono_type (t);
    mono_nullable_init (addr, 0B, D.29681);
    buf.254 = buf;
    *endbuf = buf.254;
    D.29665 = 0;
    return D.29665;
    <D.29680>:
  }
  <D.29659>:
  <D.29655>:
  buf.254 = buf;
  D.29665 = decode_value_internal (t, type, domain, addr, buf.254, endbuf, limit);
  return D.29665;
}


decode_value_internal (struct MonoType * t, int type, struct MonoDomain * domain, guint8 * addr, guint8 * buf, guint8 * * endbuf, guint8 * limit)
{
  unsigned char D.29688;
  int D.29689;
  int D.29692;
  int log_level.255;
  _Bool D.29700;
  long int D.29701;
  long int D.29702;
  struct FILE * log_file.256;
  unsigned int D.29706;
  void * D.29707;
  ErrorCode D.29708;
  guint8 * buf.257;
  int D.29710;
  unsigned char D.29711;
  int D.29712;
  short unsigned int D.29713;
  int D.29714;
  signed char D.29715;
  int D.29716;
  unsigned char D.29717;
  int D.29718;
  short int D.29719;
  int D.29720;
  short unsigned int D.29721;
  int D.29722;
  int D.29723;
  unsigned int D.29724;
  long long int D.29725;
  long long int D.29726;
  long long unsigned int D.29727;
  int D.29728;
  unsigned int D.29729;
  long long int D.29730;
  long long unsigned int D.29731;
  _Bool D.29732;
  long int D.29733;
  long int D.29734;
  long long int D.29737;
  int D.29738;
  int D.29739;
  _Bool D.29740;
  long int D.29741;
  long int D.29742;
  <unnamed type> D.29745;
  int err.258;
  int err.259;
  int D.29750;
  <unnamed type> D.29755;
  struct MonoObject * obj.260;
  int D.29761;
  char * D.29766;
  struct MonoVTable * D.29767;
  struct MonoClass * D.29768;
  const char * D.29769;
  struct MonoDomain * D.29772;
  unsigned int vtype_buf_size.261;
  _Bool D.29786;
  long int D.29787;
  long int D.29788;
  <unnamed type> D.29791;
  int err.262;
  struct MonoDomain * d.263;
  struct MonoObject * D.29796;
  unsigned int D.29800;
  void * D.29801;
  int err;
  void handle_vtype = <<< error >>>;
  void handle_ref = <<< error >>>;

  try
    {
      D.29688 = t->type;
      D.29689 = (int) D.29688;
      if (D.29689 != type) goto <D.29690>; else goto <D.29691>;
      <D.29690>:
      D.29692 = mono_type_is_reference (t);
      if (D.29692 == 0) goto <D.29693>; else goto <D.29694>;
      <D.29693>:
      D.29688 = t->type;
      if (D.29688 != 24) goto <D.29687>; else goto <D.29695>;
      <D.29695>:
      if (type != 17) goto <D.29687>; else goto <D.29684>;
      <D.29687>:
      D.29688 = t->type;
      if (D.29688 != 25) goto <D.29686>; else goto <D.29696>;
      <D.29696>:
      if (type != 17) goto <D.29686>; else goto <D.29684>;
      <D.29686>:
      D.29688 = t->type;
      if (D.29688 != 15) goto <D.29685>; else goto <D.29697>;
      <D.29697>:
      if (type != 10) goto <D.29685>; else goto <D.29684>;
      <D.29685>:
      D.29688 = t->type;
      if (D.29688 != 21) goto <D.29683>; else goto <D.29698>;
      <D.29698>:
      if (type != 17) goto <D.29683>; else goto <D.29684>;
      <D.29683>:
      {
        char * name;

        name = mono_type_full_name (t);
        log_level.255 = log_level;
        D.29700 = log_level.255 > 0;
        D.29701 = (long int) D.29700;
        D.29702 = __builtin_expect (D.29701, 0);
        if (D.29702 != 0) goto <D.29703>; else goto <D.29704>;
        <D.29703>:
        log_file.256 = log_file;
        D.29706 = GetCurrentThreadId ();
        D.29707 = (void *) D.29706;
        fprintf (log_file.256, "[%p] Expected value of type %s, got 0x%0x.\n", D.29707, name, type);
        log_file.256 = log_file;
        fflush (log_file.256);
        <D.29704>:
        monoeg_g_free (name);
        D.29708 = 102;
        return D.29708;
      }
      <D.29684>:
      <D.29694>:
      <D.29691>:
      D.29688 = t->type;
      D.29689 = (int) D.29688;
      switch (D.29689) <default: <D.26032>, case 2: <D.26012>, case 3: <D.26014>, case 4: <D.26015>, case 5: <D.26016>, case 6: <D.26017>, case 7: <D.26018>, case 8: <D.26019>, case 9: <D.26020>, case 10: <D.26021>, case 11: <D.26022>, case 12: <D.26023>, case 13: <D.26024>, case 15: <D.26025>, case 17: <D.26031>, case 21: <D.26026>, case 24: <D.26029>, case 25: <D.26030>>
      <D.26012>:
      buf.257 = buf;
      D.29710 = decode_int (buf.257, &buf, limit);
      D.29711 = (unsigned char) D.29710;
      *addr = D.29711;
      goto <D.26013>;
      <D.26014>:
      buf.257 = buf;
      D.29712 = decode_int (buf.257, &buf, limit);
      D.29713 = (short unsigned int) D.29712;
      MEM[(gunichar2 *)addr] = D.29713;
      goto <D.26013>;
      <D.26015>:
      buf.257 = buf;
      D.29714 = decode_int (buf.257, &buf, limit);
      D.29715 = (signed char) D.29714;
      MEM[(gint8 *)addr] = D.29715;
      goto <D.26013>;
      <D.26016>:
      buf.257 = buf;
      D.29716 = decode_int (buf.257, &buf, limit);
      D.29717 = (unsigned char) D.29716;
      *addr = D.29717;
      goto <D.26013>;
      <D.26017>:
      buf.257 = buf;
      D.29718 = decode_int (buf.257, &buf, limit);
      D.29719 = (short int) D.29718;
      MEM[(gint16 *)addr] = D.29719;
      goto <D.26013>;
      <D.26018>:
      buf.257 = buf;
      D.29720 = decode_int (buf.257, &buf, limit);
      D.29721 = (short unsigned int) D.29720;
      MEM[(guint16 *)addr] = D.29721;
      goto <D.26013>;
      <D.26019>:
      buf.257 = buf;
      D.29722 = decode_int (buf.257, &buf, limit);
      MEM[(gint32 *)addr] = D.29722;
      goto <D.26013>;
      <D.26020>:
      buf.257 = buf;
      D.29723 = decode_int (buf.257, &buf, limit);
      D.29724 = (unsigned int) D.29723;
      MEM[(guint32 *)addr] = D.29724;
      goto <D.26013>;
      <D.26021>:
      buf.257 = buf;
      D.29725 = decode_long (buf.257, &buf, limit);
      MEM[(gint64 *)addr] = D.29725;
      goto <D.26013>;
      <D.26022>:
      buf.257 = buf;
      D.29726 = decode_long (buf.257, &buf, limit);
      D.29727 = (long long unsigned int) D.29726;
      MEM[(guint64 *)addr] = D.29727;
      goto <D.26013>;
      <D.26023>:
      buf.257 = buf;
      D.29728 = decode_int (buf.257, &buf, limit);
      D.29729 = (unsigned int) D.29728;
      MEM[(guint32 *)addr] = D.29729;
      goto <D.26013>;
      <D.26024>:
      buf.257 = buf;
      D.29730 = decode_long (buf.257, &buf, limit);
      D.29731 = (long long unsigned int) D.29730;
      MEM[(guint64 *)addr] = D.29731;
      goto <D.26013>;
      <D.26025>:
      D.29732 = type != 10;
      D.29733 = (long int) D.29732;
      D.29734 = __builtin_expect (D.29733, 0);
      if (D.29734 != 0) goto <D.29735>; else goto <D.29736>;
      <D.29735>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 5775, "type == MONO_TYPE_I8");
      <D.29736>:
      buf.257 = buf;
      D.29737 = decode_long (buf.257, &buf, limit);
      D.29738 = (int) D.29737;
      MEM[(gssize *)addr] = D.29738;
      goto <D.26013>;
      <D.26026>:
      D.29739 = mono_type_is_struct (t);
      if (D.29739 != 0) goto handle_vtype; else goto handle_ref;
      <D.26029>:
      <D.26030>:
      D.29740 = type != 17;
      D.29741 = (long int) D.29740;
      D.29742 = __builtin_expect (D.29741, 0);
      if (D.29742 != 0) goto <D.29743>; else goto <D.29744>;
      <D.29743>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 5789, "type == MONO_TYPE_VALUETYPE");
      <D.29744>:
      handle_vtype:
      <D.26031>:
      buf.257 = buf;
      D.29745 = decode_vtype (t, domain, addr, buf.257, &buf, limit);
      err.258 = (int) D.29745;
      err = err.258;
      err.259 = err;
      if (err.259 != 0) goto <D.29748>; else goto <D.29749>;
      <D.29748>:
      err.259 = err;
      D.29708 = (ErrorCode) err.259;
      return D.29708;
      <D.29749>:
      goto <D.26013>;
      handle_ref:
      <D.26032>:
      D.29750 = mono_type_is_reference (t);
      if (D.29750 != 0) goto <D.29751>; else goto <D.29752>;
      <D.29751>:
      if (type == 28) goto <D.29753>; else goto <D.29754>;
      <D.29753>:
      {
        int objid;
        int err;
        struct MonoObject * obj;

        try
          {
            buf.257 = buf;
            objid = decode_objid (buf.257, &buf, limit);
            D.29755 = get_object (objid, &obj);
            err = (int) D.29755;
            if (err != 0) goto <D.29756>; else goto <D.29757>;
            <D.29756>:
            D.29708 = (ErrorCode) err;
            return D.29708;
            <D.29757>:
            obj.260 = obj;
            if (obj.260 != 0B) goto <D.29759>; else goto <D.29760>;
            <D.29759>:
            obj.260 = obj;
            D.29761 = obj_is_of_type (obj.260, t);
            if (D.29761 == 0) goto <D.29762>; else goto <D.29763>;
            <D.29762>:
            log_level.255 = log_level;
            D.29700 = log_level.255 > 0;
            D.29701 = (long int) D.29700;
            D.29702 = __builtin_expect (D.29701, 0);
            if (D.29702 != 0) goto <D.29764>; else goto <D.29765>;
            <D.29764>:
            log_file.256 = log_file;
            D.29766 = mono_type_full_name (t);
            obj.260 = obj;
            D.29767 = obj.260->vtable;
            D.29768 = D.29767->klass;
            D.29769 = D.29768->name;
            fprintf (log_file.256, "Expected type \'%s\', got \'%s\'\n", D.29766, D.29769);
            log_file.256 = log_file;
            fflush (log_file.256);
            <D.29765>:
            D.29708 = 102;
            return D.29708;
            <D.29763>:
            <D.29760>:
            obj.260 = obj;
            if (obj.260 != 0B) goto <D.29770>; else goto <D.29771>;
            <D.29770>:
            obj.260 = obj;
            D.29767 = obj.260->vtable;
            D.29772 = D.29767->domain;
            if (D.29772 != domain) goto <D.29773>; else goto <D.29774>;
            <D.29773>:
            D.29708 = 102;
            return D.29708;
            <D.29774>:
            <D.29771>:
            obj.260 = obj;
            mono_gc_wbarrier_generic_store (addr, obj.260);
          }
        finally
          {
            obj = {CLOBBER};
          }
      }
      goto <D.29775>;
      <D.29754>:
      if (type == 240) goto <D.29776>; else goto <D.29777>;
      <D.29776>:
      MEM[(struct MonoObject * *)addr] = 0B;
      goto <D.29778>;
      <D.29777>:
      if (type == 17) goto <D.29779>; else goto <D.29780>;
      <D.29779>:
      {
        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.29781>; else goto <D.29782>;
            <D.29781>:
            D.29708 = 100;
            return D.29708;
            <D.29782>:
            buf.257 = buf;
            klass = decode_typeid (buf.257, &buf, limit, &d, &err);
            err.259 = err;
            if (err.259 != 0) goto <D.29783>; else goto <D.29784>;
            <D.29783>:
            err.259 = err;
            D.29708 = (ErrorCode) err.259;
            return D.29708;
            <D.29784>:
            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.29786 = vtype_buf == 0B;
            D.29787 = (long int) D.29786;
            D.29788 = __builtin_expect (D.29787, 0);
            if (D.29788 != 0) goto <D.29789>; else goto <D.29790>;
            <D.29789>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 5845, "vtype_buf");
            <D.29790>:
            buf = buf2;
            buf.257 = buf;
            D.29791 = decode_vtype (0B, domain, vtype_buf, buf.257, &buf, limit);
            err.262 = (int) D.29791;
            err = err.262;
            err.259 = err;
            if (err.259 != 0) goto <D.29793>; else goto <D.29794>;
            <D.29793>:
            monoeg_g_free (vtype_buf);
            err.259 = err;
            D.29708 = (ErrorCode) err.259;
            return D.29708;
            <D.29794>:
            d.263 = d;
            D.29796 = mono_value_box (d.263, klass, vtype_buf);
            MEM[(struct MonoObject * *)addr] = D.29796;
            monoeg_g_free (vtype_buf);
          }
        finally
          {
            d = {CLOBBER};
          }
      }
      goto <D.29797>;
      <D.29780>:
      {
        char * name;

        name = mono_type_full_name (t);
        log_level.255 = log_level;
        D.29700 = log_level.255 > 0;
        D.29701 = (long int) D.29700;
        D.29702 = __builtin_expect (D.29701, 0);
        if (D.29702 != 0) goto <D.29798>; else goto <D.29799>;
        <D.29798>:
        log_file.256 = log_file;
        D.29800 = GetCurrentThreadId ();
        D.29801 = (void *) D.29800;
        fprintf (log_file.256, "[%p] Expected value of type %s, got 0x%0x.\n", D.29801, name, type);
        log_file.256 = log_file;
        fflush (log_file.256);
        <D.29799>:
        monoeg_g_free (name);
        D.29708 = 102;
        return D.29708;
      }
      <D.29797>:
      <D.29778>:
      <D.29775>:
      goto <D.29802>;
      <D.29752>:
      monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "debugger-agent.c", 5862);
      <D.29802>:
      goto <D.26013>;
      <D.26013>:
      buf.257 = buf;
      *endbuf = buf.257;
      D.29708 = 0;
      return D.29708;
    }
  finally
    {
      err = {CLOBBER};
    }
}


obj_is_of_type (struct MonoObject * obj, struct MonoType * t)
{
  struct MonoVTable * D.29809;
  struct MonoClass * D.29810;
  int D.29811;
  struct MonoClass * D.29814;
  struct MonoRemoteClass * D.29817;
  struct MonoClass * D.29818;
  int D.29819;
  gboolean D.29822;
  struct MonoClass * klass;

  D.29809 = obj->vtable;
  klass = D.29809->klass;
  D.29810 = mono_class_from_mono_type (t);
  D.29811 = mono_class_is_assignable_from (D.29810, klass);
  if (D.29811 == 0) goto <D.29812>; else goto <D.29813>;
  <D.29812>:
  D.29814 = mono_defaults.transparent_proxy_class;
  if (D.29814 == klass) goto <D.29815>; else goto <D.29816>;
  <D.29815>:
  D.29817 = MEM[(struct MonoTransparentProxy *)obj].remote_class;
  klass = D.29817->proxy_class;
  D.29818 = mono_class_from_mono_type (t);
  D.29819 = mono_class_is_assignable_from (D.29818, klass);
  if (D.29819 != 0) goto <D.29820>; else goto <D.29821>;
  <D.29820>:
  D.29822 = 1;
  return D.29822;
  <D.29821>:
  <D.29816>:
  D.29822 = 0;
  return D.29822;
  <D.29813>:
  D.29822 = 1;
  return D.29822;
}


decode_vtype (struct MonoType * t, struct MonoDomain * domain, guint8 * addr, guint8 * buf, guint8 * * endbuf, guint8 * limit)
{
  guint8 * buf.264;
  ErrorCode D.29827;
  int err.265;
  struct MonoClass * D.29833;
  struct MonoType * D.29836;
  int log_level.266;
  _Bool D.29838;
  long int D.29839;
  long int D.29840;
  struct FILE * log_file.267;
  unsigned int D.29844;
  void * D.29845;
  struct MonoType * D.29846;
  short unsigned int D.29847;
  int D.29848;
  int D.29849;
  int D.29852;
  int D.25998;
  int iftmp.268;
  int D.25997;
  const char[9] * D.29858;
  unsigned char D.29859;
  int D.29860;
  unsigned char D.29861;
  int D.29862;
  const unsigned char * D.29867;
  unsigned char D.29868;
  int D.29869;
  const unsigned char * D.29870;
  unsigned char D.29871;
  int D.29872;
  const unsigned char * D.29877;
  unsigned char D.29878;
  int D.29879;
  const unsigned char * D.29880;
  unsigned char D.29881;
  int D.29882;
  const unsigned char * D.29887;
  unsigned char D.29888;
  int D.29889;
  const unsigned char * D.29890;
  unsigned char D.29891;
  int D.29892;
  const char * D.29894;
  int D.29897;
  sizetype D.29898;
  sizetype D.29899;
  guint8 * D.29900;
  <unnamed type> D.29901;
  int err.269;
  _Bool D.29905;
  long int D.29906;
  long int D.29907;
  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.29825>; else goto <D.29826>;
      <D.29825>:
      D.29827 = 100;
      return D.29827;
      <D.29826>:
      buf.264 = buf;
      klass = decode_typeid (buf.264, &buf, limit, &d, &err);
      err.265 = err;
      if (err.265 != 0) goto <D.29829>; else goto <D.29830>;
      <D.29829>:
      err.265 = err;
      D.29827 = (ErrorCode) err.265;
      return D.29827;
      <D.29830>:
      if (t != 0B) goto <D.29831>; else goto <D.29832>;
      <D.29831>:
      D.29833 = mono_class_from_mono_type (t);
      if (D.29833 != klass) goto <D.29834>; else goto <D.29835>;
      <D.29834>:
      {
        char * name;
        char * name2;

        name = mono_type_full_name (t);
        D.29836 = &klass->byval_arg;
        name2 = mono_type_full_name (D.29836);
        log_level.266 = log_level;
        D.29838 = log_level.266 > 0;
        D.29839 = (long int) D.29838;
        D.29840 = __builtin_expect (D.29839, 0);
        if (D.29840 != 0) goto <D.29841>; else goto <D.29842>;
        <D.29841>:
        log_file.267 = log_file;
        D.29844 = GetCurrentThreadId ();
        D.29845 = (void *) D.29844;
        fprintf (log_file.267, "[%p] Expected value of type %s, got %s.\n", D.29845, name, name2);
        log_file.267 = log_file;
        fflush (log_file.267);
        <D.29842>:
        monoeg_g_free (name);
        monoeg_g_free (name2);
        D.29827 = 102;
        return D.29827;
      }
      <D.29835>:
      <D.29832>:
      buf.264 = buf;
      nfields = decode_int (buf.264, &buf, limit);
      goto <D.25989>;
      <D.25999>:
      D.29846 = f->type;
      D.29847 = D.29846->attrs;
      D.29848 = (int) D.29847;
      D.29849 = D.29848 & 16;
      if (D.29849 != 0) goto <D.29850>; else goto <D.29851>;
      <D.29850>:
      // predicted unlikely by continue predictor.
      goto <D.25989>;
      <D.29851>:
      D.29846 = f->type;
      D.29847 = D.29846->attrs;
      D.29848 = (int) D.29847;
      D.29852 = D.29848 & 1536;
      if (D.29852 != 0) goto <D.29853>; else goto <D.29854>;
      <D.29853>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          __s2 = mono_field_get_name (f);
          D.29858 = "_Deleted";
          D.29859 = MEM[(const unsigned char *)D.29858];
          D.29860 = (int) D.29859;
          D.29861 = *__s2;
          D.29862 = (int) D.29861;
          __result = D.29860 - D.29862;
          {
            if (__s2_len != 0) goto <D.29863>; else goto <D.29864>;
            <D.29863>:
            if (__result == 0) goto <D.29865>; else goto <D.29866>;
            <D.29865>:
            D.29867 = &MEM[(void *)"_Deleted" + 1B];
            D.29868 = *D.29867;
            D.29869 = (int) D.29868;
            D.29870 = __s2 + 1;
            D.29871 = *D.29870;
            D.29872 = (int) D.29871;
            __result = D.29869 - D.29872;
            if (__s2_len > 1) goto <D.29873>; else goto <D.29874>;
            <D.29873>:
            if (__result == 0) goto <D.29875>; else goto <D.29876>;
            <D.29875>:
            D.29877 = &MEM[(void *)"_Deleted" + 2B];
            D.29878 = *D.29877;
            D.29879 = (int) D.29878;
            D.29880 = __s2 + 2;
            D.29881 = *D.29880;
            D.29882 = (int) D.29881;
            __result = D.29879 - D.29882;
            if (__s2_len > 2) goto <D.29883>; else goto <D.29884>;
            <D.29883>:
            if (__result == 0) goto <D.29885>; else goto <D.29886>;
            <D.29885>:
            D.29887 = &MEM[(void *)"_Deleted" + 3B];
            D.29888 = *D.29887;
            D.29889 = (int) D.29888;
            D.29890 = __s2 + 3;
            D.29891 = *D.29890;
            D.29892 = (int) D.29891;
            __result = D.29889 - D.29892;
            <D.29886>:
            <D.29884>:
            <D.29876>:
            <D.29874>:
            <D.29866>:
            <D.29864>:
          }
          D.25997 = __result;
        }
        iftmp.268 = -D.25997;
        goto <D.29893>;
        <D.29857>:
        D.29894 = mono_field_get_name (f);
        iftmp.268 = __builtin_strcmp (D.29894, "_Deleted");
        <D.29893>:
        D.25998 = iftmp.268;
      }
      if (D.25998 == 0) goto <D.29895>; else goto <D.29896>;
      <D.29895>:
      // predicted unlikely by continue predictor.
      goto <D.25989>;
      <D.29896>:
      <D.29854>:
      D.29846 = f->type;
      D.29897 = f->offset;
      D.29898 = (sizetype) D.29897;
      D.29899 = D.29898 + 4294967288;
      D.29900 = addr + D.29899;
      buf.264 = buf;
      D.29901 = decode_value (D.29846, domain, D.29900, buf.264, &buf, limit);
      err.269 = (int) D.29901;
      err = err.269;
      err.265 = err;
      if (err.265 != 0) goto <D.29903>; else goto <D.29904>;
      <D.29903>:
      err.265 = err;
      D.29827 = (ErrorCode) err.265;
      return D.29827;
      <D.29904>:
      nfields = nfields + -1;
      <D.25989>:
      f = mono_class_get_fields (klass, &iter);
      if (f != 0B) goto <D.25999>; else goto <D.26000>;
      <D.26000>:
      D.29905 = nfields != 0;
      D.29906 = (long int) D.29905;
      D.29907 = __builtin_expect (D.29906, 0);
      if (D.29907 != 0) goto <D.29908>; else goto <D.29909>;
      <D.29908>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 5713, "nfields == 0");
      <D.29909>:
      buf.264 = buf;
      *endbuf = buf.264;
      D.29827 = 0;
      return D.29827;
    }
  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.29916;
  struct MonoImage * D.29917;
  const char * D.29918;
  unsigned int D.29919;
  unsigned int D.29920;
  struct MonoDomain * domain.272;
  _Bool D.29928;
  long int D.29929;
  long int D.29930;
  int D.29933;
  const char * D.29937;
  struct MonoClass * iftmp.273;
  const char * D.29944;
  short unsigned int D.29945;
  int D.29946;
  short unsigned int D.29947;
  int D.29948;
  short unsigned int D.29949;
  int D.29950;
  short unsigned int D.29951;
  int D.29952;
  const char * iftmp.274;
  const char * D.29956;
  char D.29958;
  const char * iftmp.275;
  unsigned char D.29961;
  const char * iftmp.276;
  unsigned int D.29966;
  unsigned int D.29967;
  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.29914>; else goto <D.29915>;
      <D.29914>:
      err.271 = err;
      D.29916 = (ErrorCode) err.271;
      return D.29916;
      <D.29915>:
      switch (command) <default: <D.26498>, case 1: <D.26479>, case 2: <D.26481>, case 3: <D.26484>, case 4: <D.26485>, case 5: <D.26487>, case 6: <D.26495>>
      <D.26479>:
      D.29917 = ass->image;
      D.29918 = mono_image_get_filename (D.29917);
      buffer_add_string (buf, D.29918);
      goto <D.26480>;
      <D.26481>:
      {
        guint32 token;
        struct MonoMethod * m;

        D.29917 = ass->image;
        D.29919 = BIT_FIELD_REF <*D.29917, 32, 128>;
        D.29920 = D.29919 & 8;
        if (D.29920 != 0) goto <D.29921>; else goto <D.29922>;
        <D.29921>:
        buffer_add_id (buf, 0);
        goto <D.29923>;
        <D.29922>:
        D.29917 = ass->image;
        token = mono_image_get_entry_point (D.29917);
        if (token == 0) goto <D.29924>; else goto <D.29925>;
        <D.29924>:
        buffer_add_id (buf, 0);
        goto <D.29926>;
        <D.29925>:
        D.29917 = ass->image;
        m = mono_get_method (D.29917, token, 0B);
        domain.272 = domain;
        buffer_add_methodid (buf, domain.272, m);
        <D.29926>:
        <D.29923>:
        goto <D.26480>;
      }
      <D.26484>:
      domain.272 = domain;
      D.29917 = ass->image;
      buffer_add_moduleid (buf, domain.272, D.29917);
      goto <D.26480>;
      <D.26485>:
      {
        struct MonoObject * o;

        domain.272 = domain;
        o = mono_assembly_get_object (domain.272, ass);
        buffer_add_objid (buf, o);
        goto <D.26480>;
      }
      <D.26487>:
      {
        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.29928 = res == 0;
            D.29929 = (long int) D.29928;
            D.29930 = __builtin_expect (D.29929, 0);
            if (D.29930 != 0) goto <D.29931>; else goto <D.29932>;
            <D.29931>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 7341, "res");
            <D.29932>:
            D.29933 = mono_reflection_parse_type (s, &info);
            if (D.29933 == 0) goto <D.29934>; else goto <D.29935>;
            <D.29934>:
            t = 0B;
            goto <D.29936>;
            <D.29935>:
            D.29937 = info.assembly.name;
            if (D.29937 != 0B) goto <D.29938>; else goto <D.29939>;
            <D.29938>:
            monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "debugger-agent.c", 7347);
            <D.29939>:
            D.29917 = ass->image;
            t = mono_reflection_get_type (D.29917, &info, ignorecase, &type_resolve);
            <D.29936>:
            domain.272 = domain;
            if (t != 0B) goto <D.29941>; else goto <D.29942>;
            <D.29941>:
            iftmp.273 = mono_class_from_mono_type (t);
            goto <D.29943>;
            <D.29942>:
            iftmp.273 = 0B;
            <D.29943>:
            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.26480>;
          }
        finally
          {
            info = {CLOBBER};
            type_resolve = {CLOBBER};
          }
      }
      <D.26495>:
      {
        gchar * name;
        struct MonoAssembly * mass;

        mass = ass;
        D.29944 = mass->aname.name;
        D.29945 = mass->aname.major;
        D.29946 = (int) D.29945;
        D.29947 = mass->aname.minor;
        D.29948 = (int) D.29947;
        D.29949 = mass->aname.build;
        D.29950 = (int) D.29949;
        D.29951 = mass->aname.revision;
        D.29952 = (int) D.29951;
        D.29956 = mass->aname.culture;
        if (D.29956 != 0B) goto <D.29957>; else goto <D.29954>;
        <D.29957>:
        D.29956 = mass->aname.culture;
        D.29958 = *D.29956;
        if (D.29958 != 0) goto <D.29959>; else goto <D.29954>;
        <D.29959>:
        iftmp.274 = mass->aname.culture;
        goto <D.29955>;
        <D.29954>:
        iftmp.274 = "neutral";
        <D.29955>:
        D.29961 = mass->aname.public_key_token[0];
        if (D.29961 != 0) goto <D.29962>; else goto <D.29963>;
        <D.29962>:
        iftmp.275 = &mass->aname.public_key_token;
        goto <D.29964>;
        <D.29963>:
        iftmp.275 = "null";
        <D.29964>:
        D.29966 = mass->aname.flags;
        D.29967 = D.29966 & 256;
        if (D.29967 != 0) goto <D.29968>; else goto <D.29969>;
        <D.29968>:
        iftmp.276 = ", Retargetable=Yes";
        goto <D.29970>;
        <D.29969>:
        iftmp.276 = "";
        <D.29970>:
        name = monoeg_g_strdup_printf ("%s, Version=%d.%d.%d.%d, Culture=%s, PublicKeyToken=%s%s", D.29944, D.29946, D.29948, D.29950, D.29952, iftmp.274, iftmp.275, iftmp.276);
        buffer_add_string (buf, name);
        monoeg_g_free (name);
        goto <D.26480>;
      }
      <D.26498>:
      D.29916 = 100;
      return D.29916;
      <D.26480>:
      D.29916 = 0;
      return D.29916;
    }
  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.29975;
  const char * D.29976;
  const char * D.29977;
  struct MonoDomain * domain.278;
  struct MonoAssembly * D.29979;
  ErrorCode D.29980;
  int err;
  struct MonoDomain * domain;

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

        p.277 = p;
        image = decode_moduleid (p.277, &p, end, &domain, &err);
        D.29975 = image->name;
        basename = monoeg_g_path_get_basename (D.29975);
        buffer_add_string (buf, basename);
        D.29976 = image->module_name;
        buffer_add_string (buf, D.29976);
        D.29975 = image->name;
        buffer_add_string (buf, D.29975);
        D.29977 = mono_image_get_guid (image);
        buffer_add_string (buf, D.29977);
        domain.278 = domain;
        D.29979 = image->assembly;
        buffer_add_assemblyid (buf, domain.278, D.29979);
        monoeg_g_free (basename);
        goto <D.26510>;
      }
      <D.26511>:
      D.29980 = 100;
      return D.29980;
      <D.26510>:
      D.29980 = 0;
      return D.29980;
    }
  finally
    {
      err = {CLOBBER};
      domain = {CLOBBER};
    }
}


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

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


type_commands (int command, guint8 * p, guint8 * end, struct Buffer * buf)
{
  guint8 * p.279;
  int err.280;
  ErrorCode D.29989;
  struct MonoDomain * domain.281;
  <unnamed type> D.29991;
  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.29987>; else goto <D.29988>;
      <D.29987>:
      err.280 = err;
      D.29989 = (ErrorCode) err.280;
      return D.29989;
      <D.29988>:
      old_domain = mono_domain_get ();
      domain.281 = domain;
      mono_domain_set (domain.281, 1);
      domain.281 = domain;
      p.279 = p;
      D.29991 = type_commands_internal (command, klass, domain.281, p.279, end, buf);
      err.282 = (int) D.29991;
      err = err.282;
      mono_domain_set (old_domain, 1);
      err.280 = err;
      D.29989 = (ErrorCode) err.280;
      return D.29989;
    }
  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.29995;
  const char * D.29996;
  struct MonoType * D.29997;
  struct MonoImage * D.29998;
  struct MonoAssembly * D.29999;
  struct MonoClass * D.30000;
  unsigned char D.30004;
  unsigned char D.30006;
  struct MonoClass * D.30007;
  unsigned int D.30008;
  int D.30009;
  unsigned int D.30010;
  unsigned char D.30013;
  unsigned int D.30018;
  unsigned int D.30019;
  unsigned char D.30022;
  unsigned int D.30027;
  unsigned int D.30028;
  struct MonoGenericContainer * D.30031;
  struct MonoGenericClass * D.30037;
  int D.30038;
  unsigned int nnested.283;
  int protocol_version_set.284;
  int major_version.285;
  int minor_version.286;
  struct MonoClass * D.30054;
  <unnamed-unsigned:22> D.30064;
  unsigned int count.287;
  struct MonoType * D.30066;
  struct MonoClass * D.30067;
  <unnamed-signed:31> D.30071;
  struct MonoGenericParamFull * D.30072;
  unsigned int i.288;
  unsigned int D.30074;
  struct MonoGenericParam * D.30075;
  unsigned int nmethods.289;
  _Bool D.30078;
  long int D.30079;
  long int D.30080;
  unsigned int nfields.290;
  const char * D.30084;
  struct MonoType * D.30085;
  struct MonoClass * D.30086;
  short unsigned int D.30087;
  unsigned int D.30088;
  _Bool D.30089;
  long int D.30090;
  long int D.30091;
  unsigned int nprops.291;
  const char * D.30095;
  struct MonoMethod * D.30096;
  struct MonoMethod * D.30097;
  unsigned int D.30098;
  _Bool D.30099;
  long int D.30100;
  long int D.30101;
  guint8 * p.292;
  int err.293;
  ErrorCode D.30108;
  <unnamed type> D.30119;
  struct MonoThread * thread_obj.294;
  struct MonoType * D.30125;
  short unsigned int D.30126;
  int D.30127;
  int D.30128;
  struct MonoClass * D.30136;
  struct MonoClass * D.30141;
  int D.30142;
  unsigned int D.30143;
  struct MonoInternalThread * iftmp.295;
  struct MonoType * D.30150;
  short unsigned int D.30151;
  int D.30152;
  int D.30153;
  int D.30156;
  struct MonoClass * D.30159;
  struct MonoClass * D.30164;
  int D.30165;
  unsigned int D.30166;
  <unnamed type> D.30167;
  int err.296;
  int D.30171;
  void * D.30174;
  unsigned int D.30176;
  void * * D.30177;
  unsigned int i.297;
  unsigned int D.30179;
  void * * D.30180;
  unsigned int i.298;
  int D.30187;
  unsigned int flags.299;
  unsigned int D.30192;
  int D.30193;
  _Bool D.30194;
  int D.30195;
  unsigned int D.30198;
  void * * D.30199;
  unsigned int i.300;
  unsigned int D.30201;
  void * * D.30202;
  unsigned int i.301;
  int D.30204;
  int D.30207;
  unsigned int D.30210;
  struct MonoClass * iface.302;
  int D.30212;
  unsigned int nmethods.303;
  struct MonoMethod * * D.30218;
  int D.30219;
  unsigned int D.30220;
  unsigned int D.30221;
  struct MonoMethod * * D.30222;
  struct MonoMethod * D.30223;
  unsigned int D.30226;
  unsigned int D.30227;
  _Bool D.30228;
  unsigned int D.30229;
  struct MonoClass * nested;
  struct MonoType * type;
  void * iter;
  guint8 b;
  int err;
  int nnested;
  char * name;

  try
    {
      switch (command) <default: <D.26718>, case 1: <D.26573>, case 2: <D.26592>, case 3: <D.26600>, case 4: <D.26627>, case 5: <D.26661>, case 6: <D.26663>, case 7: <D.26647>, case 8: <D.26672>, case 9: <D.26608>, case 10: <D.26616>, case 11: <D.26619>, case 12: <D.26623>, case 13: <D.26664>, case 14: <D.26628>, case 15: <D.26674>, case 16: <D.26684>, case 17: <D.26697>, case 18: <D.26716>>
      <D.26573>:
      D.29995 = klass->name_space;
      buffer_add_string (buf, D.29995);
      D.29996 = klass->name;
      buffer_add_string (buf, D.29996);
      D.29997 = &klass->byval_arg;
      name = mono_type_get_name_full (D.29997, 2);
      buffer_add_string (buf, name);
      monoeg_g_free (name);
      D.29998 = klass->image;
      D.29999 = D.29998->assembly;
      buffer_add_assemblyid (buf, domain, D.29999);
      D.29998 = klass->image;
      buffer_add_moduleid (buf, domain, D.29998);
      D.30000 = klass->parent;
      buffer_add_typeid (buf, domain, D.30000);
      D.30004 = klass->rank;
      if (D.30004 != 0) goto <D.30001>; else goto <D.30005>;
      <D.30005>:
      D.30006 = klass->byval_arg.type;
      if (D.30006 == 15) goto <D.30001>; else goto <D.30002>;
      <D.30001>:
      D.30007 = klass->element_class;
      buffer_add_typeid (buf, domain, D.30007);
      goto <D.30003>;
      <D.30002>:
      buffer_add_id (buf, 0);
      <D.30003>:
      D.30008 = klass->type_token;
      buffer_add_int (buf, D.30008);
      D.30004 = klass->rank;
      D.30009 = (int) D.30004;
      buffer_add_byte (buf, D.30009);
      D.30010 = klass->flags;
      buffer_add_int (buf, D.30010);
      b = 0;
      type = &klass->byval_arg;
      if (0 != 0) goto <D.30011>; else goto <D.30012>;
      <D.30011>:
      b = b | 1;
      <D.30012>:
      D.30013 = type->type;
      if (D.30013 == 15) goto <D.30014>; else goto <D.30015>;
      <D.30014>:
      b = b | 2;
      <D.30015>:
      D.30018 = BIT_FIELD_REF <*type, 32, 32>;
      D.30019 = D.30018 & 1073741824;
      if (D.30019 == 0) goto <D.30020>; else goto <D.30021>;
      <D.30020>:
      D.30013 = type->type;
      D.30022 = D.30013 + 254;
      if (D.30022 <= 11) goto <D.30016>; else goto <D.30023>;
      <D.30023>:
      D.30013 = type->type;
      if (D.30013 == 24) goto <D.30016>; else goto <D.30024>;
      <D.30024>:
      D.30013 = type->type;
      if (D.30013 == 25) goto <D.30016>; else goto <D.30017>;
      <D.30016>:
      b = b | 4;
      <D.30017>:
      <D.30021>:
      D.30013 = type->type;
      if (D.30013 == 17) goto <D.30025>; else goto <D.30026>;
      <D.30025>:
      b = b | 8;
      <D.30026>:
      D.30027 = BIT_FIELD_REF <*klass, 32, 160>;
      D.30028 = D.30027 & 16;
      if (D.30028 != 0) goto <D.30029>; else goto <D.30030>;
      <D.30029>:
      b = b | 16;
      <D.30030>:
      D.30031 = klass->generic_container;
      if (D.30031 != 0B) goto <D.30032>; else goto <D.30033>;
      <D.30032>:
      b = b | 32;
      <D.30033>:
      D.30031 = klass->generic_container;
      if (D.30031 != 0B) goto <D.30034>; else goto <D.30036>;
      <D.30036>:
      D.30037 = klass->generic_class;
      if (D.30037 != 0B) goto <D.30034>; else goto <D.30035>;
      <D.30034>:
      b = b | 64;
      <D.30035>:
      D.30038 = (int) b;
      buffer_add_byte (buf, D.30038);
      nnested = 0;
      iter = 0B;
      goto <D.26575>;
      <D.26574>:
      nnested = nnested + 1;
      <D.26575>:
      nested = mono_class_get_nested_types (klass, &iter);
      if (nested != 0B) goto <D.26574>; else goto <D.26576>;
      <D.26576>:
      nnested.283 = (unsigned int) nnested;
      buffer_add_int (buf, nnested.283);
      iter = 0B;
      goto <D.26578>;
      <D.26577>:
      buffer_add_typeid (buf, domain, nested);
      <D.26578>:
      nested = mono_class_get_nested_types (klass, &iter);
      if (nested != 0B) goto <D.26577>; else goto <D.26579>;
      <D.26579>:
      protocol_version_set.284 = protocol_version_set;
      if (protocol_version_set.284 != 0) goto <D.30043>; else goto <D.30044>;
      <D.30043>:
      major_version.285 = major_version;
      if (major_version.285 > 2) goto <D.30040>; else goto <D.30046>;
      <D.30046>:
      major_version.285 = major_version;
      if (major_version.285 == 2) goto <D.30047>; else goto <D.30041>;
      <D.30047>:
      minor_version.286 = minor_version;
      if (minor_version.286 > 11) goto <D.30040>; else goto <D.30041>;
      <D.30040>:
      D.30031 = klass->generic_container;
      if (D.30031 != 0B) goto <D.30049>; else goto <D.30050>;
      <D.30049>:
      buffer_add_typeid (buf, domain, klass);
      goto <D.30051>;
      <D.30050>:
      D.30037 = klass->generic_class;
      if (D.30037 != 0B) goto <D.30052>; else goto <D.30053>;
      <D.30052>:
      D.30037 = klass->generic_class;
      D.30054 = D.30037->container_class;
      buffer_add_typeid (buf, domain, D.30054);
      goto <D.30055>;
      <D.30053>:
      buffer_add_id (buf, 0);
      <D.30055>:
      <D.30051>:
      <D.30041>:
      <D.30044>:
      protocol_version_set.284 = protocol_version_set;
      if (protocol_version_set.284 != 0) goto <D.30058>; else goto <D.30059>;
      <D.30058>:
      major_version.285 = major_version;
      if (major_version.285 > 2) goto <D.30056>; else goto <D.30060>;
      <D.30060>:
      major_version.285 = major_version;
      if (major_version.285 == 2) goto <D.30061>; else goto <D.30057>;
      <D.30061>:
      minor_version.286 = minor_version;
      if (minor_version.286 > 14) goto <D.30056>; else goto <D.30057>;
      <D.30056>:
      {
        int count;
        int i;

        D.30037 = klass->generic_class;
        if (D.30037 != 0B) goto <D.30062>; else goto <D.30063>;
        <D.30062>:
        {
          struct MonoGenericInst * inst;

          D.30037 = klass->generic_class;
          inst = D.30037->context.class_inst;
          D.30064 = inst->type_argc;
          count = (int) D.30064;
          count.287 = (unsigned int) count;
          buffer_add_int (buf, count.287);
          i = 0;
          goto <D.26584>;
          <D.26583>:
          D.30066 = inst->type_argv[i];
          D.30067 = mono_class_from_mono_type (D.30066);
          buffer_add_typeid (buf, domain, D.30067);
          i = i + 1;
          <D.26584>:
          if (i < count) goto <D.26583>; else goto <D.26585>;
          <D.26585>:
        }
        goto <D.30068>;
        <D.30063>:
        D.30031 = klass->generic_container;
        if (D.30031 != 0B) goto <D.30069>; else goto <D.30070>;
        <D.30069>:
        {
          struct MonoGenericContainer * container;
          struct MonoClass * pklass;

          container = klass->generic_container;
          D.30071 = container->type_argc;
          count = (int) D.30071;
          count.287 = (unsigned int) count;
          buffer_add_int (buf, count.287);
          i = 0;
          goto <D.26589>;
          <D.26588>:
          D.30072 = container->type_params;
          i.288 = (unsigned int) i;
          D.30074 = i.288 * 32;
          D.30075 = D.30072 + D.30074;
          D.29998 = klass->image;
          pklass = mono_class_from_generic_parameter (D.30075, D.29998, 0);
          buffer_add_typeid (buf, domain, pklass);
          i = i + 1;
          <D.26589>:
          if (i < count) goto <D.26588>; else goto <D.26590>;
          <D.26590>:
        }
        goto <D.30076>;
        <D.30070>:
        buffer_add_int (buf, 0);
        <D.30076>:
        <D.30068>:
      }
      <D.30057>:
      <D.30059>:
      goto <D.26591>;
      <D.26592>:
      {
        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.26598>;
            <D.26597>:
            buffer_add_methodid (buf, domain, m);
            i = i + 1;
            <D.26598>:
            m = mono_class_get_methods (klass, &iter);
            if (m != 0B) goto <D.26597>; else goto <D.26599>;
            <D.26599>:
            D.30078 = i != nmethods;
            D.30079 = (long int) D.30078;
            D.30080 = __builtin_expect (D.30079, 0);
            if (D.30080 != 0) goto <D.30081>; else goto <D.30082>;
            <D.30081>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 7618, "i == nmethods");
            <D.30082>:
            goto <D.26591>;
          }
        finally
          {
            iter = {CLOBBER};
          }
      }
      <D.26600>:
      {
        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.26606>;
            <D.26605>:
            buffer_add_fieldid (buf, domain, f);
            D.30084 = f->name;
            buffer_add_string (buf, D.30084);
            D.30085 = f->type;
            D.30086 = mono_class_from_mono_type (D.30085);
            buffer_add_typeid (buf, domain, D.30086);
            D.30085 = f->type;
            D.30087 = D.30085->attrs;
            D.30088 = (unsigned int) D.30087;
            buffer_add_int (buf, D.30088);
            i = i + 1;
            <D.26606>:
            f = mono_class_get_fields (klass, &iter);
            if (f != 0B) goto <D.26605>; else goto <D.26607>;
            <D.26607>:
            D.30089 = i != nfields;
            D.30090 = (long int) D.30089;
            D.30091 = __builtin_expect (D.30090, 0);
            if (D.30091 != 0) goto <D.30092>; else goto <D.30093>;
            <D.30092>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 7638, "i == nfields");
            <D.30093>:
            goto <D.26591>;
          }
        finally
          {
            iter = {CLOBBER};
          }
      }
      <D.26608>:
      {
        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.26614>;
            <D.26613>:
            buffer_add_propertyid (buf, domain, p);
            D.30095 = p->name;
            buffer_add_string (buf, D.30095);
            D.30096 = p->get;
            buffer_add_methodid (buf, domain, D.30096);
            D.30097 = p->set;
            buffer_add_methodid (buf, domain, D.30097);
            D.30098 = p->attrs;
            buffer_add_int (buf, D.30098);
            i = i + 1;
            <D.26614>:
            p = mono_class_get_properties (klass, &iter);
            if (p != 0B) goto <D.26613>; else goto <D.26615>;
            <D.26615>:
            D.30099 = i != nprops;
            D.30100 = (long int) D.30099;
            D.30101 = __builtin_expect (D.30100, 0);
            if (D.30101 != 0) goto <D.30102>; else goto <D.30103>;
            <D.30102>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 7659, "i == nprops");
            <D.30103>:
            goto <D.26591>;
          }
        finally
          {
            iter = {CLOBBER};
          }
      }
      <D.26616>:
      {
        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.30106>; else goto <D.30107>;
        <D.30106>:
        err.293 = err;
        D.30108 = (ErrorCode) err.293;
        return D.30108;
        <D.30107>:
        cinfo = mono_custom_attrs_from_class (klass);
        D.29998 = klass->image;
        buffer_add_cattrs (buf, domain, D.29998, attr_klass, cinfo);
        goto <D.26591>;
      }
      <D.26619>:
      {
        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.30109>; else goto <D.30110>;
        <D.30109>:
        err.293 = err;
        D.30108 = (ErrorCode) err.293;
        return D.30108;
        <D.30110>:
        p.292 = p;
        attr_klass = decode_typeid (p.292, &p, end, 0B, &err);
        err.293 = err;
        if (err.293 != 0) goto <D.30111>; else goto <D.30112>;
        <D.30111>:
        err.293 = err;
        D.30108 = (ErrorCode) err.293;
        return D.30108;
        <D.30112>:
        cinfo = mono_custom_attrs_from_field (klass, field);
        D.29998 = klass->image;
        buffer_add_cattrs (buf, domain, D.29998, attr_klass, cinfo);
        goto <D.26591>;
      }
      <D.26623>:
      {
        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.30113>; else goto <D.30114>;
        <D.30113>:
        err.293 = err;
        D.30108 = (ErrorCode) err.293;
        return D.30108;
        <D.30114>:
        p.292 = p;
        attr_klass = decode_typeid (p.292, &p, end, 0B, &err);
        err.293 = err;
        if (err.293 != 0) goto <D.30115>; else goto <D.30116>;
        <D.30115>:
        err.293 = err;
        D.30108 = (ErrorCode) err.293;
        return D.30108;
        <D.30116>:
        cinfo = mono_custom_attrs_from_property (klass, prop);
        D.29998 = klass->image;
        buffer_add_cattrs (buf, domain, D.29998, attr_klass, cinfo);
        goto <D.26591>;
      }
      <D.26627>:
      <D.26628>:
      {
        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.30117>; else goto <D.30118>;
            <D.30117>:
            {
              int objid;
              int err;

              p.292 = p;
              objid = decode_objid (p.292, &p, end);
              D.30119 = get_object (objid, &thread_obj);
              err = (int) D.30119;
              if (err != 0) goto <D.30120>; else goto <D.30121>;
              <D.30120>:
              D.30108 = (ErrorCode) err;
              return D.30108;
              <D.30121>:
              thread_obj.294 = thread_obj;
              thread = thread_obj.294->internal_thread;
            }
            <D.30118>:
            p.292 = p;
            len = decode_int (p.292, &p, end);
            i = 0;
            goto <D.26645>;
            <D.26644>:
            p.292 = p;
            f = decode_fieldid (p.292, &p, end, 0B, &err);
            err.293 = err;
            if (err.293 != 0) goto <D.30123>; else goto <D.30124>;
            <D.30123>:
            err.293 = err;
            D.30108 = (ErrorCode) err.293;
            return D.30108;
            <D.30124>:
            D.30125 = f->type;
            D.30126 = D.30125->attrs;
            D.30127 = (int) D.30126;
            D.30128 = D.30127 & 16;
            if (D.30128 == 0) goto <D.30129>; else goto <D.30130>;
            <D.30129>:
            D.30108 = 25;
            return D.30108;
            <D.30130>:
            special_static_type = mono_class_field_get_special_static_type (f);
            if (special_static_type != 0) goto <D.30131>; else goto <D.30132>;
            <D.30131>:
            if (thread == 0B) goto <D.30133>; else goto <D.30135>;
            <D.30135>:
            if (special_static_type != 1) goto <D.30133>; else goto <D.30134>;
            <D.30133>:
            D.30108 = 25;
            return D.30108;
            <D.30134>:
            <D.30132>:
            found = 0;
            k = klass;
            goto <D.26643>;
            <D.26642>:
            D.30136 = f->parent;
            if (D.30136 == k) goto <D.30137>; else goto <D.30138>;
            <D.30137>:
            found = 1;
            goto <D.26641>;
            <D.30138>:
            k = k->parent;
            <D.26643>:
            if (k != 0B) goto <D.26642>; else goto <D.26641>;
            <D.26641>:
            if (found == 0) goto <D.30139>; else goto <D.30140>;
            <D.30139>:
            D.30108 = 25;
            return D.30108;
            <D.30140>:
            D.30136 = f->parent;
            vtable = mono_class_vtable (domain, D.30136);
            D.30125 = f->type;
            D.30141 = mono_class_from_mono_type (D.30125);
            D.30142 = mono_class_instance_size (D.30141);
            D.30143 = (unsigned int) D.30142;
            val = monoeg_malloc (D.30143);
            if (thread == 0B) goto <D.30145>; else goto <D.30146>;
            <D.30145>:
            iftmp.295 = mono_thread_internal_current ();
            goto <D.30147>;
            <D.30146>:
            iftmp.295 = thread;
            <D.30147>:
            mono_field_static_get_value_for_thread (iftmp.295, vtable, f, val);
            D.30125 = f->type;
            buffer_add_value (buf, D.30125, val, domain);
            monoeg_g_free (val);
            i = i + 1;
            <D.26645>:
            if (i < len) goto <D.26644>; else goto <D.26646>;
            <D.26646>:
            goto <D.26591>;
          }
        finally
          {
            thread_obj = {CLOBBER};
          }
      }
      <D.26647>:
      {
        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.26659>;
        <D.26658>:
        p.292 = p;
        f = decode_fieldid (p.292, &p, end, 0B, &err);
        err.293 = err;
        if (err.293 != 0) goto <D.30148>; else goto <D.30149>;
        <D.30148>:
        err.293 = err;
        D.30108 = (ErrorCode) err.293;
        return D.30108;
        <D.30149>:
        D.30150 = f->type;
        D.30151 = D.30150->attrs;
        D.30152 = (int) D.30151;
        D.30153 = D.30152 & 16;
        if (D.30153 == 0) goto <D.30154>; else goto <D.30155>;
        <D.30154>:
        D.30108 = 25;
        return D.30108;
        <D.30155>:
        D.30156 = mono_class_field_is_special_static (f);
        if (D.30156 != 0) goto <D.30157>; else goto <D.30158>;
        <D.30157>:
        D.30108 = 25;
        return D.30108;
        <D.30158>:
        found = 0;
        k = klass;
        goto <D.26657>;
        <D.26656>:
        D.30159 = f->parent;
        if (D.30159 == k) goto <D.30160>; else goto <D.30161>;
        <D.30160>:
        found = 1;
        goto <D.26655>;
        <D.30161>:
        k = k->parent;
        <D.26657>:
        if (k != 0B) goto <D.26656>; else goto <D.26655>;
        <D.26655>:
        if (found == 0) goto <D.30162>; else goto <D.30163>;
        <D.30162>:
        D.30108 = 25;
        return D.30108;
        <D.30163>:
        D.30159 = f->parent;
        vtable = mono_class_vtable (domain, D.30159);
        D.30150 = f->type;
        D.30164 = mono_class_from_mono_type (D.30150);
        D.30165 = mono_class_instance_size (D.30164);
        D.30166 = (unsigned int) D.30165;
        val = monoeg_malloc (D.30166);
        D.30150 = f->type;
        p.292 = p;
        D.30167 = decode_value (D.30150, domain, val, p.292, &p, end);
        err.296 = (int) D.30167;
        err = err.296;
        err.293 = err;
        if (err.293 != 0) goto <D.30169>; else goto <D.30170>;
        <D.30169>:
        monoeg_g_free (val);
        err.293 = err;
        D.30108 = (ErrorCode) err.293;
        return D.30108;
        <D.30170>:
        D.30150 = f->type;
        D.30171 = mono_type_is_reference (D.30150);
        if (D.30171 != 0) goto <D.30172>; else goto <D.30173>;
        <D.30172>:
        D.30174 = MEM[(void * *)val];
        mono_field_static_set_value (vtable, f, D.30174);
        goto <D.30175>;
        <D.30173>:
        mono_field_static_set_value (vtable, f, val);
        <D.30175>:
        monoeg_g_free (val);
        i = i + 1;
        <D.26659>:
        if (i < len) goto <D.26658>; else goto <D.26660>;
        <D.26660>:
        goto <D.26591>;
      }
      <D.26661>:
      {
        struct MonoObject * o;

        D.29997 = &klass->byval_arg;
        o = mono_type_get_object (domain, D.29997);
        buffer_add_objid (buf, o);
        goto <D.26591>;
      }
      <D.26663>:
      <D.26664>:
      {
        char * source_file;
        char * base;
        struct GPtrArray * files;
        int i;

        files = get_source_files_for_type (klass);
        D.30176 = files->len;
        buffer_add_int (buf, D.30176);
        i = 0;
        goto <D.26670>;
        <D.26669>:
        D.30177 = files->pdata;
        i.297 = (unsigned int) i;
        D.30179 = i.297 * 4;
        D.30180 = D.30177 + D.30179;
        source_file = *D.30180;
        if (command == 13) goto <D.30181>; else goto <D.30182>;
        <D.30181>:
        buffer_add_string (buf, source_file);
        goto <D.30183>;
        <D.30182>:
        base = monoeg_g_path_get_basename (source_file);
        buffer_add_string (buf, base);
        monoeg_g_free (base);
        <D.30183>:
        monoeg_g_free (source_file);
        i = i + 1;
        <D.26670>:
        i.298 = (unsigned int) i;
        D.30176 = files->len;
        if (i.298 < D.30176) goto <D.26669>; else goto <D.26671>;
        <D.26671>:
        monoeg_g_ptr_array_free (files, 1);
        goto <D.26591>;
      }
      <D.26672>:
      {
        struct MonoClass * oklass;

        p.292 = p;
        oklass = decode_typeid (p.292, &p, end, 0B, &err);
        err.293 = err;
        if (err.293 != 0) goto <D.30185>; else goto <D.30186>;
        <D.30185>:
        err.293 = err;
        D.30108 = (ErrorCode) err.293;
        return D.30108;
        <D.30186>:
        D.30187 = mono_class_is_assignable_from (klass, oklass);
        if (D.30187 != 0) goto <D.30188>; else goto <D.30189>;
        <D.30188>:
        buffer_add_byte (buf, 1);
        goto <D.30190>;
        <D.30189>:
        buffer_add_byte (buf, 0);
        <D.30190>:
        goto <D.26591>;
      }
      <D.26674>:
      {
        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.30192 = flags.299 & 2415919103;
            D.30193 = flags & 1879048192;
            D.30194 = D.30193 != 0;
            D.30195 = (int) D.30194;
            array = mono_class_get_methods_by_name (klass, name, D.30192, D.30195, 1, &ex);
            if (array == 0B) goto <D.30196>; else goto <D.30197>;
            <D.30196>:
            D.30108 = 200;
            return D.30108;
            <D.30197>:
            D.30198 = array->len;
            buffer_add_int (buf, D.30198);
            i = 0;
            goto <D.26682>;
            <D.26681>:
            {
              struct MonoMethod * method;

              D.30199 = array->pdata;
              i.300 = (unsigned int) i;
              D.30201 = i.300 * 4;
              D.30202 = D.30199 + D.30201;
              method = *D.30202;
              buffer_add_methodid (buf, domain, method);
            }
            i = i + 1;
            <D.26682>:
            i.301 = (unsigned int) i;
            D.30198 = array->len;
            if (i.301 < D.30198) goto <D.26681>; else goto <D.26683>;
            <D.26683>:
            monoeg_g_ptr_array_free (array, 1);
            monoeg_g_free (name);
            goto <D.26591>;
          }
        finally
          {
            ex = {CLOBBER};
          }
      }
      <D.26684>:
      {
        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.26692>;
            <D.26691>:
            mono_class_setup_interfaces (parent, &error);
            D.30204 = mono_error_ok (&error);
            if (D.30204 == 0) goto <D.30205>; else goto <D.30206>;
            <D.30205>:
            D.30108 = 200;
            return D.30108;
            <D.30206>:
            collect_interfaces (parent, iface_hash, &error);
            D.30207 = mono_error_ok (&error);
            if (D.30207 == 0) goto <D.30208>; else goto <D.30209>;
            <D.30208>:
            D.30108 = 200;
            return D.30108;
            <D.30209>:
            parent = parent->parent;
            <D.26692>:
            if (parent != 0B) goto <D.26691>; else goto <D.26693>;
            <D.26693>:
            D.30210 = monoeg_g_hash_table_size (iface_hash);
            buffer_add_int (buf, D.30210);
            monoeg_g_hash_table_iter_init (&iter, iface_hash);
            goto <D.26695>;
            <D.26694>:
            iface.302 = iface;
            buffer_add_typeid (buf, domain, iface.302);
            <D.26695>:
            D.30212 = monoeg_g_hash_table_iter_next (&iter, 0B, &iface);
            if (D.30212 != 0) goto <D.26694>; else goto <D.26696>;
            <D.26696>:
            monoeg_g_hash_table_destroy (iface_hash);
            goto <D.26591>;
          }
        finally
          {
            error = {CLOBBER};
            iface = {CLOBBER};
            iter = {CLOBBER};
          }
      }
      <D.26697>:
      {
        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.26714>;
            <D.26713>:
            p.292 = p;
            iclass = decode_typeid (p.292, &p, end, 0B, &err);
            err.293 = err;
            if (err.293 != 0) goto <D.30213>; else goto <D.30214>;
            <D.30213>:
            err.293 = err;
            D.30108 = (ErrorCode) err.293;
            return D.30108;
            <D.30214>:
            ioffset = mono_class_interface_offset_with_variance (klass, iclass, &variance_used);
            if (ioffset == -1) goto <D.30215>; else goto <D.30216>;
            <D.30215>:
            D.30108 = 102;
            return D.30108;
            <D.30216>:
            nmethods = mono_class_num_methods (iclass);
            nmethods.303 = (unsigned int) nmethods;
            buffer_add_int (buf, nmethods.303);
            iter = 0B;
            goto <D.26708>;
            <D.26707>:
            buffer_add_methodid (buf, domain, method);
            <D.26708>:
            method = mono_class_get_methods (iclass, &iter);
            if (method != 0B) goto <D.26707>; else goto <D.26709>;
            <D.26709>:
            i = 0;
            goto <D.26711>;
            <D.26710>:
            D.30218 = klass->vtable;
            D.30219 = i + ioffset;
            D.30220 = (unsigned int) D.30219;
            D.30221 = D.30220 * 4;
            D.30222 = D.30218 + D.30221;
            D.30223 = *D.30222;
            buffer_add_methodid (buf, domain, D.30223);
            i = i + 1;
            <D.26711>:
            if (i < nmethods) goto <D.26710>; else goto <D.26712>;
            <D.26712>:
            tindex = tindex + 1;
            <D.26714>:
            if (tindex < len) goto <D.26713>; else goto <D.26715>;
            <D.26715>:
            goto <D.26591>;
          }
        finally
          {
            variance_used = {CLOBBER};
            iter = {CLOBBER};
          }
      }
      <D.26716>:
      {
        struct MonoVTable * vtable;

        vtable = mono_class_vtable (domain, klass);
        if (vtable != 0B) goto <D.30224>; else goto <D.30225>;
        <D.30224>:
        D.30226 = BIT_FIELD_REF <*vtable, 32, 160>;
        D.30227 = D.30226 & 100663296;
        D.30228 = D.30227 != 0;
        D.30229 = (unsigned int) D.30228;
        buffer_add_int (buf, D.30229);
        goto <D.30230>;
        <D.30225>:
        buffer_add_int (buf, 0);
        <D.30230>:
        goto <D.26591>;
      }
      <D.26718>:
      D.30108 = 100;
      return D.30108;
      <D.26591>:
      D.30108 = 0;
      return D.30108;
    }
  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.30244;

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


buffer_add_cattrs (struct Buffer * buf, struct MonoDomain * domain, struct MonoImage * image, struct MonoClass * attr_klass, struct MonoCustomAttrInfo * cinfo)
{
  struct MonoMethod * D.30251;
  struct MonoClass * D.30252;
  int D.30253;
  int D.30254;
  unsigned int nattrs.304;
  struct MonoMethod * D.30259;
  struct MonoClass * D.30260;
  int D.30261;
  const mono_byte * D.30262;
  unsigned int D.30263;
  int D.30264;
  _Bool D.30265;
  long int D.30266;
  long int D.30267;
  struct MonoArray * typed_args.305;
  unsigned int D.30273;
  unsigned int j.306;
  char * D.30275;
  struct MonoMethodSignature * D.30276;
  unsigned int D.30277;
  struct MonoArray * named_args.307;
  unsigned int D.30282;
  char * D.30283;
  struct CattrNamedArg * arginfo.308;
  unsigned int j.309;
  unsigned int D.30286;
  struct CattrNamedArg * D.30287;
  struct MonoProperty * D.30288;
  struct MonoClassField * D.30292;
  struct MonoType * D.30296;
  unsigned int D.30297;
  int i;
  int j;
  int nattrs;

  nattrs = 0;
  if (cinfo == 0B) goto <D.30246>; else goto <D.30247>;
  <D.30246>:
  buffer_add_int (buf, 0);
  return;
  <D.30247>:
  i = 0;
  goto <D.26529>;
  <D.26528>:
  if (attr_klass == 0B) goto <D.30248>; else goto <D.30250>;
  <D.30250>:
  D.30251 = cinfo->attrs[i].ctor;
  D.30252 = D.30251->klass;
  D.30253 = mono_class_has_parent (D.30252, attr_klass);
  if (D.30253 != 0) goto <D.30248>; else goto <D.30249>;
  <D.30248>:
  nattrs = nattrs + 1;
  <D.30249>:
  i = i + 1;
  <D.26529>:
  D.30254 = cinfo->num_attrs;
  if (D.30254 > i) goto <D.26528>; else goto <D.26530>;
  <D.26530>:
  nattrs.304 = (unsigned int) nattrs;
  buffer_add_int (buf, nattrs.304);
  i = 0;
  goto <D.26546>;
  <D.26545>:
  {
    struct MonoCustomAttrEntry * attr;

    attr = &cinfo->attrs[i];
    if (attr_klass == 0B) goto <D.30256>; else goto <D.30258>;
    <D.30258>:
    D.30259 = attr->ctor;
    D.30260 = D.30259->klass;
    D.30261 = mono_class_has_parent (D.30260, attr_klass);
    if (D.30261 != 0) goto <D.30256>; else goto <D.30257>;
    <D.30256>:
    {
      struct MonoArray * typed_args;
      struct MonoArray * named_args;
      struct MonoType * t;
      struct CattrNamedArg * arginfo;
      struct MonoError error;

      try
        {
          arginfo = 0B;
          D.30259 = attr->ctor;
          D.30262 = attr->data;
          D.30263 = attr->data_size;
          mono_reflection_create_custom_attr_data_args (image, D.30259, D.30262, D.30263, &typed_args, &named_args, &arginfo, &error);
          D.30264 = mono_error_ok (&error);
          D.30265 = D.30264 == 0;
          D.30266 = (long int) D.30265;
          D.30267 = __builtin_expect (D.30266, 0);
          if (D.30267 != 0) goto <D.30268>; else goto <D.30269>;
          <D.30268>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 7448, "mono_error_ok (&error)");
          <D.30269>:
          D.30259 = attr->ctor;
          buffer_add_methodid (buf, domain, D.30259);
          typed_args.305 = typed_args;
          if (typed_args.305 != 0B) goto <D.30271>; else goto <D.30272>;
          <D.30271>:
          typed_args.305 = typed_args;
          D.30273 = mono_array_length (typed_args.305);
          buffer_add_int (buf, D.30273);
          j = 0;
          goto <D.26539>;
          <D.26538>:
          {
            struct MonoObject * val;

            typed_args.305 = typed_args;
            j.306 = (unsigned int) j;
            D.30275 = mono_array_addr_with_size (typed_args.305, 4, j.306);
            val = MEM[(struct MonoObject * *)D.30275];
            D.30259 = attr->ctor;
            D.30276 = mono_method_signature (D.30259);
            t = D.30276->params[j];
            buffer_add_cattr_arg (buf, t, domain, val);
          }
          j = j + 1;
          <D.26539>:
          j.306 = (unsigned int) j;
          typed_args.305 = typed_args;
          D.30277 = mono_array_length (typed_args.305);
          if (j.306 < D.30277) goto <D.26538>; else goto <D.26540>;
          <D.26540>:
          goto <D.30278>;
          <D.30272>:
          buffer_add_int (buf, 0);
          <D.30278>:
          named_args.307 = named_args;
          if (named_args.307 != 0B) goto <D.30280>; else goto <D.30281>;
          <D.30280>:
          named_args.307 = named_args;
          D.30282 = mono_array_length (named_args.307);
          buffer_add_int (buf, D.30282);
          j = 0;
          goto <D.26543>;
          <D.26542>:
          {
            struct MonoObject * val;

            named_args.307 = named_args;
            j.306 = (unsigned int) j;
            D.30283 = mono_array_addr_with_size (named_args.307, 4, j.306);
            val = MEM[(struct MonoObject * *)D.30283];
            arginfo.308 = arginfo;
            j.309 = (unsigned int) j;
            D.30286 = j.309 * 12;
            D.30287 = arginfo.308 + D.30286;
            D.30288 = D.30287->prop;
            if (D.30288 != 0B) goto <D.30289>; else goto <D.30290>;
            <D.30289>:
            buffer_add_byte (buf, 84);
            arginfo.308 = arginfo;
            j.309 = (unsigned int) j;
            D.30286 = j.309 * 12;
            D.30287 = arginfo.308 + D.30286;
            D.30288 = D.30287->prop;
            buffer_add_propertyid (buf, domain, D.30288);
            goto <D.30291>;
            <D.30290>:
            arginfo.308 = arginfo;
            j.309 = (unsigned int) j;
            D.30286 = j.309 * 12;
            D.30287 = arginfo.308 + D.30286;
            D.30292 = D.30287->field;
            if (D.30292 != 0B) goto <D.30293>; else goto <D.30294>;
            <D.30293>:
            buffer_add_byte (buf, 83);
            arginfo.308 = arginfo;
            j.309 = (unsigned int) j;
            D.30286 = j.309 * 12;
            D.30287 = arginfo.308 + D.30286;
            D.30292 = D.30287->field;
            buffer_add_fieldid (buf, domain, D.30292);
            goto <D.30295>;
            <D.30294>:
            monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "debugger-agent.c", 7480);
            <D.30295>:
            <D.30291>:
            arginfo.308 = arginfo;
            j.309 = (unsigned int) j;
            D.30286 = j.309 * 12;
            D.30287 = arginfo.308 + D.30286;
            D.30296 = D.30287->type;
            buffer_add_cattr_arg (buf, D.30296, domain, val);
          }
          j = j + 1;
          <D.26543>:
          j.306 = (unsigned int) j;
          named_args.307 = named_args;
          D.30297 = mono_array_length (named_args.307);
          if (j.306 < D.30297) goto <D.26542>; else goto <D.26544>;
          <D.26544>:
          goto <D.30298>;
          <D.30281>:
          buffer_add_int (buf, 0);
          <D.30298>:
          arginfo.308 = arginfo;
          monoeg_g_free (arginfo.308);
        }
      finally
        {
          typed_args = {CLOBBER};
          named_args = {CLOBBER};
          arginfo = {CLOBBER};
          error = {CLOBBER};
        }
    }
    <D.30257>:
  }
  i = i + 1;
  <D.26546>:
  D.30254 = cinfo->num_attrs;
  if (D.30254 > i) goto <D.26545>; else goto <D.26547>;
  <D.26547>:
}


mono_class_has_parent (struct MonoClass * klass, struct MonoClass * parent)
{
  struct MonoClass * * D.30300;
  _Bool D.30301;
  long int D.30302;
  long int D.30303;
  struct MonoClass * * D.30306;
  _Bool D.30307;
  long int D.30308;
  long int D.30309;
  gboolean D.30312;

  D.30300 = klass->supertypes;
  D.30301 = D.30300 == 0B;
  D.30302 = (long int) D.30301;
  D.30303 = __builtin_expect (D.30302, 0);
  if (D.30303 != 0) goto <D.30304>; else goto <D.30305>;
  <D.30304>:
  mono_class_setup_supertypes (klass);
  <D.30305>:
  D.30306 = parent->supertypes;
  D.30307 = D.30306 == 0B;
  D.30308 = (long int) D.30307;
  D.30309 = __builtin_expect (D.30308, 0);
  if (D.30309 != 0) goto <D.30310>; else goto <D.30311>;
  <D.30310>:
  mono_class_setup_supertypes (parent);
  <D.30311>:
  D.30312 = mono_class_has_parent_fast (klass, parent);
  return D.30312;
}


mono_class_has_parent_fast (struct MonoClass * klass, struct MonoClass * parent)
{
  gboolean D.30314;
  int iftmp.310;
  short unsigned int D.30318;
  short unsigned int D.30319;
  struct MonoClass * * D.30321;
  sizetype D.30322;
  sizetype D.30323;
  sizetype D.30324;
  struct MonoClass * * D.30325;
  struct MonoClass * D.30326;

  D.30318 = klass->idepth;
  D.30319 = parent->idepth;
  if (D.30318 >= D.30319) goto <D.30320>; else goto <D.30316>;
  <D.30320>:
  D.30321 = klass->supertypes;
  D.30319 = parent->idepth;
  D.30322 = (sizetype) D.30319;
  D.30323 = D.30322 + 1073741823;
  D.30324 = D.30323 * 4;
  D.30325 = D.30321 + D.30324;
  D.30326 = *D.30325;
  if (D.30326 == parent) goto <D.30327>; else goto <D.30316>;
  <D.30327>:
  iftmp.310 = 1;
  goto <D.30317>;
  <D.30316>:
  iftmp.310 = 0;
  <D.30317>:
  D.30314 = iftmp.310;
  return D.30314;
}


buffer_add_cattr_arg (struct Buffer * buf, struct MonoType * t, struct MonoDomain * domain, struct MonoObject * val)
{
  struct MonoObject * val.311;
  struct MonoVTable * D.30333;
  struct MonoClass * D.30334;
  struct MonoClass * D.30335;
  struct MonoType * D.30337;
  struct MonoClass * D.30338;
  int D.30339;
  void * D.30343;

  val.311 = val;
  if (val.311 != 0B) goto <D.30332>; else goto <D.30329>;
  <D.30332>:
  val.311 = val;
  D.30333 = val.311->vtable;
  D.30334 = D.30333->klass;
  D.30335 = mono_defaults.monotype_class;
  if (D.30334 == D.30335) goto <D.30336>; else goto <D.30329>;
  <D.30336>:
  buffer_add_byte (buf, 241);
  val.311 = val;
  D.30337 = MEM[(struct MonoReflectionType *)val.311].type;
  D.30338 = mono_class_from_mono_type (D.30337);
  buffer_add_typeid (buf, domain, D.30338);
  goto <D.30330>;
  <D.30329>:
  D.30339 = mono_type_is_reference (t);
  if (D.30339 != 0) goto <D.30340>; else goto <D.30341>;
  <D.30340>:
  buffer_add_value (buf, t, &val, domain);
  goto <D.30342>;
  <D.30341>:
  val.311 = val;
  D.30343 = mono_object_unbox (val.311);
  buffer_add_value (buf, t, D.30343, domain);
  <D.30342>:
  <D.30330>:
}


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 int D.30344;
  unsigned int D.30345;
  void * D.30348;
  _Bool D.30351;
  long int D.30352;
  long int D.30353;
  unsigned char D.30358;
  int D.30359;
  signed char D.30360;
  unsigned int D.30361;
  short int D.30362;
  unsigned int D.30363;
  int D.30364;
  unsigned int D.30365;
  long long int D.30366;
  long long unsigned int D.30367;
  long long unsigned int D.30368;
  struct MonoVTable * D.30372;
  struct MonoClass * D.30373;
  unsigned int D.30374;
  unsigned int D.30375;
  unsigned char D.30378;
  unsigned char D.30381;
  int D.30382;
  <unnamed-unsigned:1> D.30387;
  int D.30388;
  struct MonoType * D.30389;
  short unsigned int D.30390;
  int D.30391;
  int D.30392;
  int D.30395;
  int D.25937;
  int iftmp.312;
  int D.25936;
  const char[9] * D.30401;
  unsigned char D.30402;
  int D.30403;
  unsigned char D.30404;
  int D.30405;
  const unsigned char * D.30410;
  unsigned char D.30411;
  int D.30412;
  const unsigned char * D.30413;
  unsigned char D.30414;
  int D.30415;
  const unsigned char * D.30420;
  unsigned char D.30421;
  int D.30422;
  const unsigned char * D.30423;
  unsigned char D.30424;
  int D.30425;
  const unsigned char * D.30430;
  unsigned char D.30431;
  int D.30432;
  const unsigned char * D.30433;
  unsigned char D.30434;
  int D.30435;
  const char * D.30437;
  unsigned int nfields.313;
  int D.25949;
  int iftmp.314;
  int D.25948;
  unsigned char D.30448;
  int D.30449;
  const unsigned char * D.30454;
  unsigned char D.30455;
  int D.30456;
  const unsigned char * D.30461;
  unsigned char D.30462;
  int D.30463;
  const unsigned char * D.30468;
  unsigned char D.30469;
  int D.30470;
  const char * D.30472;
  int D.30475;
  sizetype D.30476;
  sizetype D.30477;
  void * D.30478;
  int D.30479;
  struct MonoObject * obj;
  void handle_vtype = <<< error >>>;
  void handle_ref = <<< error >>>;

  D.30344 = BIT_FIELD_REF <*t, 32, 32>;
  D.30345 = D.30344 & 1073741824;
  if (D.30345 != 0) goto <D.30346>; else goto <D.30347>;
  <D.30346>:
  D.30348 = MEM[(void * *)addr];
  if (D.30348 == 0B) goto <D.30349>; else goto <D.30350>;
  <D.30349>:
  buffer_add_byte (buf, 240);
  return;
  <D.30350>:
  D.30348 = MEM[(void * *)addr];
  D.30351 = D.30348 == 0B;
  D.30352 = (long int) D.30351;
  D.30353 = __builtin_expect (D.30352, 0);
  if (D.30353 != 0) goto <D.30354>; else goto <D.30355>;
  <D.30354>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 5513, "*(void**)addr");
  <D.30355>:
  addr = MEM[(void * *)addr];
  <D.30347>:
  if (as_vtype != 0) goto <D.30356>; else goto <D.30357>;
  <D.30356>:
  D.30358 = t->type;
  D.30359 = (int) D.30358;
  switch (D.30359) <default: <D.25897>, case 2: <D.25881>, case 3: <D.25884>, case 4: <D.25882>, case 5: <D.25883>, case 6: <D.25885>, case 7: <D.25886>, case 8: <D.25887>, case 9: <D.25888>, case 10: <D.25890>, case 11: <D.25891>, case 12: <D.25889>, case 13: <D.25892>, case 15: <D.25895>, case 24: <D.25893>, case 25: <D.25894>>
  <D.25881>:
  <D.25882>:
  <D.25883>:
  <D.25884>:
  <D.25885>:
  <D.25886>:
  <D.25887>:
  <D.25888>:
  <D.25889>:
  <D.25890>:
  <D.25891>:
  <D.25892>:
  <D.25893>:
  <D.25894>:
  <D.25895>:
  goto handle_vtype;
  <D.25897>:
  goto <D.25898>;
  <D.25898>:
  <D.30357>:
  D.30358 = t->type;
  D.30359 = (int) D.30358;
  switch (D.30359) <default: <D.25953>, case 1: <D.25899>, case 2: <D.25901>, case 3: <D.25904>, case 4: <D.25902>, case 5: <D.25903>, case 6: <D.25905>, case 7: <D.25906>, case 8: <D.25907>, case 9: <D.25908>, case 10: <D.25910>, case 11: <D.25911>, case 12: <D.25909>, case 13: <D.25912>, case 14: <D.25918>, case 15: <D.25915>, case 17: <D.25923>, case 18: <D.25921>, case 20: <D.25922>, case 21: <D.25952>, case 24: <D.25913>, case 25: <D.25914>, case 28: <D.25920>, case 29: <D.25919>>
  <D.25899>:
  D.30358 = t->type;
  D.30359 = (int) D.30358;
  buffer_add_byte (buf, D.30359);
  goto <D.25900>;
  <D.25901>:
  <D.25902>:
  <D.25903>:
  D.30358 = t->type;
  D.30359 = (int) D.30358;
  buffer_add_byte (buf, D.30359);
  D.30360 = MEM[(gint8 *)addr];
  D.30361 = (unsigned int) D.30360;
  buffer_add_int (buf, D.30361);
  goto <D.25900>;
  <D.25904>:
  <D.25905>:
  <D.25906>:
  D.30358 = t->type;
  D.30359 = (int) D.30358;
  buffer_add_byte (buf, D.30359);
  D.30362 = MEM[(gint16 *)addr];
  D.30363 = (unsigned int) D.30362;
  buffer_add_int (buf, D.30363);
  goto <D.25900>;
  <D.25907>:
  <D.25908>:
  <D.25909>:
  D.30358 = t->type;
  D.30359 = (int) D.30358;
  buffer_add_byte (buf, D.30359);
  D.30364 = MEM[(gint32 *)addr];
  D.30365 = (unsigned int) D.30364;
  buffer_add_int (buf, D.30365);
  goto <D.25900>;
  <D.25910>:
  <D.25911>:
  <D.25912>:
  D.30358 = t->type;
  D.30359 = (int) D.30358;
  buffer_add_byte (buf, D.30359);
  D.30366 = MEM[(gint64 *)addr];
  D.30367 = (long long unsigned int) D.30366;
  buffer_add_long (buf, D.30367);
  goto <D.25900>;
  <D.25913>:
  <D.25914>:
  goto handle_vtype;
  <D.25915>:
  {
    gssize val;

    val = MEM[(gssize *)addr];
    D.30358 = t->type;
    D.30359 = (int) D.30358;
    buffer_add_byte (buf, D.30359);
    D.30368 = (long long unsigned int) val;
    buffer_add_long (buf, D.30368);
    goto <D.25900>;
  }
  handle_ref:
  <D.25918>:
  <D.25919>:
  <D.25920>:
  <D.25921>:
  <D.25922>:
  obj = MEM[(struct MonoObject * *)addr];
  if (obj == 0B) goto <D.30369>; else goto <D.30370>;
  <D.30369>:
  buffer_add_byte (buf, 240);
  goto <D.30371>;
  <D.30370>:
  D.30372 = obj->vtable;
  D.30373 = D.30372->klass;
  D.30374 = BIT_FIELD_REF <*D.30373, 32, 160>;
  D.30375 = D.30374 & 8;
  if (D.30375 != 0) goto <D.30376>; else goto <D.30377>;
  <D.30376>:
  D.30372 = obj->vtable;
  D.30373 = D.30372->klass;
  t = &D.30373->byval_arg;
  addr = mono_object_unbox (obj);
  goto handle_vtype;
  <D.30377>:
  D.30372 = obj->vtable;
  D.30373 = D.30372->klass;
  D.30378 = D.30373->rank;
  if (D.30378 != 0) goto <D.30379>; else goto <D.30380>;
  <D.30379>:
  D.30372 = obj->vtable;
  D.30373 = D.30372->klass;
  D.30381 = D.30373->byval_arg.type;
  D.30382 = (int) D.30381;
  buffer_add_byte (buf, D.30382);
  goto <D.30383>;
  <D.30380>:
  D.30372 = obj->vtable;
  D.30373 = D.30372->klass;
  D.30381 = D.30373->byval_arg.type;
  if (D.30381 == 21) goto <D.30384>; else goto <D.30385>;
  <D.30384>:
  buffer_add_byte (buf, 18);
  goto <D.30386>;
  <D.30385>:
  D.30372 = obj->vtable;
  D.30373 = D.30372->klass;
  D.30381 = D.30373->byval_arg.type;
  D.30382 = (int) D.30381;
  buffer_add_byte (buf, D.30382);
  <D.30386>:
  <D.30383>:
  buffer_add_objid (buf, obj);
  <D.30371>:
  goto <D.25900>;
  handle_vtype:
  <D.25923>:
  {
    int nfields;
    void * iter;
    struct MonoClassField * f;
    struct MonoClass * klass;

    try
      {
        klass = mono_class_from_mono_type (t);
        buffer_add_byte (buf, 17);
        D.30387 = klass->enumtype;
        D.30388 = (int) D.30387;
        buffer_add_byte (buf, D.30388);
        buffer_add_typeid (buf, domain, klass);
        nfields = 0;
        iter = 0B;
        goto <D.25928>;
        <D.25938>:
        D.30389 = f->type;
        D.30390 = D.30389->attrs;
        D.30391 = (int) D.30390;
        D.30392 = D.30391 & 16;
        if (D.30392 != 0) goto <D.30393>; else goto <D.30394>;
        <D.30393>:
        // predicted unlikely by continue predictor.
        goto <D.25928>;
        <D.30394>:
        D.30389 = f->type;
        D.30390 = D.30389->attrs;
        D.30391 = (int) D.30390;
        D.30395 = D.30391 & 1536;
        if (D.30395 != 0) goto <D.30396>; else goto <D.30397>;
        <D.30396>:
        {
          size_t __s1_len;
          size_t __s2_len;

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

            __s2 = mono_field_get_name (f);
            D.30401 = "_Deleted";
            D.30402 = MEM[(const unsigned char *)D.30401];
            D.30403 = (int) D.30402;
            D.30404 = *__s2;
            D.30405 = (int) D.30404;
            __result = D.30403 - D.30405;
            {
              if (__s2_len != 0) goto <D.30406>; else goto <D.30407>;
              <D.30406>:
              if (__result == 0) goto <D.30408>; else goto <D.30409>;
              <D.30408>:
              D.30410 = &MEM[(void *)"_Deleted" + 1B];
              D.30411 = *D.30410;
              D.30412 = (int) D.30411;
              D.30413 = __s2 + 1;
              D.30414 = *D.30413;
              D.30415 = (int) D.30414;
              __result = D.30412 - D.30415;
              if (__s2_len > 1) goto <D.30416>; else goto <D.30417>;
              <D.30416>:
              if (__result == 0) goto <D.30418>; else goto <D.30419>;
              <D.30418>:
              D.30420 = &MEM[(void *)"_Deleted" + 2B];
              D.30421 = *D.30420;
              D.30422 = (int) D.30421;
              D.30423 = __s2 + 2;
              D.30424 = *D.30423;
              D.30425 = (int) D.30424;
              __result = D.30422 - D.30425;
              if (__s2_len > 2) goto <D.30426>; else goto <D.30427>;
              <D.30426>:
              if (__result == 0) goto <D.30428>; else goto <D.30429>;
              <D.30428>:
              D.30430 = &MEM[(void *)"_Deleted" + 3B];
              D.30431 = *D.30430;
              D.30432 = (int) D.30431;
              D.30433 = __s2 + 3;
              D.30434 = *D.30433;
              D.30435 = (int) D.30434;
              __result = D.30432 - D.30435;
              <D.30429>:
              <D.30427>:
              <D.30419>:
              <D.30417>:
              <D.30409>:
              <D.30407>:
            }
            D.25936 = __result;
          }
          iftmp.312 = -D.25936;
          goto <D.30436>;
          <D.30400>:
          D.30437 = mono_field_get_name (f);
          iftmp.312 = __builtin_strcmp (D.30437, "_Deleted");
          <D.30436>:
          D.25937 = iftmp.312;
        }
        if (D.25937 == 0) goto <D.30438>; else goto <D.30439>;
        <D.30438>:
        // predicted unlikely by continue predictor.
        goto <D.25928>;
        <D.30439>:
        <D.30397>:
        nfields = nfields + 1;
        <D.25928>:
        f = mono_class_get_fields (klass, &iter);
        if (f != 0B) goto <D.25938>; else goto <D.25939>;
        <D.25939>:
        nfields.313 = (unsigned int) nfields;
        buffer_add_int (buf, nfields.313);
        iter = 0B;
        goto <D.25940>;
        <D.25950>:
        D.30389 = f->type;
        D.30390 = D.30389->attrs;
        D.30391 = (int) D.30390;
        D.30392 = D.30391 & 16;
        if (D.30392 != 0) goto <D.30441>; else goto <D.30442>;
        <D.30441>:
        // predicted unlikely by continue predictor.
        goto <D.25940>;
        <D.30442>:
        D.30389 = f->type;
        D.30390 = D.30389->attrs;
        D.30391 = (int) D.30390;
        D.30395 = D.30391 & 1536;
        if (D.30395 != 0) goto <D.30443>; else goto <D.30444>;
        <D.30443>:
        {
          size_t __s1_len;
          size_t __s2_len;

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

            __s2 = mono_field_get_name (f);
            D.30401 = "_Deleted";
            D.30402 = MEM[(const unsigned char *)D.30401];
            D.30403 = (int) D.30402;
            D.30448 = *__s2;
            D.30449 = (int) D.30448;
            __result = D.30403 - D.30449;
            {
              if (__s2_len != 0) goto <D.30450>; else goto <D.30451>;
              <D.30450>:
              if (__result == 0) goto <D.30452>; else goto <D.30453>;
              <D.30452>:
              D.30410 = &MEM[(void *)"_Deleted" + 1B];
              D.30411 = *D.30410;
              D.30412 = (int) D.30411;
              D.30454 = __s2 + 1;
              D.30455 = *D.30454;
              D.30456 = (int) D.30455;
              __result = D.30412 - D.30456;
              if (__s2_len > 1) goto <D.30457>; else goto <D.30458>;
              <D.30457>:
              if (__result == 0) goto <D.30459>; else goto <D.30460>;
              <D.30459>:
              D.30420 = &MEM[(void *)"_Deleted" + 2B];
              D.30421 = *D.30420;
              D.30422 = (int) D.30421;
              D.30461 = __s2 + 2;
              D.30462 = *D.30461;
              D.30463 = (int) D.30462;
              __result = D.30422 - D.30463;
              if (__s2_len > 2) goto <D.30464>; else goto <D.30465>;
              <D.30464>:
              if (__result == 0) goto <D.30466>; else goto <D.30467>;
              <D.30466>:
              D.30430 = &MEM[(void *)"_Deleted" + 3B];
              D.30431 = *D.30430;
              D.30432 = (int) D.30431;
              D.30468 = __s2 + 3;
              D.30469 = *D.30468;
              D.30470 = (int) D.30469;
              __result = D.30432 - D.30470;
              <D.30467>:
              <D.30465>:
              <D.30460>:
              <D.30458>:
              <D.30453>:
              <D.30451>:
            }
            D.25948 = __result;
          }
          iftmp.314 = -D.25948;
          goto <D.30471>;
          <D.30447>:
          D.30472 = mono_field_get_name (f);
          iftmp.314 = __builtin_strcmp (D.30472, "_Deleted");
          <D.30471>:
          D.25949 = iftmp.314;
        }
        if (D.25949 == 0) goto <D.30473>; else goto <D.30474>;
        <D.30473>:
        // predicted unlikely by continue predictor.
        goto <D.25940>;
        <D.30474>:
        <D.30444>:
        D.30389 = f->type;
        D.30475 = f->offset;
        D.30476 = (sizetype) D.30475;
        D.30477 = D.30476 + 4294967288;
        D.30478 = addr + D.30477;
        buffer_add_value_full (buf, D.30389, D.30478, domain, 0);
        <D.25940>:
        f = mono_class_get_fields (klass, &iter);
        if (f != 0B) goto <D.25950>; else goto <D.25951>;
        <D.25951>:
        goto <D.25900>;
      }
    finally
      {
        iter = {CLOBBER};
      }
  }
  <D.25952>:
  D.30479 = mono_type_generic_inst_is_valuetype (t);
  if (D.30479 != 0) goto handle_vtype; else goto handle_ref;
  <D.25953>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "debugger-agent.c", 5645);
  <D.25900>:
}


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

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


collect_interfaces (struct MonoClass * klass, struct GHashTable * ifaces, struct MonoError * error)
{
  int D.30485;
  struct MonoClass * * D.30488;
  unsigned int i.315;
  unsigned int D.30490;
  struct MonoClass * * D.30491;
  int D.30492;
  short unsigned int D.30495;
  int D.30496;
  int i;
  struct MonoClass * ic;

  mono_class_setup_interfaces (klass, error);
  D.30485 = mono_error_ok (error);
  if (D.30485 == 0) goto <D.30486>; else goto <D.30487>;
  <D.30486>:
  return;
  <D.30487>:
  i = 0;
  goto <D.26556>;
  <D.26555>:
  D.30488 = klass->interfaces;
  i.315 = (unsigned int) i;
  D.30490 = i.315 * 4;
  D.30491 = D.30488 + D.30490;
  ic = *D.30491;
  monoeg_g_hash_table_insert_replace (ifaces, ic, ic, 0);
  collect_interfaces (ic, ifaces, error);
  D.30492 = mono_error_ok (error);
  if (D.30492 == 0) goto <D.30493>; else goto <D.30494>;
  <D.30493>:
  return;
  <D.30494>:
  i = i + 1;
  <D.26556>:
  D.30495 = klass->interface_count;
  D.30496 = (int) D.30495;
  if (D.30496 > i) goto <D.26555>; else goto <D.26557>;
  <D.26557>:
}


method_commands (int command, guint8 * p, guint8 * end, struct Buffer * buf)
{
  guint8 * p.316;
  int err.317;
  ErrorCode D.30502;
  struct MonoDomain * domain.318;
  <unnamed type> D.30504;
  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.30500>; else goto <D.30501>;
      <D.30500>:
      err.317 = err;
      D.30502 = (ErrorCode) err.317;
      return D.30502;
      <D.30501>:
      old_domain = mono_domain_get ();
      domain.318 = domain;
      mono_domain_set (domain.318, 1);
      domain.318 = domain;
      p.316 = p;
      D.30504 = method_commands_internal (command, method, domain.318, p.316, end, buf);
      err.319 = (int) D.30504;
      err = err.319;
      mono_domain_set (old_domain, 1);
      err.317 = err;
      D.30502 = (ErrorCode) err.317;
      return D.30502;
    }
  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.30508;
  struct MonoClass * D.30509;
  unsigned int D.30514;
  int protocol_version_set.320;
  int major_version.321;
  int minor_version.322;
  struct GPtrArray * source_file_list.323;
  unsigned int D.30525;
  void * * D.30526;
  unsigned int i.324;
  unsigned int D.30528;
  void * * D.30529;
  char * D.30530;
  guint8 * D.30536;
  sizetype j.325;
  guint8 * D.30538;
  unsigned char D.30539;
  int D.30540;
  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.30546;
  long int D.30547;
  long int D.30548;
  struct FILE * log_file.331;
  char * D.30552;
  int * source_files.332;
  int * D.30554;
  int D.30555;
  unsigned int D.30558;
  unsigned int D.30559;
  void * * D.30560;
  int * il_offsets.333;
  int * D.30564;
  int D.30565;
  int * line_numbers.334;
  int * D.30567;
  int D.30568;
  int iftmp.335;
  int * column_numbers.336;
  int * D.30573;
  unsigned int D.30575;
  unsigned int D.30576;
  unsigned int D.30583;
  guint32 iftmp.337;
  int D.30593;
  <unnamed-unsigned:6> D.30595;
  unsigned int D.30596;
  short unsigned int D.30597;
  unsigned int D.30598;
  short unsigned int D.30599;
  unsigned int D.30600;
  struct MonoType * D.30601;
  struct MonoClass * D.30602;
  struct MonoType * D.30603;
  struct MonoClass * D.30604;
  unsigned int D.30605;
  unsigned int D.30606;
  unsigned int D.30607;
  char * * D.30608;
  char * D.30609;
  ErrorCode D.30612;
  short unsigned int D.30613;
  unsigned int D.30614;
  struct MonoType * D.30615;
  struct MonoClass * D.30616;
  int D.30617;
  struct MonoDebugLocalVar * D.30621;
  unsigned int j.338;
  unsigned int D.30623;
  struct MonoDebugLocalVar * D.30624;
  int D.30625;
  char * D.30629;
  struct MonoDebugCodeBlock * D.30635;
  int D.30637;
  unsigned int D.30638;
  int D.30639;
  unsigned int D.30640;
  short unsigned int D.30643;
  unsigned int D.30644;
  short unsigned int D.30645;
  unsigned int D.30646;
  unsigned int D.30647;
  unsigned int D.30654;
  unsigned int D.30655;
  struct MonoMethodSignature * D.30658;
  short unsigned int D.30659;
  int D.30662;
  unsigned int D.30663;
  struct MonoGenericInst * D.30669;
  struct MonoGenericContext * D.30672;
  struct MonoGenericContext * D.30675;
  struct MonoMethodSignature * D.30683;
  short unsigned int D.30684;
  unsigned int D.30687;
  struct MonoGenericContext * D.30690;
  <unnamed-unsigned:22> D.30693;
  unsigned int count.339;
  struct MonoType * D.30695;
  struct MonoClass * D.30696;
  struct MonoMethodSignature * D.30701;
  short unsigned int D.30702;
  struct MonoGenericParamFull * D.30703;
  unsigned int i.340;
  unsigned int D.30705;
  struct MonoImage * D.30706;
  const unsigned char * D.30718;
  sizetype i.341;
  const unsigned char * D.30720;
  unsigned char D.30721;
  int D.30722;
  unsigned int i.342;
  <unnamed-unsigned:15> D.30729;
  unsigned int D.30730;
  struct MonoExceptionClause * D.30731;
  unsigned int i.343;
  unsigned int D.30733;
  unsigned int D.30734;
  unsigned int D.30735;
  unsigned int D.30736;
  unsigned int D.30737;
  unsigned int D.30738;
  struct MonoClass * D.30741;
  unsigned int D.30745;
  int D.30746;
  guint8 * p.344;
  int D.30748;
  unsigned int D.30749;
  unsigned int D.30750;
  _Bool D.30751;
  long int D.30752;
  long int D.30753;
  unsigned int D.30756;
  unsigned int D.30759;
  void * handle_class.345;
  struct MonoClass * handle_class.346;
  _Bool D.30765;
  long int D.30766;
  long int D.30767;
  struct MonoClass * D.30770;
  struct MonoClass * D.30776;
  struct MonoClass * D.30778;
  struct MonoClass * D.30782;
  struct MonoClass * D.30786;
  int err.347;
  unsigned int type_argc.348;
  unsigned int D.30794;
  struct MonoDomain * d.349;
  unsigned int i.350;
  unsigned int D.30801;
  struct MonoType * * D.30802;
  struct MonoType * D.30803;
  struct MonoGenericInst * iftmp.351;
  struct MonoGenericClass * D.30805;
  int D.30809;
  struct MonoMethodHeader * header;
  int err;

  try
    {
      switch (command) <default: <D.26846>, case 1: <D.26739>, case 2: <D.26741>, case 3: <D.26742>, case 4: <D.26765>, case 5: <D.26775>, case 6: <D.26795>, case 7: <D.26812>, case 8: <D.26821>, case 9: <D.26831>, case 10: <D.26834>>
      <D.26739>:
      D.30508 = method->name;
      buffer_add_string (buf, D.30508);
      goto <D.26740>;
      <D.26741>:
      D.30509 = method->klass;
      buffer_add_typeid (buf, domain, D.30509);
      goto <D.26740>;
      <D.26742>:
      {
        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.30510>; else goto <D.30511>;
            <D.30510>:
            buffer_add_int (buf, 0);
            buffer_add_string (buf, "");
            buffer_add_int (buf, 0);
            goto <D.26740>;
            <D.30511>:
            minfo = mono_debug_lookup_method (method);
            if (minfo == 0B) goto <D.30512>; else goto <D.30513>;
            <D.30512>:
            D.30514 = header->code_size;
            buffer_add_int (buf, D.30514);
            buffer_add_string (buf, "");
            buffer_add_int (buf, 0);
            mono_metadata_free_mh (header);
            goto <D.26740>;
            <D.30513>:
            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.30514 = header->code_size;
            buffer_add_int (buf, D.30514);
            protocol_version_set.320 = protocol_version_set;
            if (protocol_version_set.320 != 0) goto <D.30519>; else goto <D.30515>;
            <D.30519>:
            major_version.321 = major_version;
            if (major_version.321 > 2) goto <D.30516>; else goto <D.30521>;
            <D.30521>:
            major_version.321 = major_version;
            if (major_version.321 == 2) goto <D.30522>; else goto <D.30515>;
            <D.30522>:
            minor_version.322 = minor_version;
            if (minor_version.322 > 12) goto <D.30516>; else goto <D.30515>;
            <D.30516>:
            source_file_list.323 = source_file_list;
            D.30525 = source_file_list.323->len;
            buffer_add_int (buf, D.30525);
            i = 0;
            goto <D.26758>;
            <D.26757>:
            {
              struct MonoDebugSourceInfo * sinfo;

              source_file_list.323 = source_file_list;
              D.30526 = source_file_list.323->pdata;
              i.324 = (unsigned int) i;
              D.30528 = i.324 * 4;
              D.30529 = D.30526 + D.30528;
              sinfo = *D.30529;
              D.30530 = sinfo->source_file;
              buffer_add_string (buf, D.30530);
              protocol_version_set.320 = protocol_version_set;
              if (protocol_version_set.320 != 0) goto <D.30532>; else goto <D.30533>;
              <D.30532>:
              major_version.321 = major_version;
              if (major_version.321 > 2) goto <D.30531>; else goto <D.30534>;
              <D.30534>:
              major_version.321 = major_version;
              if (major_version.321 == 2) goto <D.30535>; else goto <D.26756>;
              <D.30535>:
              minor_version.322 = minor_version;
              if (minor_version.322 > 13) goto <D.30531>; else goto <D.26756>;
              <D.30531>:
              j = 0;
              goto <D.26755>;
              <D.26754>:
              D.30536 = sinfo->hash;
              j.325 = (sizetype) j;
              D.30538 = D.30536 + j.325;
              D.30539 = *D.30538;
              D.30540 = (int) D.30539;
              buffer_add_byte (buf, D.30540);
              j = j + 1;
              <D.26755>:
              if (j <= 15) goto <D.26754>; else goto <D.26756>;
              <D.26756>:
              <D.30533>:
            }
            i = i + 1;
            <D.26758>:
            i.326 = (unsigned int) i;
            source_file_list.323 = source_file_list;
            D.30525 = source_file_list.323->len;
            if (i.326 < D.30525) goto <D.26757>; else goto <D.26759>;
            <D.26759>:
            goto <D.30517>;
            <D.30515>:
            source_file.327 = source_file;
            buffer_add_string (buf, source_file.327);
            <D.30517>:
            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.30546 = log_level.330 > 9;
            D.30547 = (long int) D.30546;
            D.30548 = __builtin_expect (D.30547, 0);
            if (D.30548 != 0) goto <D.30549>; else goto <D.30550>;
            <D.30549>:
            log_file.331 = log_file;
            D.30552 = mono_method_full_name (method, 1);
            fprintf (log_file.331, "Line number table for method %s:\n", D.30552);
            log_file.331 = log_file;
            fflush (log_file.331);
            <D.30550>:
            i = 0;
            goto <D.26763>;
            <D.26762>:
            {
              const char * srcfile;

              srcfile = "";
              source_files.332 = source_files;
              i.324 = (unsigned int) i;
              D.30528 = i.324 * 4;
              D.30554 = source_files.332 + D.30528;
              D.30555 = *D.30554;
              if (D.30555 != -1) goto <D.30556>; else goto <D.30557>;
              <D.30556>:
              {
                struct MonoDebugSourceInfo * sinfo;

                source_file_list.323 = source_file_list;
                D.30526 = source_file_list.323->pdata;
                source_files.332 = source_files;
                i.324 = (unsigned int) i;
                D.30528 = i.324 * 4;
                D.30554 = source_files.332 + D.30528;
                D.30555 = *D.30554;
                D.30558 = (unsigned int) D.30555;
                D.30559 = D.30558 * 4;
                D.30560 = D.30526 + D.30559;
                sinfo = *D.30560;
                srcfile = sinfo->source_file;
              }
              <D.30557>:
              log_level.330 = log_level;
              D.30546 = log_level.330 > 9;
              D.30547 = (long int) D.30546;
              D.30548 = __builtin_expect (D.30547, 0);
              if (D.30548 != 0) goto <D.30561>; else goto <D.30562>;
              <D.30561>:
              log_file.331 = log_file;
              il_offsets.333 = il_offsets;
              i.324 = (unsigned int) i;
              D.30528 = i.324 * 4;
              D.30564 = il_offsets.333 + D.30528;
              D.30565 = *D.30564;
              line_numbers.334 = line_numbers;
              i.324 = (unsigned int) i;
              D.30528 = i.324 * 4;
              D.30567 = line_numbers.334 + D.30528;
              D.30568 = *D.30567;
              column_numbers.336 = column_numbers;
              if (column_numbers.336 != 0B) goto <D.30571>; else goto <D.30572>;
              <D.30571>:
              column_numbers.336 = column_numbers;
              i.324 = (unsigned int) i;
              D.30528 = i.324 * 4;
              D.30573 = column_numbers.336 + D.30528;
              iftmp.335 = *D.30573;
              goto <D.30574>;
              <D.30572>:
              iftmp.335 = -1;
              <D.30574>:
              fprintf (log_file.331, "IL%x -> %s:%d %d\n", D.30565, srcfile, D.30568, iftmp.335);
              log_file.331 = log_file;
              fflush (log_file.331);
              <D.30562>:
              il_offsets.333 = il_offsets;
              i.324 = (unsigned int) i;
              D.30528 = i.324 * 4;
              D.30564 = il_offsets.333 + D.30528;
              D.30565 = *D.30564;
              D.30575 = (unsigned int) D.30565;
              buffer_add_int (buf, D.30575);
              line_numbers.334 = line_numbers;
              i.324 = (unsigned int) i;
              D.30528 = i.324 * 4;
              D.30567 = line_numbers.334 + D.30528;
              D.30568 = *D.30567;
              D.30576 = (unsigned int) D.30568;
              buffer_add_int (buf, D.30576);
              protocol_version_set.320 = protocol_version_set;
              if (protocol_version_set.320 != 0) goto <D.30579>; else goto <D.30580>;
              <D.30579>:
              major_version.321 = major_version;
              if (major_version.321 > 2) goto <D.30577>; else goto <D.30581>;
              <D.30581>:
              major_version.321 = major_version;
              if (major_version.321 == 2) goto <D.30582>; else goto <D.30578>;
              <D.30582>:
              minor_version.322 = minor_version;
              if (minor_version.322 > 12) goto <D.30577>; else goto <D.30578>;
              <D.30577>:
              source_files.332 = source_files;
              i.324 = (unsigned int) i;
              D.30528 = i.324 * 4;
              D.30554 = source_files.332 + D.30528;
              D.30555 = *D.30554;
              D.30583 = (unsigned int) D.30555;
              buffer_add_int (buf, D.30583);
              <D.30578>:
              <D.30580>:
              protocol_version_set.320 = protocol_version_set;
              if (protocol_version_set.320 != 0) goto <D.30586>; else goto <D.30587>;
              <D.30586>:
              major_version.321 = major_version;
              if (major_version.321 > 2) goto <D.30584>; else goto <D.30588>;
              <D.30588>:
              major_version.321 = major_version;
              if (major_version.321 == 2) goto <D.30589>; else goto <D.30585>;
              <D.30589>:
              minor_version.322 = minor_version;
              if (minor_version.322 > 18) goto <D.30584>; else goto <D.30585>;
              <D.30584>:
              column_numbers.336 = column_numbers;
              if (column_numbers.336 != 0B) goto <D.30591>; else goto <D.30592>;
              <D.30591>:
              column_numbers.336 = column_numbers;
              i.324 = (unsigned int) i;
              D.30528 = i.324 * 4;
              D.30573 = column_numbers.336 + D.30528;
              D.30593 = *D.30573;
              iftmp.337 = (guint32) D.30593;
              goto <D.30594>;
              <D.30592>:
              iftmp.337 = 4294967295;
              <D.30594>:
              buffer_add_int (buf, iftmp.337);
              <D.30585>:
              <D.30587>:
            }
            i = i + 1;
            <D.26763>:
            n_il_offsets.328 = n_il_offsets;
            if (i < n_il_offsets.328) goto <D.26762>; else goto <D.26764>;
            <D.26764>:
            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.26740>;
          }
        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.26765>:
      {
        struct MonoMethodSignature * sig;
        guint32 i;
        char * * names;

        sig = mono_method_signature (method);
        D.30595 = sig->call_convention;
        D.30596 = (unsigned int) D.30595;
        buffer_add_int (buf, D.30596);
        D.30597 = sig->param_count;
        D.30598 = (unsigned int) D.30597;
        buffer_add_int (buf, D.30598);
        D.30599 = sig->generic_param_count;
        D.30600 = (unsigned int) D.30599;
        buffer_add_int (buf, D.30600);
        D.30601 = sig->ret;
        D.30602 = mono_class_from_mono_type (D.30601);
        buffer_add_typeid (buf, domain, D.30602);
        i = 0;
        goto <D.26770>;
        <D.26769>:
        D.30603 = sig->params[i];
        D.30604 = mono_class_from_mono_type (D.30603);
        buffer_add_typeid (buf, domain, D.30604);
        i = i + 1;
        <D.26770>:
        D.30597 = sig->param_count;
        D.30598 = (unsigned int) D.30597;
        if (D.30598 > i) goto <D.26769>; else goto <D.26771>;
        <D.26771>:
        D.30597 = sig->param_count;
        D.30605 = (unsigned int) D.30597;
        D.30606 = D.30605 * 4;
        names = monoeg_malloc (D.30606);
        mono_method_get_param_names (method, names);
        i = 0;
        goto <D.26773>;
        <D.26772>:
        D.30607 = i * 4;
        D.30608 = names + D.30607;
        D.30609 = *D.30608;
        buffer_add_string (buf, D.30609);
        i = i + 1;
        <D.26773>:
        D.30597 = sig->param_count;
        D.30598 = (unsigned int) D.30597;
        if (D.30598 > i) goto <D.26772>; else goto <D.26774>;
        <D.26774>:
        monoeg_g_free (names);
        goto <D.26740>;
      }
      <D.26775>:
      {
        int i;
        int j;
        int num_locals;
        struct MonoDebugLocalsInfo * locals;

        header = mono_method_get_header (method);
        if (header == 0B) goto <D.30610>; else goto <D.30611>;
        <D.30610>:
        D.30612 = 102;
        return D.30612;
        <D.30611>:
        D.30613 = header->num_locals;
        D.30614 = (unsigned int) D.30613;
        buffer_add_int (buf, D.30614);
        i = 0;
        goto <D.26781>;
        <D.26780>:
        D.30615 = header->locals[i];
        D.30616 = mono_class_from_mono_type (D.30615);
        buffer_add_typeid (buf, domain, D.30616);
        i = i + 1;
        <D.26781>:
        D.30613 = header->num_locals;
        D.30617 = (int) D.30613;
        if (D.30617 > i) goto <D.26780>; else goto <D.26782>;
        <D.26782>:
        locals = mono_debug_lookup_locals (method);
        if (locals != 0B) goto <D.30618>; else goto <D.30619>;
        <D.30618>:
        num_locals = locals->num_locals;
        goto <D.30620>;
        <D.30619>:
        num_locals = 0;
        <D.30620>:
        i = 0;
        goto <D.26787>;
        <D.26786>:
        j = 0;
        goto <D.26785>;
        <D.26784>:
        D.30621 = locals->locals;
        j.338 = (unsigned int) j;
        D.30623 = j.338 * 12;
        D.30624 = D.30621 + D.30623;
        D.30625 = D.30624->index;
        if (D.30625 == i) goto <D.26783>; else goto <D.30626>;
        <D.30626>:
        j = j + 1;
        <D.26785>:
        if (j < num_locals) goto <D.26784>; else goto <D.26783>;
        <D.26783>:
        if (j < num_locals) goto <D.30627>; else goto <D.30628>;
        <D.30627>:
        D.30621 = locals->locals;
        j.338 = (unsigned int) j;
        D.30623 = j.338 * 12;
        D.30624 = D.30621 + D.30623;
        D.30629 = D.30624->name;
        buffer_add_string (buf, D.30629);
        goto <D.30630>;
        <D.30628>:
        buffer_add_string (buf, "");
        <D.30630>:
        i = i + 1;
        <D.26787>:
        D.30613 = header->num_locals;
        D.30617 = (int) D.30613;
        if (D.30617 > i) goto <D.26786>; else goto <D.26788>;
        <D.26788>:
        i = 0;
        goto <D.26793>;
        <D.26792>:
        j = 0;
        goto <D.26791>;
        <D.26790>:
        D.30621 = locals->locals;
        j.338 = (unsigned int) j;
        D.30623 = j.338 * 12;
        D.30624 = D.30621 + D.30623;
        D.30625 = D.30624->index;
        if (D.30625 == i) goto <D.26789>; else goto <D.30631>;
        <D.30631>:
        j = j + 1;
        <D.26791>:
        if (j < num_locals) goto <D.26790>; else goto <D.26789>;
        <D.26789>:
        if (j < num_locals) goto <D.30634>; else goto <D.30632>;
        <D.30634>:
        D.30621 = locals->locals;
        j.338 = (unsigned int) j;
        D.30623 = j.338 * 12;
        D.30624 = D.30621 + D.30623;
        D.30635 = D.30624->block;
        if (D.30635 != 0B) goto <D.30636>; else goto <D.30632>;
        <D.30636>:
        D.30621 = locals->locals;
        j.338 = (unsigned int) j;
        D.30623 = j.338 * 12;
        D.30624 = D.30621 + D.30623;
        D.30635 = D.30624->block;
        D.30637 = D.30635->start_offset;
        D.30638 = (unsigned int) D.30637;
        buffer_add_int (buf, D.30638);
        D.30621 = locals->locals;
        j.338 = (unsigned int) j;
        D.30623 = j.338 * 12;
        D.30624 = D.30621 + D.30623;
        D.30635 = D.30624->block;
        D.30639 = D.30635->end_offset;
        D.30640 = (unsigned int) D.30639;
        buffer_add_int (buf, D.30640);
        goto <D.30633>;
        <D.30632>:
        buffer_add_int (buf, 0);
        D.30514 = header->code_size;
        buffer_add_int (buf, D.30514);
        <D.30633>:
        i = i + 1;
        <D.26793>:
        D.30613 = header->num_locals;
        D.30617 = (int) D.30613;
        if (D.30617 > i) goto <D.26792>; else goto <D.26794>;
        <D.26794>:
        mono_metadata_free_mh (header);
        if (locals != 0B) goto <D.30641>; else goto <D.30642>;
        <D.30641>:
        mono_debug_symfile_free_locals (locals);
        <D.30642>:
        goto <D.26740>;
      }
      <D.26795>:
      D.30643 = method->flags;
      D.30644 = (unsigned int) D.30643;
      buffer_add_int (buf, D.30644);
      D.30645 = method->iflags;
      D.30646 = (unsigned int) D.30645;
      buffer_add_int (buf, D.30646);
      D.30647 = method->token;
      buffer_add_int (buf, D.30647);
      protocol_version_set.320 = protocol_version_set;
      if (protocol_version_set.320 != 0) goto <D.30650>; else goto <D.30651>;
      <D.30650>:
      major_version.321 = major_version;
      if (major_version.321 > 2) goto <D.30648>; else goto <D.30652>;
      <D.30652>:
      major_version.321 = major_version;
      if (major_version.321 == 2) goto <D.30653>; else goto <D.30649>;
      <D.30653>:
      minor_version.322 = minor_version;
      if (minor_version.322 > 11) goto <D.30648>; else goto <D.30649>;
      <D.30648>:
      {
        guint8 attrs;

        attrs = 0;
        D.30654 = BIT_FIELD_REF <*method, 32, 160>;
        D.30655 = D.30654 & 2048;
        if (D.30655 != 0) goto <D.30656>; else goto <D.30657>;
        <D.30656>:
        attrs = attrs | 1;
        <D.30657>:
        D.30658 = mono_method_signature (method);
        D.30659 = D.30658->generic_param_count;
        if (D.30659 != 0) goto <D.30660>; else goto <D.30661>;
        <D.30660>:
        attrs = attrs | 2;
        <D.30661>:
        D.30662 = (int) attrs;
        buffer_add_byte (buf, D.30662);
        D.30654 = BIT_FIELD_REF <*method, 32, 160>;
        D.30663 = D.30654 & 6144;
        if (D.30663 != 0) goto <D.30664>; else goto <D.30665>;
        <D.30664>:
        {
          struct MonoMethod * result;

          D.30654 = BIT_FIELD_REF <*method, 32, 160>;
          D.30655 = D.30654 & 2048;
          if (D.30655 != 0) goto <D.30666>; else goto <D.30667>;
          <D.30666>:
          result = method;
          goto <D.30668>;
          <D.30667>:
          {
            struct MonoMethodInflated * imethod;

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

              klass = MEM[(struct MonoMethod *)imethod].klass;
              D.30672 = mono_class_get_context (klass);
              if (D.30672 != 0B) goto <D.30673>; else goto <D.30674>;
              <D.30673>:
              D.30675 = mono_class_get_context (klass);
              result = mono_class_inflate_generic_method_full (result, klass, D.30675);
              <D.30674>:
            }
            <D.30671>:
          }
          <D.30668>:
          buffer_add_methodid (buf, domain, result);
        }
        goto <D.30676>;
        <D.30665>:
        buffer_add_id (buf, 0);
        <D.30676>:
        protocol_version_set.320 = protocol_version_set;
        if (protocol_version_set.320 != 0) goto <D.30679>; else goto <D.30680>;
        <D.30679>:
        major_version.321 = major_version;
        if (major_version.321 > 2) goto <D.30677>; else goto <D.30681>;
        <D.30681>:
        major_version.321 = major_version;
        if (major_version.321 == 2) goto <D.30682>; else goto <D.30678>;
        <D.30682>:
        minor_version.322 = minor_version;
        if (minor_version.322 > 14) goto <D.30677>; else goto <D.30678>;
        <D.30677>:
        D.30683 = mono_method_signature (method);
        D.30684 = D.30683->generic_param_count;
        if (D.30684 != 0) goto <D.30685>; else goto <D.30686>;
        <D.30685>:
        {
          int count;
          int i;

          D.30654 = BIT_FIELD_REF <*method, 32, 160>;
          D.30687 = D.30654 & 4096;
          if (D.30687 != 0) goto <D.30688>; else goto <D.30689>;
          <D.30688>:
          {
            struct MonoGenericInst * inst;

            D.30690 = mono_method_get_context (method);
            inst = D.30690->method_inst;
            if (inst != 0B) goto <D.30691>; else goto <D.30692>;
            <D.30691>:
            D.30693 = inst->type_argc;
            count = (int) D.30693;
            count.339 = (unsigned int) count;
            buffer_add_int (buf, count.339);
            i = 0;
            goto <D.26804>;
            <D.26803>:
            D.30695 = inst->type_argv[i];
            D.30696 = mono_class_from_mono_type (D.30695);
            buffer_add_typeid (buf, domain, D.30696);
            i = i + 1;
            <D.26804>:
            if (i < count) goto <D.26803>; else goto <D.26805>;
            <D.26805>:
            goto <D.30697>;
            <D.30692>:
            buffer_add_int (buf, 0);
            <D.30697>:
          }
          goto <D.30698>;
          <D.30689>:
          D.30654 = BIT_FIELD_REF <*method, 32, 160>;
          D.30655 = D.30654 & 2048;
          if (D.30655 != 0) goto <D.30699>; else goto <D.30700>;
          <D.30699>:
          {
            struct MonoGenericContainer * container;

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

              D.30703 = container->type_params;
              i.340 = (unsigned int) i;
              D.30705 = i.340 * 32;
              param = D.30703 + D.30705;
              D.30509 = method->klass;
              D.30706 = D.30509->image;
              pklass = mono_class_from_generic_parameter (param, D.30706, 1);
              buffer_add_typeid (buf, domain, pklass);
            }
            i = i + 1;
            <D.26810>:
            if (i < count) goto <D.26809>; else goto <D.26811>;
            <D.26811>:
          }
          goto <D.30707>;
          <D.30700>:
          buffer_add_int (buf, 0);
          <D.30707>:
          <D.30698>:
        }
        goto <D.30708>;
        <D.30686>:
        buffer_add_int (buf, 0);
        <D.30708>:
        <D.30678>:
        <D.30680>:
      }
      <D.30649>:
      <D.30651>:
      goto <D.26740>;
      <D.26812>:
      {
        int i;

        header = mono_method_get_header (method);
        if (header == 0B) goto <D.30709>; else goto <D.30710>;
        <D.30709>:
        buffer_add_int (buf, 0);
        protocol_version_set.320 = protocol_version_set;
        if (protocol_version_set.320 != 0) goto <D.30713>; else goto <D.30714>;
        <D.30713>:
        major_version.321 = major_version;
        if (major_version.321 > 2) goto <D.30711>; else goto <D.30715>;
        <D.30715>:
        major_version.321 = major_version;
        if (major_version.321 == 2) goto <D.30716>; else goto <D.30712>;
        <D.30716>:
        minor_version.322 = minor_version;
        if (minor_version.322 > 17) goto <D.30711>; else goto <D.30712>;
        <D.30711>:
        buffer_add_int (buf, 0);
        <D.30712>:
        <D.30714>:
        goto <D.30717>;
        <D.30710>:
        D.30514 = header->code_size;
        buffer_add_int (buf, D.30514);
        i = 0;
        goto <D.26815>;
        <D.26814>:
        D.30718 = header->code;
        i.341 = (sizetype) i;
        D.30720 = D.30718 + i.341;
        D.30721 = *D.30720;
        D.30722 = (int) D.30721;
        buffer_add_byte (buf, D.30722);
        i = i + 1;
        <D.26815>:
        i.342 = (unsigned int) i;
        D.30514 = header->code_size;
        if (i.342 < D.30514) goto <D.26814>; else goto <D.26816>;
        <D.26816>:
        protocol_version_set.320 = protocol_version_set;
        if (protocol_version_set.320 != 0) goto <D.30725>; else goto <D.30726>;
        <D.30725>:
        major_version.321 = major_version;
        if (major_version.321 > 2) goto <D.30724>; else goto <D.30727>;
        <D.30727>:
        major_version.321 = major_version;
        if (major_version.321 == 2) goto <D.30728>; else goto <D.26820>;
        <D.30728>:
        minor_version.322 = minor_version;
        if (minor_version.322 > 17) goto <D.30724>; else goto <D.26820>;
        <D.30724>:
        D.30729 = header->num_clauses;
        D.30730 = (unsigned int) D.30729;
        buffer_add_int (buf, D.30730);
        i = 0;
        goto <D.26819>;
        <D.26818>:
        {
          struct MonoExceptionClause * clause;

          D.30731 = header->clauses;
          i.343 = (unsigned int) i;
          D.30733 = i.343 * 24;
          clause = D.30731 + D.30733;
          D.30734 = clause->flags;
          buffer_add_int (buf, D.30734);
          D.30735 = clause->try_offset;
          buffer_add_int (buf, D.30735);
          D.30736 = clause->try_len;
          buffer_add_int (buf, D.30736);
          D.30737 = clause->handler_offset;
          buffer_add_int (buf, D.30737);
          D.30738 = clause->handler_len;
          buffer_add_int (buf, D.30738);
          D.30734 = clause->flags;
          if (D.30734 == 0) goto <D.30739>; else goto <D.30740>;
          <D.30739>:
          D.30741 = clause->data.catch_class;
          buffer_add_typeid (buf, domain, D.30741);
          goto <D.30742>;
          <D.30740>:
          D.30734 = clause->flags;
          if (D.30734 == 1) goto <D.30743>; else goto <D.30744>;
          <D.30743>:
          D.30745 = clause->data.filter_offset;
          buffer_add_int (buf, D.30745);
          <D.30744>:
          <D.30742>:
        }
        i = i + 1;
        <D.26819>:
        D.30729 = header->num_clauses;
        D.30746 = (int) D.30729;
        if (D.30746 > i) goto <D.26818>; else goto <D.26820>;
        <D.26820>:
        <D.30726>:
        mono_metadata_free_mh (header);
        <D.30717>:
        goto <D.26740>;
      }
      <D.26821>:
      {
        guint32 token;

        p.344 = p;
        D.30748 = decode_int (p.344, &p, end);
        token = (guint32) D.30748;
        D.30749 = token & 4278190080;
        switch (D.30749) <default: <D.26827>, case 1879048192: <D.26823>>
        <D.26823>:
        {
          struct MonoString * s;
          char * s2;

          D.30509 = method->klass;
          D.30706 = D.30509->image;
          D.30750 = token & 16777215;
          s = mono_ldstr (domain, D.30706, D.30750);
          D.30751 = s == 0B;
          D.30752 = (long int) D.30751;
          D.30753 = __builtin_expect (D.30752, 0);
          if (D.30753 != 0) goto <D.30754>; else goto <D.30755>;
          <D.30754>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 8237, "s");
          <D.30755>:
          s2 = mono_string_to_utf8 (s);
          buffer_add_byte (buf, 0);
          buffer_add_string (buf, s2);
          monoeg_g_free (s2);
          goto <D.26826>;
        }
        <D.26827>:
        {
          void * val;
          struct MonoClass * handle_class;

          try
            {
              D.30654 = BIT_FIELD_REF <*method, 32, 160>;
              D.30756 = D.30654 & 124;
              if (D.30756 == 68) goto <D.30757>; else goto <D.30758>;
              <D.30757>:
              val = mono_method_get_wrapper_data (method, token);
              D.30759 = token + 1;
              handle_class.345 = mono_method_get_wrapper_data (method, D.30759);
              handle_class = handle_class.345;
              handle_class.346 = handle_class;
              if (handle_class.346 == 0B) goto <D.30762>; else goto <D.30763>;
              <D.30762>:
              buffer_add_byte (buf, 4);
              goto <D.26826>;
              <D.30763>:
              goto <D.30764>;
              <D.30758>:
              D.30509 = method->klass;
              D.30706 = D.30509->image;
              val = mono_ldtoken (D.30706, token, &handle_class, 0B);
              D.30765 = val == 0B;
              D.30766 = (long int) D.30765;
              D.30767 = __builtin_expect (D.30766, 0);
              if (D.30767 != 0) goto <D.30768>; else goto <D.30769>;
              <D.30768>:
              monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 8261, "val");
              <D.30769>:
              <D.30764>:
              D.30770 = mono_defaults.typehandle_class;
              handle_class.346 = handle_class;
              if (D.30770 == handle_class.346) goto <D.30771>; else goto <D.30772>;
              <D.30771>:
              buffer_add_byte (buf, 1);
              D.30654 = BIT_FIELD_REF <*method, 32, 160>;
              D.30756 = D.30654 & 124;
              if (D.30756 == 68) goto <D.30773>; else goto <D.30774>;
              <D.30773>:
              buffer_add_typeid (buf, domain, val);
              goto <D.30775>;
              <D.30774>:
              D.30776 = mono_class_from_mono_type (val);
              buffer_add_typeid (buf, domain, D.30776);
              <D.30775>:
              goto <D.30777>;
              <D.30772>:
              D.30778 = mono_defaults.fieldhandle_class;
              handle_class.346 = handle_class;
              if (D.30778 == handle_class.346) goto <D.30779>; else goto <D.30780>;
              <D.30779>:
              buffer_add_byte (buf, 2);
              buffer_add_fieldid (buf, domain, val);
              goto <D.30781>;
              <D.30780>:
              D.30782 = mono_defaults.methodhandle_class;
              handle_class.346 = handle_class;
              if (D.30782 == handle_class.346) goto <D.30783>; else goto <D.30784>;
              <D.30783>:
              buffer_add_byte (buf, 3);
              buffer_add_methodid (buf, domain, val);
              goto <D.30785>;
              <D.30784>:
              D.30786 = mono_defaults.string_class;
              handle_class.346 = handle_class;
              if (D.30786 == handle_class.346) goto <D.30787>; else goto <D.30788>;
              <D.30787>:
              {
                char * s;

                s = mono_string_to_utf8 (val);
                buffer_add_byte (buf, 0);
                buffer_add_string (buf, s);
                monoeg_g_free (s);
              }
              goto <D.30789>;
              <D.30788>:
              monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "debugger-agent.c", 8284);
              <D.30789>:
              <D.30785>:
              <D.30781>:
              <D.30777>:
              goto <D.26826>;
            }
          finally
            {
              handle_class = {CLOBBER};
            }
        }
        <D.26826>:
        goto <D.26740>;
      }
      <D.26831>:
      {
        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.30791>; else goto <D.30792>;
        <D.30791>:
        err.347 = err;
        D.30612 = (ErrorCode) err.347;
        return D.30612;
        <D.30792>:
        cinfo = mono_custom_attrs_from_method (method);
        D.30509 = method->klass;
        D.30706 = D.30509->image;
        buffer_add_cattrs (buf, domain, D.30706, attr_klass, cinfo);
        goto <D.26740>;
      }
      <D.26834>:
      {
        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.30794 = type_argc.348 * 4;
            type_argv = monoeg_malloc0 (D.30794);
            i = 0;
            goto <D.26844>;
            <D.26843>:
            p.344 = p;
            klass = decode_typeid (p.344, &p, end, &d, &err);
            err.347 = err;
            if (err.347 != 0) goto <D.30795>; else goto <D.30796>;
            <D.30795>:
            monoeg_g_free (type_argv);
            err.347 = err;
            D.30612 = (ErrorCode) err.347;
            return D.30612;
            <D.30796>:
            d.349 = d;
            if (domain != d.349) goto <D.30798>; else goto <D.30799>;
            <D.30798>:
            monoeg_g_free (type_argv);
            D.30612 = 102;
            return D.30612;
            <D.30799>:
            i.350 = (unsigned int) i;
            D.30801 = i.350 * 4;
            D.30802 = type_argv + D.30801;
            D.30803 = &klass->byval_arg;
            *D.30802 = D.30803;
            i = i + 1;
            <D.26844>:
            if (i < type_argc) goto <D.26843>; else goto <D.26845>;
            <D.26845>:
            ginst = mono_metadata_get_generic_inst (type_argc, type_argv);
            monoeg_g_free (type_argv);
            D.30509 = method->klass;
            D.30805 = D.30509->generic_class;
            if (D.30805 != 0B) goto <D.30806>; else goto <D.30807>;
            <D.30806>:
            D.30509 = method->klass;
            D.30805 = D.30509->generic_class;
            iftmp.351 = D.30805->context.class_inst;
            goto <D.30808>;
            <D.30807>:
            iftmp.351 = 0B;
            <D.30808>:
            tmp_context.class_inst = iftmp.351;
            tmp_context.method_inst = ginst;
            inflated = mono_class_inflate_generic_method (method, &tmp_context);
            D.30809 = mono_verifier_is_method_valid_generic_instantiation (inflated);
            if (D.30809 == 0) goto <D.30810>; else goto <D.30811>;
            <D.30810>:
            D.30612 = 102;
            return D.30612;
            <D.30811>:
            buffer_add_methodid (buf, domain, inflated);
            goto <D.26740>;
          }
        finally
          {
            d = {CLOBBER};
            tmp_context = {CLOBBER};
          }
      }
      <D.26846>:
      D.30612 = 100;
      return D.30612;
      <D.26740>:
      D.30612 = 0;
      return D.30612;
    }
  finally
    {
      err = {CLOBBER};
    }
}


thread_commands (int command, guint8 * p, guint8 * end, struct Buffer * buf)
{
  guint8 * p.352;
  <unnamed type> D.30819;
  ErrorCode D.30822;
  struct MonoThread * thread_obj.353;
  unsigned int name_len.354;
  long int name_len.355;
  _Bool D.30829;
  long int D.30830;
  long int D.30831;
  long int len.356;
  unsigned int len.357;
  int suspend_count.358;
  int D.30839;
  struct MonoGHashTable * thread_to_tls.359;
  _Bool D.30844;
  long int D.30845;
  long int D.30846;
  int D.30849;
  unsigned int D.30850;
  struct StackFrame * * D.30851;
  unsigned int i.360;
  unsigned int D.30853;
  struct StackFrame * * D.30854;
  struct StackFrame * D.30855;
  int D.30856;
  unsigned int D.30857;
  struct MonoDomain * D.30858;
  struct MonoMethod * D.30859;
  unsigned int D.30860;
  int D.30861;
  unsigned char D.30862;
  int D.30863;
  unsigned int D.30864;
  unsigned char D.30865;
  int D.30866;
  unsigned int thread.361;
  long long unsigned int D.30868;
  long long unsigned int D.30869;
  int objid;
  int err;
  struct MonoThread * thread_obj;
  struct MonoInternalThread * thread;

  try
    {
      p.352 = p;
      objid = decode_objid (p.352, &p, end);
      D.30819 = get_object (objid, &thread_obj);
      err = (int) D.30819;
      if (err != 0) goto <D.30820>; else goto <D.30821>;
      <D.30820>:
      D.30822 = (ErrorCode) err;
      return D.30822;
      <D.30821>:
      thread_obj.353 = thread_obj;
      thread = thread_obj.353->internal_thread;
      switch (command) <default: <D.26888>, case 1: <D.26873>, case 2: <D.26867>, case 3: <D.26884>, case 4: <D.26885>, case 5: <D.26886>, case 6: <D.26887>>
      <D.26867>:
      {
        guint32 name_len;
        gunichar2 * s;

        try
          {
            s = mono_thread_get_name (thread, &name_len);
            if (s == 0B) goto <D.30824>; else goto <D.30825>;
            <D.30824>:
            buffer_add_int (buf, 0);
            goto <D.30826>;
            <D.30825>:
            {
              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.30829 = name == 0B;
                  D.30830 = (long int) D.30829;
                  D.30831 = __builtin_expect (D.30830, 0);
                  if (D.30831 != 0) goto <D.30832>; else goto <D.30833>;
                  <D.30832>:
                  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 8395, "name");
                  <D.30833>:
                  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.30826>:
            goto <D.26872>;
          }
        finally
          {
            name_len = {CLOBBER};
          }
      }
      <D.26873>:
      {
        struct DebuggerTlsData * tls;
        int i;
        int start_frame;
        int length;

        goto <D.26879>;
        <D.26878>:
        suspend_count.358 = suspend_count;
        if (suspend_count.358 != 0) goto <D.30837>; else goto <D.30838>;
        <D.30837>:
        wait_for_suspend ();
        <D.30838>:
        <D.26879>:
        D.30839 = is_suspended ();
        if (D.30839 == 0) goto <D.26878>; else goto <D.26880>;
        <D.26880>:
        p.352 = p;
        start_frame = decode_int (p.352, &p, end);
        p.352 = p;
        length = decode_int (p.352, &p, end);
        if (start_frame != 0) goto <D.30840>; else goto <D.30842>;
        <D.30842>:
        if (length != -1) goto <D.30840>; else goto <D.30841>;
        <D.30840>:
        D.30822 = 100;
        return D.30822;
        <D.30841>:
        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.30844 = tls == 0B;
        D.30845 = (long int) D.30844;
        D.30846 = __builtin_expect (D.30845, 0);
        if (D.30846 != 0) goto <D.30847>; else goto <D.30848>;
        <D.30847>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 8428, "tls");
        <D.30848>:
        compute_frame_info (thread, tls);
        D.30849 = tls->frame_count;
        D.30850 = (unsigned int) D.30849;
        buffer_add_int (buf, D.30850);
        i = 0;
        goto <D.26882>;
        <D.26881>:
        D.30851 = tls->frames;
        i.360 = (unsigned int) i;
        D.30853 = i.360 * 4;
        D.30854 = D.30851 + D.30853;
        D.30855 = *D.30854;
        D.30856 = D.30855->id;
        D.30857 = (unsigned int) D.30856;
        buffer_add_int (buf, D.30857);
        D.30851 = tls->frames;
        i.360 = (unsigned int) i;
        D.30853 = i.360 * 4;
        D.30854 = D.30851 + D.30853;
        D.30855 = *D.30854;
        D.30858 = D.30855->domain;
        D.30851 = tls->frames;
        i.360 = (unsigned int) i;
        D.30853 = i.360 * 4;
        D.30854 = D.30851 + D.30853;
        D.30855 = *D.30854;
        D.30859 = D.30855->actual_method;
        buffer_add_methodid (buf, D.30858, D.30859);
        D.30851 = tls->frames;
        i.360 = (unsigned int) i;
        D.30853 = i.360 * 4;
        D.30854 = D.30851 + D.30853;
        D.30855 = *D.30854;
        D.30860 = D.30855->il_offset;
        buffer_add_int (buf, D.30860);
        D.30851 = tls->frames;
        i.360 = (unsigned int) i;
        D.30853 = i.360 * 4;
        D.30854 = D.30851 + D.30853;
        D.30855 = *D.30854;
        D.30861 = D.30855->flags;
        D.30862 = (unsigned char) D.30861;
        D.30863 = (int) D.30862;
        buffer_add_byte (buf, D.30863);
        i = i + 1;
        <D.26882>:
        D.30849 = tls->frame_count;
        if (D.30849 > i) goto <D.26881>; else goto <D.26883>;
        <D.26883>:
        goto <D.26872>;
      }
      <D.26884>:
      D.30864 = thread->state;
      buffer_add_int (buf, D.30864);
      goto <D.26872>;
      <D.26885>:
      D.30865 = thread->threadpool_thread;
      D.30866 = (int) D.30865;
      buffer_add_byte (buf, D.30866);
      goto <D.26872>;
      <D.26886>:
      thread.361 = (unsigned int) thread;
      D.30868 = (long long unsigned int) thread.361;
      buffer_add_long (buf, D.30868);
      goto <D.26872>;
      <D.26887>:
      D.30869 = thread->tid;
      buffer_add_long (buf, D.30869);
      goto <D.26872>;
      <D.26888>:
      D.30822 = 100;
      return D.30822;
      <D.26872>:
      D.30822 = 0;
      return D.30822;
    }
  finally
    {
      thread_obj = {CLOBBER};
    }
}


frame_commands (int command, guint8 * p, guint8 * end, struct Buffer * buf)
{
  guint8 * p.362;
  <unnamed type> D.30875;
  ErrorCode D.30878;
  struct MonoThread * thread_obj.363;
  struct MonoGHashTable * thread_to_tls.364;
  _Bool D.30881;
  long int D.30882;
  long int D.30883;
  struct StackFrame * * D.30886;
  unsigned int i.365;
  unsigned int D.30888;
  struct StackFrame * * D.30889;
  struct StackFrame * D.30890;
  int D.30891;
  int D.30893;
  unsigned int frame_idx.366;
  unsigned int D.30897;
  struct StackFrame * * D.30898;
  int D.30899;
  struct MonoDebugMethodJitInfo * D.30902;
  struct MonoMethod * D.30905;
  struct MonoDomain * D.30906;
  struct MonoDebugMethodJitInfo * D.30907;
  unsigned int D.30910;
  unsigned int D.30911;
  struct MonoMethod * D.30914;
  struct MonoDebugMethodJitInfo * D.30915;
  int log_level.367;
  _Bool D.30919;
  long int D.30920;
  long int D.30921;
  struct FILE * log_file.368;
  struct MonoMethod * D.30925;
  struct MonoSeqPointInfo * D.30926;
  int iftmp.369;
  unsigned int pos.370;
  unsigned int D.30937;
  _Bool D.30938;
  long int D.30939;
  long int D.30940;
  struct MonoDebugVarInfo * D.30943;
  unsigned int pos.371;
  unsigned int D.30945;
  struct MonoType * D.30946;
  struct MonoDebugVarInfo * D.30947;
  struct MonoContext * D.30948;
  int iftmp.372;
  unsigned int D.30955;
  _Bool D.30956;
  long int D.30957;
  long int D.30958;
  struct MonoDebugVarInfo * D.30961;
  struct MonoType * D.30962;
  struct MonoDebugVarInfo * D.30963;
  struct MonoClass * D.30964;
  unsigned int D.30965;
  unsigned int D.30966;
  unsigned int D.30969;
  unsigned int D.30970;
  struct MonoClass * D.30973;
  struct MonoType * D.30974;
  struct MonoClass * D.30976;
  struct MonoType * D.30977;
  struct MonoDebugVarInfo * D.30978;
  struct MonoType * D.30982;
  struct MonoType * D.30984;
  int iftmp.373;
  _Bool D.30992;
  long int D.30993;
  long int D.30994;
  int iftmp.374;
  _Bool D.31003;
  long int D.31004;
  long int D.31005;
  int D.31008;
  struct MonoClass * D.31012;
  int D.31013;
  unsigned int D.31014;
  <unnamed type> D.31015;
  mgreg_t *[32] * D.31018;
  struct MonoContext * D.31019;
  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.30875 = get_object (objid, &thread_obj);
      err = (int) D.30875;
      if (err != 0) goto <D.30876>; else goto <D.30877>;
      <D.30876>:
      D.30878 = (ErrorCode) err;
      return D.30878;
      <D.30877>:
      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.30881 = tls == 0B;
      D.30882 = (long int) D.30881;
      D.30883 = __builtin_expect (D.30882, 0);
      if (D.30883 != 0) goto <D.30884>; else goto <D.30885>;
      <D.30884>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 8495, "tls");
      <D.30885>:
      i = 0;
      goto <D.26912>;
      <D.26911>:
      D.30886 = tls->frames;
      i.365 = (unsigned int) i;
      D.30888 = i.365 * 4;
      D.30889 = D.30886 + D.30888;
      D.30890 = *D.30889;
      D.30891 = D.30890->id;
      if (D.30891 == id) goto <D.26910>; else goto <D.30892>;
      <D.30892>:
      i = i + 1;
      <D.26912>:
      D.30893 = tls->frame_count;
      if (D.30893 > i) goto <D.26911>; else goto <D.26910>;
      <D.26910>:
      D.30893 = tls->frame_count;
      if (D.30893 == i) goto <D.30894>; else goto <D.30895>;
      <D.30894>:
      D.30878 = 30;
      return D.30878;
      <D.30895>:
      frame_idx = i;
      D.30886 = tls->frames;
      frame_idx.366 = (unsigned int) frame_idx;
      D.30897 = frame_idx.366 * 4;
      D.30898 = D.30886 + D.30897;
      frame = *D.30898;
      D.30899 = frame->has_ctx;
      if (D.30899 == 0) goto <D.30900>; else goto <D.30901>;
      <D.30900>:
      D.30878 = 105;
      return D.30878;
      <D.30901>:
      D.30902 = frame->jit;
      if (D.30902 == 0B) goto <D.30903>; else goto <D.30904>;
      <D.30903>:
      D.30905 = frame->api_method;
      D.30906 = frame->domain;
      D.30907 = mono_debug_find_method (D.30905, D.30906);
      frame->jit = D.30907;
      D.30902 = frame->jit;
      if (D.30902 == 0B) goto <D.30908>; else goto <D.30909>;
      <D.30908>:
      D.30905 = frame->api_method;
      D.30910 = BIT_FIELD_REF <*D.30905, 32, 160>;
      D.30911 = D.30910 & 4096;
      if (D.30911 != 0) goto <D.30912>; else goto <D.30913>;
      <D.30912>:
      D.30905 = frame->api_method;
      D.30914 = mono_method_get_declaring_generic_method (D.30905);
      D.30906 = frame->domain;
      D.30915 = mono_debug_find_method (D.30914, D.30906);
      frame->jit = D.30915;
      <D.30913>:
      <D.30909>:
      D.30902 = frame->jit;
      if (D.30902 == 0B) goto <D.30916>; else goto <D.30917>;
      <D.30916>:
      {
        char * s;

        D.30905 = frame->api_method;
        s = mono_method_full_name (D.30905, 1);
        log_level.367 = log_level;
        D.30919 = log_level.367 > 0;
        D.30920 = (long int) D.30919;
        D.30921 = __builtin_expect (D.30920, 0);
        if (D.30921 != 0) goto <D.30922>; else goto <D.30923>;
        <D.30922>:
        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.30923>:
        monoeg_g_free (s);
        D.30878 = 105;
        return D.30878;
      }
      <D.30917>:
      <D.30904>:
      jit = frame->jit;
      D.30925 = frame->actual_method;
      sig = mono_method_signature (D.30925);
      D.30906 = frame->domain;
      D.30925 = frame->actual_method;
      D.30926 = get_seq_points (D.30906, D.30925);
      if (D.30926 == 0B) goto <D.30927>; else goto <D.30928>;
      <D.30927>:
      D.30878 = 105;
      return D.30878;
      <D.30928>:
      switch (command) <default: <D.26929>, case 1: <D.26914>, case 2: <D.26919>, case 3: <D.26922>>
      <D.26914>:
      p.362 = p;
      len = decode_int (p.362, &p, end);
      D.30925 = frame->actual_method;
      header = mono_method_get_header (D.30925);
      i = 0;
      goto <D.26916>;
      <D.26915>:
      p.362 = p;
      pos = decode_int (p.362, &p, end);
      if (pos < 0) goto <D.30929>; else goto <D.30930>;
      <D.30929>:
      pos = ~pos;
      if (pos < 0) goto <D.30932>; else goto <D.30935>;
      <D.30935>:
      pos.370 = (unsigned int) pos;
      D.30937 = jit->num_params;
      if (pos.370 >= D.30937) goto <D.30932>; else goto <D.30933>;
      <D.30932>:
      iftmp.369 = 1;
      goto <D.30934>;
      <D.30933>:
      iftmp.369 = 0;
      <D.30934>:
      D.30938 = iftmp.369 != 0;
      D.30939 = (long int) D.30938;
      D.30940 = __builtin_expect (D.30939, 0);
      if (D.30940 != 0) goto <D.30941>; else goto <D.30942>;
      <D.30941>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 8545, "pos >= 0 && pos < jit->num_params");
      <D.30942>:
      D.30943 = jit->params;
      pos.371 = (unsigned int) pos;
      D.30945 = pos.371 * 24;
      var = D.30943 + D.30945;
      D.30946 = sig->params[pos];
      D.30943 = jit->params;
      pos.371 = (unsigned int) pos;
      D.30945 = pos.371 * 24;
      D.30947 = D.30943 + D.30945;
      D.30948 = &frame->ctx;
      D.30906 = frame->domain;
      add_var (buf, jit, D.30946, D.30947, D.30948, D.30906, 0);
      goto <D.30949>;
      <D.30930>:
      if (pos < 0) goto <D.30951>; else goto <D.30954>;
      <D.30954>:
      pos.370 = (unsigned int) pos;
      D.30955 = jit->num_locals;
      if (pos.370 >= D.30955) goto <D.30951>; else goto <D.30952>;
      <D.30951>:
      iftmp.372 = 1;
      goto <D.30953>;
      <D.30952>:
      iftmp.372 = 0;
      <D.30953>:
      D.30956 = iftmp.372 != 0;
      D.30957 = (long int) D.30956;
      D.30958 = __builtin_expect (D.30957, 0);
      if (D.30958 != 0) goto <D.30959>; else goto <D.30960>;
      <D.30959>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 8551, "pos >= 0 && pos < jit->num_locals");
      <D.30960>:
      D.30961 = jit->locals;
      pos.371 = (unsigned int) pos;
      D.30945 = pos.371 * 24;
      var = D.30961 + D.30945;
      D.30962 = header->locals[pos];
      D.30961 = jit->locals;
      pos.371 = (unsigned int) pos;
      D.30945 = pos.371 * 24;
      D.30963 = D.30961 + D.30945;
      D.30948 = &frame->ctx;
      D.30906 = frame->domain;
      add_var (buf, jit, D.30962, D.30963, D.30948, D.30906, 0);
      <D.30949>:
      i = i + 1;
      <D.26916>:
      if (i < len) goto <D.26915>; else goto <D.26917>;
      <D.26917>:
      mono_metadata_free_mh (header);
      goto <D.26918>;
      <D.26919>:
      D.30905 = frame->api_method;
      D.30964 = D.30905->klass;
      D.30965 = BIT_FIELD_REF <*D.30964, 32, 160>;
      D.30966 = D.30965 & 8;
      if (D.30966 != 0) goto <D.30967>; else goto <D.30968>;
      <D.30967>:
      D.30969 = BIT_FIELD_REF <*sig, 32, 64>;
      D.30970 = D.30969 & 4194304;
      if (D.30970 == 0) goto <D.30971>; else goto <D.30972>;
      <D.30971>:
      {
        struct MonoObject * p;

        try
          {
            p = 0B;
            D.30973 = mono_defaults.object_class;
            D.30974 = &D.30973->byval_arg;
            D.30906 = frame->domain;
            buffer_add_value (buf, D.30974, &p, D.30906);
          }
        finally
          {
            p = {CLOBBER};
          }
      }
      goto <D.30975>;
      <D.30972>:
      D.30925 = frame->actual_method;
      D.30976 = D.30925->klass;
      D.30977 = &D.30976->this_arg;
      D.30978 = jit->this_var;
      D.30948 = &frame->ctx;
      D.30906 = frame->domain;
      add_var (buf, jit, D.30977, D.30978, D.30948, D.30906, 1);
      <D.30975>:
      goto <D.30979>;
      <D.30968>:
      D.30969 = BIT_FIELD_REF <*sig, 32, 64>;
      D.30970 = D.30969 & 4194304;
      if (D.30970 == 0) goto <D.30980>; else goto <D.30981>;
      <D.30980>:
      {
        struct MonoObject * p;

        try
          {
            p = 0B;
            D.30925 = frame->actual_method;
            D.30976 = D.30925->klass;
            D.30982 = &D.30976->byval_arg;
            D.30906 = frame->domain;
            buffer_add_value (buf, D.30982, &p, D.30906);
          }
        finally
          {
            p = {CLOBBER};
          }
      }
      goto <D.30983>;
      <D.30981>:
      D.30905 = frame->api_method;
      D.30964 = D.30905->klass;
      D.30984 = &D.30964->byval_arg;
      D.30978 = jit->this_var;
      D.30948 = &frame->ctx;
      D.30906 = frame->domain;
      add_var (buf, jit, D.30984, D.30978, D.30948, D.30906, 1);
      <D.30983>:
      <D.30979>:
      goto <D.26918>;
      <D.26922>:
      {
        guint8 * val_buf;
        struct MonoType * t;
        struct MonoDebugVarInfo * var;

        p.362 = p;
        len = decode_int (p.362, &p, end);
        D.30925 = frame->actual_method;
        header = mono_method_get_header (D.30925);
        i = 0;
        goto <D.26927>;
        <D.26926>:
        p.362 = p;
        pos = decode_int (p.362, &p, end);
        if (pos < 0) goto <D.30985>; else goto <D.30986>;
        <D.30985>:
        pos = ~pos;
        if (pos < 0) goto <D.30988>; else goto <D.30991>;
        <D.30991>:
        pos.370 = (unsigned int) pos;
        D.30937 = jit->num_params;
        if (pos.370 >= D.30937) goto <D.30988>; else goto <D.30989>;
        <D.30988>:
        iftmp.373 = 1;
        goto <D.30990>;
        <D.30989>:
        iftmp.373 = 0;
        <D.30990>:
        D.30992 = iftmp.373 != 0;
        D.30993 = (long int) D.30992;
        D.30994 = __builtin_expect (D.30993, 0);
        if (D.30994 != 0) goto <D.30995>; else goto <D.30996>;
        <D.30995>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 8593, "pos >= 0 && pos < jit->num_params");
        <D.30996>:
        t = sig->params[pos];
        D.30943 = jit->params;
        pos.371 = (unsigned int) pos;
        D.30945 = pos.371 * 24;
        var = D.30943 + D.30945;
        goto <D.30997>;
        <D.30986>:
        if (pos < 0) goto <D.30999>; else goto <D.31002>;
        <D.31002>:
        pos.370 = (unsigned int) pos;
        D.30955 = jit->num_locals;
        if (pos.370 >= D.30955) goto <D.30999>; else goto <D.31000>;
        <D.30999>:
        iftmp.374 = 1;
        goto <D.31001>;
        <D.31000>:
        iftmp.374 = 0;
        <D.31001>:
        D.31003 = iftmp.374 != 0;
        D.31004 = (long int) D.31003;
        D.31005 = __builtin_expect (D.31004, 0);
        if (D.31005 != 0) goto <D.31006>; else goto <D.31007>;
        <D.31006>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 8598, "pos >= 0 && pos < jit->num_locals");
        <D.31007>:
        t = header->locals[pos];
        D.30961 = jit->locals;
        pos.371 = (unsigned int) pos;
        D.30945 = pos.371 * 24;
        var = D.30961 + D.30945;
        <D.30997>:
        D.31008 = mono_type_is_reference (t);
        if (D.31008 != 0) goto <D.31009>; else goto <D.31010>;
        <D.31009>:
        val_buf = __builtin_alloca (4);
        goto <D.31011>;
        <D.31010>:
        D.31012 = mono_class_from_mono_type (t);
        D.31013 = mono_class_instance_size (D.31012);
        D.31014 = (unsigned int) D.31013;
        val_buf = __builtin_alloca (D.31014);
        <D.31011>:
        D.30906 = frame->domain;
        p.362 = p;
        D.31015 = decode_value (t, D.30906, val_buf, p.362, &p, end);
        err = (int) D.31015;
        if (err != 0) goto <D.31016>; else goto <D.31017>;
        <D.31016>:
        D.30878 = (ErrorCode) err;
        return D.30878;
        <D.31017>:
        D.30948 = &frame->ctx;
        D.30906 = frame->domain;
        D.31018 = &frame->reg_locations;
        D.31019 = &tls->restore_ctx;
        set_var (t, var, D.30948, D.30906, val_buf, D.31018, D.31019);
        i = i + 1;
        <D.26927>:
        if (i < len) goto <D.26926>; else goto <D.26928>;
        <D.26928>:
        mono_metadata_free_mh (header);
        goto <D.26918>;
      }
      <D.26929>:
      D.30878 = 100;
      return D.30878;
      <D.26918>:
      D.30878 = 0;
      return D.30878;
    }
  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.31022;
  int D.31023;
  int reg_val.375;
  int D.31025;
  unsigned int D.31026;
  int D.31027;
  _Bool D.31028;
  long int D.31029;
  long int D.31030;
  _Bool D.31033;
  long int D.31034;
  long int D.31035;
  _Bool D.31038;
  long int D.31039;
  long int D.31040;
  unsigned int D.31043;
  int D.31044;
  int D.31047;
  unsigned int D.31048;
  int D.31052;
  _Bool D.31054;
  long int D.31055;
  long int D.31056;
  unsigned int D.31059;
  int D.31060;
  int D.31063;
  unsigned int D.31064;
  int D.31068;
  _Bool D.31070;
  long int D.31071;
  long int D.31072;
  void * D.31075;
  sizetype D.31076;
  guint32 flags;
  int reg;
  guint8 * addr;
  guint8 * gaddr;
  mgreg_t reg_val;

  try
    {
      D.31022 = var->index;
      flags = D.31022 & 4026531840;
      D.31022 = var->index;
      D.31023 = (int) D.31022;
      reg = D.31023 & 268435455;
      switch (flags) <default: <D.26081>, case 0: <D.26069>, case 268435456: <D.26071>, case 805306368: <D.26072>, case 1073741824: <D.26073>, case 1342177280: <D.26075>, case 1610612736: <D.26074>>
      <D.26069>:
      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.26070>;
      <D.26071>:
      D.31025 = mono_arch_context_get_int_reg (ctx, reg);
      addr = (guint8 *) D.31025;
      D.31026 = var->offset;
      addr = addr + D.31026;
      buffer_add_value_full (buf, t, addr, domain, as_vtype);
      goto <D.26070>;
      <D.26072>:
      monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "debugger-agent.c", 5939);
      <D.26073>:
      <D.26074>:
      D.31027 = mono_arch_context_get_int_reg (ctx, reg);
      addr = (guint8 *) D.31027;
      D.31026 = var->offset;
      addr = addr + D.31026;
      gaddr = MEM[(void * *)addr];
      D.31028 = gaddr == 0B;
      D.31029 = (long int) D.31028;
      D.31030 = __builtin_expect (D.31029, 0);
      if (D.31030 != 0) goto <D.31031>; else goto <D.31032>;
      <D.31031>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 5948, "gaddr");
      <D.31032>:
      buffer_add_value_full (buf, t, gaddr, domain, as_vtype);
      goto <D.26070>;
      <D.26075>:
      {
        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.31033 = info_var == 0B;
        D.31034 = (long int) D.31033;
        D.31035 = __builtin_expect (D.31034, 0);
        if (D.31035 != 0) goto <D.31036>; else goto <D.31037>;
        <D.31036>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 5960, "info_var");
        <D.31037>:
        D.31038 = locals_var == 0B;
        D.31039 = (long int) D.31038;
        D.31040 = __builtin_expect (D.31039, 0);
        if (D.31040 != 0) goto <D.31041>; else goto <D.31042>;
        <D.31041>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 5961, "locals_var");
        <D.31042>:
        D.31043 = info_var->index;
        flags = D.31043 & 4026531840;
        D.31043 = info_var->index;
        D.31044 = (int) D.31043;
        reg = D.31044 & 268435455;
        if (flags == 268435456) goto <D.31045>; else goto <D.31046>;
        <D.31045>:
        D.31047 = mono_arch_context_get_int_reg (ctx, reg);
        addr = (guint8 *) D.31047;
        D.31048 = info_var->offset;
        addr = addr + D.31048;
        info = MEM[(void * *)addr];
        goto <D.31049>;
        <D.31046>:
        if (flags == 0) goto <D.31050>; else goto <D.31051>;
        <D.31050>:
        D.31052 = mono_arch_context_get_int_reg (ctx, reg);
        info = (struct MonoGSharedVtMethodRuntimeInfo *) D.31052;
        goto <D.31053>;
        <D.31051>:
        monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "debugger-agent.c", 5972);
        <D.31053>:
        <D.31049>:
        D.31054 = info == 0B;
        D.31055 = (long int) D.31054;
        D.31056 = __builtin_expect (D.31055, 0);
        if (D.31056 != 0) goto <D.31057>; else goto <D.31058>;
        <D.31057>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 5974, "info");
        <D.31058>:
        D.31059 = locals_var->index;
        flags = D.31059 & 4026531840;
        D.31059 = locals_var->index;
        D.31060 = (int) D.31059;
        reg = D.31060 & 268435455;
        if (flags == 268435456) goto <D.31061>; else goto <D.31062>;
        <D.31061>:
        D.31063 = mono_arch_context_get_int_reg (ctx, reg);
        addr = (guint8 *) D.31063;
        D.31064 = locals_var->offset;
        addr = addr + D.31064;
        locals = MEM[(void * *)addr];
        goto <D.31065>;
        <D.31062>:
        if (flags == 0) goto <D.31066>; else goto <D.31067>;
        <D.31066>:
        D.31068 = mono_arch_context_get_int_reg (ctx, reg);
        locals = (guint8 *) D.31068;
        goto <D.31069>;
        <D.31067>:
        monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "debugger-agent.c", 5985);
        <D.31069>:
        <D.31065>:
        D.31070 = locals == 0B;
        D.31071 = (long int) D.31070;
        D.31072 = __builtin_expect (D.31071, 0);
        if (D.31072 != 0) goto <D.31073>; else goto <D.31074>;
        <D.31073>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 5987, "locals");
        <D.31074>:
        D.31075 = info->entries[idx];
        D.31076 = (sizetype) D.31075;
        addr = locals + D.31076;
        buffer_add_value_full (buf, t, addr, domain, as_vtype);
        goto <D.26070>;
      }
      <D.26081>:
      monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "debugger-agent.c", 5996);
      <D.26070>:
    }
  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.31077;
  int D.31078;
  int D.31079;
  struct MonoClass * D.31083;
  int D.31084;
  unsigned int D.31085;
  unsigned int D.31086;
  unsigned int D.31087;
  unsigned int size.376;
  int D.31092;
  _Bool D.31093;
  long int D.31094;
  long int D.31095;
  guint32 flags;
  int reg;
  int size;
  guint8 * addr;
  guint8 * gaddr;

  D.31077 = var->index;
  flags = D.31077 & 4026531840;
  D.31077 = var->index;
  D.31078 = (int) D.31077;
  reg = D.31078 & 268435455;
  D.31079 = mono_type_is_reference (t);
  if (D.31079 != 0) goto <D.31080>; else goto <D.31081>;
  <D.31080>:
  size = 4;
  goto <D.31082>;
  <D.31081>:
  D.31083 = mono_class_from_mono_type (t);
  size = mono_class_value_size (D.31083, 0B);
  <D.31082>:
  switch (flags) <default: <D.26101>, case 0: <D.26096>, case 268435456: <D.26097>, case 805306368: <D.26100>, case 1073741824: <D.26099>>
  <D.26096>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "debugger-agent.c", 6066);
  <D.26097>:
  D.31084 = mono_arch_context_get_int_reg (ctx, reg);
  addr = (guint8 *) D.31084;
  D.31085 = var->offset;
  addr = addr + D.31085;
  D.31086 = BIT_FIELD_REF <*t, 32, 32>;
  D.31087 = D.31086 & 1073741824;
  if (D.31087 != 0) goto <D.31088>; else goto <D.31089>;
  <D.31088>:
  addr = MEM[(guint8 * *)addr];
  if (addr == 0B) goto <D.26098>; else goto <D.31090>;
  <D.31090>:
  <D.31089>:
  size.376 = (unsigned int) size;
  mono_gc_memmove_atomic (addr, val, size.376);
  goto <D.26098>;
  <D.26099>:
  D.31092 = mono_arch_context_get_int_reg (ctx, reg);
  addr = (guint8 *) D.31092;
  D.31085 = var->offset;
  addr = addr + D.31085;
  gaddr = MEM[(void * *)addr];
  D.31093 = gaddr == 0B;
  D.31094 = (long int) D.31093;
  D.31095 = __builtin_expect (D.31094, 0);
  if (D.31095 != 0) goto <D.31096>; else goto <D.31097>;
  <D.31096>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 6092, "gaddr");
  <D.31097>:
  size.376 = (unsigned int) size;
  mono_gc_memmove_atomic (gaddr, val, size.376);
  goto <D.26098>;
  <D.26100>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "debugger-agent.c", 6097);
  <D.26101>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "debugger-agent.c", 6100);
  <D.26098>:
}


array_commands (int command, guint8 * p, guint8 * end, struct Buffer * buf)
{
  guint8 * p.377;
  <unnamed type> D.31099;
  ErrorCode D.31102;
  struct MonoArray * arr.378;
  struct MonoVTable * D.31104;
  struct MonoClass * D.31105;
  unsigned char D.31106;
  unsigned int D.31107;
  struct MonoArrayBounds * D.31108;
  unsigned int D.31111;
  unsigned int i.379;
  unsigned int D.31114;
  struct MonoArrayBounds * D.31115;
  unsigned int D.31116;
  int D.31117;
  unsigned int D.31118;
  int D.31119;
  int iftmp.380;
  _Bool D.31125;
  long int D.31126;
  long int D.31127;
  unsigned int index.381;
  unsigned int len.382;
  unsigned int D.31132;
  _Bool D.31133;
  long int D.31134;
  long int D.31135;
  double[0:] * D.31138;
  int D.31139;
  sizetype D.31140;
  struct MonoClass * D.31141;
  struct MonoType * D.31142;
  struct MonoDomain * D.31143;
  int D.31144;
  int iftmp.383;
  _Bool D.31150;
  long int D.31151;
  long int D.31152;
  struct MonoArray * arr;
  int objid;
  int err;
  int index;
  int len;
  int i;
  int esize;
  void * elem;

  try
    {
      p.377 = p;
      objid = decode_objid (p.377, &p, end);
      D.31099 = get_object (objid, &arr);
      err = (int) D.31099;
      if (err != 0) goto <D.31100>; else goto <D.31101>;
      <D.31100>:
      D.31102 = (ErrorCode) err;
      return D.31102;
      <D.31101>:
      switch (command) <default: <D.26957>, case 1: <D.26944>, case 2: <D.26949>, case 3: <D.26953>>
      <D.26944>:
      arr.378 = arr;
      D.31104 = arr.378->obj.vtable;
      D.31105 = D.31104->klass;
      D.31106 = D.31105->rank;
      D.31107 = (unsigned int) D.31106;
      buffer_add_int (buf, D.31107);
      arr.378 = arr;
      D.31108 = arr.378->bounds;
      if (D.31108 == 0B) goto <D.31109>; else goto <D.31110>;
      <D.31109>:
      arr.378 = arr;
      D.31111 = arr.378->max_length;
      buffer_add_int (buf, D.31111);
      buffer_add_int (buf, 0);
      goto <D.31112>;
      <D.31110>:
      i = 0;
      goto <D.26946>;
      <D.26945>:
      arr.378 = arr;
      D.31108 = arr.378->bounds;
      i.379 = (unsigned int) i;
      D.31114 = i.379 * 8;
      D.31115 = D.31108 + D.31114;
      D.31116 = D.31115->length;
      buffer_add_int (buf, D.31116);
      arr.378 = arr;
      D.31108 = arr.378->bounds;
      i.379 = (unsigned int) i;
      D.31114 = i.379 * 8;
      D.31115 = D.31108 + D.31114;
      D.31117 = D.31115->lower_bound;
      D.31118 = (unsigned int) D.31117;
      buffer_add_int (buf, D.31118);
      i = i + 1;
      <D.26946>:
      arr.378 = arr;
      D.31104 = arr.378->obj.vtable;
      D.31105 = D.31104->klass;
      D.31106 = D.31105->rank;
      D.31119 = (int) D.31106;
      if (D.31119 > i) goto <D.26945>; else goto <D.26947>;
      <D.26947>:
      <D.31112>:
      goto <D.26948>;
      <D.26949>:
      p.377 = p;
      index = decode_int (p.377, &p, end);
      p.377 = p;
      len = decode_int (p.377, &p, end);
      if (index < 0) goto <D.31121>; else goto <D.31124>;
      <D.31124>:
      if (len < 0) goto <D.31121>; else goto <D.31122>;
      <D.31121>:
      iftmp.380 = 1;
      goto <D.31123>;
      <D.31122>:
      iftmp.380 = 0;
      <D.31123>:
      D.31125 = iftmp.380 != 0;
      D.31126 = (long int) D.31125;
      D.31127 = __builtin_expect (D.31126, 0);
      if (D.31127 != 0) goto <D.31128>; else goto <D.31129>;
      <D.31128>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 8653, "index >= 0 && len >= 0");
      <D.31129>:
      index.381 = (unsigned int) index;
      arr.378 = arr;
      D.31111 = arr.378->max_length;
      len.382 = (unsigned int) len;
      D.31132 = D.31111 - len.382;
      D.31133 = index.381 > D.31132;
      D.31134 = (long int) D.31133;
      D.31135 = __builtin_expect (D.31134, 0);
      if (D.31135 != 0) goto <D.31136>; else goto <D.31137>;
      <D.31136>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 8655, "!(index > arr->max_length - len)");
      <D.31137>:
      arr.378 = arr;
      D.31104 = arr.378->obj.vtable;
      D.31105 = D.31104->klass;
      esize = mono_array_element_size (D.31105);
      i = index;
      goto <D.26951>;
      <D.26950>:
      arr.378 = arr;
      D.31138 = &arr.378->vector;
      D.31139 = i * esize;
      D.31140 = (sizetype) D.31139;
      elem = D.31138 + D.31140;
      arr.378 = arr;
      D.31104 = arr.378->obj.vtable;
      D.31105 = D.31104->klass;
      D.31141 = D.31105->element_class;
      D.31142 = &D.31141->byval_arg;
      arr.378 = arr;
      D.31104 = arr.378->obj.vtable;
      D.31143 = D.31104->domain;
      buffer_add_value (buf, D.31142, elem, D.31143);
      i = i + 1;
      <D.26951>:
      D.31144 = index + len;
      if (D.31144 > i) goto <D.26950>; else goto <D.26952>;
      <D.26952>:
      goto <D.26948>;
      <D.26953>:
      p.377 = p;
      index = decode_int (p.377, &p, end);
      p.377 = p;
      len = decode_int (p.377, &p, end);
      if (index < 0) goto <D.31146>; else goto <D.31149>;
      <D.31149>:
      if (len < 0) goto <D.31146>; else goto <D.31147>;
      <D.31146>:
      iftmp.383 = 1;
      goto <D.31148>;
      <D.31147>:
      iftmp.383 = 0;
      <D.31148>:
      D.31150 = iftmp.383 != 0;
      D.31151 = (long int) D.31150;
      D.31152 = __builtin_expect (D.31151, 0);
      if (D.31152 != 0) goto <D.31153>; else goto <D.31154>;
      <D.31153>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 8667, "index >= 0 && len >= 0");
      <D.31154>:
      index.381 = (unsigned int) index;
      arr.378 = arr;
      D.31111 = arr.378->max_length;
      len.382 = (unsigned int) len;
      D.31132 = D.31111 - len.382;
      D.31133 = index.381 > D.31132;
      D.31134 = (long int) D.31133;
      D.31135 = __builtin_expect (D.31134, 0);
      if (D.31135 != 0) goto <D.31155>; else goto <D.31156>;
      <D.31155>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 8669, "!(index > arr->max_length - len)");
      <D.31156>:
      arr.378 = arr;
      D.31104 = arr.378->obj.vtable;
      D.31105 = D.31104->klass;
      esize = mono_array_element_size (D.31105);
      i = index;
      goto <D.26955>;
      <D.26954>:
      arr.378 = arr;
      D.31138 = &arr.378->vector;
      D.31139 = i * esize;
      D.31140 = (sizetype) D.31139;
      elem = D.31138 + D.31140;
      arr.378 = arr;
      D.31104 = arr.378->obj.vtable;
      D.31105 = D.31104->klass;
      D.31141 = D.31105->element_class;
      D.31142 = &D.31141->byval_arg;
      arr.378 = arr;
      D.31104 = arr.378->obj.vtable;
      D.31143 = D.31104->domain;
      p.377 = p;
      decode_value (D.31142, D.31143, elem, p.377, &p, end);
      i = i + 1;
      <D.26955>:
      D.31144 = index + len;
      if (D.31144 > i) goto <D.26954>; else goto <D.26956>;
      <D.26956>:
      goto <D.26948>;
      <D.26957>:
      D.31102 = 100;
      return D.31102;
      <D.26948>:
      D.31102 = 0;
      return D.31102;
    }
  finally
    {
      arr = {CLOBBER};
    }
}


string_commands (int command, guint8 * p, guint8 * end, struct Buffer * buf)
{
  guint8 * p.384;
  <unnamed type> D.31160;
  ErrorCode D.31163;
  struct MonoString * str.385;
  int D.31165;
  long long unsigned int D.31166;
  long long int D.31167;
  long long int D.31168;
  int D.31169;
  int D.31170;
  mono_unichar2 * D.31173;
  unsigned int index.386;
  unsigned int D.31175;
  unsigned int i.387;
  unsigned int D.31177;
  gunichar2 * D.31178;
  short unsigned int D.31179;
  unsigned int D.31180;
  int objid;
  int err;
  struct MonoString * str;
  char * s;
  int i;
  int index;
  int length;
  gunichar2 * c;

  try
    {
      p.384 = p;
      objid = decode_objid (p.384, &p, end);
      D.31160 = get_object (objid, &str);
      err = (int) D.31160;
      if (err != 0) goto <D.31161>; else goto <D.31162>;
      <D.31161>:
      D.31163 = (ErrorCode) err;
      return D.31163;
      <D.31162>:
      switch (command) <default: <D.26979>, case 1: <D.26972>, case 2: <D.26974>, case 3: <D.26975>>
      <D.26972>:
      str.385 = str;
      s = mono_string_to_utf8 (str.385);
      buffer_add_string (buf, s);
      monoeg_g_free (s);
      goto <D.26973>;
      <D.26974>:
      str.385 = str;
      D.31165 = mono_string_length (str.385);
      D.31166 = (long long unsigned int) D.31165;
      buffer_add_long (buf, D.31166);
      goto <D.26973>;
      <D.26975>:
      p.384 = p;
      D.31167 = decode_long (p.384, &p, end);
      index = (int) D.31167;
      p.384 = p;
      D.31168 = decode_long (p.384, &p, end);
      length = (int) D.31168;
      str.385 = str;
      D.31169 = mono_string_length (str.385);
      D.31170 = D.31169 - length;
      if (D.31170 < index) goto <D.31171>; else goto <D.31172>;
      <D.31171>:
      D.31163 = 102;
      return D.31163;
      <D.31172>:
      str.385 = str;
      D.31173 = mono_string_chars (str.385);
      index.386 = (unsigned int) index;
      D.31175 = index.386 * 2;
      c = D.31173 + D.31175;
      i = 0;
      goto <D.26977>;
      <D.26976>:
      i.387 = (unsigned int) i;
      D.31177 = i.387 * 2;
      D.31178 = c + D.31177;
      D.31179 = *D.31178;
      D.31180 = (unsigned int) D.31179;
      buffer_add_short (buf, D.31180);
      i = i + 1;
      <D.26977>:
      if (i < length) goto <D.26976>; else goto <D.26978>;
      <D.26978>:
      goto <D.26973>;
      <D.26979>:
      D.31163 = 100;
      return D.31163;
      <D.26973>:
      D.31163 = 0;
      return D.31163;
    }
  finally
    {
      str = {CLOBBER};
    }
}


buffer_add_short (struct Buffer * buf, guint32 val)
{
  guint8 * D.31183;
  unsigned int D.31184;
  unsigned char D.31185;
  guint8 * D.31186;
  unsigned char D.31187;
  guint8 * D.31188;

  buffer_make_room (buf, 2);
  D.31183 = buf->p;
  D.31184 = val >> 8;
  D.31185 = (unsigned char) D.31184;
  *D.31183 = D.31185;
  D.31183 = buf->p;
  D.31186 = D.31183 + 1;
  D.31187 = (unsigned char) val;
  *D.31186 = D.31187;
  D.31183 = buf->p;
  D.31188 = D.31183 + 2;
  buf->p = D.31188;
}


object_commands (int command, guint8 * p, guint8 * end, struct Buffer * buf)
{
  guint8 * p.388;
  <unnamed type> D.31192;
  int err.389;
  int err.390;
  ErrorCode D.31198;
  <unnamed type> D.31199;
  int err.391;
  struct MonoObject * obj.392;
  struct MonoVTable * D.31204;
  struct MonoDomain * D.31205;
  void * D.31206;
  struct MonoType * D.31207;
  struct MonoClass * D.31208;
  struct MonoClass * D.31211;
  struct MonoType * D.31216;
  short unsigned int D.31217;
  int D.31218;
  int D.31219;
  int D.31222;
  _Bool D.31225;
  long int D.31226;
  long int D.31227;
  struct MonoClass * D.31230;
  int D.31231;
  unsigned int D.31232;
  int D.31234;
  sizetype D.31235;
  void * D.31236;
  struct MonoClass * D.31239;
  struct MonoType * D.31244;
  short unsigned int D.31245;
  int D.31246;
  int D.31247;
  int D.31250;
  _Bool D.31253;
  long int D.31254;
  long int D.31255;
  struct MonoClass * D.31258;
  int D.31259;
  unsigned int D.31260;
  <unnamed type> D.31261;
  int err.393;
  int D.31266;
  sizetype D.31267;
  guint8 * D.31268;
  <unnamed type> D.31269;
  int err.394;
  int obj.395;
  long long unsigned int D.31274;
  struct MonoClass * D.31275;
  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.31189>; else goto <D.31190>;
      <D.31189>:
      p.388 = p;
      objid = decode_objid (p.388, &p, end);
      D.31192 = get_object (objid, &obj);
      err.389 = (int) D.31192;
      err = err.389;
      err.390 = err;
      if (err.390 != 0) goto <D.31195>; else goto <D.31196>;
      <D.31195>:
      buffer_add_int (buf, 1);
      goto <D.31197>;
      <D.31196>:
      buffer_add_int (buf, 0);
      <D.31197>:
      D.31198 = 0;
      return D.31198;
      <D.31190>:
      p.388 = p;
      objid = decode_objid (p.388, &p, end);
      D.31199 = get_object (objid, &obj);
      err.391 = (int) D.31199;
      err = err.391;
      err.390 = err;
      if (err.390 != 0) goto <D.31201>; else goto <D.31202>;
      <D.31201>:
      err.390 = err;
      D.31198 = (ErrorCode) err.390;
      return D.31198;
      <D.31202>:
      switch (command) <default: <D.27018>, case 1: <D.26994>, case 2: <D.26996>, case 4: <D.27015>, case 5: <D.27016>, case 6: <D.27006>, case 7: <D.27017>>
      <D.26994>:
      obj.392 = obj;
      D.31204 = obj.392->vtable;
      D.31205 = D.31204->domain;
      obj.392 = obj;
      D.31204 = obj.392->vtable;
      D.31206 = D.31204->type;
      D.31207 = MEM[(struct MonoReflectionType *)D.31206].type;
      D.31208 = mono_class_from_mono_type (D.31207);
      buffer_add_typeid (buf, D.31205, D.31208);
      goto <D.26995>;
      <D.26996>:
      p.388 = p;
      len = decode_int (p.388, &p, end);
      i = 0;
      goto <D.27004>;
      <D.27003>:
      {
        struct MonoClassField * f;

        p.388 = p;
        f = decode_fieldid (p.388, &p, end, 0B, &err);
        err.390 = err;
        if (err.390 != 0) goto <D.31209>; else goto <D.31210>;
        <D.31209>:
        err.390 = err;
        D.31198 = (ErrorCode) err.390;
        return D.31198;
        <D.31210>:
        found = 0;
        obj.392 = obj;
        D.31204 = obj.392->vtable;
        k = D.31204->klass;
        goto <D.27000>;
        <D.26999>:
        D.31211 = f->parent;
        if (D.31211 == k) goto <D.31212>; else goto <D.31213>;
        <D.31212>:
        found = 1;
        goto <D.26998>;
        <D.31213>:
        k = k->parent;
        <D.27000>:
        if (k != 0B) goto <D.26999>; else goto <D.26998>;
        <D.26998>:
        if (found == 0) goto <D.31214>; else goto <D.31215>;
        <D.31214>:
        D.31198 = 25;
        return D.31198;
        <D.31215>:
        D.31216 = f->type;
        D.31217 = D.31216->attrs;
        D.31218 = (int) D.31217;
        D.31219 = D.31218 & 16;
        if (D.31219 != 0) goto <D.31220>; else goto <D.31221>;
        <D.31220>:
        {
          guint8 * val;
          struct MonoVTable * vtable;

          D.31222 = mono_class_field_is_special_static (f);
          if (D.31222 != 0) goto <D.31223>; else goto <D.31224>;
          <D.31223>:
          D.31198 = 25;
          return D.31198;
          <D.31224>:
          D.31216 = f->type;
          D.31217 = D.31216->attrs;
          D.31218 = (int) D.31217;
          D.31219 = D.31218 & 16;
          D.31225 = D.31219 == 0;
          D.31226 = (long int) D.31225;
          D.31227 = __builtin_expect (D.31226, 0);
          if (D.31227 != 0) goto <D.31228>; else goto <D.31229>;
          <D.31228>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 8780, "f->type->attrs & FIELD_ATTRIBUTE_STATIC");
          <D.31229>:
          obj.392 = obj;
          D.31204 = obj.392->vtable;
          D.31205 = D.31204->domain;
          D.31211 = f->parent;
          vtable = mono_class_vtable (D.31205, D.31211);
          D.31216 = f->type;
          D.31230 = mono_class_from_mono_type (D.31216);
          D.31231 = mono_class_instance_size (D.31230);
          D.31232 = (unsigned int) D.31231;
          val = monoeg_malloc (D.31232);
          mono_field_static_get_value (vtable, f, val);
          D.31216 = f->type;
          obj.392 = obj;
          D.31204 = obj.392->vtable;
          D.31205 = D.31204->domain;
          buffer_add_value (buf, D.31216, val, D.31205);
          monoeg_g_free (val);
        }
        goto <D.31233>;
        <D.31221>:
        D.31216 = f->type;
        obj.392 = obj;
        D.31234 = f->offset;
        D.31235 = (sizetype) D.31234;
        D.31236 = obj.392 + D.31235;
        obj.392 = obj;
        D.31204 = obj.392->vtable;
        D.31205 = D.31204->domain;
        buffer_add_value (buf, D.31216, D.31236, D.31205);
        <D.31233>:
      }
      i = i + 1;
      <D.27004>:
      if (i < len) goto <D.27003>; else goto <D.27005>;
      <D.27005>:
      goto <D.26995>;
      <D.27006>:
      p.388 = p;
      len = decode_int (p.388, &p, end);
      i = 0;
      goto <D.27013>;
      <D.27012>:
      p.388 = p;
      f = decode_fieldid (p.388, &p, end, 0B, &err);
      err.390 = err;
      if (err.390 != 0) goto <D.31237>; else goto <D.31238>;
      <D.31237>:
      err.390 = err;
      D.31198 = (ErrorCode) err.390;
      return D.31198;
      <D.31238>:
      found = 0;
      obj.392 = obj;
      D.31204 = obj.392->vtable;
      k = D.31204->klass;
      goto <D.27009>;
      <D.27008>:
      D.31239 = f->parent;
      if (D.31239 == k) goto <D.31240>; else goto <D.31241>;
      <D.31240>:
      found = 1;
      goto <D.27007>;
      <D.31241>:
      k = k->parent;
      <D.27009>:
      if (k != 0B) goto <D.27008>; else goto <D.27007>;
      <D.27007>:
      if (found == 0) goto <D.31242>; else goto <D.31243>;
      <D.31242>:
      D.31198 = 25;
      return D.31198;
      <D.31243>:
      D.31244 = f->type;
      D.31245 = D.31244->attrs;
      D.31246 = (int) D.31245;
      D.31247 = D.31246 & 16;
      if (D.31247 != 0) goto <D.31248>; else goto <D.31249>;
      <D.31248>:
      {
        guint8 * val;
        struct MonoVTable * vtable;

        D.31250 = mono_class_field_is_special_static (f);
        if (D.31250 != 0) goto <D.31251>; else goto <D.31252>;
        <D.31251>:
        D.31198 = 25;
        return D.31198;
        <D.31252>:
        D.31244 = f->type;
        D.31245 = D.31244->attrs;
        D.31246 = (int) D.31245;
        D.31247 = D.31246 & 16;
        D.31253 = D.31247 == 0;
        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", 8817, "f->type->attrs & FIELD_ATTRIBUTE_STATIC");
        <D.31257>:
        obj.392 = obj;
        D.31204 = obj.392->vtable;
        D.31205 = D.31204->domain;
        D.31239 = f->parent;
        vtable = mono_class_vtable (D.31205, D.31239);
        D.31244 = f->type;
        D.31258 = mono_class_from_mono_type (D.31244);
        D.31259 = mono_class_instance_size (D.31258);
        D.31260 = (unsigned int) D.31259;
        val = monoeg_malloc (D.31260);
        D.31244 = f->type;
        obj.392 = obj;
        D.31204 = obj.392->vtable;
        D.31205 = D.31204->domain;
        p.388 = p;
        D.31261 = decode_value (D.31244, D.31205, val, p.388, &p, end);
        err.393 = (int) D.31261;
        err = err.393;
        err.390 = err;
        if (err.390 != 0) goto <D.31263>; else goto <D.31264>;
        <D.31263>:
        monoeg_g_free (val);
        err.390 = err;
        D.31198 = (ErrorCode) err.390;
        return D.31198;
        <D.31264>:
        mono_field_static_set_value (vtable, f, val);
        monoeg_g_free (val);
      }
      goto <D.31265>;
      <D.31249>:
      D.31244 = f->type;
      obj.392 = obj;
      D.31204 = obj.392->vtable;
      D.31205 = D.31204->domain;
      obj.392 = obj;
      D.31266 = f->offset;
      D.31267 = (sizetype) D.31266;
      D.31268 = obj.392 + D.31267;
      p.388 = p;
      D.31269 = decode_value (D.31244, D.31205, D.31268, p.388, &p, end);
      err.394 = (int) D.31269;
      err = err.394;
      err.390 = err;
      if (err.390 != 0) goto <D.31271>; else goto <D.31272>;
      <D.31271>:
      err.390 = err;
      D.31198 = (ErrorCode) err.390;
      return D.31198;
      <D.31272>:
      <D.31265>:
      i = i + 1;
      <D.27013>:
      if (i < len) goto <D.27012>; else goto <D.27014>;
      <D.27014>:
      goto <D.26995>;
      <D.27015>:
      obj.392 = obj;
      obj.395 = (int) obj.392;
      D.31274 = (long long unsigned int) obj.395;
      buffer_add_long (buf, D.31274);
      goto <D.26995>;
      <D.27016>:
      obj.392 = obj;
      D.31204 = obj.392->vtable;
      D.31205 = D.31204->domain;
      buffer_add_domainid (buf, D.31205);
      goto <D.26995>;
      <D.27017>:
      obj.392 = obj;
      D.31204 = obj.392->vtable;
      D.31205 = D.31204->domain;
      obj.392 = obj;
      D.31204 = obj.392->vtable;
      D.31206 = D.31204->type;
      D.31207 = MEM[(struct MonoReflectionType *)D.31206].type;
      D.31275 = mono_class_from_mono_type (D.31207);
      buffer_add_typeid (buf, D.31205, D.31275);
      obj.392 = obj;
      D.31204 = obj.392->vtable;
      D.31205 = D.31204->domain;
      buffer_add_domainid (buf, D.31205);
      goto <D.26995>;
      <D.27018>:
      D.31198 = 100;
      return D.31198;
      <D.26995>:
      D.31198 = 0;
      return D.31198;
    }
  finally
    {
      err = {CLOBBER};
      obj = {CLOBBER};
    }
}


send_reply_packet (int id, int error, struct Buffer * data)
{
  guint8 * D.31278;
  int D.31279;
  guint8 * D.31280;
  int D.31281;
  int D.31282;
  unsigned int len.396;
  unsigned int id.397;
  int D.31285;
  unsigned char D.31286;
  int D.31287;
  unsigned char D.31288;
  int D.31289;
  guint8 * D.31290;
  guint8 * D.31291;
  unsigned int D.31292;
  gboolean D.31293;
  struct Buffer buf;
  int len;
  gboolean res;

  try
    {
      D.31278 = data->p;
      D.31279 = (int) D.31278;
      D.31280 = data->buf;
      D.31281 = (int) D.31280;
      D.31282 = D.31279 - D.31281;
      len = D.31282 + 11;
      buffer_init (&buf, len);
      len.396 = (unsigned int) len;
      buffer_add_int (&buf, len.396);
      id.397 = (unsigned int) id;
      buffer_add_int (&buf, id.397);
      buffer_add_byte (&buf, 128);
      D.31285 = error >> 8;
      D.31286 = (unsigned char) D.31285;
      D.31287 = (int) D.31286;
      buffer_add_byte (&buf, D.31287);
      D.31288 = (unsigned char) error;
      D.31289 = (int) D.31288;
      buffer_add_byte (&buf, D.31289);
      D.31290 = buf.buf;
      D.31291 = D.31290 + 11;
      D.31280 = data->buf;
      D.31278 = data->p;
      D.31279 = (int) D.31278;
      D.31280 = data->buf;
      D.31281 = (int) D.31280;
      D.31282 = D.31279 - D.31281;
      D.31292 = (unsigned int) D.31282;
      memcpy (D.31291, D.31280, D.31292);
      D.31290 = buf.buf;
      res = transport_send (D.31290, len);
      buffer_free (&buf);
      D.31293 = res;
      return D.31293;
    }
  finally
    {
      buf = {CLOBBER};
    }
}


save_thread_context (struct MonoContext * ctx)
{
  unsigned int debugger_tls_id.398;
  _Bool D.31297;
  long int D.31298;
  long int D.31299;
  struct MonoThreadUnwindState * D.31304;
  struct DebuggerTlsData * tls;

  debugger_tls_id.398 = debugger_tls_id;
  tls = pthread_getspecific (debugger_tls_id.398);
  D.31297 = tls == 0B;
  D.31298 = (long int) D.31297;
  D.31299 = __builtin_expect (D.31298, 0);
  if (D.31299 != 0) goto <D.31300>; else goto <D.31301>;
  <D.31300>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 2357, "tls");
  <D.31301>:
  if (ctx != 0B) goto <D.31302>; else goto <D.31303>;
  <D.31302>:
  D.31304 = &tls->context;
  mono_thread_state_init_from_monoctx (D.31304, ctx);
  goto <D.31305>;
  <D.31303>:
  D.31304 = &tls->context;
  mono_thread_state_init_from_current (D.31304);
  <D.31305>:
}


suspend_vm ()
{
  int suspend_count.399;
  int suspend_count.400;
  int log_level.401;
  _Bool D.31309;
  long int D.31310;
  long int D.31311;
  struct FILE * log_file.402;
  unsigned int D.31315;
  void * D.31316;
  struct MonoGHashTable * thread_to_tls.403;

  mono_loader_lock ();
  pthread_mutex_lock (&suspend_mutex);
  suspend_count.399 = suspend_count;
  suspend_count.400 = suspend_count.399 + 1;
  suspend_count = suspend_count.400;
  log_level.401 = log_level;
  D.31309 = log_level.401 > 0;
  D.31310 = (long int) D.31309;
  D.31311 = __builtin_expect (D.31310, 0);
  if (D.31311 != 0) goto <D.31312>; else goto <D.31313>;
  <D.31312>:
  log_file.402 = log_file;
  D.31315 = GetCurrentThreadId ();
  D.31316 = (void *) D.31315;
  fprintf (log_file.402, "[%p] Suspending vm...\n", D.31316);
  log_file.402 = log_file;
  fflush (log_file.402);
  <D.31313>:
  suspend_count.399 = suspend_count;
  if (suspend_count.399 == 1) goto <D.31317>; else goto <D.31318>;
  <D.31317>:
  start_single_stepping ();
  thread_to_tls.403 = thread_to_tls;
  mono_g_hash_table_foreach (thread_to_tls.403, notify_thread, 0B);
  <D.31318>:
  pthread_mutex_unlock (&suspend_mutex);
  suspend_count.399 = suspend_count;
  if (suspend_count.399 == 1) goto <D.31320>; else goto <D.31321>;
  <D.31320>:
  mono_thread_pool_suspend ();
  <D.31321>:
  mono_loader_unlock ();
}


notify_thread (void * key, void * value, void * user_data)
{
  long long unsigned int D.31322;
  unsigned int D.31325;
  int D.31327;
  int log_level.404;
  _Bool D.31329;
  long int D.31330;
  long int D.31331;
  struct FILE * log_file.405;
  unsigned int D.31335;
  void * D.31336;
  void * tid.406;
  gint32 * D.31338;
  int D.31339;
  long unsigned int D.31342;
  unsigned int D.31347;
  void * D.31348;
  void * D.31350;
  int D.31351;
  char * D.31352;
  unsigned int D.31353;
  int D.31355;
  unsigned int D.31360;
  void * D.31361;
  struct MonoInternalThread * thread;
  struct DebuggerTlsData * tls;
  gsize tid;
  int res;

  thread = key;
  tls = value;
  D.31322 = thread->tid;
  tid = (gsize) D.31322;
  D.31325 = GetCurrentThreadId ();
  if (D.31325 == tid) goto <D.31323>; else goto <D.31326>;
  <D.31326>:
  D.31327 = tls->terminated;
  if (D.31327 != 0) goto <D.31323>; else goto <D.31324>;
  <D.31323>:
  return;
  <D.31324>:
  log_level.404 = log_level;
  D.31329 = log_level.404 > 0;
  D.31330 = (long int) D.31329;
  D.31331 = __builtin_expect (D.31330, 0);
  if (D.31331 != 0) goto <D.31332>; else goto <D.31333>;
  <D.31332>:
  log_file.405 = log_file;
  D.31335 = GetCurrentThreadId ();
  D.31336 = (void *) D.31335;
  tid.406 = (void *) tid;
  fprintf (log_file.405, "[%p] Interrupting %p...\n", D.31336, tid.406);
  log_file.405 = log_file;
  fflush (log_file.405);
  <D.31333>:
  D.31338 = &tls->interrupt_count;
  InterlockedIncrement (D.31338);
  D.31339 = mono_thread_info_new_interrupt_enabled ();
  if (D.31339 != 0) goto <D.31340>; else goto <D.31341>;
  <D.31340>:
  {
    struct MonoThreadInfo * info;
    struct MonoJitInfo * ji;

    D.31322 = thread->tid;
    D.31342 = (long unsigned int) D.31322;
    info = mono_thread_info_safe_suspend_sync (D.31342, 0);
    if (info == 0B) goto <D.31343>; else goto <D.31344>;
    <D.31343>:
    log_level.404 = log_level;
    D.31329 = log_level.404 > 0;
    D.31330 = (long int) D.31329;
    D.31331 = __builtin_expect (D.31330, 0);
    if (D.31331 != 0) goto <D.31345>; else goto <D.31346>;
    <D.31345>:
    log_file.405 = log_file;
    D.31347 = GetCurrentThreadId ();
    D.31348 = (void *) D.31347;
    tid.406 = (void *) tid;
    fprintf (log_file.405, "[%p] mono_thread_info_suspend_sync () failed for %p...\n", D.31348, tid.406);
    log_file.405 = log_file;
    fflush (log_file.405);
    <D.31346>:
    tls->terminated = 1;
    goto <D.31349>;
    <D.31344>:
    D.31350 = info->suspend_state.unwind_data[0];
    D.31351 = info->suspend_state.ctx.sc_pc;
    D.31352 = (char *) D.31351;
    ji = mono_jit_info_table_find (D.31350, D.31352);
    thread_interrupt (tls, info, 0B, ji);
    D.31353 = info->node.key;
    mono_thread_info_resume (D.31353);
    <D.31349>:
  }
  goto <D.31354>;
  <D.31341>:
  D.31355 = mono_thread_get_abort_signal ();
  res = mono_thread_kill (thread, D.31355);
  if (res != 0) goto <D.31356>; else goto <D.31357>;
  <D.31356>:
  log_level.404 = log_level;
  D.31329 = log_level.404 > 0;
  D.31330 = (long int) D.31329;
  D.31331 = __builtin_expect (D.31330, 0);
  if (D.31331 != 0) goto <D.31358>; else goto <D.31359>;
  <D.31358>:
  log_file.405 = log_file;
  D.31360 = GetCurrentThreadId ();
  D.31361 = (void *) D.31360;
  tid.406 = (void *) tid;
  fprintf (log_file.405, "[%p] mono_thread_kill () failed for %p: %d...\n", D.31361, tid.406, res);
  log_file.405 = log_file;
  fflush (log_file.405);
  <D.31359>:
  tls->terminated = 1;
  <D.31357>:
  <D.31354>:
}


thread_interrupt (struct DebuggerTlsData * tls, struct MonoThreadInfo * info, void * sigctx, struct MonoJitInfo * ji)
{
  int D.31363;
  gboolean D.31366;
  gint32 * D.31367;
  int D.31373;
  int log_level.407;
  _Bool D.31381;
  long int D.31382;
  long int D.31383;
  struct FILE * log_file.408;
  void * tid.409;
  struct MonoMethod * D.31388;
  const char * D.31389;
  int D.31390;
  int D.31393;
  struct MonoInternalThread * D.31400;
  struct MonoRuntimeExceptionHandlingCallbacks * D.31408;
  void (*<T2776>) (gboolean (*MonoInternalStackWalk) (struct MonoStackFrameInfo *, struct MonoContext *, void *), struct MonoThreadUnwindState *, MonoUnwindOptions, void *) D.31409;
  struct MonoThreadUnwindState * D.31410;
  int D.31411;
  struct StackFrameInfo * D.31414;
  struct MonoThreadUnwindState * D.31415;
  _Bool D.31416;
  long int D.31417;
  long int D.31418;
  struct MonoThreadUnwindState * D.31421;
  struct MonoContext * D.31424;
  void * D.31425;
  void * D.31426;
  gboolean res;
  void * ip;
  MonoNativeThreadId tid;

  D.31363 = tls->interrupt_count;
  if (D.31363 == 0) goto <D.31364>; else goto <D.31365>;
  <D.31364>:
  D.31366 = 0;
  return D.31366;
  <D.31365>:
  D.31367 = &tls->interrupt_count;
  InterlockedDecrement (D.31367);
  if (sigctx != 0B) goto <D.31368>; else goto <D.31369>;
  <D.31368>:
  ip = mono_arch_ip_from_context (sigctx);
  goto <D.31370>;
  <D.31369>:
  if (info != 0B) goto <D.31371>; else goto <D.31372>;
  <D.31371>:
  D.31373 = info->suspend_state.ctx.sc_pc;
  ip = (void *) D.31373;
  goto <D.31374>;
  <D.31372>:
  ip = 0B;
  <D.31374>:
  <D.31370>:
  if (info != 0B) goto <D.31375>; else goto <D.31376>;
  <D.31375>:
  tid = info->node.key;
  goto <D.31377>;
  <D.31376>:
  tid = GetCurrentThreadId ();
  <D.31377>:
  if (ji != 0B) goto <D.31378>; else goto <D.31379>;
  <D.31378>:
  log_level.407 = log_level;
  D.31381 = log_level.407 > 0;
  D.31382 = (long int) D.31381;
  D.31383 = __builtin_expect (D.31382, 0);
  if (D.31383 != 0) goto <D.31384>; else goto <D.31385>;
  <D.31384>:
  log_file.408 = log_file;
  tid.409 = (void *) tid;
  D.31388 = jinfo_get_method (ji);
  D.31389 = D.31388->name;
  fprintf (log_file.408, "[%p] Received interrupt while at %s(%p), continuing.\n", tid.409, D.31389, ip);
  log_file.408 = log_file;
  fflush (log_file.408);
  <D.31385>:
  D.31366 = 1;
  return D.31366;
  <D.31379>:
  D.31390 = tls->suspended;
  if (D.31390 == 0) goto <D.31391>; else goto <D.31392>;
  <D.31391>:
  D.31393 = tls->suspending;
  if (D.31393 == 0) goto <D.31394>; else goto <D.31395>;
  <D.31394>:
  {
    struct MonoContext ctx;
    struct GetLastFrameUserData data;

    try
      {
        if (ip != 0B) goto <D.31396>; else goto <D.31397>;
        <D.31396>:
        log_level.407 = log_level;
        D.31381 = log_level.407 > 0;
        D.31382 = (long int) D.31381;
        D.31383 = __builtin_expect (D.31382, 0);
        if (D.31383 != 0) goto <D.31398>; else goto <D.31399>;
        <D.31398>:
        log_file.408 = log_file;
        tid.409 = (void *) tid;
        fprintf (log_file.408, "[%p] Received interrupt while at %p, treating as suspended.\n", tid.409, ip);
        log_file.408 = log_file;
        fflush (log_file.408);
        <D.31399>:
        <D.31397>:
        D.31400 = tls->thread;
        if (D.31400 == 0B) goto <D.31401>; else goto <D.31402>;
        <D.31401>:
        D.31366 = 1;
        return D.31366;
        <D.31402>:
        data.last_frame_set = 0;
        if (sigctx != 0B) goto <D.31403>; else goto <D.31404>;
        <D.31403>:
        mono_arch_sigctx_to_monoctx (sigctx, &ctx);
        mono_walk_stack_with_ctx (get_last_frame, &ctx, 0, &data);
        goto <D.31405>;
        <D.31404>:
        if (info != 0B) goto <D.31406>; else goto <D.31407>;
        <D.31406>:
        D.31408 = mono_get_eh_callbacks ();
        D.31409 = D.31408->mono_walk_stack_with_state;
        D.31410 = &info->suspend_state;
        D.31409 (get_last_frame, D.31410, 0, &data);
        <D.31407>:
        <D.31405>:
        D.31411 = data.last_frame_set;
        if (D.31411 != 0) goto <D.31412>; else goto <D.31413>;
        <D.31412>:
        D.31414 = &tls->async_last_frame;
        memcpy (D.31414, &data.last_frame, 52);
        D.31415 = &tls->async_state;
        res = mono_thread_state_init_from_monoctx (D.31415, &ctx);
        D.31416 = res == 0;
        D.31417 = (long int) D.31416;
        D.31418 = __builtin_expect (D.31417, 0);
        if (D.31418 != 0) goto <D.31419>; else goto <D.31420>;
        <D.31419>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 2519, "res");
        <D.31420>:
        D.31421 = &tls->context;
        mono_thread_state_init_from_monoctx (D.31421, &ctx);
        D.31416 = res == 0;
        D.31417 = (long int) D.31416;
        D.31418 = __builtin_expect (D.31417, 0);
        if (D.31418 != 0) goto <D.31422>; else goto <D.31423>;
        <D.31422>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 2521, "res");
        <D.31423>:
        D.31424 = &tls->async_state.ctx;
        memcpy (D.31424, &data.ctx, 260);
        D.31425 = data.lmf;
        tls->async_state.unwind_data[1] = D.31425;
        D.31400 = tls->thread;
        D.31426 = D.31400->jit_data;
        tls->async_state.unwind_data[2] = D.31426;
        goto <D.31427>;
        <D.31413>:
        tls->async_state.valid = 0;
        <D.31427>:
        mono_memory_barrier ();
        tls->suspended = 1;
        mono_sem_post (&suspend_sem);
      }
    finally
      {
        ctx = {CLOBBER};
        data = {CLOBBER};
      }
  }
  <D.31395>:
  <D.31392>:
  D.31366 = 1;
  return D.31366;
}


get_last_frame (struct StackFrameInfo * info, struct MonoContext * ctx, void * user_data)
{
  <unnamed type> D.31431;
  gboolean D.31434;
  int D.31435;
  struct StackFrameInfo * D.31438;
  struct MonoContext * D.31439;
  void * D.31440;
  struct GetLastFrameUserData * data;

  data = user_data;
  D.31431 = info->type;
  if (D.31431 == 2) goto <D.31432>; else goto <D.31433>;
  <D.31432>:
  D.31434 = 0;
  return D.31434;
  <D.31433>:
  D.31435 = data->last_frame_set;
  if (D.31435 == 0) goto <D.31436>; else goto <D.31437>;
  <D.31436>:
  D.31438 = &data->last_frame;
  memcpy (D.31438, info, 52);
  data->last_frame_set = 1;
  D.31434 = 0;
  return D.31434;
  <D.31437>:
  D.31439 = &data->ctx;
  memcpy (D.31439, ctx, 260);
  D.31440 = info->lmf;
  data->lmf = D.31440;
  D.31434 = 1;
  return D.31434;
}


mono_memory_barrier ()
{
  __sync_synchronize ();
}


get_objref (struct MonoObject * obj)
{
  struct ObjRef * D.31444;
  struct GHashTable * obj_to_objref.410;
  struct GHashTable * obj_to_objref.411;
  struct MonoGHashTable * suspended_objs.412;
  int D.31450;
  int suspend_count.413;
  struct MonoGHashTable * suspended_objs.414;
  int D.31457;
  const void * hash.415;
  unsigned int D.31463;
  struct MonoObject * D.31464;
  unsigned int obj.416;
  unsigned int D.31469;
  const void * D.31470;
  struct MonoObject * D.31473;
  int D.31476;
  unsigned int D.31477;
  struct GHashTable * objrefs.417;
  int D.31479;
  void * D.31480;
  int D.31481;
  void * hash.418;
  void * D.31486;
  struct ObjRef * ref;
  struct GSList * reflist;
  struct GSList * l;
  int hash;

  reflist = 0B;
  hash = 0;
  if (obj == 0B) goto <D.31442>; else goto <D.31443>;
  <D.31442>:
  D.31444 = 0B;
  return D.31444;
  <D.31443>:
  mono_loader_lock ();
  obj_to_objref.410 = obj_to_objref;
  if (obj_to_objref.410 == 0B) goto <D.31446>; else goto <D.31447>;
  <D.31446>:
  obj_to_objref.411 = monoeg_g_hash_table_new (0B, 0B);
  obj_to_objref = obj_to_objref.411;
  suspended_objs.412 = mono_g_hash_table_new_type (0B, 0B, 1);
  suspended_objs = suspended_objs.412;
  D.31450 = mono_gc_is_moving ();
  if (D.31450 == 0) goto <D.31451>; else goto <D.31452>;
  <D.31451>:
  mono_gc_register_root (&suspended_objs, 4, 0B);
  <D.31452>:
  <D.31447>:
  suspend_count.413 = suspend_count;
  if (suspend_count.413 != 0) goto <D.31454>; else goto <D.31455>;
  <D.31454>:
  suspended_objs.414 = suspended_objs;
  mono_g_hash_table_insert (suspended_objs.414, obj, 0B);
  <D.31455>:
  D.31457 = mono_gc_is_moving ();
  if (D.31457 != 0) goto <D.31458>; else goto <D.31459>;
  <D.31458>:
  hash = mono_object_hash (obj);
  obj_to_objref.410 = obj_to_objref;
  hash.415 = (const void *) hash;
  reflist = monoeg_g_hash_table_lookup (obj_to_objref.410, hash.415);
  l = reflist;
  goto <D.24761>;
  <D.24760>:
  ref = l->data;
  if (ref != 0B) goto <D.31461>; else goto <D.31462>;
  <D.31461>:
  D.31463 = ref->handle;
  D.31464 = mono_gchandle_get_target (D.31463);
  if (D.31464 == obj) goto <D.31465>; else goto <D.31466>;
  <D.31465>:
  mono_loader_unlock ();
  D.31444 = ref;
  return D.31444;
  <D.31466>:
  <D.31462>:
  l = l->next;
  <D.24761>:
  if (l != 0B) goto <D.24760>; else goto <D.24762>;
  <D.24762>:
  goto <D.31467>;
  <D.31459>:
  obj_to_objref.410 = obj_to_objref;
  obj.416 = (unsigned int) obj;
  D.31469 = ~obj.416;
  D.31470 = (const void *) D.31469;
  ref = monoeg_g_hash_table_lookup (obj_to_objref.410, D.31470);
  if (ref != 0B) goto <D.31471>; else goto <D.31472>;
  <D.31471>:
  D.31463 = ref->handle;
  D.31473 = mono_gchandle_get_target (D.31463);
  if (D.31473 == obj) goto <D.31474>; else goto <D.31475>;
  <D.31474>:
  mono_loader_unlock ();
  D.31444 = ref;
  return D.31444;
  <D.31475>:
  <D.31472>:
  <D.31467>:
  ref = monoeg_malloc0 (8);
  D.31476 = InterlockedIncrement (&objref_id);
  ref->id = D.31476;
  D.31477 = mono_gchandle_new_weakref (obj, 0);
  ref->handle = D.31477;
  objrefs.417 = objrefs;
  D.31479 = ref->id;
  D.31480 = (void *) D.31479;
  monoeg_g_hash_table_insert_replace (objrefs.417, D.31480, ref, 0);
  D.31481 = mono_gc_is_moving ();
  if (D.31481 != 0) goto <D.31482>; else goto <D.31483>;
  <D.31482>:
  reflist = monoeg_g_slist_append (reflist, ref);
  obj_to_objref.410 = obj_to_objref;
  hash.418 = (void *) hash;
  monoeg_g_hash_table_insert_replace (obj_to_objref.410, hash.418, reflist, 0);
  goto <D.31485>;
  <D.31483>:
  obj_to_objref.410 = obj_to_objref;
  obj.416 = (unsigned int) obj;
  D.31469 = ~obj.416;
  D.31486 = (void *) D.31469;
  monoeg_g_hash_table_insert_replace (obj_to_objref.410, D.31486, ref, 0);
  <D.31485>:
  mono_loader_unlock ();
  D.31444 = ref;
  return D.31444;
}


send_packet (int command_set, int command, struct Buffer * data)
{
  guint8 * D.31488;
  int D.31489;
  guint8 * D.31490;
  int D.31491;
  int D.31492;
  unsigned int len.419;
  unsigned int id.420;
  unsigned char D.31495;
  int D.31496;
  unsigned char D.31497;
  int D.31498;
  guint8 * D.31499;
  guint8 * D.31500;
  unsigned int D.31501;
  gboolean D.31502;
  struct Buffer buf;
  int len;
  int id;
  gboolean res;

  try
    {
      id = InterlockedIncrement (&packet_id);
      D.31488 = data->p;
      D.31489 = (int) D.31488;
      D.31490 = data->buf;
      D.31491 = (int) D.31490;
      D.31492 = D.31489 - D.31491;
      len = D.31492 + 11;
      buffer_init (&buf, len);
      len.419 = (unsigned int) len;
      buffer_add_int (&buf, len.419);
      id.420 = (unsigned int) id;
      buffer_add_int (&buf, id.420);
      buffer_add_byte (&buf, 0);
      D.31495 = (unsigned char) command_set;
      D.31496 = (int) D.31495;
      buffer_add_byte (&buf, D.31496);
      D.31497 = (unsigned char) command;
      D.31498 = (int) D.31497;
      buffer_add_byte (&buf, D.31498);
      D.31499 = buf.buf;
      D.31500 = D.31499 + 11;
      D.31490 = data->buf;
      D.31488 = data->p;
      D.31489 = (int) D.31488;
      D.31490 = data->buf;
      D.31491 = (int) D.31490;
      D.31492 = D.31489 - D.31491;
      D.31501 = (unsigned int) D.31492;
      memcpy (D.31500, D.31490, D.31501);
      D.31499 = buf.buf;
      res = transport_send (D.31499, len);
      buffer_free (&buf);
      D.31502 = res;
      return D.31502;
    }
  finally
    {
      buf = {CLOBBER};
    }
}


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

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


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

  switch (event) <default: <D.25308>, case 0: <D.25291>, case 1: <D.25292>, case 2: <D.25293>, case 3: <D.25294>, case 4: <D.25295>, case 5: <D.25296>, case 6: <D.25297>, case 7: <D.25298>, case 8: <D.25299>, case 9: <D.25300>, case 10: <D.25301>, case 11: <D.25302>, case 12: <D.25303>, case 13: <D.25304>, case 14: <D.25305>, case 15: <D.25306>, case 16: <D.25307>>
  <D.25291>:
  D.31506 = "VM_START";
  return D.31506;
  <D.25292>:
  D.31506 = "VM_DEATH";
  return D.31506;
  <D.25293>:
  D.31506 = "THREAD_START";
  return D.31506;
  <D.25294>:
  D.31506 = "THREAD_DEATH";
  return D.31506;
  <D.25295>:
  D.31506 = "APPDOMAIN_CREATE";
  return D.31506;
  <D.25296>:
  D.31506 = "APPDOMAIN_UNLOAD";
  return D.31506;
  <D.25297>:
  D.31506 = "METHOD_ENTRY";
  return D.31506;
  <D.25298>:
  D.31506 = "METHOD_EXIT";
  return D.31506;
  <D.25299>:
  D.31506 = "ASSEMBLY_LOAD";
  return D.31506;
  <D.25300>:
  D.31506 = "ASSEMBLY_UNLOAD";
  return D.31506;
  <D.25301>:
  D.31506 = "BREAKPOINT";
  return D.31506;
  <D.25302>:
  D.31506 = "STEP";
  return D.31506;
  <D.25303>:
  D.31506 = "TYPE_LOAD";
  return D.31506;
  <D.25304>:
  D.31506 = "EXCEPTION";
  return D.31506;
  <D.25305>:
  D.31506 = "KEEPALIVE";
  return D.31506;
  <D.25306>:
  D.31506 = "USER_BREAK";
  return D.31506;
  <D.25307>:
  D.31506 = "USER_LOG";
  return D.31506;
  <D.25308>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "debugger-agent.c", 3535);
  D.31506 = "";
  return D.31506;
}


suspend_current ()
{
  unsigned int D.31508;
  unsigned int debugger_thread_id.421;
  _Bool D.31510;
  long int D.31511;
  long int D.31512;
  int D.31515;
  unsigned int debugger_tls_id.422;
  _Bool D.31519;
  long int D.31520;
  long int D.31521;
  int D.31524;
  int log_level.423;
  _Bool D.31528;
  long int D.31529;
  long int D.31530;
  struct FILE * log_file.424;
  unsigned int D.31534;
  void * D.31535;
  _Bool D.31536;
  long int D.31537;
  long int D.31538;
  int suspend_count.425;
  unsigned int suspend_count.426;
  unsigned int D.31543;
  int threads_suspend_count.427;
  int threads_suspend_count.428;
  unsigned int D.31548;
  void * D.31549;
  struct InvokeData * D.31550;
  int err;
  struct DebuggerTlsData * tls;

  D.31508 = GetCurrentThreadId ();
  debugger_thread_id.421 = debugger_thread_id;
  D.31510 = D.31508 == debugger_thread_id.421;
  D.31511 = (long int) D.31510;
  D.31512 = __builtin_expect (D.31511, 0);
  if (D.31512 != 0) goto <D.31513>; else goto <D.31514>;
  <D.31513>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 2855, "debugger_thread_id != GetCurrentThreadId ()");
  <D.31514>:
  D.31515 = mono_loader_lock_is_owned_by_self ();
  if (D.31515 != 0) goto <D.31516>; else goto <D.31517>;
  <D.31516>:
  return;
  <D.31517>:
  debugger_tls_id.422 = debugger_tls_id;
  tls = pthread_getspecific (debugger_tls_id.422);
  D.31519 = tls == 0B;
  D.31520 = (long int) D.31519;
  D.31521 = __builtin_expect (D.31520, 0);
  if (D.31521 != 0) goto <D.31522>; else goto <D.31523>;
  <D.31522>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 2866, "tls");
  <D.31523>:
  pthread_mutex_lock (&suspend_mutex);
  tls->suspending = 0;
  tls->really_suspended = 1;
  D.31524 = tls->suspended;
  if (D.31524 == 0) goto <D.31525>; else goto <D.31526>;
  <D.31525>:
  tls->suspended = 1;
  mono_sem_post (&suspend_sem);
  <D.31526>:
  log_level.423 = log_level;
  D.31528 = log_level.423 > 0;
  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>:
  log_file.424 = log_file;
  D.31534 = GetCurrentThreadId ();
  D.31535 = (void *) D.31534;
  fprintf (log_file.424, "[%p] Suspended.\n", D.31535);
  log_file.424 = log_file;
  fflush (log_file.424);
  <D.31532>:
  goto <D.25095>;
  <D.25094>:
  err = pthread_cond_wait (&suspend_cond, &suspend_mutex);
  D.31536 = err != 0;
  D.31537 = (long int) D.31536;
  D.31538 = __builtin_expect (D.31537, 0);
  if (D.31538 != 0) goto <D.31539>; else goto <D.31540>;
  <D.31539>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 2893, "err == 0");
  <D.31540>:
  <D.25095>:
  suspend_count.425 = suspend_count;
  suspend_count.426 = (unsigned int) suspend_count.425;
  D.31543 = tls->resume_count;
  if (suspend_count.426 != D.31543) goto <D.25094>; else goto <D.25096>;
  <D.25096>:
  tls->suspended = 0;
  tls->really_suspended = 0;
  threads_suspend_count.427 = threads_suspend_count;
  threads_suspend_count.428 = threads_suspend_count.427 + -1;
  threads_suspend_count = threads_suspend_count.428;
  pthread_mutex_unlock (&suspend_mutex);
  log_level.423 = log_level;
  D.31528 = log_level.423 > 0;
  D.31529 = (long int) D.31528;
  D.31530 = __builtin_expect (D.31529, 0);
  if (D.31530 != 0) goto <D.31546>; else goto <D.31547>;
  <D.31546>:
  log_file.424 = log_file;
  D.31548 = GetCurrentThreadId ();
  D.31549 = (void *) D.31548;
  fprintf (log_file.424, "[%p] Resumed.\n", D.31549);
  log_file.424 = log_file;
  fflush (log_file.424);
  <D.31547>:
  D.31550 = tls->pending_invoke;
  if (D.31550 != 0B) goto <D.31551>; else goto <D.31552>;
  <D.31551>:
  D.31550 = tls->pending_invoke;
  D.31550->has_ctx = 1;
  D.31550 = tls->pending_invoke;
  D.31550->ctx = tls->context.ctx;
  invoke_method ();
  <D.31552>:
  tls->context.valid = 0;
  tls->async_state.valid = 0;
  invalidate_frames (tls);
}


invoke_method ()
{
  unsigned int debugger_tls_id.429;
  _Bool D.31555;
  long int D.31556;
  long int D.31557;
  _Bool D.31560;
  long int D.31561;
  long int D.31562;
  struct InvokeData * D.31565;
  guint8 * p.430;
  guint8 * p.431;
  <unnamed type> D.31571;
  int D.31572;
  int D.31573;
  int D.31576;
  int D.31577;
  unsigned int i.432;
  unsigned int D.31581;
  struct MonoContext * D.31582;
  int D.31583;
  unsigned int D.31588;
  _Bool D.31589;
  long int D.31590;
  long int D.31591;
  unsigned int D.31594;
  int log_level.433;
  _Bool D.31596;
  long int D.31597;
  long int D.31598;
  struct FILE * log_file.434;
  unsigned int D.31602;
  void * D.31603;
  int D.31604;
  struct MonoInternalThread * D.31607;
  struct InvokeData * D.31608;
  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.429 = debugger_tls_id;
      tls = pthread_getspecific (debugger_tls_id.429);
      D.31555 = tls == 0B;
      D.31556 = (long int) D.31555;
      D.31557 = __builtin_expect (D.31556, 0);
      if (D.31557 != 0) goto <D.31558>; else goto <D.31559>;
      <D.31558>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 6421, "tls");
      <D.31559>:
      mono_loader_lock ();
      invoke = tls->pending_invoke;
      D.31560 = invoke == 0B;
      D.31561 = (long int) D.31560;
      D.31562 = __builtin_expect (D.31561, 0);
      if (D.31562 != 0) goto <D.31563>; else goto <D.31564>;
      <D.31563>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 6431, "invoke");
      <D.31564>:
      tls->pending_invoke = 0B;
      D.31565 = tls->invoke;
      invoke->last_invoke = D.31565;
      tls->invoke = invoke;
      mono_loader_unlock ();
      tls->frames_up_to_date = 0;
      id = invoke->id;
      p.430 = invoke->p;
      p = p.430;
      err = 0;
      mindex = 0;
      goto <D.26216>;
      <D.26215>:
      buffer_init (&buf, 128);
      if (err != 0) goto <D.31567>; else goto <D.31568>;
      <D.31567>:
      goto <D.31569>;
      <D.31568>:
      p.431 = p;
      D.31571 = do_invoke_method (tls, &buf, invoke, p.431, &p);
      err = (int) D.31571;
      <D.31569>:
      D.31572 = invoke->nmethods;
      D.31573 = D.31572 + -1;
      if (D.31573 == mindex) goto <D.31574>; else goto <D.31575>;
      <D.31574>:
      D.31576 = invoke->flags;
      D.31577 = D.31576 & 2;
      if (D.31577 == 0) goto <D.31578>; else goto <D.31579>;
      <D.31578>:
      i = 0;
      goto <D.26213>;
      <D.26212>:
      suspend_vm ();
      i = i + 1;
      <D.26213>:
      i.432 = (unsigned int) i;
      D.31581 = invoke->suspend_count;
      if (i.432 < D.31581) goto <D.26212>; else goto <D.26214>;
      <D.26214>:
      <D.31579>:
      <D.31575>:
      send_reply_packet (id, err, &buf);
      buffer_free (&buf);
      mindex = mindex + 1;
      <D.26216>:
      D.31572 = invoke->nmethods;
      if (D.31572 > mindex) goto <D.26215>; else goto <D.26217>;
      <D.26217>:
      D.31582 = &invoke->ctx;
      memcpy (&restore_ctx, D.31582, 260);
      D.31583 = invoke->has_ctx;
      if (D.31583 != 0) goto <D.31584>; else goto <D.31585>;
      <D.31584>:
      save_thread_context (&restore_ctx);
      <D.31585>:
      D.31576 = invoke->flags;
      D.31577 = D.31576 & 2;
      if (D.31577 != 0) goto <D.31586>; else goto <D.31587>;
      <D.31586>:
      D.31588 = tls->resume_count;
      D.31589 = D.31588 == 0;
      D.31590 = (long int) D.31589;
      D.31591 = __builtin_expect (D.31590, 0);
      if (D.31591 != 0) goto <D.31592>; else goto <D.31593>;
      <D.31592>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 6473, "tls->resume_count");
      <D.31593>:
      D.31588 = tls->resume_count;
      D.31581 = invoke->suspend_count;
      D.31594 = D.31588 - D.31581;
      tls->resume_count = D.31594;
      <D.31587>:
      log_level.433 = log_level;
      D.31596 = log_level.433 > 0;
      D.31597 = (long int) D.31596;
      D.31598 = __builtin_expect (D.31597, 0);
      if (D.31598 != 0) goto <D.31599>; else goto <D.31600>;
      <D.31599>:
      log_file.434 = log_file;
      D.31602 = GetCurrentThreadId ();
      D.31603 = (void *) D.31602;
      D.31588 = tls->resume_count;
      fprintf (log_file.434, "[%p] Invoke finished (%d), resume_count = %d.\n", D.31603, err, D.31588);
      log_file.434 = log_file;
      fflush (log_file.434);
      <D.31600>:
      mono_loader_lock ();
      D.31604 = tls->abort_requested;
      if (D.31604 != 0) goto <D.31605>; else goto <D.31606>;
      <D.31605>:
      D.31607 = tls->thread;
      mono_thread_internal_reset_abort (D.31607);
      <D.31606>:
      D.31565 = tls->invoke;
      D.31608 = D.31565->last_invoke;
      tls->invoke = D.31608;
      tls->abort_requested = 0;
      mono_loader_unlock ();
      p.430 = invoke->p;
      monoeg_g_free (p.430);
      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.31609;
  int log_level.435;
  _Bool D.31613;
  long int D.31614;
  long int D.31615;
  struct FILE * log_file.436;
  unsigned int D.31619;
  void * D.31620;
  char * D.31621;
  const char * iftmp.437;
  struct MonoObject * this.438;
  struct MonoVTable * D.31626;
  struct MonoClass * D.31627;
  void * * D.31629;
  guint8 * p.439;
  int err.440;
  ErrorCode D.31634;
  struct MonoClass * D.31635;
  unsigned int D.31636;
  unsigned int D.31637;
  int D.31640;
  unsigned int D.31641;
  short unsigned int D.31646;
  int D.31647;
  int D.31648;
  unsigned int D.31654;
  void * D.31655;
  int D.31656;
  unsigned int D.31657;
  struct MonoType * D.31658;
  struct MonoDomain * domain.441;
  <unnamed type> D.31660;
  int err.442;
  struct MonoObject * this.443;
  unsigned int D.31670;
  unsigned int D.31671;
  unsigned char D.31673;
  unsigned int D.31679;
  void * D.31680;
  unsigned int D.31683;
  void * D.31684;
  char * D.31685;
  const char * iftmp.444;
  struct MonoDomain * D.31692;
  int D.26184;
  int iftmp.445;
  int D.26183;
  const char[6] * D.31704;
  unsigned char D.31705;
  int D.31706;
  unsigned char D.31707;
  int D.31708;
  const unsigned char * D.31713;
  unsigned char D.31714;
  int D.31715;
  const unsigned char * D.31716;
  unsigned char D.31717;
  int D.31718;
  const unsigned char * D.31723;
  unsigned char D.31724;
  int D.31725;
  const unsigned char * D.31726;
  unsigned char D.31727;
  int D.31728;
  const unsigned char * D.31733;
  unsigned char D.31734;
  int D.31735;
  const unsigned char * D.31736;
  unsigned char D.31737;
  int D.31738;
  const char * D.31740;
  unsigned int D.31743;
  struct MonoObject * this.446;
  int D.31750;
  short unsigned int D.31753;
  int D.31754;
  unsigned int nargs.447;
  unsigned int D.31758;
  struct MonoType * D.31759;
  int D.31760;
  unsigned int i.448;
  unsigned int D.31764;
  guint8 * D.31765;
  <unnamed type> D.31766;
  int err.449;
  void * * D.31769;
  void * D.31770;
  struct MonoVTable * D.31773;
  struct MonoDomain * D.31774;
  guint8 * * D.31778;
  struct MonoClass * D.31779;
  int D.31780;
  unsigned int D.31781;
  void * D.31782;
  guint8 * D.31783;
  <unnamed type> D.31784;
  int err.450;
  int D.31789;
  int D.31790;
  int D.31794;
  struct MonoLMF * D.31797;
  struct MonoContext * D.31798;
  struct MonoObject * res.451;
  struct MonoObject * res.452;
  unsigned int D.31806;
  void * D.31807;
  struct MonoObject * res.453;
  const char * iftmp.454;
  struct MonoObject * exc.455;
  struct MonoVTable * D.31813;
  struct MonoClass * D.31814;
  long long unsigned int D.31816;
  long int D.31817;
  struct MonoClass * D.31820;
  struct MonoType * D.31821;
  struct MonoType * D.31823;
  unsigned char D.31824;
  int D.26197;
  int iftmp.456;
  int D.26196;
  unsigned char D.31832;
  int D.31833;
  const unsigned char * D.31838;
  unsigned char D.31839;
  int D.31840;
  const unsigned char * D.31845;
  unsigned char D.31846;
  int D.31847;
  const unsigned char * D.31852;
  unsigned char D.31853;
  int D.31854;
  struct MonoClass * D.31858;
  struct MonoType * D.31859;
  int D.31861;
  struct MonoClass * D.31868;
  unsigned int D.31869;
  unsigned int D.31870;
  struct MonoClass * D.31873;
  int D.31874;
  int D.31877;
  unsigned int D.31878;
  _Bool D.31879;
  long int D.31880;
  long int D.31881;
  _Bool D.31885;
  long int D.31886;
  long int D.31887;
  void * D.31890;
  void * D.31893;
  int D.31894;
  int D.31895;
  struct MonoLMF * D.31896;
  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.31609 = invoke->method;
      if (D.31609 != 0B) goto <D.31610>; else goto <D.31611>;
      <D.31610>:
      this = 0B;
      log_level.435 = log_level;
      D.31613 = log_level.435 > 0;
      D.31614 = (long int) D.31613;
      D.31615 = __builtin_expect (D.31614, 0);
      if (D.31615 != 0) goto <D.31616>; else goto <D.31617>;
      <D.31616>:
      log_file.436 = log_file;
      D.31619 = GetCurrentThreadId ();
      D.31620 = (void *) D.31619;
      D.31609 = invoke->method;
      D.31621 = mono_method_full_name (D.31609, 1);
      this.438 = this;
      if (this.438 != 0B) goto <D.31624>; else goto <D.31625>;
      <D.31624>:
      this.438 = this;
      D.31626 = this.438->vtable;
      D.31627 = D.31626->klass;
      iftmp.437 = D.31627->name;
      goto <D.31628>;
      <D.31625>:
      iftmp.437 = "<null>";
      <D.31628>:
      fprintf (log_file.436, "[%p] Invoking method \'%s\' on receiver \'%s\'.\n", D.31620, D.31621, iftmp.437);
      log_file.436 = log_file;
      fflush (log_file.436);
      <D.31617>:
      D.31609 = invoke->method;
      D.31629 = invoke->args;
      mono_runtime_invoke (D.31609, 0B, D.31629, &exc);
      monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "debugger-agent.c", 6243);
      <D.31611>:
      p.439 = p;
      m = decode_methodid (p.439, &p, end, &domain, &err);
      err.440 = err;
      if (err.440 != 0) goto <D.31632>; else goto <D.31633>;
      <D.31632>:
      err.440 = err;
      D.31634 = (ErrorCode) err.440;
      return D.31634;
      <D.31633>:
      sig = mono_method_signature (m);
      D.31635 = m->klass;
      D.31636 = BIT_FIELD_REF <*D.31635, 32, 160>;
      D.31637 = D.31636 & 8;
      if (D.31637 != 0) goto <D.31638>; else goto <D.31639>;
      <D.31638>:
      D.31635 = m->klass;
      D.31640 = mono_class_instance_size (D.31635);
      D.31641 = (unsigned int) D.31640;
      this_buf = __builtin_alloca (D.31641);
      goto <D.31642>;
      <D.31639>:
      this_buf = __builtin_alloca (4);
      <D.31642>:
      D.31635 = m->klass;
      D.31636 = BIT_FIELD_REF <*D.31635, 32, 160>;
      D.31637 = D.31636 & 8;
      if (D.31637 != 0) goto <D.31645>; else goto <D.31643>;
      <D.31645>:
      D.31646 = m->flags;
      D.31647 = (int) D.31646;
      D.31648 = D.31647 & 16;
      if (D.31648 != 0) goto <D.31649>; else goto <D.31643>;
      <D.31649>:
      {
        int type;

        p.439 = p;
        type = decode_byte (p.439, &p, end);
        if (type != 240) goto <D.31650>; else goto <D.31651>;
        <D.31650>:
        log_level.435 = log_level;
        D.31613 = log_level.435 > 0;
        D.31614 = (long int) D.31613;
        D.31615 = __builtin_expect (D.31614, 0);
        if (D.31615 != 0) goto <D.31652>; else goto <D.31653>;
        <D.31652>:
        log_file.436 = log_file;
        D.31654 = GetCurrentThreadId ();
        D.31655 = (void *) D.31654;
        fprintf (log_file.436, "[%p] Error: Static vtype method invoked with this argument.\n", D.31655);
        log_file.436 = log_file;
        fflush (log_file.436);
        <D.31653>:
        D.31634 = 102;
        return D.31634;
        <D.31651>:
        D.31635 = m->klass;
        D.31656 = mono_class_instance_size (D.31635);
        D.31657 = (unsigned int) D.31656;
        memset (this_buf, 0, D.31657);
      }
      goto <D.31644>;
      <D.31643>:
      D.31635 = m->klass;
      D.31658 = &D.31635->byval_arg;
      domain.441 = domain;
      p.439 = p;
      D.31660 = decode_value (D.31658, domain.441, this_buf, p.439, &p, end);
      err.442 = (int) D.31660;
      err = err.442;
      err.440 = err;
      if (err.440 != 0) goto <D.31662>; else goto <D.31663>;
      <D.31662>:
      err.440 = err;
      D.31634 = (ErrorCode) err.440;
      return D.31634;
      <D.31663>:
      <D.31644>:
      D.31635 = m->klass;
      D.31636 = BIT_FIELD_REF <*D.31635, 32, 160>;
      D.31637 = D.31636 & 8;
      if (D.31637 == 0) goto <D.31664>; else goto <D.31665>;
      <D.31664>:
      this.443 = MEM[(struct MonoObject * *)this_buf];
      this = this.443;
      goto <D.31667>;
      <D.31665>:
      this = 0B;
      <D.31667>:
      D.31635 = m->klass;
      D.31670 = D.31635->flags;
      D.31671 = D.31670 & 32;
      if (D.31671 != 0) goto <D.31668>; else goto <D.31672>;
      <D.31672>:
      D.31635 = m->klass;
      D.31673 = D.31635->byval_arg.type;
      if (D.31673 == 19) goto <D.31668>; else goto <D.31674>;
      <D.31674>:
      D.31635 = m->klass;
      D.31673 = D.31635->byval_arg.type;
      if (D.31673 == 30) goto <D.31668>; else goto <D.31669>;
      <D.31668>:
      this.438 = this;
      if (this.438 == 0B) goto <D.31675>; else goto <D.31676>;
      <D.31675>:
      log_level.435 = log_level;
      D.31613 = log_level.435 > 0;
      D.31614 = (long int) D.31613;
      D.31615 = __builtin_expect (D.31614, 0);
      if (D.31615 != 0) goto <D.31677>; else goto <D.31678>;
      <D.31677>:
      log_file.436 = log_file;
      D.31679 = GetCurrentThreadId ();
      D.31680 = (void *) D.31679;
      fprintf (log_file.436, "[%p] Error: Interface method invoked without this argument.\n", D.31680);
      log_file.436 = log_file;
      fflush (log_file.436);
      <D.31678>:
      D.31634 = 102;
      return D.31634;
      <D.31676>:
      this.438 = this;
      m = mono_object_get_virtual_method (this.438, m);
      <D.31669>:
      log_level.435 = log_level;
      D.31613 = log_level.435 > 0;
      D.31614 = (long int) D.31613;
      D.31615 = __builtin_expect (D.31614, 0);
      if (D.31615 != 0) goto <D.31681>; else goto <D.31682>;
      <D.31681>:
      log_file.436 = log_file;
      D.31683 = GetCurrentThreadId ();
      D.31684 = (void *) D.31683;
      D.31685 = mono_method_full_name (m, 1);
      this.438 = this;
      if (this.438 != 0B) goto <D.31687>; else goto <D.31688>;
      <D.31687>:
      this.438 = this;
      D.31626 = this.438->vtable;
      D.31627 = D.31626->klass;
      iftmp.444 = D.31627->name;
      goto <D.31689>;
      <D.31688>:
      iftmp.444 = "<null>";
      <D.31689>:
      fprintf (log_file.436, "[%p] Invoking method \'%s\' on receiver \'%s\'.\n", D.31684, D.31685, iftmp.444);
      log_file.436 = log_file;
      fflush (log_file.436);
      <D.31682>:
      this.438 = this;
      if (this.438 != 0B) goto <D.31690>; else goto <D.31691>;
      <D.31690>:
      this.438 = this;
      D.31626 = this.438->vtable;
      D.31692 = D.31626->domain;
      domain.441 = domain;
      if (D.31692 != domain.441) goto <D.31693>; else goto <D.31694>;
      <D.31693>:
      monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "debugger-agent.c", 6285);
      <D.31694>:
      <D.31691>:
      D.31635 = m->klass;
      D.31636 = BIT_FIELD_REF <*D.31635, 32, 160>;
      D.31637 = D.31636 & 8;
      if (D.31637 == 0) goto <D.31695>; else goto <D.31696>;
      <D.31695>:
      D.31646 = m->flags;
      D.31647 = (int) D.31646;
      D.31648 = D.31647 & 16;
      if (D.31648 == 0) goto <D.31697>; else goto <D.31698>;
      <D.31697>:
      this.438 = this;
      if (this.438 == 0B) goto <D.31699>; else goto <D.31700>;
      <D.31699>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          __s2 = m->name;
          D.31704 = ".ctor";
          D.31705 = MEM[(const unsigned char *)D.31704];
          D.31706 = (int) D.31705;
          D.31707 = *__s2;
          D.31708 = (int) D.31707;
          __result = D.31706 - D.31708;
          {
            if (__s2_len != 0) goto <D.31709>; else goto <D.31710>;
            <D.31709>:
            if (__result == 0) goto <D.31711>; else goto <D.31712>;
            <D.31711>:
            D.31713 = &MEM[(void *)".ctor" + 1B];
            D.31714 = *D.31713;
            D.31715 = (int) D.31714;
            D.31716 = __s2 + 1;
            D.31717 = *D.31716;
            D.31718 = (int) D.31717;
            __result = D.31715 - D.31718;
            if (__s2_len > 1) goto <D.31719>; else goto <D.31720>;
            <D.31719>:
            if (__result == 0) goto <D.31721>; else goto <D.31722>;
            <D.31721>:
            D.31723 = &MEM[(void *)".ctor" + 2B];
            D.31724 = *D.31723;
            D.31725 = (int) D.31724;
            D.31726 = __s2 + 2;
            D.31727 = *D.31726;
            D.31728 = (int) D.31727;
            __result = D.31725 - D.31728;
            if (__s2_len > 2) goto <D.31729>; else goto <D.31730>;
            <D.31729>:
            if (__result == 0) goto <D.31731>; else goto <D.31732>;
            <D.31731>:
            D.31733 = &MEM[(void *)".ctor" + 3B];
            D.31734 = *D.31733;
            D.31735 = (int) D.31734;
            D.31736 = __s2 + 3;
            D.31737 = *D.31736;
            D.31738 = (int) D.31737;
            __result = D.31735 - D.31738;
            <D.31732>:
            <D.31730>:
            <D.31722>:
            <D.31720>:
            <D.31712>:
            <D.31710>:
          }
          D.26183 = __result;
        }
        iftmp.445 = -D.26183;
        goto <D.31739>;
        <D.31703>:
        D.31740 = m->name;
        iftmp.445 = __builtin_strcmp (D.31740, ".ctor");
        <D.31739>:
        D.26184 = iftmp.445;
      }
      if (D.26184 == 0) goto <D.31741>; else goto <D.31742>;
      <D.31741>:
      D.31635 = m->klass;
      D.31670 = D.31635->flags;
      D.31743 = D.31670 & 128;
      if (D.31743 != 0) goto <D.31744>; else goto <D.31745>;
      <D.31744>:
      D.31634 = 102;
      return D.31634;
      <D.31745>:
      domain.441 = domain;
      D.31635 = m->klass;
      this.446 = mono_object_new (domain.441, D.31635);
      this = this.446;
      goto <D.31747>;
      <D.31742>:
      D.31634 = 102;
      return D.31634;
      <D.31747>:
      <D.31700>:
      <D.31698>:
      <D.31696>:
      this.438 = this;
      if (this.438 != 0B) goto <D.31748>; else goto <D.31749>;
      <D.31748>:
      this.438 = this;
      D.31635 = m->klass;
      D.31658 = &D.31635->byval_arg;
      D.31750 = obj_is_of_type (this.438, D.31658);
      if (D.31750 == 0) goto <D.31751>; else goto <D.31752>;
      <D.31751>:
      D.31634 = 102;
      return D.31634;
      <D.31752>:
      <D.31749>:
      p.439 = p;
      nargs = decode_int (p.439, &p, end);
      D.31753 = sig->param_count;
      D.31754 = (int) D.31753;
      if (D.31754 != nargs) goto <D.31755>; else goto <D.31756>;
      <D.31755>:
      D.31634 = 102;
      return D.31634;
      <D.31756>:
      nargs.447 = (unsigned int) nargs;
      D.31758 = nargs.447 * 4;
      arg_buf = __builtin_alloca (D.31758);
      nargs.447 = (unsigned int) nargs;
      D.31758 = nargs.447 * 4;
      memset (arg_buf, 0, D.31758);
      nargs.447 = (unsigned int) nargs;
      D.31758 = nargs.447 * 4;
      args = __builtin_alloca (D.31758);
      i = 0;
      goto <D.26187>;
      <D.26186>:
      D.31759 = sig->params[i];
      D.31760 = mono_type_is_reference (D.31759);
      if (D.31760 != 0) goto <D.31761>; else goto <D.31762>;
      <D.31761>:
      D.31759 = sig->params[i];
      domain.441 = domain;
      i.448 = (unsigned int) i;
      D.31764 = i.448 * 4;
      D.31765 = args + D.31764;
      p.439 = p;
      D.31766 = decode_value (D.31759, domain.441, D.31765, p.439, &p, end);
      err.449 = (int) D.31766;
      err = err.449;
      err.440 = err;
      if (err.440 != 0) goto <D.26185>; else goto <D.31768>;
      <D.31768>:
      i.448 = (unsigned int) i;
      D.31764 = i.448 * 4;
      D.31769 = args + D.31764;
      D.31770 = *D.31769;
      if (D.31770 != 0B) goto <D.31771>; else goto <D.31772>;
      <D.31771>:
      i.448 = (unsigned int) i;
      D.31764 = i.448 * 4;
      D.31769 = args + D.31764;
      D.31770 = *D.31769;
      D.31773 = MEM[(struct MonoObject *)D.31770].vtable;
      D.31774 = D.31773->domain;
      domain.441 = domain;
      if (D.31774 != domain.441) goto <D.31775>; else goto <D.31776>;
      <D.31775>:
      monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "debugger-agent.c", 6315);
      <D.31776>:
      <D.31772>:
      goto <D.31777>;
      <D.31762>:
      i.448 = (unsigned int) i;
      D.31764 = i.448 * 4;
      D.31778 = arg_buf + D.31764;
      D.31759 = sig->params[i];
      D.31779 = mono_class_from_mono_type (D.31759);
      D.31780 = mono_class_instance_size (D.31779);
      D.31781 = (unsigned int) D.31780;
      D.31782 = __builtin_alloca (D.31781);
      *D.31778 = D.31782;
      D.31759 = sig->params[i];
      domain.441 = domain;
      i.448 = (unsigned int) i;
      D.31764 = i.448 * 4;
      D.31778 = arg_buf + D.31764;
      D.31783 = *D.31778;
      p.439 = p;
      D.31784 = decode_value (D.31759, domain.441, D.31783, p.439, &p, end);
      err.450 = (int) D.31784;
      err = err.450;
      err.440 = err;
      if (err.440 != 0) goto <D.26185>; else goto <D.31786>;
      <D.31786>:
      i.448 = (unsigned int) i;
      D.31764 = i.448 * 4;
      D.31769 = args + D.31764;
      i.448 = (unsigned int) i;
      D.31764 = i.448 * 4;
      D.31778 = arg_buf + D.31764;
      D.31783 = *D.31778;
      *D.31769 = D.31783;
      <D.31777>:
      i = i + 1;
      <D.26187>:
      if (i < nargs) goto <D.26186>; else goto <D.26185>;
      <D.26185>:
      if (i < nargs) goto <D.31787>; else goto <D.31788>;
      <D.31787>:
      err.440 = err;
      D.31634 = (ErrorCode) err.440;
      return D.31634;
      <D.31788>:
      D.31789 = invoke->flags;
      D.31790 = D.31789 & 1;
      if (D.31790 != 0) goto <D.31791>; else goto <D.31792>;
      <D.31791>:
      tls->disable_breakpoints = 1;
      goto <D.31793>;
      <D.31792>:
      tls->disable_breakpoints = 0;
      <D.31793>:
      D.31794 = invoke->has_ctx;
      if (D.31794 != 0) goto <D.31795>; else goto <D.31796>;
      <D.31795>:
      {
        struct MonoLMF * * lmf_addr;

        lmf_addr = mono_get_lmf_addr ();
        memset (&ext, 0, 540);
        D.31797 = *lmf_addr;
        mono_arch_init_lmf_ext (&ext, D.31797);
        ext.debugger_invoke = 1;
        D.31798 = &invoke->ctx;
        memcpy (&ext.ctx, D.31798, 260);
        mono_set_lmf (&ext);
      }
      <D.31796>:
      mono_stopwatch_start (&watch);
      D.31635 = m->klass;
      D.31636 = BIT_FIELD_REF <*D.31635, 32, 160>;
      D.31637 = D.31636 & 8;
      if (D.31637 != 0) goto <D.31799>; else goto <D.31800>;
      <D.31799>:
      res.451 = mono_runtime_invoke (m, this_buf, args, &exc);
      res = res.451;
      goto <D.31802>;
      <D.31800>:
      this.438 = this;
      res.452 = mono_runtime_invoke (m, this.438, args, &exc);
      res = res.452;
      <D.31802>:
      mono_stopwatch_stop (&watch);
      log_level.435 = log_level;
      D.31613 = log_level.435 > 0;
      D.31614 = (long int) D.31613;
      D.31615 = __builtin_expect (D.31614, 0);
      if (D.31615 != 0) goto <D.31804>; else goto <D.31805>;
      <D.31804>:
      log_file.436 = log_file;
      D.31806 = GetCurrentThreadId ();
      D.31807 = (void *) D.31806;
      res.453 = res;
      exc.455 = exc;
      if (exc.455 != 0B) goto <D.31811>; else goto <D.31812>;
      <D.31811>:
      exc.455 = exc;
      D.31813 = exc.455->vtable;
      D.31814 = D.31813->klass;
      iftmp.454 = D.31814->name;
      goto <D.31815>;
      <D.31812>:
      iftmp.454 = 0B;
      <D.31815>:
      D.31816 = mono_stopwatch_elapsed_ms (&watch);
      D.31817 = (long int) D.31816;
      fprintf (log_file.436, "[%p] Invoke result: %p, exc: %s, time: %ld ms.\n", D.31807, res.453, iftmp.454, D.31817);
      log_file.436 = log_file;
      fflush (log_file.436);
      <D.31805>:
      exc.455 = exc;
      if (exc.455 != 0B) goto <D.31818>; else goto <D.31819>;
      <D.31818>:
      buffer_add_byte (buf, 0);
      D.31820 = mono_defaults.object_class;
      D.31821 = &D.31820->byval_arg;
      domain.441 = domain;
      buffer_add_value (buf, D.31821, &exc, domain.441);
      goto <D.31822>;
      <D.31819>:
      buffer_add_byte (buf, 1);
      D.31823 = sig->ret;
      D.31824 = D.31823->type;
      if (D.31824 == 1) goto <D.31825>; else goto <D.31826>;
      <D.31825>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          __s2 = m->name;
          D.31704 = ".ctor";
          D.31705 = MEM[(const unsigned char *)D.31704];
          D.31706 = (int) D.31705;
          D.31832 = *__s2;
          D.31833 = (int) D.31832;
          __result = D.31706 - D.31833;
          {
            if (__s2_len != 0) goto <D.31834>; else goto <D.31835>;
            <D.31834>:
            if (__result == 0) goto <D.31836>; else goto <D.31837>;
            <D.31836>:
            D.31713 = &MEM[(void *)".ctor" + 1B];
            D.31714 = *D.31713;
            D.31715 = (int) D.31714;
            D.31838 = __s2 + 1;
            D.31839 = *D.31838;
            D.31840 = (int) D.31839;
            __result = D.31715 - D.31840;
            if (__s2_len > 1) goto <D.31841>; else goto <D.31842>;
            <D.31841>:
            if (__result == 0) goto <D.31843>; else goto <D.31844>;
            <D.31843>:
            D.31723 = &MEM[(void *)".ctor" + 2B];
            D.31724 = *D.31723;
            D.31725 = (int) D.31724;
            D.31845 = __s2 + 2;
            D.31846 = *D.31845;
            D.31847 = (int) D.31846;
            __result = D.31725 - D.31847;
            if (__s2_len > 2) goto <D.31848>; else goto <D.31849>;
            <D.31848>:
            if (__result == 0) goto <D.31850>; else goto <D.31851>;
            <D.31850>:
            D.31733 = &MEM[(void *)".ctor" + 3B];
            D.31734 = *D.31733;
            D.31735 = (int) D.31734;
            D.31852 = __s2 + 3;
            D.31853 = *D.31852;
            D.31854 = (int) D.31853;
            __result = D.31735 - D.31854;
            <D.31851>:
            <D.31849>:
            <D.31844>:
            <D.31842>:
            <D.31837>:
            <D.31835>:
          }
          D.26196 = __result;
        }
        iftmp.456 = -D.26196;
        goto <D.31855>;
        <D.31831>:
        D.31740 = m->name;
        iftmp.456 = __builtin_strcmp (D.31740, ".ctor");
        <D.31855>:
        D.26197 = iftmp.456;
      }
      if (D.26197 == 0) goto <D.31856>; else goto <D.31827>;
      <D.31856>:
      D.31635 = m->klass;
      D.31636 = BIT_FIELD_REF <*D.31635, 32, 160>;
      D.31637 = D.31636 & 8;
      if (D.31637 == 0) goto <D.31857>; else goto <D.31827>;
      <D.31857>:
      D.31820 = mono_defaults.object_class;
      D.31821 = &D.31820->byval_arg;
      domain.441 = domain;
      buffer_add_value (buf, D.31821, &this, domain.441);
      goto <D.31828>;
      <D.31827>:
      D.31858 = mono_defaults.void_class;
      D.31859 = &D.31858->byval_arg;
      domain.441 = domain;
      buffer_add_value (buf, D.31859, 0B, domain.441);
      <D.31828>:
      goto <D.31860>;
      <D.31826>:
      D.31823 = sig->ret;
      D.31861 = mono_type_is_reference (D.31823);
      if (D.31861 != 0) goto <D.31862>; else goto <D.31863>;
      <D.31862>:
      D.31823 = sig->ret;
      domain.441 = domain;
      buffer_add_value (buf, D.31823, &res, domain.441);
      goto <D.31864>;
      <D.31863>:
      D.31823 = sig->ret;
      D.31868 = mono_class_from_mono_type (D.31823);
      D.31869 = BIT_FIELD_REF <*D.31868, 32, 160>;
      D.31870 = D.31869 & 8;
      if (D.31870 != 0) goto <D.31865>; else goto <D.31871>;
      <D.31871>:
      D.31823 = sig->ret;
      D.31824 = D.31823->type;
      if (D.31824 == 15) goto <D.31865>; else goto <D.31872>;
      <D.31872>:
      D.31823 = sig->ret;
      D.31824 = D.31823->type;
      if (D.31824 == 27) goto <D.31865>; else goto <D.31866>;
      <D.31865>:
      D.31823 = sig->ret;
      D.31873 = mono_class_from_mono_type (D.31823);
      D.31874 = mono_class_is_nullable (D.31873);
      if (D.31874 != 0) goto <D.31875>; else goto <D.31876>;
      <D.31875>:
      {
        struct MonoClass * k;
        guint8 * nullable_buf;

        D.31823 = sig->ret;
        k = mono_class_from_mono_type (D.31823);
        D.31877 = mono_class_value_size (k, 0B);
        D.31878 = (unsigned int) D.31877;
        nullable_buf = __builtin_alloca (D.31878);
        D.31879 = nullable_buf == 0B;
        D.31880 = (long int) D.31879;
        D.31881 = __builtin_expect (D.31880, 0);
        if (D.31881 != 0) goto <D.31882>; else goto <D.31883>;
        <D.31882>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 6379, "nullable_buf");
        <D.31883>:
        res.453 = res;
        mono_nullable_init (nullable_buf, res.453, k);
        D.31823 = sig->ret;
        domain.441 = domain;
        buffer_add_value (buf, D.31823, nullable_buf, domain.441);
      }
      goto <D.31884>;
      <D.31876>:
      res.453 = res;
      D.31885 = res.453 == 0B;
      D.31886 = (long int) D.31885;
      D.31887 = __builtin_expect (D.31886, 0);
      if (D.31887 != 0) goto <D.31888>; else goto <D.31889>;
      <D.31888>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 6383, "res");
      <D.31889>:
      D.31823 = sig->ret;
      res.453 = res;
      D.31890 = mono_object_unbox (res.453);
      domain.441 = domain;
      buffer_add_value (buf, D.31823, D.31890, domain.441);
      <D.31884>:
      goto <D.31867>;
      <D.31866>:
      monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "debugger-agent.c", 6387);
      <D.31867>:
      <D.31864>:
      <D.31860>:
      <D.31822>:
      tls->disable_breakpoints = 0;
      D.31794 = invoke->has_ctx;
      if (D.31794 != 0) goto <D.31891>; else goto <D.31892>;
      <D.31891>:
      D.31893 = ext.lmf.previous_lmf;
      D.31894 = (int) D.31893;
      D.31895 = D.31894 & -4;
      D.31896 = (struct MonoLMF *) D.31895;
      mono_set_lmf (D.31896);
      <D.31892>:
      p.439 = p;
      *endp = p.439;
      D.31634 = 0;
      return D.31634;
    }
  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.31901;
  int D.31906;
  void * D.31908;
  unsigned int D.31909;

  D.31901 = __builtin_constant_p (__len);
  if (D.31901 != 0) goto <D.31902>; else goto <D.31903>;
  <D.31902>:
  if (__len == 0) goto <D.31904>; else goto <D.31905>;
  <D.31904>:
  D.31906 = __builtin_constant_p (__ch);
  if (D.31906 == 0) goto <D.31899>; else goto <D.31907>;
  <D.31907>:
  if (__ch != 0) goto <D.31899>; else goto <D.31900>;
  <D.31899>:
  __warn_memset_zero_len ();
  D.31908 = __dest;
  return D.31908;
  <D.31900>:
  <D.31905>:
  <D.31903>:
  D.31909 = __builtin_object_size (__dest, 0);
  D.31908 = __builtin___memset_chk (__dest, __ch, __len, D.31909);
  return D.31908;
}


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

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


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

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


mono_stopwatch_elapsed_ms (struct MonoStopwatch * w)
{
  guint64 D.31913;
  long long unsigned int D.31914;
  long long unsigned int D.31915;

  D.31914 = mono_stopwatch_elapsed (w);
  D.31915 = D.31914 + 500;
  D.31913 = D.31915 / 1000;
  return D.31913;
}


mono_stopwatch_elapsed (struct MonoStopwatch * w)
{
  guint64 D.31917;
  long long int D.31918;
  long long int D.31919;
  long long int D.31920;
  long long int D.31921;

  D.31918 = w->stop;
  D.31919 = w->start;
  D.31920 = D.31918 - D.31919;
  D.31921 = D.31920 / 10;
  D.31917 = (guint64) D.31921;
  return D.31917;
}


send_type_load (struct MonoClass * klass)
{
  union mono_mutex_t * D.31923;
  _Bool D.31926;
  long int D.31927;
  long int D.31928;
  struct GHashTable * D.31931;
  void * D.31932;
  _Bool D.31937;
  long int D.31938;
  long int D.31939;
  gboolean type_load;
  struct MonoDomain * domain;
  struct AgentDomainInfo * info;

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

    D.31923 = &domain->lock.mutex;
    ret = pthread_mutex_lock (D.31923);
    if (ret != 0) goto <D.31924>; else goto <D.31925>;
    <D.31924>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.31925>:
    D.31926 = ret != 0;
    D.31927 = (long int) D.31926;
    D.31928 = __builtin_expect (D.31927, 0);
    if (D.31928 != 0) goto <D.31929>; else goto <D.31930>;
    <D.31929>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 3983, "ret == 0");
    <D.31930>:
  }
  info = get_agent_domain_info (domain);
  D.31931 = info->loaded_classes;
  D.31932 = monoeg_g_hash_table_lookup (D.31931, klass);
  if (D.31932 == 0B) goto <D.31933>; else goto <D.31934>;
  <D.31933>:
  type_load = 1;
  D.31931 = info->loaded_classes;
  monoeg_g_hash_table_insert_replace (D.31931, klass, klass, 0);
  <D.31934>:
  {
    int ret;

    D.31923 = &domain->lock.mutex;
    ret = pthread_mutex_unlock (D.31923);
    if (ret != 0) goto <D.31935>; else goto <D.31936>;
    <D.31935>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.31936>:
    D.31937 = ret != 0;
    D.31938 = (long int) D.31937;
    D.31939 = __builtin_expect (D.31938, 0);
    if (D.31939 != 0) goto <D.31940>; else goto <D.31941>;
    <D.31940>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 3992, "ret == 0");
    <D.31941>:
  }
  mono_loader_unlock ();
  if (type_load != 0) goto <D.31942>; else goto <D.31943>;
  <D.31942>:
  emit_type_load (klass, klass, 0B);
  <D.31943>:
}


add_pending_breakpoints (struct MonoMethod * method, struct MonoJitInfo * ji)
{
  struct GPtrArray * breakpoints.457;
  void * * D.31947;
  unsigned int i.458;
  unsigned int D.31949;
  void * * D.31950;
  int D.31951;
  struct GPtrArray * D.31954;
  void * * D.31955;
  unsigned int j.459;
  unsigned int D.31957;
  void * * D.31958;
  struct MonoJitInfo * D.31959;
  unsigned int j.460;
  unsigned int D.31963;
  union mono_mutex_t * D.31966;
  _Bool D.31969;
  long int D.31970;
  long int D.31971;
  void * D.31974;
  struct GHashTable * D.31975;
  unsigned int D.31978;
  unsigned int D.31979;
  struct MonoMethod * D.31982;
  _Bool D.31985;
  long int D.31986;
  long int D.31987;
  _Bool D.31992;
  long int D.31993;
  long int D.31994;
  unsigned int i.461;
  unsigned int D.31998;
  int i;
  int j;
  struct MonoSeqPointInfo * seq_points;
  struct MonoDomain * domain;
  struct MonoMethod * jmethod;

  breakpoints.457 = breakpoints;
  if (breakpoints.457 == 0B) goto <D.31945>; else goto <D.31946>;
  <D.31945>:
  return;
  <D.31946>:
  domain = mono_domain_get ();
  mono_loader_lock ();
  i = 0;
  goto <D.25521>;
  <D.25520>:
  {
    struct MonoBreakpoint * bp;
    gboolean found;

    breakpoints.457 = breakpoints;
    D.31947 = breakpoints.457->pdata;
    i.458 = (unsigned int) i;
    D.31949 = i.458 * 4;
    D.31950 = D.31947 + D.31949;
    bp = *D.31950;
    found = 0;
    D.31951 = bp_matches_method (bp, method);
    if (D.31951 == 0) goto <D.31952>; else goto <D.31953>;
    <D.31952>:
    // predicted unlikely by continue predictor.
    goto <D.25513>;
    <D.31953>:
    j = 0;
    goto <D.25516>;
    <D.25515>:
    {
      struct BreakpointInstance * inst;

      D.31954 = bp->children;
      D.31955 = D.31954->pdata;
      j.459 = (unsigned int) j;
      D.31957 = j.459 * 4;
      D.31958 = D.31955 + D.31957;
      inst = *D.31958;
      D.31959 = inst->ji;
      if (D.31959 == ji) goto <D.31960>; else goto <D.31961>;
      <D.31960>:
      found = 1;
      <D.31961>:
    }
    j = j + 1;
    <D.25516>:
    j.460 = (unsigned int) j;
    D.31954 = bp->children;
    D.31963 = D.31954->len;
    if (j.460 < D.31963) goto <D.25515>; else goto <D.25517>;
    <D.25517>:
    if (found == 0) goto <D.31964>; else goto <D.31965>;
    <D.31964>:
    jmethod = jinfo_get_method (ji);
    {
      int ret;

      D.31966 = &domain->lock.mutex;
      ret = pthread_mutex_lock (D.31966);
      if (ret != 0) goto <D.31967>; else goto <D.31968>;
      <D.31967>:
      monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
      <D.31968>:
      D.31969 = ret != 0;
      D.31970 = (long int) D.31969;
      D.31971 = __builtin_expect (D.31970, 0);
      if (D.31971 != 0) goto <D.31972>; else goto <D.31973>;
      <D.31972>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 4271, "ret == 0");
      <D.31973>:
    }
    D.31974 = domain->runtime_info;
    D.31975 = MEM[(struct MonoJitDomainInfo *)D.31974].seq_points;
    seq_points = monoeg_g_hash_table_lookup (D.31975, jmethod);
    if (seq_points == 0B) goto <D.31976>; else goto <D.31977>;
    <D.31976>:
    D.31978 = BIT_FIELD_REF <*jmethod, 32, 160>;
    D.31979 = D.31978 & 4096;
    if (D.31979 != 0) goto <D.31980>; else goto <D.31981>;
    <D.31980>:
    D.31974 = domain->runtime_info;
    D.31975 = MEM[(struct MonoJitDomainInfo *)D.31974].seq_points;
    D.31982 = mono_method_get_declaring_generic_method (jmethod);
    seq_points = monoeg_g_hash_table_lookup (D.31975, D.31982);
    <D.31981>:
    <D.31977>:
    {
      int ret;

      D.31966 = &domain->lock.mutex;
      ret = pthread_mutex_unlock (D.31966);
      if (ret != 0) goto <D.31983>; else goto <D.31984>;
      <D.31983>:
      monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
      <D.31984>:
      D.31985 = ret != 0;
      D.31986 = (long int) D.31985;
      D.31987 = __builtin_expect (D.31986, 0);
      if (D.31987 != 0) goto <D.31988>; else goto <D.31989>;
      <D.31988>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 4275, "ret == 0");
      <D.31989>:
    }
    if (seq_points == 0B) goto <D.31990>; else goto <D.31991>;
    <D.31990>:
    // predicted unlikely by continue predictor.
    goto <D.25513>;
    <D.31991>:
    D.31992 = seq_points == 0B;
    D.31993 = (long int) D.31992;
    D.31994 = __builtin_expect (D.31993, 0);
    if (D.31994 != 0) goto <D.31995>; else goto <D.31996>;
    <D.31995>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 4279, "seq_points");
    <D.31996>:
    insert_breakpoint (seq_points, domain, ji, bp, 0B);
    <D.31965>:
  }
  <D.25513>:
  i = i + 1;
  <D.25521>:
  i.461 = (unsigned int) i;
  breakpoints.457 = breakpoints;
  D.31998 = breakpoints.457->len;
  if (i.461 < D.31998) goto <D.25520>; else goto <D.25522>;
  <D.25522>:
  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.462;
  void * * D.32001;
  unsigned int i.463;
  unsigned int D.32003;
  void * * D.32004;
  int D.32005;
  int D.32008;
  int D.32009;
  unsigned int i.464;
  unsigned int D.32011;
  int i;
  gboolean found;

  mono_loader_lock ();
  found = 1;
  goto <D.26134>;
  <D.26133>:
  found = 0;
  i = 0;
  goto <D.26132>;
  <D.26131>:
  {
    struct EventRequest * req;

    event_requests.462 = event_requests;
    D.32001 = event_requests.462->pdata;
    i.463 = (unsigned int) i;
    D.32003 = i.463 * 4;
    D.32004 = D.32001 + D.32003;
    req = *D.32004;
    D.32005 = event_req_matches_assembly (req, assembly);
    if (D.32005 != 0) goto <D.32006>; else goto <D.32007>;
    <D.32006>:
    D.32008 = req->id;
    D.32009 = req->event_kind;
    clear_event_request (D.32008, D.32009);
    found = 1;
    goto <D.26130>;
    <D.32007>:
  }
  i = i + 1;
  <D.26132>:
  i.464 = (unsigned int) i;
  event_requests.462 = event_requests;
  D.32011 = event_requests.462->len;
  if (i.464 < D.32011) goto <D.26131>; else goto <D.26130>;
  <D.26130>:
  <D.26134>:
  if (found != 0) goto <D.26133>; else goto <D.26135>;
  <D.26135>:
  mono_loader_unlock ();
}


event_req_matches_assembly (struct EventRequest * req, struct MonoAssembly * assembly)
{
  int D.32012;
  gboolean D.32015;
  void * D.32016;
  <unnamed type> D.32017;
  struct MonoClass * D.32020;
  struct MonoImage * D.32023;
  struct MonoAssembly * D.32024;
  struct MonoAssembly * * D.32029;
  unsigned int j.465;
  unsigned int D.32033;
  struct MonoAssembly * * D.32034;
  struct MonoAssembly * D.32035;
  int D.32038;

  D.32012 = req->event_kind;
  if (D.32012 == 10) goto <D.32013>; else goto <D.32014>;
  <D.32013>:
  D.32016 = req->info;
  D.32015 = breakpoint_matches_assembly (D.32016, assembly);
  return D.32015;
  <D.32014>:
  {
    int i;
    int j;

    i = 0;
    goto <D.26122>;
    <D.26121>:
    {
      struct Modifier * m;

      m = &req->modifiers[i];
      D.32017 = m->kind;
      if (D.32017 == 8) goto <D.32018>; else goto <D.32019>;
      <D.32018>:
      D.32020 = m->data.exc_class;
      if (D.32020 != 0B) goto <D.32021>; else goto <D.32022>;
      <D.32021>:
      D.32020 = m->data.exc_class;
      D.32023 = D.32020->image;
      D.32024 = D.32023->assembly;
      if (D.32024 == assembly) goto <D.32025>; else goto <D.32026>;
      <D.32025>:
      D.32015 = 1;
      return D.32015;
      <D.32026>:
      <D.32022>:
      <D.32019>:
      D.32017 = m->kind;
      if (D.32017 == 11) goto <D.32027>; else goto <D.32028>;
      <D.32027>:
      D.32029 = m->data.assemblies;
      if (D.32029 != 0B) goto <D.32030>; else goto <D.32031>;
      <D.32030>:
      j = 0;
      goto <D.26119>;
      <D.26118>:
      D.32029 = m->data.assemblies;
      j.465 = (unsigned int) j;
      D.32033 = j.465 * 4;
      D.32034 = D.32029 + D.32033;
      D.32035 = *D.32034;
      if (D.32035 == assembly) goto <D.32036>; else goto <D.32037>;
      <D.32036>:
      D.32015 = 1;
      return D.32015;
      <D.32037>:
      j = j + 1;
      <D.26119>:
      D.32029 = m->data.assemblies;
      j.465 = (unsigned int) j;
      D.32033 = j.465 * 4;
      D.32034 = D.32029 + D.32033;
      D.32035 = *D.32034;
      if (D.32035 != 0B) goto <D.26118>; else goto <D.26120>;
      <D.26120>:
      <D.32031>:
      <D.32028>:
    }
    i = i + 1;
    <D.26122>:
    D.32038 = req->nmodifiers;
    if (D.32038 > i) goto <D.26121>; else goto <D.26123>;
    <D.26123>:
  }
  D.32015 = 0;
  return D.32015;
}


breakpoint_matches_assembly (struct MonoBreakpoint * bp, struct MonoAssembly * assembly)
{
  gboolean D.32040;
  int iftmp.466;
  struct MonoMethod * D.32044;
  struct MonoClass * D.32046;
  struct MonoImage * D.32047;
  struct MonoAssembly * D.32048;

  D.32044 = bp->method;
  if (D.32044 != 0B) goto <D.32045>; else goto <D.32042>;
  <D.32045>:
  D.32044 = bp->method;
  D.32046 = D.32044->klass;
  D.32047 = D.32046->image;
  D.32048 = D.32047->assembly;
  if (D.32048 == assembly) goto <D.32049>; else goto <D.32042>;
  <D.32049>:
  iftmp.466 = 1;
  goto <D.32043>;
  <D.32042>:
  iftmp.466 = 0;
  <D.32043>:
  D.32040 = iftmp.466;
  return D.32040;
}


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

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


type_comes_from_assembly (void * klass, void * also_klass, void * assembly)
{
  gboolean D.32052;
  struct MonoImage * D.32053;
  struct MonoImage * D.32054;
  _Bool D.32055;

  D.32053 = mono_class_get_image (klass);
  D.32054 = mono_assembly_get_image (assembly);
  D.32055 = D.32053 == D.32054;
  D.32052 = (gboolean) D.32055;
  return D.32052;
}


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

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


thread_end (struct MonoProfiler * prof, uintptr_t tid)
{
  struct MonoGHashTable * tid_to_thread.468;
  const void * tid.469;
  struct MonoGHashTable * tid_to_thread_obj.470;
  struct MonoGHashTable * thread_to_tls.471;
  struct MonoInternalThread * * D.32066;
  int log_level.472;
  _Bool D.32070;
  long int D.32071;
  long int D.32072;
  struct FILE * log_file.473;
  void * tid.474;
  struct MonoInternalThread * thread;
  struct DebuggerTlsData * tls;

  tls = 0B;
  mono_loader_lock ();
  tid_to_thread.468 = tid_to_thread;
  tid.469 = (const void *) tid;
  thread = mono_g_hash_table_lookup (tid_to_thread.468, tid.469);
  if (thread != 0B) goto <D.32060>; else goto <D.32061>;
  <D.32060>:
  tid_to_thread_obj.470 = tid_to_thread_obj;
  tid.469 = (const void *) tid;
  mono_g_hash_table_remove (tid_to_thread_obj.470, tid.469);
  thread_to_tls.471 = thread_to_tls;
  tls = mono_g_hash_table_lookup (thread_to_tls.471, thread);
  if (tls != 0B) goto <D.32064>; else goto <D.32065>;
  <D.32064>:
  tls->terminated = 1;
  D.32066 = &tls->thread;
  mono_gc_deregister_root (D.32066);
  tls->thread = 0B;
  <D.32065>:
  <D.32061>:
  mono_loader_unlock ();
  if (thread != 0B) goto <D.32067>; else goto <D.32068>;
  <D.32067>:
  log_level.472 = log_level;
  D.32070 = log_level.472 > 0;
  D.32071 = (long int) D.32070;
  D.32072 = __builtin_expect (D.32071, 0);
  if (D.32072 != 0) goto <D.32073>; else goto <D.32074>;
  <D.32073>:
  log_file.473 = log_file;
  tid.474 = (void *) tid;
  fprintf (log_file.473, "[%p] Thread terminated, obj=%p, tls=%p.\n", tid.474, thread, tls);
  log_file.473 = log_file;
  fflush (log_file.473);
  <D.32074>:
  process_profiler_event (3, thread);
  <D.32068>:
}


thread_startup (struct MonoProfiler * prof, uintptr_t tid)
{
  unsigned int debugger_thread_id.475;
  long long unsigned int D.32080;
  long long unsigned int D.32081;
  _Bool D.32082;
  long int D.32083;
  long int D.32084;
  struct MonoGHashTable * tid_to_thread.476;
  const void * tid.477;
  int log_level.478;
  _Bool D.32094;
  long int D.32095;
  long int D.32096;
  struct FILE * log_file.479;
  void * tid.480;
  struct MonoGHashTable * thread_to_tls.481;
  struct MonoGHashTable * tid_to_thread_obj.482;
  unsigned int debugger_tls_id.483;
  _Bool D.32106;
  long int D.32107;
  long int D.32108;
  struct MonoInternalThread * * D.32113;
  void * D.32114;
  struct MonoThread * D.32117;
  struct MonoInternalThread * thread;
  struct MonoInternalThread * old_thread;
  struct DebuggerTlsData * tls;

  thread = mono_thread_internal_current ();
  debugger_thread_id.475 = debugger_thread_id;
  if (tid == debugger_thread_id.475) goto <D.32078>; else goto <D.32079>;
  <D.32078>:
  return;
  <D.32079>:
  D.32080 = thread->tid;
  D.32081 = (long long unsigned int) tid;
  D.32082 = D.32080 != D.32081;
  D.32083 = (long int) D.32082;
  D.32084 = __builtin_expect (D.32083, 0);
  if (D.32084 != 0) goto <D.32085>; else goto <D.32086>;
  <D.32085>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 3789, "thread->tid == tid");
  <D.32086>:
  mono_loader_lock ();
  tid_to_thread.476 = tid_to_thread;
  tid.477 = (const void *) tid;
  old_thread = mono_g_hash_table_lookup (tid_to_thread.476, tid.477);
  mono_loader_unlock ();
  if (old_thread != 0B) goto <D.32089>; else goto <D.32090>;
  <D.32089>:
  if (thread == old_thread) goto <D.32091>; else goto <D.32092>;
  <D.32091>:
  log_level.478 = log_level;
  D.32094 = log_level.478 > 0;
  D.32095 = (long int) D.32094;
  D.32096 = __builtin_expect (D.32095, 0);
  if (D.32096 != 0) goto <D.32097>; else goto <D.32098>;
  <D.32097>:
  log_file.479 = log_file;
  tid.480 = (void *) tid;
  tid.480 = (void *) tid;
  fprintf (log_file.479, "[%p] thread_start () called multiple times for %p, ignored.\n", tid.480, tid.480);
  log_file.479 = log_file;
  fflush (log_file.479);
  <D.32098>:
  return;
  <D.32092>:
  log_level.478 = log_level;
  D.32094 = log_level.478 > 0;
  D.32095 = (long int) D.32094;
  D.32096 = __builtin_expect (D.32095, 0);
  if (D.32096 != 0) goto <D.32101>; else goto <D.32102>;
  <D.32101>:
  log_file.479 = log_file;
  tid.480 = (void *) tid;
  tid.480 = (void *) tid;
  fprintf (log_file.479, "[%p] Removing stale data for tid %p.\n", tid.480, tid.480);
  log_file.479 = log_file;
  fflush (log_file.479);
  <D.32102>:
  mono_loader_lock ();
  thread_to_tls.481 = thread_to_tls;
  mono_g_hash_table_remove (thread_to_tls.481, old_thread);
  tid_to_thread.476 = tid_to_thread;
  tid.477 = (const void *) tid;
  mono_g_hash_table_remove (tid_to_thread.476, tid.477);
  tid_to_thread_obj.482 = tid_to_thread_obj;
  tid.477 = (const void *) tid;
  mono_g_hash_table_remove (tid_to_thread_obj.482, tid.477);
  mono_loader_unlock ();
  <D.32090>:
  debugger_tls_id.483 = debugger_tls_id;
  tls = pthread_getspecific (debugger_tls_id.483);
  D.32106 = tls != 0B;
  D.32107 = (long int) D.32106;
  D.32108 = __builtin_expect (D.32107, 0);
  if (D.32108 != 0) goto <D.32109>; else goto <D.32110>;
  <D.32109>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 3817, "!tls");
  <D.32110>:
  tls = monoeg_malloc0 (1736);
  if (0 != 0) goto <D.32111>; else goto <D.32112>;
  <D.32111>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 3820, "sizeof (tls->thread) == sizeof (MonoObject*)");
  <D.32112>:
  D.32113 = &tls->thread;
  D.32114 = mono_gc_make_root_descr_all_refs (1);
  mono_gc_register_root (D.32113, 4, D.32114);
  tls->thread = thread;
  debugger_tls_id.483 = debugger_tls_id;
  mono_native_tls_set_value (debugger_tls_id.483, tls);
  log_level.478 = log_level;
  D.32094 = log_level.478 > 0;
  D.32095 = (long int) D.32094;
  D.32096 = __builtin_expect (D.32095, 0);
  if (D.32096 != 0) goto <D.32115>; else goto <D.32116>;
  <D.32115>:
  log_file.479 = log_file;
  tid.480 = (void *) tid;
  fprintf (log_file.479, "[%p] Thread started, obj=%p, tls=%p.\n", tid.480, thread, tls);
  log_file.479 = log_file;
  fflush (log_file.479);
  <D.32116>:
  mono_loader_lock ();
  thread_to_tls.481 = thread_to_tls;
  mono_g_hash_table_insert (thread_to_tls.481, thread, tls);
  tid_to_thread.476 = tid_to_thread;
  tid.480 = (void *) tid;
  mono_g_hash_table_insert (tid_to_thread.476, tid.480, thread);
  tid_to_thread_obj.482 = tid_to_thread_obj;
  tid.480 = (void *) tid;
  D.32117 = mono_thread_current ();
  mono_g_hash_table_insert (tid_to_thread_obj.482, tid.480, D.32117);
  mono_loader_unlock ();
  process_profiler_event (2, thread);
  suspend_current ();
}


mono_native_tls_set_value (pthread_key_t key, void * value)
{
  int D.32119;
  int D.32120;
  _Bool D.32121;

  D.32120 = pthread_setspecific (key, value);
  D.32121 = D.32120 == 0;
  D.32119 = (int) D.32121;
  return D.32119;
}


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

  clear_breakpoints_for_domain (domain);
  mono_loader_lock ();
  thread_to_tls.484 = thread_to_tls;
  mono_g_hash_table_foreach (thread_to_tls.484, 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.485;
  void * * D.32127;
  unsigned int i.486;
  unsigned int D.32129;
  void * * D.32130;
  struct GPtrArray * D.32131;
  void * * D.32132;
  unsigned int j.487;
  unsigned int D.32134;
  void * * D.32135;
  struct MonoDomain * D.32136;
  unsigned int j.488;
  unsigned int D.32141;
  unsigned int i.489;
  unsigned int D.32143;
  int i;
  int j;

  breakpoints.485 = breakpoints;
  if (breakpoints.485 == 0B) goto <D.32125>; else goto <D.32126>;
  <D.32125>:
  return;
  <D.32126>:
  mono_loader_lock ();
  i = 0;
  goto <D.25584>;
  <D.25583>:
  {
    struct MonoBreakpoint * bp;

    breakpoints.485 = breakpoints;
    D.32127 = breakpoints.485->pdata;
    i.486 = (unsigned int) i;
    D.32129 = i.486 * 4;
    D.32130 = D.32127 + D.32129;
    bp = *D.32130;
    j = 0;
    goto <D.25581>;
    <D.25580>:
    {
      struct BreakpointInstance * inst;

      D.32131 = bp->children;
      D.32132 = D.32131->pdata;
      j.487 = (unsigned int) j;
      D.32134 = j.487 * 4;
      D.32135 = D.32132 + D.32134;
      inst = *D.32135;
      D.32136 = inst->domain;
      if (D.32136 == domain) goto <D.32137>; else goto <D.32138>;
      <D.32137>:
      remove_breakpoint (inst);
      monoeg_g_free (inst);
      D.32131 = bp->children;
      j.488 = (unsigned int) j;
      monoeg_g_ptr_array_remove_index_fast (D.32131, j.488);
      goto <D.32140>;
      <D.32138>:
      j = j + 1;
      <D.32140>:
    }
    <D.25581>:
    j.488 = (unsigned int) j;
    D.32131 = bp->children;
    D.32141 = D.32131->len;
    if (j.488 < D.32141) goto <D.25580>; else goto <D.25582>;
    <D.25582>:
  }
  i = i + 1;
  <D.25584>:
  i.489 = (unsigned int) i;
  breakpoints.485 = breakpoints;
  D.32143 = breakpoints.485->len;
  if (i.489 < D.32143) goto <D.25583>; else goto <D.25585>;
  <D.25585>:
  mono_loader_unlock ();
}


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

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


runtime_initialized (struct MonoProfiler * prof)
{
  struct MonoThread * D.32146;
  int D.32147;

  D.32146 = mono_thread_current ();
  process_profiler_event (0, D.32146);
  D.32147 = agent_config.defer;
  if (D.32147 != 0) goto <D.32148>; else goto <D.32149>;
  <D.32148>:
  start_debugger_thread ();
  <D.32149>:
}


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

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


mono_debugger_agent_cleanup ()
{
  int inited.491;

  inited.491 = inited;
  if (inited.491 == 0) goto <D.32152>; else goto <D.32153>;
  <D.32152>:
  return;
  <D.32153>:
  stop_debugger_thread ();
  breakpoints_cleanup ();
  objrefs_cleanup ();
  ids_cleanup ();
  pthread_mutex_destroy (&debugger_thread_exited_mutex);
}


stop_debugger_thread ()
{
  int inited.492;
  unsigned int D.32158;
  unsigned int debugger_thread_id.493;
  int debugger_thread_exited.494;

  inited.492 = inited;
  if (inited.492 == 0) goto <D.32156>; else goto <D.32157>;
  <D.32156>:
  return;
  <D.32157>:
  transport_close1 ();
  D.32158 = GetCurrentThreadId ();
  debugger_thread_id.493 = debugger_thread_id;
  if (D.32158 != debugger_thread_id.493) goto <D.32160>; else goto <D.32161>;
  <D.32160>:
  <D.24637>:
  pthread_mutex_lock (&debugger_thread_exited_mutex);
  debugger_thread_exited.494 = debugger_thread_exited;
  if (debugger_thread_exited.494 == 0) goto <D.32163>; else goto <D.32164>;
  <D.32163>:
  pthread_cond_wait (&debugger_thread_exited_cond, &debugger_thread_exited_mutex);
  <D.32164>:
  pthread_mutex_unlock (&debugger_thread_exited_mutex);
  debugger_thread_exited.494 = debugger_thread_exited;
  if (debugger_thread_exited.494 == 0) goto <D.24637>; else goto <D.24638>;
  <D.24638>:
  <D.32161>:
  transport_close2 ();
}


transport_close1 ()
{
  struct DebuggerTransport * transport.495;
  void (*<T7a8>) (void) D.32167;

  transport.495 = transport;
  D.32167 = transport.495->close1;
  D.32167 ();
}


breakpoints_cleanup ()
{
  struct GPtrArray * event_requests.496;
  void * * D.32169;
  unsigned int i.497;
  unsigned int D.32171;
  void * * D.32172;
  int D.32173;
  void * D.32176;
  unsigned int i.498;
  unsigned int D.32179;
  struct GPtrArray * breakpoints.499;
  void * * D.32181;
  void * * D.32182;
  void * D.32183;
  unsigned int D.32184;
  struct GHashTable * bp_locs.500;
  int i;

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

    event_requests.496 = event_requests;
    D.32169 = event_requests.496->pdata;
    i.497 = (unsigned int) i;
    D.32171 = i.497 * 4;
    D.32172 = D.32169 + D.32171;
    req = *D.32172;
    D.32173 = req->event_kind;
    if (D.32173 == 10) goto <D.32174>; else goto <D.32175>;
    <D.32174>:
    D.32176 = req->info;
    clear_breakpoint (D.32176);
    event_requests.496 = event_requests;
    i.498 = (unsigned int) i;
    monoeg_g_ptr_array_remove_index_fast (event_requests.496, i.498);
    monoeg_g_free (req);
    goto <D.32178>;
    <D.32175>:
    i = i + 1;
    <D.32178>:
  }
  <D.25568>:
  i.498 = (unsigned int) i;
  event_requests.496 = event_requests;
  D.32179 = event_requests.496->len;
  if (i.498 < D.32179) goto <D.25567>; else goto <D.25569>;
  <D.25569>:
  i = 0;
  goto <D.25571>;
  <D.25570>:
  breakpoints.499 = breakpoints;
  D.32181 = breakpoints.499->pdata;
  i.497 = (unsigned int) i;
  D.32171 = i.497 * 4;
  D.32182 = D.32181 + D.32171;
  D.32183 = *D.32182;
  monoeg_g_free (D.32183);
  i = i + 1;
  <D.25571>:
  i.498 = (unsigned int) i;
  breakpoints.499 = breakpoints;
  D.32184 = breakpoints.499->len;
  if (i.498 < D.32184) goto <D.25570>; else goto <D.25572>;
  <D.25572>:
  breakpoints.499 = breakpoints;
  monoeg_g_ptr_array_free (breakpoints.499, 1);
  bp_locs.500 = bp_locs;
  monoeg_g_hash_table_destroy (bp_locs.500);
  breakpoints = 0B;
  bp_locs = 0B;
  mono_loader_unlock ();
}


objrefs_cleanup ()
{
  struct GHashTable * objrefs.501;

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


ids_cleanup ()
{
  struct GPtrArray * D.32187;
  void * * D.32190;
  unsigned int j.502;
  unsigned int D.32192;
  void * * D.32193;
  void * D.32194;
  unsigned int j.503;
  unsigned int D.32196;
  int i;
  int j;

  i = 0;
  goto <D.24841>;
  <D.24840>:
  D.32187 = ids[i];
  if (D.32187 != 0B) goto <D.32188>; else goto <D.32189>;
  <D.32188>:
  j = 0;
  goto <D.24838>;
  <D.24837>:
  D.32187 = ids[i];
  D.32190 = D.32187->pdata;
  j.502 = (unsigned int) j;
  D.32192 = j.502 * 4;
  D.32193 = D.32190 + D.32192;
  D.32194 = *D.32193;
  monoeg_g_free (D.32194);
  j = j + 1;
  <D.24838>:
  j.503 = (unsigned int) j;
  D.32187 = ids[i];
  D.32196 = D.32187->len;
  if (j.503 < D.32196) goto <D.24837>; else goto <D.24839>;
  <D.24839>:
  D.32187 = ids[i];
  monoeg_g_ptr_array_free (D.32187, 1);
  <D.32189>:
  ids[i] = 0B;
  i = i + 1;
  <D.24841>:
  if (i <= 6) goto <D.24840>; else goto <D.24842>;
  <D.24842>:
}


transport_init ()
{
  int D.24597;
  char * D.32197;
  const char * D.32198;
  int ntransports.504;
  struct _IO_FILE * stderr.505;
  const char * iftmp.506;
  struct DebuggerTransport * transport.507;
  int i;

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

    D.32197 = agent_config.transport;
    D.32198 = transports[i].name;
    D.24597 = __builtin_strcmp (D.32197, D.32198);
  }
  if (D.24597 == 0) goto <D.24598>; else goto <D.32199>;
  <D.32199>:
  i = i + 1;
  <D.24600>:
  ntransports.504 = ntransports;
  if (i < ntransports.504) goto <D.24599>; else goto <D.24598>;
  <D.24598>:
  ntransports.504 = ntransports;
  if (i == ntransports.504) goto <D.32201>; else goto <D.32202>;
  <D.32201>:
  stderr.505 = stderr;
  fprintf (stderr.505, "debugger-agent: The supported values for the \'transport\' option are: ");
  i = 0;
  goto <D.24602>;
  <D.24601>:
  stderr.505 = stderr;
  if (i > 0) goto <D.32205>; else goto <D.32206>;
  <D.32205>:
  iftmp.506 = ", ";
  goto <D.32207>;
  <D.32206>:
  iftmp.506 = "";
  <D.32207>:
  D.32198 = transports[i].name;
  fprintf (stderr.505, "%s\'%s\'", iftmp.506, D.32198);
  i = i + 1;
  <D.24602>:
  ntransports.504 = ntransports;
  if (i < ntransports.504) goto <D.24601>; else goto <D.24603>;
  <D.24603>:
  stderr.505 = stderr;
  fprintf (stderr.505, "\n");
  exit (1);
  <D.32202>:
  transport.507 = &transports[i];
  transport = transport.507;
}


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.508;
  void * D.32210;
  int D.32211;
  unsigned int D.32212;
  int D.32215;
  int * D.32221;
  int D.32222;
  unsigned int D.32226;
  int last_keepalive.509;
  int D.32228;
  int D.32236;
  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.24513>:
  again:
  total.508 = (sizetype) total;
  D.32210 = buf + total.508;
  D.32211 = len - total;
  D.32212 = (unsigned int) D.32211;
  res = recv (fd, D.32210, D.32212, flags);
  if (res > 0) goto <D.32213>; else goto <D.32214>;
  <D.32213>:
  total = total + res;
  <D.32214>:
  D.32215 = agent_config.keepalive;
  if (D.32215 != 0) goto <D.32216>; else goto <D.32217>;
  <D.32216>:
  {
    gboolean need_keepalive;

    need_keepalive = 0;
    if (res == -1) goto <D.32220>; else goto <D.32218>;
    <D.32220>:
    D.32221 = __errno_location ();
    D.32222 = *D.32221;
    if (D.32222 == 11) goto <D.32223>; else goto <D.32218>;
    <D.32223>:
    need_keepalive = 1;
    goto <D.32219>;
    <D.32218>:
    if (res == -1) goto <D.32224>; else goto <D.32225>;
    <D.32224>:
    D.32226 = mono_msec_ticks ();
    msecs = (gint32) D.32226;
    last_keepalive.509 = last_keepalive;
    D.32228 = msecs - last_keepalive.509;
    D.32215 = agent_config.keepalive;
    if (D.32228 >= D.32215) goto <D.32229>; else goto <D.32230>;
    <D.32229>:
    need_keepalive = 1;
    last_keepalive = msecs;
    <D.32230>:
    <D.32225>:
    <D.32219>:
    if (need_keepalive != 0) goto <D.32231>; else goto <D.32232>;
    <D.32231>:
    process_profiler_event (14, 0B);
    goto again;
    <D.32232>:
  }
  <D.32217>:
  if (res > 0) goto <D.32234>; else goto <D.32233>;
  <D.32234>:
  if (total < len) goto <D.24513>; else goto <D.32233>;
  <D.32233>:
  if (res == -1) goto <D.32235>; else goto <D.24514>;
  <D.32235>:
  D.32221 = __errno_location ();
  D.32222 = *D.32221;
  if (D.32222 == 4) goto <D.24513>; else goto <D.24514>;
  <D.24514>:
  D.32236 = total;
  return D.32236;
}


recv (int __fd, void * __buf, size_t __n, int __flags)
{
  unsigned int D.32238;
  int D.32241;
  ssize_t D.32244;
  unsigned int D.32245;
  unsigned int D.32246;
  unsigned int D.32249;

  D.32238 = __builtin_object_size (__buf, 0);
  if (D.32238 != 4294967295) goto <D.32239>; else goto <D.32240>;
  <D.32239>:
  D.32241 = __builtin_constant_p (__n);
  if (D.32241 == 0) goto <D.32242>; else goto <D.32243>;
  <D.32242>:
  D.32245 = __builtin_object_size (__buf, 0);
  D.32244 = __recv_chk (__fd, __buf, __n, D.32245, __flags);
  return D.32244;
  <D.32243>:
  D.32246 = __builtin_object_size (__buf, 0);
  if (D.32246 < __n) goto <D.32247>; else goto <D.32248>;
  <D.32247>:
  D.32249 = __builtin_object_size (__buf, 0);
  D.32244 = __recv_chk_warn (__fd, __buf, __n, D.32249, __flags);
  return D.32244;
  <D.32248>:
  <D.32240>:
  D.32244 = __recv_alias (__fd, __buf, __n, __flags);
  return D.32244;
}


socket_transport_send (void * data, int len)
{
  int conn_fd.510;
  unsigned int len.511;
  int * D.32254;
  int D.32255;
  gboolean D.32258;
  int res;

  <D.24528>:
  conn_fd.510 = conn_fd;
  len.511 = (unsigned int) len;
  res = send (conn_fd.510, data, len.511, 0);
  if (res == -1) goto <D.32253>; else goto <D.24529>;
  <D.32253>:
  D.32254 = __errno_location ();
  D.32255 = *D.32254;
  if (D.32255 == 4) goto <D.24528>; else goto <D.24529>;
  <D.24529>:
  if (res != len) goto <D.32256>; else goto <D.32257>;
  <D.32256>:
  D.32258 = 0;
  return D.32258;
  <D.32257>:
  D.32258 = 1;
  return D.32258;
}


socket_transport_close2 ()
{
  int conn_fd.512;

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


socket_transport_close1 ()
{
  int conn_fd.513;
  int listen_fd.514;

  conn_fd.513 = conn_fd;
  shutdown (conn_fd.513, 0);
  listen_fd.514 = listen_fd;
  shutdown (listen_fd.514, 2);
  listen_fd.514 = listen_fd;
  close (listen_fd.514);
}


socket_transport_connect (const char * address)
{
  char * D.32263;
  _Bool D.32266;
  long int D.32267;
  long int D.32268;
  char * host.515;
  int port.516;
  struct _IO_FILE * stderr.517;
  const char * D.32279;
  int D.32280;
  _Bool D.32285;
  long int D.32286;
  long int D.32287;
  int * D.32292;
  int D.32293;
  char * D.32294;
  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.32295;
  short unsigned int D.24545;
  int port.518;
  int D.32300;
  int D.32301;
  int D.32302;
  int D.32305;
  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.32308;
  struct sockaddr * D.32309;
  unsigned int D.32310;
  struct addrinfo * result.519;
  int D.32316;
  int log_level.520;
  _Bool D.32320;
  long int D.32321;
  long int D.32322;
  struct FILE * log_file.521;
  int D.32326;
  int D.32329;
  long int D.24559;
  long int iftmp.522;
  int D.32331;
  long int iftmp.523;
  unsigned int __d.524;
  long int D.32340;
  long int D.32341;
  int D.32342;
  long int D.32343;
  long int D.32344;
  int D.32345;
  int conn_fd.525;
  int conn_fd.526;
  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.32357;
  int D.32358;
  int D.32362;
  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.32263 = agent_config.address;
      if (D.32263 != 0B) goto <D.32264>; else goto <D.32265>;
      <D.32264>:
      D.32263 = agent_config.address;
      res = parse_address (D.32263, &host, &port);
      D.32266 = res != 0;
      D.32267 = (long int) D.32266;
      D.32268 = __builtin_expect (D.32267, 0);
      if (D.32268 != 0) goto <D.32269>; else goto <D.32270>;
      <D.32269>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 1177, "res == 0");
      <D.32270>:
      goto <D.32271>;
      <D.32265>:
      host = 0B;
      port = 0;
      <D.32271>:
      conn_fd = -1;
      listen_fd = -1;
      host.515 = host;
      if (host.515 != 0B) goto <D.32273>; else goto <D.32274>;
      <D.32273>:
      port.516 = port;
      sprintf (&port_string, "%d", port.516);
      mono_network_init ();
      memset (&hints, 0, 32);
      hints.ai_family = 0;
      hints.ai_socktype = 2;
      hints.ai_flags = 0;
      hints.ai_protocol = 0;
      host.515 = host;
      s = getaddrinfo (host.515, &port_string, &hints, &result);
      if (s != 0) goto <D.32276>; else goto <D.32277>;
      <D.32276>:
      stderr.517 = stderr;
      host.515 = host;
      port.516 = port;
      D.32279 = gai_strerror (s);
      fprintf (stderr.517, "debugger-agent: Unable to resolve %s:%d: %s\n", host.515, port.516, D.32279);
      exit (1);
      <D.32277>:
      <D.32274>:
      D.32280 = agent_config.server;
      if (D.32280 != 0) goto <D.32281>; else goto <D.32282>;
      <D.32281>:
      host.515 = host;
      if (host.515 == 0B) goto <D.32283>; else goto <D.32284>;
      <D.32283>:
      {
        struct sockaddr_in addr;
        socklen_t addrlen;

        try
          {
            sfd = socket (2, 2, 0);
            D.32285 = sfd == 0;
            D.32286 = (long int) D.32285;
            D.32287 = __builtin_expect (D.32286, 0);
            if (D.32287 != 0) goto <D.32288>; else goto <D.32289>;
            <D.32288>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 1222, "sfd");
            <D.32289>:
            res = listen (sfd, 16);
            if (res == -1) goto <D.32290>; else goto <D.32291>;
            <D.32290>:
            stderr.517 = stderr;
            D.32292 = __errno_location ();
            D.32293 = *D.32292;
            D.32294 = strerror (D.32293);
            fprintf (stderr.517, "debugger-agent: Unable to setup listening socket: %s\n", D.32294);
            exit (1);
            <D.32291>:
            listen_fd = sfd;
            addrlen = 16;
            memset (&addr, 0, 16);
            D.32295.__sockaddr__ = &addr;
            res = getsockname (sfd, D.32295, &addrlen);
            D.32266 = res != 0;
            D.32267 = (long int) D.32266;
            D.32268 = __builtin_expect (D.32267, 0);
            if (D.32268 != 0) goto <D.32296>; else goto <D.32297>;
            <D.32296>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 1235, "res == 0");
            <D.32297>:
            host = "127.0.0.1";
            {
              short unsigned int __bsx;

              __bsx = addr.sin_port;
              D.24545 = __bsx r>> 8;
            }
            port.518 = (int) D.24545;
            port = port.518;
            host.515 = host;
            port.516 = port;
            printf ("%s:%d\n", host.515, port.516);
          }
        finally
          {
            addr = {CLOBBER};
            addrlen = {CLOBBER};
          }
      }
      goto <D.32299>;
      <D.32284>:
      rp = result;
      goto <D.24550>;
      <D.24549>:
      {
        int n;

        try
          {
            n = 1;
            D.32300 = rp->ai_family;
            D.32301 = rp->ai_socktype;
            D.32302 = rp->ai_protocol;
            sfd = socket (D.32300, D.32301, D.32302);
            if (sfd == -1) goto <D.32303>; else goto <D.32304>;
            <D.32303>:
            // predicted unlikely by continue predictor.
            goto <D.24547>;
            <D.32304>:
            D.32305 = setsockopt (sfd, 65535, 4, &n, 4);
            if (D.32305 == -1) goto <D.32306>; else goto <D.32307>;
            <D.32306>:
            // predicted unlikely by continue predictor.
            goto <D.24547>;
            <D.32307>:
            D.32309 = rp->ai_addr;
            D.32308.__sockaddr__ = D.32309;
            D.32310 = rp->ai_addrlen;
            res = bind (sfd, D.32308, D.32310);
            if (res == -1) goto <D.32311>; else goto <D.32312>;
            <D.32311>:
            // predicted unlikely by continue predictor.
            goto <D.24547>;
            <D.32312>:
            res = listen (sfd, 16);
            if (res == -1) goto <D.32313>; else goto <D.32314>;
            <D.32313>:
            // predicted unlikely by continue predictor.
            goto <D.24547>;
            <D.32314>:
            listen_fd = sfd;
            goto <D.24548>;
          }
        finally
          {
            n = {CLOBBER};
          }
      }
      <D.24547>:
      rp = rp->ai_next;
      <D.24550>:
      if (rp != 0B) goto <D.24549>; else goto <D.24548>;
      <D.24548>:
      result.519 = result;
      freeaddrinfo (result.519);
      <D.32299>:
      D.32316 = agent_config.defer;
      if (D.32316 != 0) goto <D.32317>; else goto <D.32318>;
      <D.32317>:
      return;
      <D.32318>:
      log_level.520 = log_level;
      D.32320 = log_level.520 > 0;
      D.32321 = (long int) D.32320;
      D.32322 = __builtin_expect (D.32321, 0);
      if (D.32322 != 0) goto <D.32323>; else goto <D.32324>;
      <D.32323>:
      log_file.521 = log_file;
      host.515 = host;
      port.516 = port;
      D.32326 = agent_config.timeout;
      fprintf (log_file.521, "Listening on %s:%d (timeout=%d ms)...\n", host.515, port.516, D.32326);
      log_file.521 = log_file;
      fflush (log_file.521);
      <D.32324>:
      D.32326 = agent_config.timeout;
      if (D.32326 != 0) goto <D.32327>; else goto <D.32328>;
      <D.32327>:
      {
        struct fd_set readfds;
        struct timeval tv;

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

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

              __d = sfd;
              D.32331 = __builtin_constant_p (__d);
              if (D.32331 != 0) goto <D.32332>; else goto <D.32333>;
              <D.32332>:
              __d.524 = (unsigned int) __d;
              if (__d.524 <= 1023) goto <D.32336>; else goto <D.32337>;
              <D.32336>:
              iftmp.523 = __d / 32;
              goto <D.32338>;
              <D.32337>:
              iftmp.523 = __fdelt_warn (__d);
              <D.32338>:
              iftmp.522 = iftmp.523;
              goto <D.32339>;
              <D.32333>:
              iftmp.522 = __fdelt_chk (__d);
              <D.32339>:
              D.24559 = iftmp.522;
            }
            D.32340 = D.24559;
            D.32341 = readfds.fds_bits[D.32340];
            D.32342 = sfd % 32;
            D.32343 = 1 << D.32342;
            D.32344 = D.32341 | D.32343;
            readfds.fds_bits[D.32340] = D.32344;
            D.32345 = sfd + 1;
            res = select (D.32345, &readfds, 0B, 0B, &tv);
            if (res == 0) goto <D.32346>; else goto <D.32347>;
            <D.32346>:
            stderr.517 = stderr;
            fprintf (stderr.517, "debugger-agent: Timed out waiting to connect.\n");
            exit (1);
            <D.32347>:
          }
        finally
          {
            readfds = {CLOBBER};
            tv = {CLOBBER};
          }
      }
      <D.32328>:
      conn_fd.525 = socket_transport_accept (sfd);
      conn_fd = conn_fd.525;
      conn_fd.526 = conn_fd;
      if (conn_fd.526 == -1) goto <D.32350>; else goto <D.32351>;
      <D.32350>:
      exit (1);
      <D.32351>:
      log_level.520 = log_level;
      D.32320 = log_level.520 > 0;
      D.32321 = (long int) D.32320;
      D.32322 = __builtin_expect (D.32321, 0);
      if (D.32322 != 0) goto <D.32352>; else goto <D.32353>;
      <D.32352>:
      log_file.521 = log_file;
      conn_fd.526 = conn_fd;
      fprintf (log_file.521, "Accepted connection from client, socket fd=%d.\n", conn_fd.526);
      log_file.521 = log_file;
      fflush (log_file.521);
      <D.32353>:
      goto <D.32354>;
      <D.32282>:
      rp = result;
      goto <D.24563>;
      <D.24562>:
      D.32300 = rp->ai_family;
      D.32301 = rp->ai_socktype;
      D.32302 = rp->ai_protocol;
      sfd = socket (D.32300, D.32301, D.32302);
      if (sfd == -1) goto <D.32355>; else goto <D.32356>;
      <D.32355>:
      // predicted unlikely by continue predictor.
      goto <D.24560>;
      <D.32356>:
      D.32309 = rp->ai_addr;
      D.32357.__sockaddr__ = D.32309;
      D.32310 = rp->ai_addrlen;
      D.32358 = connect (sfd, D.32357, D.32310);
      if (D.32358 != -1) goto <D.24561>; else goto <D.32359>;
      <D.32359>:
      close (sfd);
      <D.24560>:
      rp = rp->ai_next;
      <D.24563>:
      if (rp != 0B) goto <D.24562>; else goto <D.24561>;
      <D.24561>:
      if (rp == 0B) goto <D.32360>; else goto <D.32361>;
      <D.32360>:
      stderr.517 = stderr;
      host.515 = host;
      port.516 = port;
      fprintf (stderr.517, "debugger-agent: Unable to connect to %s:%d\n", host.515, port.516);
      exit (1);
      <D.32361>:
      conn_fd = sfd;
      result.519 = result;
      freeaddrinfo (result.519);
      <D.32354>:
      D.32362 = transport_handshake ();
      if (D.32362 == 0) goto <D.32363>; else goto <D.32364>;
      <D.32363>:
      exit (1);
      <D.32364>:
    }
  finally
    {
      hints = {CLOBBER};
      result = {CLOBBER};
      port_string = {CLOBBER};
      host = {CLOBBER};
      port = {CLOBBER};
    }
}


register_transport (struct DebuggerTransport * trans)
{
  int ntransports.527;
  _Bool D.32371;
  long int D.32372;
  long int D.32373;
  struct DebuggerTransport * D.32376;
  int ntransports.528;

  ntransports.527 = ntransports;
  D.32371 = ntransports.527 > 15;
  D.32372 = (long int) D.32371;
  D.32373 = __builtin_expect (D.32372, 0);
  if (D.32373 != 0) goto <D.32374>; else goto <D.32375>;
  <D.32374>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 1419, "ntransports < MAX_TRANSPORTS");
  <D.32375>:
  ntransports.527 = ntransports;
  D.32376 = &transports[ntransports.527];
  memcpy (D.32376, trans, 24);
  ntransports.527 = ntransports;
  ntransports.528 = ntransports.527 + 1;
  ntransports = ntransports.528;
}


mono_native_tls_alloc (pthread_key_t * key, void * destructor)
{
  int D.32378;
  void (*<Tc3>) (void *) destructor.529;
  int D.32380;
  _Bool D.32381;

  destructor.529 = (void (*<Tc3>) (void *)) destructor;
  D.32380 = pthread_key_create (key, destructor.529);
  D.32381 = D.32380 == 0;
  D.32378 = (int) D.32381;
  return D.32378;
}


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

  i = 0;
  goto <D.24830>;
  <D.24829>:
  D.32383 = monoeg_g_ptr_array_new ();
  ids[i] = D.32383;
  i = i + 1;
  <D.24830>:
  if (i <= 6) goto <D.24829>; else goto <D.24831>;
  <D.24831>:
}


objrefs_init ()
{
  struct GHashTable * objrefs.530;

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


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

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


breakpoints_init ()
{
  struct GPtrArray * breakpoints.531;
  struct GHashTable * bp_locs.532;

  breakpoints.531 = monoeg_g_ptr_array_new ();
  breakpoints = breakpoints.531;
  bp_locs.532 = monoeg_g_hash_table_new (0B, 0B);
  bp_locs = bp_locs.532;
}


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.32388;
  char * D.32391;
  char * D.32394;
  char * D.32395;
  struct _IO_FILE * stderr.533;
  int res;

  D.32388 = InterlockedCompareExchange (&inited, 1, 0);
  if (D.32388 == 1) goto <D.32389>; else goto <D.32390>;
  <D.32389>:
  return;
  <D.32390>:
  D.32391 = agent_config.launch;
  if (D.32391 != 0B) goto <D.32392>; else goto <D.32393>;
  <D.32392>:
  {
    char * argv[16];

    try
      {
        D.32391 = agent_config.launch;
        argv[0] = D.32391;
        D.32394 = agent_config.transport;
        argv[1] = D.32394;
        D.32395 = agent_config.address;
        argv[2] = D.32395;
        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.32396>; else goto <D.32397>;
        <D.32396>:
        stderr.533 = stderr;
        D.32391 = agent_config.launch;
        fprintf (stderr.533, "Failed to execute \'%s\'.\n", D.32391);
        exit (1);
        <D.32397>:
      }
    finally
      {
        argv = {CLOBBER};
      }
  }
  <D.32393>:
  D.32395 = agent_config.address;
  transport_connect (D.32395);
  if (on_startup == 0) goto <D.32399>; else goto <D.32400>;
  <D.32399>:
  vm_start_event_sent = 1;
  start_debugger_thread ();
  <D.32400>:
}


InterlockedCompareExchange (volatile gint32 * dest, gint32 exch, gint32 comp)
{
  gint32 D.32402;
  unsigned int comp.534;
  unsigned int exch.535;
  unsigned int D.32405;

  comp.534 = (unsigned int) comp;
  exch.535 = (unsigned int) exch;
  D.32405 = __sync_val_compare_and_swap_4 (dest, comp.534, exch.535);
  D.32402 = (gint32) D.32405;
  return D.32402;
}


transport_connect (const char * address)
{
  struct DebuggerTransport * transport.536;
  void (*<T3e5b>) (const char *) D.32408;

  transport.536 = transport;
  D.32408 = transport.536->connect;
  D.32408 (address);
}


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


mono_debugger_agent_transport_handshake ()
{
  gboolean D.32409;

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


mono_debugger_agent_free_domain_info (struct MonoDomain * domain)
{
  void * D.32411;
  struct GHashTable * D.32414;
  struct GHashTable * D.32417;
  struct GHashTable * D.32418;
  struct GPtrArray * file_names.537;
  void * * D.32420;
  unsigned int i.538;
  unsigned int D.32422;
  void * * D.32423;
  void * D.32424;
  unsigned int i.539;
  unsigned int D.32426;
  int D.32427;
  struct GHashTable * D.32428;
  char * basename.540;
  struct GSList * l.541;
  int D.32431;
  struct GHashTable * D.32432;
  int D.32433;
  struct GPtrArray * D.32434;
  void * * D.32437;
  unsigned int j.542;
  unsigned int D.32439;
  void * * D.32440;
  struct MonoDomain * D.32441;
  unsigned int j.543;
  unsigned int D.32445;
  struct GHashTable * domains.544;
  struct AgentDomainInfo * info;
  int i;
  int j;
  struct GHashTableIter iter;
  struct GPtrArray * file_names;
  char * basename;
  struct GSList * l;

  try
    {
      D.32411 = domain->runtime_info;
      info = MEM[(struct MonoJitDomainInfo *)D.32411].agent_info;
      if (info != 0B) goto <D.32412>; else goto <D.32413>;
      <D.32412>:
      i = 0;
      goto <D.24854>;
      <D.24853>:
      D.32414 = info->val_to_id[i];
      if (D.32414 != 0B) goto <D.32415>; else goto <D.32416>;
      <D.32415>:
      D.32414 = info->val_to_id[i];
      monoeg_g_hash_table_destroy (D.32414);
      <D.32416>:
      i = i + 1;
      <D.24854>:
      if (i <= 6) goto <D.24853>; else goto <D.24855>;
      <D.24855>:
      D.32417 = info->loaded_classes;
      monoeg_g_hash_table_destroy (D.32417);
      D.32418 = info->source_files;
      monoeg_g_hash_table_iter_init (&iter, D.32418);
      goto <D.24860>;
      <D.24859>:
      i = 0;
      goto <D.24857>;
      <D.24856>:
      file_names.537 = file_names;
      D.32420 = file_names.537->pdata;
      i.538 = (unsigned int) i;
      D.32422 = i.538 * 4;
      D.32423 = D.32420 + D.32422;
      D.32424 = *D.32423;
      monoeg_g_free (D.32424);
      i = i + 1;
      <D.24857>:
      i.539 = (unsigned int) i;
      file_names.537 = file_names;
      D.32426 = file_names.537->len;
      if (i.539 < D.32426) goto <D.24856>; else goto <D.24858>;
      <D.24858>:
      file_names.537 = file_names;
      monoeg_g_ptr_array_free (file_names.537, 1);
      <D.24860>:
      D.32427 = monoeg_g_hash_table_iter_next (&iter, 0B, &file_names);
      if (D.32427 != 0) goto <D.24859>; else goto <D.24861>;
      <D.24861>:
      D.32428 = info->source_file_to_class;
      monoeg_g_hash_table_iter_init (&iter, D.32428);
      goto <D.24863>;
      <D.24862>:
      basename.540 = basename;
      monoeg_g_free (basename.540);
      l.541 = l;
      monoeg_g_slist_free (l.541);
      <D.24863>:
      D.32431 = monoeg_g_hash_table_iter_next (&iter, &basename, &l);
      if (D.32431 != 0) goto <D.24862>; else goto <D.24864>;
      <D.24864>:
      D.32432 = info->source_file_to_class_ignorecase;
      monoeg_g_hash_table_iter_init (&iter, D.32432);
      goto <D.24866>;
      <D.24865>:
      basename.540 = basename;
      monoeg_g_free (basename.540);
      l.541 = l;
      monoeg_g_slist_free (l.541);
      <D.24866>:
      D.32433 = monoeg_g_hash_table_iter_next (&iter, &basename, &l);
      if (D.32433 != 0) goto <D.24865>; else goto <D.24867>;
      <D.24867>:
      monoeg_g_free (info);
      <D.32413>:
      D.32411 = domain->runtime_info;
      MEM[(struct MonoJitDomainInfo *)D.32411].agent_info = 0B;
      i = 0;
      goto <D.24873>;
      <D.24872>:
      D.32434 = ids[i];
      if (D.32434 != 0B) goto <D.32435>; else goto <D.32436>;
      <D.32435>:
      j = 0;
      goto <D.24870>;
      <D.24869>:
      {
        struct Id * id;

        D.32434 = ids[i];
        D.32437 = D.32434->pdata;
        j.542 = (unsigned int) j;
        D.32439 = j.542 * 4;
        D.32440 = D.32437 + D.32439;
        id = *D.32440;
        D.32441 = id->domain;
        if (D.32441 == domain) goto <D.32442>; else goto <D.32443>;
        <D.32442>:
        id->domain = 0B;
        <D.32443>:
      }
      j = j + 1;
      <D.24870>:
      j.543 = (unsigned int) j;
      D.32434 = ids[i];
      D.32445 = D.32434->len;
      if (j.543 < D.32445) goto <D.24869>; else goto <D.24871>;
      <D.24871>:
      <D.32436>:
      i = i + 1;
      <D.24873>:
      if (i <= 6) goto <D.24872>; else goto <D.24874>;
      <D.24874>:
      mono_loader_lock ();
      domains.544 = domains;
      monoeg_g_hash_table_remove (domains.544, 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.545;
  gboolean D.32450;
  unsigned int debugger_tls_id.546;
  int log_level.547;
  _Bool D.32455;
  long int D.32456;
  long int D.32457;
  struct FILE * log_file.548;
  unsigned int D.32461;
  void * D.32462;
  struct DebuggerTlsData * tls;

  inited.545 = inited;
  if (inited.545 == 0) goto <D.32448>; else goto <D.32449>;
  <D.32448>:
  D.32450 = 0;
  return D.32450;
  <D.32449>:
  debugger_tls_id.546 = debugger_tls_id;
  tls = pthread_getspecific (debugger_tls_id.546);
  if (tls == 0B) goto <D.32452>; else goto <D.32453>;
  <D.32452>:
  log_level.547 = log_level;
  D.32455 = log_level.547 > 0;
  D.32456 = (long int) D.32455;
  D.32457 = __builtin_expect (D.32456, 0);
  if (D.32457 != 0) goto <D.32458>; else goto <D.32459>;
  <D.32458>:
  log_file.548 = log_file;
  D.32461 = GetCurrentThreadId ();
  D.32462 = (void *) D.32461;
  fprintf (log_file.548, "[%p] Received interrupt with no TLS, continuing.\n", D.32462);
  log_file.548 = log_file;
  fflush (log_file.548);
  <D.32459>:
  D.32450 = 0;
  return D.32450;
  <D.32453>:
  D.32450 = thread_interrupt (tls, 0B, sigctx, ji);
  return D.32450;
}


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.32464;
  struct MonoDomain * D.32465;
  _Bool D.32466;
  long int D.32467;
  long int D.32468;
  int ip.549;
  void * D.32472;
  int D.32473;
  int D.32474;
  unsigned int D.32477;
  unsigned int D.32478;
  int D.32480;
  struct MonoDomain * D.32481;
  int native_offset.550;
  _Bool D.32485;
  long int D.32486;
  long int D.32487;
  int log_level.551;
  _Bool D.32491;
  long int D.32492;
  long int D.32493;
  struct FILE * log_file.552;
  unsigned int D.32497;
  void * D.32498;
  const char * D.32499;
  int iftmp.553;
  struct GPtrArray * breakpoints.554;
  void * * D.32505;
  unsigned int i.555;
  unsigned int D.32507;
  void * * D.32508;
  struct MonoMethod * D.32509;
  struct GPtrArray * D.32512;
  void * * D.32513;
  unsigned int j.556;
  unsigned int D.32515;
  void * * D.32516;
  struct MonoJitInfo * D.32517;
  struct SeqPoint * D.32520;
  struct EventRequest * D.32523;
  int D.32524;
  unsigned int j.557;
  unsigned int D.32529;
  unsigned int i.558;
  unsigned int D.32531;
  unsigned int D.32532;
  unsigned int D.32535;
  int D.32538;
  void * * D.32544;
  void * * D.32545;
  struct MonoInternalThread * D.32546;
  struct MonoInternalThread * D.32547;
  struct MonoSeqPointInfo * info.559;
  unsigned int D.32553;
  int suspend_policy.560;
  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.32464 = ctx->sc_pc;
      ip = (guint8 *) D.32464;
      D.32465 = mono_domain_get ();
      ji = mini_jit_info_table_find (D.32465, ip, 0B);
      D.32466 = ji == 0B;
      D.32467 = (long int) D.32466;
      D.32468 = __builtin_expect (D.32467, 0);
      if (D.32468 != 0) goto <D.32469>; else goto <D.32470>;
      <D.32469>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 4554, "ji");
      <D.32470>:
      method = jinfo_get_method (ji);
      ip.549 = (int) ip;
      D.32472 = ji->code_start;
      D.32473 = (int) D.32472;
      D.32474 = ip.549 - D.32473;
      native_offset = (guint32) D.32474;
      mono_arch_skip_breakpoint (ctx, ji);
      D.32477 = BIT_FIELD_REF <*method, 32, 160>;
      D.32478 = D.32477 & 124;
      if (D.32478 != 0) goto <D.32475>; else goto <D.32479>;
      <D.32479>:
      D.32480 = tls->disable_breakpoints;
      if (D.32480 != 0) goto <D.32475>; else goto <D.32476>;
      <D.32475>:
      return;
      <D.32476>:
      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.32481 = mono_domain_get ();
      native_offset.550 = (int) native_offset;
      sp = find_prev_seq_point_for_native_offset (D.32481, method, native_offset.550, &info);
      if (sp == 0B) goto <D.32483>; else goto <D.32484>;
      <D.32483>:
      no_seq_points_found (method);
      <D.32484>:
      D.32485 = sp == 0B;
      D.32486 = (long int) D.32485;
      D.32487 = __builtin_expect (D.32486, 0);
      if (D.32487 != 0) goto <D.32488>; else goto <D.32489>;
      <D.32488>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 4581, "sp");
      <D.32489>:
      log_level.551 = log_level;
      D.32491 = log_level.551 > 0;
      D.32492 = (long int) D.32491;
      D.32493 = __builtin_expect (D.32492, 0);
      if (D.32493 != 0) goto <D.32494>; else goto <D.32495>;
      <D.32494>:
      log_file.552 = log_file;
      D.32497 = GetCurrentThreadId ();
      D.32498 = (void *) D.32497;
      D.32499 = method->name;
      if (sp != 0B) goto <D.32501>; else goto <D.32502>;
      <D.32501>:
      iftmp.553 = sp->il_offset;
      goto <D.32503>;
      <D.32502>:
      iftmp.553 = -1;
      <D.32503>:
      fprintf (log_file.552, "[%p] Breakpoint hit, method=%s, ip=%p, offset=0x%x, sp il offset=0x%x.\n", D.32498, D.32499, ip, native_offset, iftmp.553);
      log_file.552 = log_file;
      fflush (log_file.552);
      <D.32495>:
      bp = 0B;
      i = 0;
      goto <D.25628>;
      <D.25627>:
      breakpoints.554 = breakpoints;
      D.32505 = breakpoints.554->pdata;
      i.555 = (unsigned int) i;
      D.32507 = i.555 * 4;
      D.32508 = D.32505 + D.32507;
      bp = *D.32508;
      D.32509 = bp->method;
      if (D.32509 == 0B) goto <D.32510>; else goto <D.32511>;
      <D.32510>:
      // predicted unlikely by continue predictor.
      goto <D.25623>;
      <D.32511>:
      j = 0;
      goto <D.25625>;
      <D.25624>:
      D.32512 = bp->children;
      D.32513 = D.32512->pdata;
      j.556 = (unsigned int) j;
      D.32515 = j.556 * 4;
      D.32516 = D.32513 + D.32515;
      inst = *D.32516;
      D.32517 = inst->ji;
      if (D.32517 == ji) goto <D.32518>; else goto <D.32519>;
      <D.32518>:
      D.32520 = inst->sp;
      if (D.32520 == sp) goto <D.32521>; else goto <D.32522>;
      <D.32521>:
      D.32523 = bp->req;
      D.32524 = D.32523->event_kind;
      if (D.32524 == 11) goto <D.32525>; else goto <D.32526>;
      <D.32525>:
      D.32523 = bp->req;
      monoeg_g_ptr_array_add (ss_reqs_orig, D.32523);
      goto <D.32527>;
      <D.32526>:
      D.32523 = bp->req;
      monoeg_g_ptr_array_add (bp_reqs, D.32523);
      <D.32527>:
      <D.32522>:
      <D.32519>:
      j = j + 1;
      <D.25625>:
      j.557 = (unsigned int) j;
      D.32512 = bp->children;
      D.32529 = D.32512->len;
      if (j.557 < D.32529) goto <D.25624>; else goto <D.25626>;
      <D.25626>:
      <D.25623>:
      i = i + 1;
      <D.25628>:
      i.558 = (unsigned int) i;
      breakpoints.554 = breakpoints;
      D.32531 = breakpoints.554->len;
      if (i.558 < D.32531) goto <D.25627>; else goto <D.25629>;
      <D.25629>:
      D.32532 = bp_reqs->len;
      if (D.32532 == 0) goto <D.32533>; else goto <D.32534>;
      <D.32533>:
      D.32535 = ss_reqs_orig->len;
      if (D.32535 == 0) goto <D.32536>; else goto <D.32537>;
      <D.32536>:
      D.32538 = sp->il_offset;
      if (D.32538 == -1) goto <D.32539>; else goto <D.32540>;
      <D.32539>:
      kind = 6;
      goto <D.32541>;
      <D.32540>:
      D.32538 = sp->il_offset;
      if (D.32538 == 16777215) goto <D.32542>; else goto <D.32543>;
      <D.32542>:
      kind = 7;
      <D.32543>:
      <D.32541>:
      <D.32537>:
      <D.32534>:
      i = 0;
      goto <D.25635>;
      <D.25634>:
      {
        struct EventRequest * req;
        struct SingleStepReq * ss_req;
        gboolean hit;

        D.32544 = ss_reqs_orig->pdata;
        i.555 = (unsigned int) i;
        D.32507 = i.555 * 4;
        D.32545 = D.32544 + D.32507;
        req = *D.32545;
        ss_req = req->info;
        D.32546 = mono_thread_internal_current ();
        D.32547 = ss_req->thread;
        if (D.32546 != D.32547) goto <D.32548>; else goto <D.32549>;
        <D.32548>:
        // predicted unlikely by continue predictor.
        goto <D.25633>;
        <D.32549>:
        hit = ss_update (ss_req, ji, sp, tls, ctx);
        if (hit != 0) goto <D.32550>; else goto <D.32551>;
        <D.32550>:
        monoeg_g_ptr_array_add (ss_reqs, req);
        <D.32551>:
        info.559 = info;
        ss_start (ss_req, method, sp, info.559, ctx, tls, 0);
      }
      <D.25633>:
      i = i + 1;
      <D.25635>:
      i.558 = (unsigned int) i;
      D.32535 = ss_reqs_orig->len;
      if (i.558 < D.32535) goto <D.25634>; else goto <D.25636>;
      <D.25636>:
      D.32553 = ss_reqs->len;
      if (D.32553 != 0) goto <D.32554>; else goto <D.32555>;
      <D.32554>:
      ss_events = create_event_list (11, ss_reqs, ji, 0B, &suspend_policy);
      <D.32555>:
      D.32532 = bp_reqs->len;
      if (D.32532 != 0) goto <D.32556>; else goto <D.32557>;
      <D.32556>:
      bp_events = create_event_list (10, bp_reqs, ji, 0B, &suspend_policy);
      <D.32557>:
      if (kind != 10) goto <D.32558>; else goto <D.32559>;
      <D.32558>:
      enter_leave_events = create_event_list (kind, 0B, ji, 0B, &suspend_policy);
      <D.32559>:
      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.32560>; else goto <D.32561>;
      <D.32560>:
      suspend_policy.560 = suspend_policy;
      process_event (11, method, 0, ctx, ss_events, suspend_policy.560);
      <D.32561>:
      if (bp_events != 0B) goto <D.32563>; else goto <D.32564>;
      <D.32563>:
      suspend_policy.560 = suspend_policy;
      process_event (kind, method, 0, ctx, bp_events, suspend_policy.560);
      <D.32564>:
      if (enter_leave_events != 0B) goto <D.32565>; else goto <D.32566>;
      <D.32565>:
      suspend_policy.560 = suspend_policy;
      process_event (kind, method, 0, ctx, enter_leave_events, suspend_policy.560);
      <D.32566>:
    }
  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.32570;
  int D.32573;
  int D.32574;
  int log_level.561;
  _Bool D.32578;
  long int D.32579;
  long int D.32580;
  struct FILE * log_file.562;
  unsigned int D.32584;
  void * D.32585;
  int D.32586;
  gboolean D.32587;
  int D.32592;
  struct MonoThreadUnwindState * D.32595;
  struct MonoInternalThread * D.32596;
  int D.32597;
  int D.32600;
  unsigned int D.32607;
  void * D.32608;
  <unnamed type> D.32609;
  unsigned int D.32614;
  struct SingleStepReq * ss_req.563;
  struct MonoMethod * D.32619;
  unsigned int D.32621;
  int D.32622;
  unsigned int D.32623;
  unsigned int D.32628;
  void * D.32629;
  unsigned int D.32633;
  void * D.32634;
  int D.32637;
  struct MonoDebugMethodInfo * minfo;
  struct MonoDebugSourceLocation * loc;
  gboolean hit;
  struct MonoMethod * method;

  loc = 0B;
  hit = 1;
  D.32570 = req->depth;
  if (D.32570 == 1) goto <D.32571>; else goto <D.32572>;
  <D.32571>:
  D.32573 = sp->flags;
  D.32574 = D.32573 & 1;
  if (D.32574 != 0) goto <D.32575>; else goto <D.32576>;
  <D.32575>:
  log_level.561 = log_level;
  D.32578 = log_level.561 > 0;
  D.32579 = (long int) D.32578;
  D.32580 = __builtin_expect (D.32579, 0);
  if (D.32580 != 0) goto <D.32581>; else goto <D.32582>;
  <D.32581>:
  log_file.562 = log_file;
  D.32584 = GetCurrentThreadId ();
  D.32585 = (void *) D.32584;
  D.32586 = sp->il_offset;
  fprintf (log_file.562, "[%p] Seq point at nonempty stack %x while stepping over, continuing single stepping.\n", D.32585, D.32586);
  log_file.562 = log_file;
  fflush (log_file.562);
  <D.32582>:
  D.32587 = 0;
  return D.32587;
  <D.32576>:
  <D.32572>:
  D.32570 = req->depth;
  if (D.32570 == 1) goto <D.32588>; else goto <D.32589>;
  <D.32588>:
  if (hit != 0) goto <D.32590>; else goto <D.32591>;
  <D.32590>:
  D.32592 = tls->context.valid;
  if (D.32592 == 0) goto <D.32593>; else goto <D.32594>;
  <D.32593>:
  D.32595 = &tls->context;
  mono_thread_state_init_from_monoctx (D.32595, ctx);
  <D.32594>:
  D.32596 = tls->thread;
  compute_frame_info (D.32596, tls);
  D.32597 = req->nframes;
  if (D.32597 != 0) goto <D.32598>; else goto <D.32599>;
  <D.32598>:
  D.32600 = tls->frame_count;
  if (D.32600 != 0) goto <D.32601>; else goto <D.32602>;
  <D.32601>:
  D.32600 = tls->frame_count;
  D.32597 = req->nframes;
  if (D.32600 > D.32597) goto <D.32603>; else goto <D.32604>;
  <D.32603>:
  log_level.561 = log_level;
  D.32578 = log_level.561 > 0;
  D.32579 = (long int) D.32578;
  D.32580 = __builtin_expect (D.32579, 0);
  if (D.32580 != 0) goto <D.32605>; else goto <D.32606>;
  <D.32605>:
  log_file.562 = log_file;
  D.32607 = GetCurrentThreadId ();
  D.32608 = (void *) D.32607;
  fprintf (log_file.562, "[%p] Breakpoint at lower frame while stepping over, continuing single stepping.\n", D.32608);
  log_file.562 = log_file;
  fflush (log_file.562);
  <D.32606>:
  D.32587 = 0;
  return D.32587;
  <D.32604>:
  <D.32602>:
  <D.32599>:
  <D.32591>:
  <D.32589>:
  D.32609 = req->size;
  if (D.32609 != 1) goto <D.32610>; else goto <D.32611>;
  <D.32610>:
  D.32587 = 1;
  return D.32587;
  <D.32611>:
  method = jinfo_get_method (ji);
  minfo = mono_debug_lookup_method (method);
  if (minfo != 0B) goto <D.32612>; else goto <D.32613>;
  <D.32612>:
  D.32586 = sp->il_offset;
  D.32614 = (unsigned int) D.32586;
  loc = mono_debug_symfile_lookup_location (minfo, D.32614);
  <D.32613>:
  if (loc == 0B) goto <D.32615>; else goto <D.32617>;
  <D.32617>:
  ss_req.563 = ss_req;
  D.32619 = ss_req.563->last_method;
  if (D.32619 == method) goto <D.32620>; else goto <D.32616>;
  <D.32620>:
  D.32621 = loc->row;
  ss_req.563 = ss_req;
  D.32622 = ss_req.563->last_line;
  D.32623 = (unsigned int) D.32622;
  if (D.32621 == D.32623) goto <D.32615>; else goto <D.32616>;
  <D.32615>:
  if (loc == 0B) goto <D.32624>; else goto <D.32625>;
  <D.32624>:
  log_level.561 = log_level;
  D.32578 = log_level.561 > 0;
  D.32579 = (long int) D.32578;
  D.32580 = __builtin_expect (D.32579, 0);
  if (D.32580 != 0) goto <D.32626>; else goto <D.32627>;
  <D.32626>:
  log_file.562 = log_file;
  D.32628 = GetCurrentThreadId ();
  D.32629 = (void *) D.32628;
  D.32586 = sp->il_offset;
  fprintf (log_file.562, "[%p] No line number info for il offset %x, continuing single stepping.\n", D.32629, D.32586);
  log_file.562 = log_file;
  fflush (log_file.562);
  <D.32627>:
  goto <D.32630>;
  <D.32625>:
  log_level.561 = log_level;
  D.32578 = log_level.561 > 0;
  D.32579 = (long int) D.32578;
  D.32580 = __builtin_expect (D.32579, 0);
  if (D.32580 != 0) goto <D.32631>; else goto <D.32632>;
  <D.32631>:
  log_file.562 = log_file;
  D.32633 = GetCurrentThreadId ();
  D.32634 = (void *) D.32633;
  D.32621 = loc->row;
  fprintf (log_file.562, "[%p] Same source line (%d), continuing single stepping.\n", D.32634, D.32621);
  log_file.562 = log_file;
  fflush (log_file.562);
  <D.32632>:
  <D.32630>:
  hit = 0;
  <D.32616>:
  if (loc != 0B) goto <D.32635>; else goto <D.32636>;
  <D.32635>:
  ss_req.563 = ss_req;
  ss_req.563->last_method = method;
  ss_req.563 = ss_req;
  D.32621 = loc->row;
  D.32637 = (int) D.32621;
  ss_req.563->last_line = D.32637;
  mono_debug_free_source_location (loc);
  <D.32636>:
  D.32587 = hit;
  return D.32587;
}


process_signal_event (void (*<T44d3>) (struct DebuggerTlsData *) func)
{
  unsigned int debugger_tls_id.564;
  struct MonoContext * D.32640;
  struct MonoContext * D.32641;
  struct DebuggerTlsData * tls;
  struct MonoContext orig_restore_ctx;
  struct MonoContext ctx;

  try
    {
      debugger_tls_id.564 = debugger_tls_id;
      tls = pthread_getspecific (debugger_tls_id.564);
      D.32640 = &tls->restore_ctx;
      memcpy (&orig_restore_ctx, D.32640, 260);
      D.32640 = &tls->restore_ctx;
      D.32641 = &tls->handler_ctx;
      memcpy (D.32640, D.32641, 260);
      func (tls);
      D.32640 = &tls->restore_ctx;
      memcpy (&ctx, D.32640, 260);
      D.32640 = &tls->restore_ctx;
      memcpy (D.32640, &orig_restore_ctx, 260);
      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.565;
  struct _IO_FILE * stderr.566;
  unsigned int D.32646;
  void * D.32647;
  _Bool D.32648;
  long int D.32649;
  long int D.32650;
  struct MonoContext * D.32653;
  struct DebuggerTlsData * tls;
  struct MonoContext ctx;

  try
    {
      debugger_tls_id.565 = debugger_tls_id;
      tls = pthread_getspecific (debugger_tls_id.565);
      if (tls == 0B) goto <D.32643>; else goto <D.32644>;
      <D.32643>:
      stderr.566 = stderr;
      D.32646 = GetCurrentThreadId ();
      D.32647 = (void *) D.32646;
      fprintf (stderr.566, "Thread %p is not attached to the JIT.\n", D.32647);
      <D.32644>:
      D.32648 = tls == 0B;
      D.32649 = (long int) D.32648;
      D.32650 = __builtin_expect (D.32649, 0);
      if (D.32650 != 0) goto <D.32651>; else goto <D.32652>;
      <D.32651>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 4690, "tls");
      <D.32652>:
      mono_arch_sigctx_to_monoctx (sigctx, &ctx);
      D.32653 = &tls->handler_ctx;
      memcpy (D.32653, &ctx, 260);
      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.32654;
  int D.32657;
  void * D.32658;
  _Bool D.32659;
  long int D.32660;
  long int D.32661;
  int suspend_policy.567;

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

    try
      {
        ctx.sc_pc = 0;
        mono_walk_stack_with_ctx (user_break_cb, 0B, 0, &ctx);
        D.32657 = ctx.sc_pc;
        D.32658 = (void *) D.32657;
        D.32659 = D.32658 == 0B;
        D.32660 = (long int) D.32659;
        D.32661 = __builtin_expect (D.32660, 0);
        if (D.32661 != 0) goto <D.32662>; else goto <D.32663>;
        <D.32662>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 4747, "MONO_CONTEXT_GET_IP (&ctx) != NULL");
        <D.32663>:
        mono_loader_lock ();
        events = create_event_list (15, 0B, 0B, 0B, &suspend_policy);
        mono_loader_unlock ();
        suspend_policy.567 = suspend_policy;
        process_event (15, 0B, 0, &ctx, events, suspend_policy.567);
      }
    finally
      {
        ctx = {CLOBBER};
        suspend_policy = {CLOBBER};
      }
  }
  goto <D.32665>;
  <D.32656>:
  raise (5);
  <D.32665>:
}


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

  D.32666 = frame->managed;
  if (D.32666 != 0) goto <D.32667>; else goto <D.32668>;
  <D.32667>:
  MEM[(struct MonoContext *)data] = *ctx;
  D.32669 = 1;
  return D.32669;
  <D.32668>:
  D.32669 = 0;
  return D.32669;
}


mono_debugger_agent_single_step_event (void * sigctx)
{
  unsigned int D.32671;
  unsigned int debugger_thread_id.568;

  D.32671 = GetCurrentThreadId ();
  debugger_thread_id.568 = debugger_thread_id;
  if (D.32671 == debugger_thread_id.568) goto <D.32673>; else goto <D.32674>;
  <D.32673>:
  {
    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.32674>:
  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.32677;
  int suspend_count.569;
  struct SingleStepReq * ss_req.570;
  struct MonoInternalThread * D.32684;
  struct MonoInternalThread * D.32685;
  int log_level.571;
  struct MonoDomain * D.32691;
  _Bool D.32692;
  long int D.32693;
  long int D.32694;
  struct FILE * log_file.572;
  unsigned int D.32698;
  void * D.32699;
  <unnamed type> D.32700;
  const char * D.32701;
  struct MonoMethod * D.32702;
  char * D.32703;
  void * D.32704;
  int D.32705;
  void * D.32706;
  void * D.32707;
  struct MonoDomain * D.32708;
  _Bool D.32709;
  long int D.32710;
  long int D.32711;
  _Bool D.32714;
  long int D.32715;
  long int D.32716;
  unsigned int D.32719;
  unsigned int D.32720;
  struct MonoClass * D.32727;
  struct MonoClass * D.32728;
  int D.25696;
  int iftmp.573;
  int D.25695;
  const char[7] * D.32734;
  unsigned char D.32735;
  int D.32736;
  unsigned char D.32737;
  int D.32738;
  const unsigned char * D.32743;
  unsigned char D.32744;
  int D.32745;
  const unsigned char * D.32746;
  unsigned char D.32747;
  int D.32748;
  const unsigned char * D.32753;
  unsigned char D.32754;
  int D.32755;
  const unsigned char * D.32756;
  unsigned char D.32757;
  int D.32758;
  const unsigned char * D.32763;
  unsigned char D.32764;
  int D.32765;
  const unsigned char * D.32766;
  unsigned char D.32767;
  int D.32768;
  const char * D.32770;
  char * D.32772;
  struct MonoDomain * domain.574;
  int ip.575;
  void * D.32775;
  int D.32776;
  int D.32777;
  int D.32780;
  struct MonoSeqPointInfo * info.576;
  <unnamed type> D.32784;
  unsigned int D.32785;
  short unsigned int D.32788;
  int D.32789;
  int D.32790;
  int D.25705;
  int iftmp.577;
  int D.25704;
  const char[7] * D.32796;
  unsigned char D.32797;
  int D.32798;
  unsigned char D.32799;
  int D.32800;
  const unsigned char * D.32805;
  unsigned char D.32806;
  int D.32807;
  const unsigned char * D.32808;
  unsigned char D.32809;
  int D.32810;
  const unsigned char * D.32815;
  unsigned char D.32816;
  int D.32817;
  const unsigned char * D.32818;
  unsigned char D.32819;
  int D.32820;
  const unsigned char * D.32825;
  unsigned char D.32826;
  int D.32827;
  const unsigned char * D.32828;
  unsigned char D.32829;
  int D.32830;
  struct EventRequest * D.32834;
  struct MonoMethod * D.32835;
  int suspend_policy.578;
  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.32677 = ctx->sc_pc;
      ip = (guint8 *) D.32677;
      mono_arch_skip_single_step (ctx);
      suspend_count.569 = suspend_count;
      if (suspend_count.569 > 0) goto <D.32679>; else goto <D.32680>;
      <D.32679>:
      process_suspend (tls, ctx);
      return;
      <D.32680>:
      ss_req.570 = ss_req;
      if (ss_req.570 == 0B) goto <D.32682>; else goto <D.32683>;
      <D.32682>:
      return;
      <D.32683>:
      D.32684 = mono_thread_internal_current ();
      ss_req.570 = ss_req;
      D.32685 = ss_req.570->thread;
      if (D.32684 != D.32685) goto <D.32686>; else goto <D.32687>;
      <D.32686>:
      return;
      <D.32687>:
      log_level.571 = log_level;
      if (log_level.571 > 0) goto <D.32689>; else goto <D.32690>;
      <D.32689>:
      D.32691 = mono_domain_get ();
      ji = mini_jit_info_table_find (D.32691, ip, &domain);
      log_level.571 = log_level;
      D.32692 = log_level.571 > 0;
      D.32693 = (long int) D.32692;
      D.32694 = __builtin_expect (D.32693, 0);
      if (D.32694 != 0) goto <D.32695>; else goto <D.32696>;
      <D.32695>:
      log_file.572 = log_file;
      D.32698 = GetCurrentThreadId ();
      D.32699 = (void *) D.32698;
      ss_req.570 = ss_req;
      D.32700 = ss_req.570->depth;
      D.32701 = ss_depth_to_string (D.32700);
      D.32702 = jinfo_get_method (ji);
      D.32703 = mono_method_full_name (D.32702, 1);
      D.32677 = ctx->sc_pc;
      D.32704 = (void *) D.32677;
      D.32705 = ctx->sc_regs[29];
      D.32706 = (void *) D.32705;
      ss_req.570 = ss_req;
      D.32707 = ss_req.570->last_sp;
      fprintf (log_file.572, "[%p] Single step event (depth=%s) at %s (%p), sp %p, last sp %p\n", D.32699, D.32701, D.32703, D.32704, D.32706, D.32707);
      log_file.572 = log_file;
      fflush (log_file.572);
      <D.32696>:
      <D.32690>:
      D.32708 = mono_domain_get ();
      ji = mini_jit_info_table_find (D.32708, ip, &domain);
      D.32709 = ji == 0B;
      D.32710 = (long int) D.32709;
      D.32711 = __builtin_expect (D.32710, 0);
      if (D.32711 != 0) goto <D.32712>; else goto <D.32713>;
      <D.32712>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 4813, "ji");
      <D.32713>:
      method = jinfo_get_method (ji);
      D.32714 = method == 0B;
      D.32715 = (long int) D.32714;
      D.32716 = __builtin_expect (D.32715, 0);
      if (D.32716 != 0) goto <D.32717>; else goto <D.32718>;
      <D.32717>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 4815, "method");
      <D.32718>:
      D.32719 = BIT_FIELD_REF <*method, 32, 160>;
      D.32720 = D.32719 & 124;
      if (D.32720 != 0) goto <D.32721>; else goto <D.32722>;
      <D.32721>:
      D.32719 = BIT_FIELD_REF <*method, 32, 160>;
      D.32720 = D.32719 & 124;
      if (D.32720 != 68) goto <D.32723>; else goto <D.32724>;
      <D.32723>:
      return;
      <D.32724>:
      <D.32722>:
      D.32727 = method->klass;
      D.32728 = mono_defaults.string_class;
      if (D.32727 == D.32728) goto <D.32729>; else goto <D.32730>;
      <D.32729>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          __s2 = method->name;
          D.32734 = "memset";
          D.32735 = MEM[(const unsigned char *)D.32734];
          D.32736 = (int) D.32735;
          D.32737 = *__s2;
          D.32738 = (int) D.32737;
          __result = D.32736 - D.32738;
          {
            if (__s2_len != 0) goto <D.32739>; else goto <D.32740>;
            <D.32739>:
            if (__result == 0) goto <D.32741>; else goto <D.32742>;
            <D.32741>:
            D.32743 = &MEM[(void *)"memset" + 1B];
            D.32744 = *D.32743;
            D.32745 = (int) D.32744;
            D.32746 = __s2 + 1;
            D.32747 = *D.32746;
            D.32748 = (int) D.32747;
            __result = D.32745 - D.32748;
            if (__s2_len > 1) goto <D.32749>; else goto <D.32750>;
            <D.32749>:
            if (__result == 0) goto <D.32751>; else goto <D.32752>;
            <D.32751>:
            D.32753 = &MEM[(void *)"memset" + 2B];
            D.32754 = *D.32753;
            D.32755 = (int) D.32754;
            D.32756 = __s2 + 2;
            D.32757 = *D.32756;
            D.32758 = (int) D.32757;
            __result = D.32755 - D.32758;
            if (__s2_len > 2) goto <D.32759>; else goto <D.32760>;
            <D.32759>:
            if (__result == 0) goto <D.32761>; else goto <D.32762>;
            <D.32761>:
            D.32763 = &MEM[(void *)"memset" + 3B];
            D.32764 = *D.32763;
            D.32765 = (int) D.32764;
            D.32766 = __s2 + 3;
            D.32767 = *D.32766;
            D.32768 = (int) D.32767;
            __result = D.32765 - D.32768;
            <D.32762>:
            <D.32760>:
            <D.32752>:
            <D.32750>:
            <D.32742>:
            <D.32740>:
          }
          D.25695 = __result;
        }
        iftmp.573 = -D.25695;
        goto <D.32769>;
        <D.32733>:
        D.32770 = method->name;
        iftmp.573 = __builtin_strcmp (D.32770, "memset");
        <D.32769>:
        D.25696 = iftmp.573;
      }
      if (D.25696 == 0) goto <D.32725>; else goto <D.32771>;
      <D.32771>:
      D.32770 = method->name;
      D.32772 = strstr (D.32770, "memcpy");
      if (D.32772 != 0B) goto <D.32725>; else goto <D.32726>;
      <D.32725>:
      return;
      <D.32726>:
      <D.32730>:
      domain.574 = domain;
      ip.575 = (int) ip;
      D.32775 = ji->code_start;
      D.32776 = (int) D.32775;
      D.32777 = ip.575 - D.32776;
      sp = find_next_seq_point_for_native_offset (domain.574, method, D.32777, &info);
      if (sp == 0B) goto <D.32778>; else goto <D.32779>;
      <D.32778>:
      return;
      <D.32779>:
      il_offset = sp->il_offset;
      ss_req.570 = ss_req;
      D.32780 = ss_update (ss_req.570, ji, sp, tls, ctx);
      if (D.32780 == 0) goto <D.32781>; else goto <D.32782>;
      <D.32781>:
      return;
      <D.32782>:
      ss_req.570 = ss_req;
      info.576 = info;
      ss_start (ss_req.570, method, sp, info.576, ctx, tls, 0);
      ss_req.570 = ss_req;
      D.32784 = ss_req.570->filter;
      D.32785 = D.32784 & 1;
      if (D.32785 != 0) goto <D.32786>; else goto <D.32787>;
      <D.32786>:
      D.32788 = method->flags;
      D.32789 = (int) D.32788;
      D.32790 = D.32789 & 2048;
      if (D.32790 != 0) goto <D.32791>; else goto <D.32792>;
      <D.32791>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          __s2 = method->name;
          D.32796 = ".cctor";
          D.32797 = MEM[(const unsigned char *)D.32796];
          D.32798 = (int) D.32797;
          D.32799 = *__s2;
          D.32800 = (int) D.32799;
          __result = D.32798 - D.32800;
          {
            if (__s2_len != 0) goto <D.32801>; else goto <D.32802>;
            <D.32801>:
            if (__result == 0) goto <D.32803>; else goto <D.32804>;
            <D.32803>:
            D.32805 = &MEM[(void *)".cctor" + 1B];
            D.32806 = *D.32805;
            D.32807 = (int) D.32806;
            D.32808 = __s2 + 1;
            D.32809 = *D.32808;
            D.32810 = (int) D.32809;
            __result = D.32807 - D.32810;
            if (__s2_len > 1) goto <D.32811>; else goto <D.32812>;
            <D.32811>:
            if (__result == 0) goto <D.32813>; else goto <D.32814>;
            <D.32813>:
            D.32815 = &MEM[(void *)".cctor" + 2B];
            D.32816 = *D.32815;
            D.32817 = (int) D.32816;
            D.32818 = __s2 + 2;
            D.32819 = *D.32818;
            D.32820 = (int) D.32819;
            __result = D.32817 - D.32820;
            if (__s2_len > 2) goto <D.32821>; else goto <D.32822>;
            <D.32821>:
            if (__result == 0) goto <D.32823>; else goto <D.32824>;
            <D.32823>:
            D.32825 = &MEM[(void *)".cctor" + 3B];
            D.32826 = *D.32825;
            D.32827 = (int) D.32826;
            D.32828 = __s2 + 3;
            D.32829 = *D.32828;
            D.32830 = (int) D.32829;
            __result = D.32827 - D.32830;
            <D.32824>:
            <D.32822>:
            <D.32814>:
            <D.32812>:
            <D.32804>:
            <D.32802>:
          }
          D.25704 = __result;
        }
        iftmp.577 = -D.25704;
        goto <D.32831>;
        <D.32795>:
        D.32770 = method->name;
        iftmp.577 = __builtin_strcmp (D.32770, ".cctor");
        <D.32831>:
        D.25705 = iftmp.577;
      }
      if (D.25705 == 0) goto <D.32832>; else goto <D.32833>;
      <D.32832>:
      return;
      <D.32833>:
      <D.32792>:
      <D.32787>:
      reqs = monoeg_g_ptr_array_new ();
      mono_loader_lock ();
      ss_req.570 = ss_req;
      D.32834 = ss_req.570->req;
      monoeg_g_ptr_array_add (reqs, D.32834);
      events = create_event_list (11, reqs, ji, 0B, &suspend_policy);
      monoeg_g_ptr_array_free (reqs, 1);
      mono_loader_unlock ();
      D.32835 = jinfo_get_method (ji);
      suspend_policy.578 = suspend_policy;
      process_event (11, D.32835, il_offset, ctx, events, suspend_policy.578);
    }
  finally
    {
      suspend_policy = {CLOBBER};
      domain = {CLOBBER};
      info = {CLOBBER};
    }
}


process_suspend (struct DebuggerTlsData * tls, struct MonoContext * ctx)
{
  int D.32840;
  int D.32841;
  unsigned int D.32844;
  unsigned int debugger_thread_id.579;
  int suspend_count.580;
  unsigned int suspend_count.581;
  unsigned int D.32850;
  int log_level.582;
  _Bool D.32854;
  long int D.32855;
  long int D.32856;
  struct FILE * log_file.583;
  unsigned int D.32860;
  void * D.32861;
  unsigned int D.32866;
  void * D.32867;
  struct MonoDomain * D.32868;
  struct MonoClass * D.32871;
  struct MonoClass * D.32872;
  int D.25069;
  int iftmp.584;
  int D.25068;
  const char[7] * D.32878;
  unsigned char D.32879;
  int D.32880;
  unsigned char D.32881;
  int D.32882;
  const unsigned char * D.32887;
  unsigned char D.32888;
  int D.32889;
  const unsigned char * D.32890;
  unsigned char D.32891;
  int D.32892;
  const unsigned char * D.32897;
  unsigned char D.32898;
  int D.32899;
  const unsigned char * D.32900;
  unsigned char D.32901;
  int D.32902;
  const unsigned char * D.32907;
  unsigned char D.32908;
  int D.32909;
  const unsigned char * D.32910;
  unsigned char D.32911;
  int D.32912;
  const char * D.32914;
  char * D.32916;
  guint8 * ip;
  struct MonoJitInfo * ji;
  struct MonoMethod * method;

  D.32840 = ctx->sc_pc;
  ip = (guint8 *) D.32840;
  D.32841 = mono_loader_lock_is_owned_by_self ();
  if (D.32841 != 0) goto <D.32842>; else goto <D.32843>;
  <D.32842>:
  return;
  <D.32843>:
  D.32844 = GetCurrentThreadId ();
  debugger_thread_id.579 = debugger_thread_id;
  if (D.32844 == debugger_thread_id.579) goto <D.32846>; else goto <D.32847>;
  <D.32846>:
  return;
  <D.32847>:
  suspend_count.580 = suspend_count;
  suspend_count.581 = (unsigned int) suspend_count.580;
  D.32850 = tls->resume_count;
  if (suspend_count.581 != D.32850) goto <D.32851>; else goto <D.32852>;
  <D.32851>:
  tls->suspending = 1;
  <D.32852>:
  log_level.582 = log_level;
  D.32854 = log_level.582 > 0;
  D.32855 = (long int) D.32854;
  D.32856 = __builtin_expect (D.32855, 0);
  if (D.32856 != 0) goto <D.32857>; else goto <D.32858>;
  <D.32857>:
  log_file.583 = log_file;
  D.32860 = GetCurrentThreadId ();
  D.32861 = (void *) D.32860;
  fprintf (log_file.583, "[%p] Received single step event for suspending.\n", D.32861);
  log_file.583 = log_file;
  fflush (log_file.583);
  <D.32858>:
  suspend_count.580 = suspend_count;
  suspend_count.581 = (unsigned int) suspend_count.580;
  D.32850 = tls->resume_count;
  if (suspend_count.581 == D.32850) goto <D.32862>; else goto <D.32863>;
  <D.32862>:
  log_level.582 = log_level;
  D.32854 = log_level.582 > 0;
  D.32855 = (long int) D.32854;
  D.32856 = __builtin_expect (D.32855, 0);
  if (D.32856 != 0) goto <D.32864>; else goto <D.32865>;
  <D.32864>:
  log_file.583 = log_file;
  D.32866 = GetCurrentThreadId ();
  D.32867 = (void *) D.32866;
  fprintf (log_file.583, "[%p] Ignored during single threaded invoke.\n", D.32867);
  log_file.583 = log_file;
  fflush (log_file.583);
  <D.32865>:
  return;
  <D.32863>:
  D.32868 = mono_domain_get ();
  ji = mini_jit_info_table_find (D.32868, ip, 0B);
  method = jinfo_get_method (ji);
  D.32871 = method->klass;
  D.32872 = mono_defaults.string_class;
  if (D.32871 == D.32872) goto <D.32873>; else goto <D.32874>;
  <D.32873>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = method->name;
      D.32878 = "memset";
      D.32879 = MEM[(const unsigned char *)D.32878];
      D.32880 = (int) D.32879;
      D.32881 = *__s2;
      D.32882 = (int) D.32881;
      __result = D.32880 - D.32882;
      {
        if (__s2_len != 0) goto <D.32883>; else goto <D.32884>;
        <D.32883>:
        if (__result == 0) goto <D.32885>; else goto <D.32886>;
        <D.32885>:
        D.32887 = &MEM[(void *)"memset" + 1B];
        D.32888 = *D.32887;
        D.32889 = (int) D.32888;
        D.32890 = __s2 + 1;
        D.32891 = *D.32890;
        D.32892 = (int) D.32891;
        __result = D.32889 - D.32892;
        if (__s2_len > 1) goto <D.32893>; else goto <D.32894>;
        <D.32893>:
        if (__result == 0) goto <D.32895>; else goto <D.32896>;
        <D.32895>:
        D.32897 = &MEM[(void *)"memset" + 2B];
        D.32898 = *D.32897;
        D.32899 = (int) D.32898;
        D.32900 = __s2 + 2;
        D.32901 = *D.32900;
        D.32902 = (int) D.32901;
        __result = D.32899 - D.32902;
        if (__s2_len > 2) goto <D.32903>; else goto <D.32904>;
        <D.32903>:
        if (__result == 0) goto <D.32905>; else goto <D.32906>;
        <D.32905>:
        D.32907 = &MEM[(void *)"memset" + 3B];
        D.32908 = *D.32907;
        D.32909 = (int) D.32908;
        D.32910 = __s2 + 3;
        D.32911 = *D.32910;
        D.32912 = (int) D.32911;
        __result = D.32909 - D.32912;
        <D.32906>:
        <D.32904>:
        <D.32896>:
        <D.32894>:
        <D.32886>:
        <D.32884>:
      }
      D.25068 = __result;
    }
    iftmp.584 = -D.25068;
    goto <D.32913>;
    <D.32877>:
    D.32914 = method->name;
    iftmp.584 = __builtin_strcmp (D.32914, "memset");
    <D.32913>:
    D.25069 = iftmp.584;
  }
  if (D.25069 == 0) goto <D.32869>; else goto <D.32915>;
  <D.32915>:
  D.32914 = method->name;
  D.32916 = strstr (D.32914, "memcpy");
  if (D.32916 != 0B) goto <D.32869>; else goto <D.32870>;
  <D.32869>:
  return;
  <D.32870>:
  <D.32874>:
  save_thread_context (ctx);
  suspend_current ();
}


debugger_agent_single_step_from_context (struct MonoContext * ctx)
{
  unsigned int debugger_tls_id.585;
  _Bool D.32919;
  long int D.32920;
  long int D.32921;
  struct MonoContext * D.32924;
  struct DebuggerTlsData * tls;
  struct MonoContext orig_restore_ctx;

  try
    {
      debugger_tls_id.585 = debugger_tls_id;
      tls = pthread_getspecific (debugger_tls_id.585);
      D.32919 = tls == 0B;
      D.32920 = (long int) D.32919;
      D.32921 = __builtin_expect (D.32920, 0);
      if (D.32921 != 0) goto <D.32922>; else goto <D.32923>;
      <D.32922>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 4909, "tls");
      <D.32923>:
      D.32924 = &tls->restore_ctx;
      memcpy (&orig_restore_ctx, D.32924, 260);
      D.32924 = &tls->restore_ctx;
      memcpy (D.32924, ctx, 260);
      process_single_step_inner (tls);
      D.32924 = &tls->restore_ctx;
      memcpy (ctx, D.32924, 260);
      D.32924 = &tls->restore_ctx;
      memcpy (D.32924, &orig_restore_ctx, 260);
    }
  finally
    {
      orig_restore_ctx = {CLOBBER};
    }
}


debugger_agent_breakpoint_from_context (struct MonoContext * ctx)
{
  unsigned int debugger_tls_id.586;
  _Bool D.32926;
  long int D.32927;
  long int D.32928;
  struct MonoContext * D.32931;
  struct DebuggerTlsData * tls;
  struct MonoContext orig_restore_ctx;

  try
    {
      debugger_tls_id.586 = debugger_tls_id;
      tls = pthread_getspecific (debugger_tls_id.586);
      D.32926 = tls == 0B;
      D.32927 = (long int) D.32926;
      D.32928 = __builtin_expect (D.32927, 0);
      if (D.32928 != 0) goto <D.32929>; else goto <D.32930>;
      <D.32929>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 4928, "tls");
      <D.32930>:
      D.32931 = &tls->restore_ctx;
      memcpy (&orig_restore_ctx, D.32931, 260);
      D.32931 = &tls->restore_ctx;
      memcpy (D.32931, ctx, 260);
      process_breakpoint_inner (tls);
      D.32931 = &tls->restore_ctx;
      memcpy (ctx, D.32931, 260);
      D.32931 = &tls->restore_ctx;
      memcpy (D.32931, &orig_restore_ctx, 260);
    }
  finally
    {
      orig_restore_ctx = {CLOBBER};
    }
}


mono_debugger_agent_debug_log (int level, struct MonoString * category, struct MonoString * message)
{
  int D.32932;
  char * iftmp.587;
  char * iftmp.588;
  int suspend_policy.589;
  char * D.32944;
  char * D.32945;
  int suspend_policy;
  struct GSList * events;
  struct EventInfo ei;

  try
    {
      D.32932 = agent_config.enabled;
      if (D.32932 == 0) goto <D.32933>; else goto <D.32934>;
      <D.32933>:
      return;
      <D.32934>:
      mono_loader_lock ();
      events = create_event_list (16, 0B, 0B, 0B, &suspend_policy);
      mono_loader_unlock ();
      ei.level = level;
      if (category != 0B) goto <D.32936>; else goto <D.32937>;
      <D.32936>:
      iftmp.587 = mono_string_to_utf8 (category);
      goto <D.32938>;
      <D.32937>:
      iftmp.587 = 0B;
      <D.32938>:
      ei.category = iftmp.587;
      if (message != 0B) goto <D.32940>; else goto <D.32941>;
      <D.32940>:
      iftmp.588 = mono_string_to_utf8 (message);
      goto <D.32942>;
      <D.32941>:
      iftmp.588 = 0B;
      <D.32942>:
      ei.message = iftmp.588;
      suspend_policy.589 = suspend_policy;
      process_event (16, &ei, 0, 0B, events, suspend_policy.589);
      D.32944 = ei.category;
      monoeg_g_free (D.32944);
      D.32945 = ei.message;
      monoeg_g_free (D.32945);
    }
  finally
    {
      suspend_policy = {CLOBBER};
      ei = {CLOBBER};
    }
}


mono_debugger_agent_debug_log_is_enabled ()
{
  gboolean D.32949;

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


mono_debugger_agent_handle_exception (struct MonoException * exc, struct MonoContext * throw_ctx, struct MonoContext * catch_ctx)
{
  struct MonoGHashTable * thread_to_tls.590;
  int D.32956;
  int D.32961;
  int D.32966;
  int inited.591;
  struct GSList * D.32973;
  struct MonoVTable * D.32978;
  struct MonoClass * D.32979;
  struct MonoType * D.32980;
  int D.25833;
  int iftmp.592;
  int D.25832;
  const char[1] * D.32986;
  unsigned char D.32987;
  int D.32988;
  unsigned char D.32989;
  int D.32990;
  const unsigned char * D.32995;
  unsigned char D.32996;
  int D.32997;
  const unsigned char * D.32998;
  unsigned char D.32999;
  int D.33000;
  const unsigned char * D.33005;
  unsigned char D.33006;
  int D.33007;
  const unsigned char * D.33008;
  unsigned char D.33009;
  int D.33010;
  const unsigned char * D.33015;
  unsigned char D.33016;
  int D.33017;
  const unsigned char * D.33018;
  unsigned char D.33019;
  int D.33020;
  unsigned char D.33022;
  int D.25842;
  struct MonoDomain * D.33028;
  int D.33029;
  char * D.33030;
  struct MonoDomain * D.33033;
  int D.33034;
  char * D.33035;
  _Bool D.33037;
  int D.33038;
  struct GPtrArray * event_requests.593;
  void * * D.33040;
  unsigned int i.594;
  unsigned int D.33042;
  void * * D.33043;
  int D.33044;
  <unnamed type> D.33047;
  unsigned int k.595;
  unsigned int D.33055;
  struct MonoAssembly * * D.33056;
  struct MonoAssembly * D.33057;
  struct MonoMethod * D.33058;
  struct MonoClass * D.33059;
  struct MonoImage * D.33060;
  struct MonoAssembly * D.33061;
  int D.33066;
  unsigned int i.596;
  unsigned int D.33068;
  int D.33071;
  struct MonoThreadUnwindState * D.33076;
  struct MonoDomain * D.33077;
  int suspend_policy.597;
  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.590 = thread_to_tls;
      if (thread_to_tls.590 != 0B) goto <D.32952>; else goto <D.32953>;
      <D.32952>:
      {
        struct MonoInternalThread * thread;

        thread = mono_thread_internal_current ();
        mono_loader_lock ();
        thread_to_tls.590 = thread_to_tls;
        tls = mono_g_hash_table_lookup (thread_to_tls.590, thread);
        mono_loader_unlock ();
        if (tls != 0B) goto <D.32954>; else goto <D.32955>;
        <D.32954>:
        D.32956 = tls->abort_requested;
        if (D.32956 != 0) goto <D.32957>; else goto <D.32958>;
        <D.32957>:
        return;
        <D.32958>:
        <D.32955>:
        if (tls != 0B) goto <D.32959>; else goto <D.32960>;
        <D.32959>:
        D.32961 = tls->disable_breakpoints;
        if (D.32961 != 0) goto <D.32962>; else goto <D.32963>;
        <D.32962>:
        return;
        <D.32963>:
        <D.32960>:
      }
      <D.32953>:
      memset (&ei, 0, 284);
      if (catch_ctx == 0B) goto <D.32964>; else goto <D.32965>;
      <D.32964>:
      D.32966 = agent_config.onuncaught;
      if (D.32966 != 0) goto <D.32967>; else goto <D.32968>;
      <D.32967>:
      inited.591 = inited;
      if (inited.591 == 0) goto <D.32970>; else goto <D.32971>;
      <D.32970>:
      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.32971>:
      <D.32968>:
      goto <D.32972>;
      <D.32965>:
      D.32973 = agent_config.onthrow;
      if (D.32973 != 0B) goto <D.32974>; else goto <D.32975>;
      <D.32974>:
      inited.591 = inited;
      if (inited.591 == 0) goto <D.32976>; else goto <D.32977>;
      <D.32976>:
      {
        struct GSList * l;
        gboolean found;

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

          ex_type = l->data;
          D.32978 = exc->object.vtable;
          D.32979 = D.32978->klass;
          D.32980 = &D.32979->byval_arg;
          f = mono_type_full_name (D.32980);
          {
            size_t __s1_len;
            size_t __s2_len;

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

              __s2 = ex_type;
              D.32986 = "";
              D.32987 = MEM[(const unsigned char *)D.32986];
              D.32988 = (int) D.32987;
              D.32989 = *__s2;
              D.32990 = (int) D.32989;
              __result = D.32988 - D.32990;
              {
                if (__s2_len != 0) goto <D.32991>; else goto <D.32992>;
                <D.32991>:
                if (__result == 0) goto <D.32993>; else goto <D.32994>;
                <D.32993>:
                D.32995 = &MEM[(void *)"" + 1B];
                D.32996 = *D.32995;
                D.32997 = (int) D.32996;
                D.32998 = __s2 + 1;
                D.32999 = *D.32998;
                D.33000 = (int) D.32999;
                __result = D.32997 - D.33000;
                if (__s2_len > 1) goto <D.33001>; else goto <D.33002>;
                <D.33001>:
                if (__result == 0) goto <D.33003>; else goto <D.33004>;
                <D.33003>:
                D.33005 = &MEM[(void *)"" + 2B];
                D.33006 = *D.33005;
                D.33007 = (int) D.33006;
                D.33008 = __s2 + 2;
                D.33009 = *D.33008;
                D.33010 = (int) D.33009;
                __result = D.33007 - D.33010;
                if (__s2_len > 2) goto <D.33011>; else goto <D.33012>;
                <D.33011>:
                if (__result == 0) goto <D.33013>; else goto <D.33014>;
                <D.33013>:
                D.33015 = &MEM[(void *)"" + 3B];
                D.33016 = *D.33015;
                D.33017 = (int) D.33016;
                D.33018 = __s2 + 3;
                D.33019 = *D.33018;
                D.33020 = (int) D.33019;
                __result = D.33017 - D.33020;
                <D.33014>:
                <D.33012>:
                <D.33004>:
                <D.33002>:
                <D.32994>:
                <D.32992>:
              }
              D.25832 = __result;
            }
            iftmp.592 = -D.25832;
            goto <D.33021>;
            <D.32985>:
            D.33022 = MEM[(const unsigned char * {ref-all})ex_type];
            iftmp.592 = (int) D.33022;
            <D.33021>:
            D.25833 = iftmp.592;
          }
          if (D.25833 == 0) goto <D.32981>; else goto <D.33023>;
          <D.33023>:
          {
            size_t __s1_len;
            size_t __s2_len;

            D.25842 = __builtin_strcmp (ex_type, f);
          }
          if (D.25842 == 0) goto <D.32981>; else goto <D.32982>;
          <D.32981>:
          found = 1;
          <D.32982>:
          monoeg_g_free (f);
        }
        l = l->next;
        <D.25844>:
        if (l != 0B) goto <D.25843>; else goto <D.25845>;
        <D.25845>:
        if (found != 0) goto <D.33024>; else goto <D.33025>;
        <D.33024>:
        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.33025>:
      }
      <D.32977>:
      <D.32975>:
      <D.32972>:
      inited.591 = inited;
      if (inited.591 == 0) goto <D.33026>; else goto <D.33027>;
      <D.33026>:
      return;
      <D.33027>:
      D.33028 = mono_domain_get ();
      D.33029 = throw_ctx->sc_pc;
      D.33030 = (char *) D.33029;
      ji = mini_jit_info_table_find (D.33028, D.33030, 0B);
      if (catch_ctx != 0B) goto <D.33031>; else goto <D.33032>;
      <D.33031>:
      D.33033 = mono_domain_get ();
      D.33034 = catch_ctx->sc_pc;
      D.33035 = (char *) D.33034;
      catch_ji = mini_jit_info_table_find (D.33033, D.33035, 0B);
      goto <D.33036>;
      <D.33032>:
      catch_ji = 0B;
      <D.33036>:
      ei.exc = exc;
      D.33037 = catch_ctx != 0B;
      D.33038 = (int) D.33037;
      ei.caught = D.33038;
      mono_loader_lock ();
      i = 0;
      goto <D.25859>;
      <D.25858>:
      {
        struct EventRequest * req;

        event_requests.593 = event_requests;
        D.33040 = event_requests.593->pdata;
        i.594 = (unsigned int) i;
        D.33042 = i.594 * 4;
        D.33043 = D.33040 + D.33042;
        req = *D.33043;
        D.33044 = req->event_kind;
        if (D.33044 != 13) goto <D.33045>; else goto <D.33046>;
        <D.33045>:
        // predicted unlikely by continue predictor.
        goto <D.25847>;
        <D.33046>:
        j = 0;
        goto <D.25856>;
        <D.25855>:
        {
          struct Modifier * mod;

          mod = &req->modifiers[j];
          D.33047 = mod->kind;
          if (D.33047 == 11) goto <D.33048>; else goto <D.33049>;
          <D.33048>:
          if (catch_ji != 0B) goto <D.33050>; else goto <D.33051>;
          <D.33050>:
          {
            int k;
            gboolean found;
            struct MonoAssembly * * assemblies;

            found = 0;
            assemblies = mod->data.assemblies;
            if (assemblies != 0B) goto <D.33052>; else goto <D.33053>;
            <D.33052>:
            k = 0;
            goto <D.25853>;
            <D.25852>:
            k.595 = (unsigned int) k;
            D.33055 = k.595 * 4;
            D.33056 = assemblies + D.33055;
            D.33057 = *D.33056;
            D.33058 = jinfo_get_method (catch_ji);
            D.33059 = D.33058->klass;
            D.33060 = D.33059->image;
            D.33061 = D.33060->assembly;
            if (D.33057 == D.33061) goto <D.33062>; else goto <D.33063>;
            <D.33062>:
            found = 1;
            <D.33063>:
            k = k + 1;
            <D.25853>:
            k.595 = (unsigned int) k;
            D.33055 = k.595 * 4;
            D.33056 = assemblies + D.33055;
            D.33057 = *D.33056;
            if (D.33057 != 0B) goto <D.25852>; else goto <D.25854>;
            <D.25854>:
            <D.33053>:
            if (found == 0) goto <D.33064>; else goto <D.33065>;
            <D.33064>:
            ei.caught = 0;
            <D.33065>:
          }
          <D.33051>:
          <D.33049>:
        }
        j = j + 1;
        <D.25856>:
        D.33066 = req->nmodifiers;
        if (D.33066 > j) goto <D.25855>; else goto <D.25857>;
        <D.25857>:
      }
      <D.25847>:
      i = i + 1;
      <D.25859>:
      i.596 = (unsigned int) i;
      event_requests.593 = event_requests;
      D.33068 = event_requests.593->len;
      if (i.596 < D.33068) goto <D.25858>; else goto <D.25860>;
      <D.25860>:
      events = create_event_list (13, 0B, ji, &ei, &suspend_policy);
      mono_loader_unlock ();
      if (tls != 0B) goto <D.33069>; else goto <D.33070>;
      <D.33069>:
      D.33071 = ei.caught;
      if (D.33071 != 0) goto <D.33072>; else goto <D.33073>;
      <D.33072>:
      if (catch_ctx != 0B) goto <D.33074>; else goto <D.33075>;
      <D.33074>:
      D.33076 = &tls->catch_state;
      memset (D.33076, 0, 276);
      tls->catch_state.ctx = *catch_ctx;
      D.33077 = mono_domain_get ();
      tls->catch_state.unwind_data[0] = D.33077;
      tls->catch_state.valid = 1;
      <D.33075>:
      <D.33073>:
      <D.33070>:
      suspend_policy.597 = suspend_policy;
      process_event (13, &ei, 0, throw_ctx, events, suspend_policy.597);
      if (tls != 0B) goto <D.33079>; else goto <D.33080>;
      <D.33079>:
      tls->catch_state.valid = 0;
      <D.33080>:
    }
  finally
    {
      suspend_policy = {CLOBBER};
      ei = {CLOBBER};
    }
}


mono_debugger_agent_begin_exception_filter (struct MonoException * exc, struct MonoContext * ctx, struct MonoContext * orig_ctx)
{
  int inited.598;
  unsigned int debugger_tls_id.599;
  struct MonoThreadUnwindState * D.33090;
  int D.33091;
  _Bool D.33092;
  long int D.33093;
  long int D.33094;
  struct DebuggerTlsData * tls;

  inited.598 = inited;
  if (inited.598 == 0) goto <D.33085>; else goto <D.33086>;
  <D.33085>:
  return;
  <D.33086>:
  debugger_tls_id.599 = debugger_tls_id;
  tls = pthread_getspecific (debugger_tls_id.599);
  if (tls == 0B) goto <D.33088>; else goto <D.33089>;
  <D.33088>:
  return;
  <D.33089>:
  D.33090 = &tls->filter_state;
  D.33091 = mono_thread_state_init_from_monoctx (D.33090, orig_ctx);
  D.33092 = D.33091 == 0;
  D.33093 = (long int) D.33092;
  D.33094 = __builtin_expect (D.33093, 0);
  if (D.33094 != 0) goto <D.33095>; else goto <D.33096>;
  <D.33095>:
  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.33096>:
}


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

  inited.600 = inited;
  if (inited.600 == 0) goto <D.33099>; else goto <D.33100>;
  <D.33099>:
  return;
  <D.33100>:
  debugger_tls_id.601 = debugger_tls_id;
  tls = pthread_getspecific (debugger_tls_id.601);
  if (tls == 0B) goto <D.33102>; else goto <D.33103>;
  <D.33102>:
  return;
  <D.33103>:
  tls->filter_state.valid = 0;
}