mono_debugger_agent_parse_options (char * options)
{
  int D.27960;
  const gchar * D.27963;
  gchar * D.27964;
  int D.27966;
  const gchar * D.27969;
  gchar * D.27970;
  int D.27972;
  const char * D.27975;
  int D.27976;
  int D.27978;
  gchar * D.27981;
  int D.27983;
  char * D.27986;
  int D.27987;
  int D.27989;
  char * D.27992;
  int D.27993;
  int D.27995;
  char * D.27998;
  int D.27999;
  int D.28001;
  struct GSList * D.28004;
  gchar * D.28005;
  struct GSList * D.28006;
  int D.28008;
  gchar * D.28011;
  struct GSList * D.28012;
  int D.28014;
  int D.28017;
  const char * D.28020;
  int D.28021;
  int D.28023;
  const gchar * D.28026;
  gchar * D.28027;
  int D.28029;
  const char * D.28032;
  int D.28033;
  _Bool D.28034;
  int D.28035;
  int D.28037;
  int D.28040;
  int D.28042;
  int D.28045;
  char * D.28048;
  int D.28049;
  int D.28052;
  char * D.28055;
  unsigned int D.28058;
  unsigned int D.28059;
  unsigned int D.28060;
  gchar * D.28061;
  char * D.28062;
  struct _IO_FILE * stderr.0;
  int D.25338;
  int iftmp.1;
  int D.25337;
  const char[10] * D.28073;
  unsigned char D.28074;
  int D.28075;
  unsigned char D.28076;
  int D.28077;
  const unsigned char * D.28082;
  unsigned char D.28083;
  int D.28084;
  const unsigned char * D.28085;
  unsigned char D.28086;
  int D.28087;
  const unsigned char * D.28092;
  unsigned char D.28093;
  int D.28094;
  const unsigned char * D.28095;
  unsigned char D.28096;
  int D.28097;
  const unsigned char * D.28102;
  unsigned char D.28103;
  int D.28104;
  const unsigned char * D.28105;
  unsigned char D.28106;
  int D.28107;
  int D.28113;
  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.27958>; else goto <D.27959>;
      <D.27958>:
      options = monoeg_g_strdup_printf ("%s,%s", options, extra);
      <D.27959>:
      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.25328>;
      <D.25327>:
      {
        char * arg;

        arg = *ptr;
        D.27960 = strncmp (arg, "transport=", 10);
        if (D.27960 == 0) goto <D.27961>; else goto <D.27962>;
        <D.27961>:
        D.27963 = arg + 10;
        D.27964 = monoeg_strdup (D.27963);
        agent_config.transport = D.27964;
        goto <D.27965>;
        <D.27962>:
        D.27966 = strncmp (arg, "address=", 8);
        if (D.27966 == 0) goto <D.27967>; else goto <D.27968>;
        <D.27967>:
        D.27969 = arg + 8;
        D.27970 = monoeg_strdup (D.27969);
        agent_config.address = D.27970;
        goto <D.27971>;
        <D.27968>:
        D.27972 = strncmp (arg, "loglevel=", 9);
        if (D.27972 == 0) goto <D.27973>; else goto <D.27974>;
        <D.27973>:
        D.27975 = arg + 9;
        D.27976 = atoi (D.27975);
        agent_config.log_level = D.27976;
        goto <D.27977>;
        <D.27974>:
        D.27978 = strncmp (arg, "logfile=", 8);
        if (D.27978 == 0) goto <D.27979>; else goto <D.27980>;
        <D.27979>:
        D.27969 = arg + 8;
        D.27981 = monoeg_strdup (D.27969);
        agent_config.log_file = D.27981;
        goto <D.27982>;
        <D.27980>:
        D.27983 = strncmp (arg, "suspend=", 8);
        if (D.27983 == 0) goto <D.27984>; else goto <D.27985>;
        <D.27984>:
        D.27986 = arg + 8;
        D.27987 = parse_flag ("suspend", D.27986);
        agent_config.suspend = D.27987;
        goto <D.27988>;
        <D.27985>:
        D.27989 = strncmp (arg, "server=", 7);
        if (D.27989 == 0) goto <D.27990>; else goto <D.27991>;
        <D.27990>:
        D.27992 = arg + 7;
        D.27993 = parse_flag ("server", D.27992);
        agent_config.server = D.27993;
        goto <D.27994>;
        <D.27991>:
        D.27995 = strncmp (arg, "onuncaught=", 11);
        if (D.27995 == 0) goto <D.27996>; else goto <D.27997>;
        <D.27996>:
        D.27998 = arg + 11;
        D.27999 = parse_flag ("onuncaught", D.27998);
        agent_config.onuncaught = D.27999;
        goto <D.28000>;
        <D.27997>:
        D.28001 = strncmp (arg, "onthrow=", 8);
        if (D.28001 == 0) goto <D.28002>; else goto <D.28003>;
        <D.28002>:
        D.28004 = agent_config.onthrow;
        D.27969 = arg + 8;
        D.28005 = monoeg_strdup (D.27969);
        D.28006 = monoeg_g_slist_append (D.28004, D.28005);
        agent_config.onthrow = D.28006;
        goto <D.28007>;
        <D.28003>:
        D.28008 = strncmp (arg, "onthrow", 7);
        if (D.28008 == 0) goto <D.28009>; else goto <D.28010>;
        <D.28009>:
        D.28004 = agent_config.onthrow;
        D.28011 = monoeg_strdup ("");
        D.28012 = monoeg_g_slist_append (D.28004, D.28011);
        agent_config.onthrow = D.28012;
        goto <D.28013>;
        <D.28010>:
        D.28014 = strncmp (arg, "help", 4);
        if (D.28014 == 0) goto <D.28015>; else goto <D.28016>;
        <D.28015>:
        print_usage ();
        exit (0);
        <D.28016>:
        D.28017 = strncmp (arg, "timeout=", 8);
        if (D.28017 == 0) goto <D.28018>; else goto <D.28019>;
        <D.28018>:
        D.28020 = arg + 8;
        D.28021 = atoi (D.28020);
        agent_config.timeout = D.28021;
        goto <D.28022>;
        <D.28019>:
        D.28023 = strncmp (arg, "launch=", 7);
        if (D.28023 == 0) goto <D.28024>; else goto <D.28025>;
        <D.28024>:
        D.28026 = arg + 7;
        D.28027 = monoeg_strdup (D.28026);
        agent_config.launch = D.28027;
        goto <D.28028>;
        <D.28025>:
        D.28029 = strncmp (arg, "embedding=", 10);
        if (D.28029 == 0) goto <D.28030>; else goto <D.28031>;
        <D.28030>:
        D.28032 = arg + 10;
        D.28033 = atoi (D.28032);
        D.28034 = D.28033 == 1;
        D.28035 = (int) D.28034;
        agent_config.embedding = D.28035;
        goto <D.28036>;
        <D.28031>:
        D.28037 = strncmp (arg, "keepalive=", 10);
        if (D.28037 == 0) goto <D.28038>; else goto <D.28039>;
        <D.28038>:
        D.28032 = arg + 10;
        D.28040 = atoi (D.28032);
        agent_config.keepalive = D.28040;
        goto <D.28041>;
        <D.28039>:
        D.28042 = strncmp (arg, "setpgid=", 8);
        if (D.28042 == 0) goto <D.28043>; else goto <D.28044>;
        <D.28043>:
        D.27986 = arg + 8;
        D.28045 = parse_flag ("setpgid", D.27986);
        agent_config.setpgid = D.28045;
        goto <D.28046>;
        <D.28044>:
        print_usage ();
        exit (1);
        <D.28046>:
        <D.28041>:
        <D.28036>:
        <D.28028>:
        <D.28022>:
        <D.28013>:
        <D.28007>:
        <D.28000>:
        <D.27994>:
        <D.27988>:
        <D.27982>:
        <D.27977>:
        <D.27971>:
        <D.27965>:
      }
      ptr = ptr + 8;
      <D.25328>:
      if (ptr != 0B) goto <D.28047>; else goto <D.25329>;
      <D.28047>:
      D.28048 = *ptr;
      if (D.28048 != 0B) goto <D.25327>; else goto <D.25329>;
      <D.25329>:
      D.28049 = agent_config.server;
      if (D.28049 != 0) goto <D.28050>; else goto <D.28051>;
      <D.28050>:
      D.28052 = agent_config.suspend;
      if (D.28052 == 0) goto <D.28053>; else goto <D.28054>;
      <D.28053>:
      agent_config.defer = 1;
      D.28055 = agent_config.address;
      if (D.28055 == 0B) goto <D.28056>; else goto <D.28057>;
      <D.28056>:
      D.28058 = GetCurrentProcessId ();
      D.28059 = D.28058 % 1000;
      D.28060 = D.28059 + 56000;
      D.28061 = monoeg_g_strdup_printf ("0.0.0.0:%u", D.28060);
      agent_config.address = D.28061;
      <D.28057>:
      <D.28054>:
      <D.28051>:
      D.28062 = agent_config.transport;
      if (D.28062 == 0B) goto <D.28063>; else goto <D.28064>;
      <D.28063>:
      stderr.0 = stderr;
      fprintf (stderr.0, "debugger-agent: The \'transport\' option is mandatory.\n");
      exit (1);
      <D.28064>:
      D.28055 = agent_config.address;
      if (D.28055 == 0B) goto <D.28066>; else goto <D.28067>;
      <D.28066>:
      D.28049 = agent_config.server;
      if (D.28049 == 0) goto <D.28068>; else goto <D.28069>;
      <D.28068>:
      stderr.0 = stderr;
      fprintf (stderr.0, "debugger-agent: The \'address\' option is mandatory.\n");
      exit (1);
      <D.28069>:
      <D.28067>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          __s2 = agent_config.transport;
          D.28073 = "dt_socket";
          D.28074 = MEM[(const unsigned char *)D.28073];
          D.28075 = (int) D.28074;
          D.28076 = *__s2;
          D.28077 = (int) D.28076;
          __result = D.28075 - D.28077;
          {
            if (__s2_len != 0) goto <D.28078>; else goto <D.28079>;
            <D.28078>:
            if (__result == 0) goto <D.28080>; else goto <D.28081>;
            <D.28080>:
            D.28082 = &MEM[(void *)"dt_socket" + 1B];
            D.28083 = *D.28082;
            D.28084 = (int) D.28083;
            D.28085 = __s2 + 1;
            D.28086 = *D.28085;
            D.28087 = (int) D.28086;
            __result = D.28084 - D.28087;
            if (__s2_len > 1) goto <D.28088>; else goto <D.28089>;
            <D.28088>:
            if (__result == 0) goto <D.28090>; else goto <D.28091>;
            <D.28090>:
            D.28092 = &MEM[(void *)"dt_socket" + 2B];
            D.28093 = *D.28092;
            D.28094 = (int) D.28093;
            D.28095 = __s2 + 2;
            D.28096 = *D.28095;
            D.28097 = (int) D.28096;
            __result = D.28094 - D.28097;
            if (__s2_len > 2) goto <D.28098>; else goto <D.28099>;
            <D.28098>:
            if (__result == 0) goto <D.28100>; else goto <D.28101>;
            <D.28100>:
            D.28102 = &MEM[(void *)"dt_socket" + 3B];
            D.28103 = *D.28102;
            D.28104 = (int) D.28103;
            D.28105 = __s2 + 3;
            D.28106 = *D.28105;
            D.28107 = (int) D.28106;
            __result = D.28104 - D.28107;
            <D.28101>:
            <D.28099>:
            <D.28091>:
            <D.28089>:
            <D.28081>:
            <D.28079>:
          }
          D.25337 = __result;
        }
        iftmp.1 = -D.25337;
        goto <D.28108>;
        <D.28072>:
        D.28062 = agent_config.transport;
        iftmp.1 = __builtin_strcmp (D.28062, "dt_socket");
        <D.28108>:
        D.25338 = iftmp.1;
      }
      if (D.25338 == 0) goto <D.28109>; else goto <D.28110>;
      <D.28109>:
      D.28055 = agent_config.address;
      if (D.28055 != 0B) goto <D.28111>; else goto <D.28112>;
      <D.28111>:
      D.28055 = agent_config.address;
      D.28113 = parse_address (D.28055, &host, &port);
      if (D.28113 != 0) goto <D.28114>; else goto <D.28115>;
      <D.28114>:
      stderr.0 = stderr;
      fprintf (stderr.0, "debugger-agent: The format of the \'address\' options is \'<host>:<port>\'\n");
      exit (1);
      <D.28115>:
      <D.28112>:
      <D.28110>:
    }
  finally
    {
      host = {CLOBBER};
      port = {CLOBBER};
    }
}


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

  if (str != 0B) goto <D.28116>; else goto <D.28117>;
  <D.28116>:
  D.28118 = __strdup (str);
  return D.28118;
  <D.28117>:
  D.28118 = 0B;
  return D.28118;
}


atoi (const char * __nptr)
{
  int D.28120;
  long int D.28121;

  D.28121 = strtol (__nptr, 0B, 10);
  D.28120 = (int) D.28121;
  return D.28120;
}


parse_flag (const char * option, char * flag)
{
  int D.25173;
  int iftmp.2;
  int D.25172;
  const char[2] * D.28126;
  unsigned char D.28127;
  int D.28128;
  unsigned char D.28129;
  int D.28130;
  const unsigned char * D.28135;
  unsigned char D.28136;
  int D.28137;
  const unsigned char * D.28138;
  unsigned char D.28139;
  int D.28140;
  const unsigned char * D.28145;
  unsigned char D.28146;
  int D.28147;
  const unsigned char * D.28148;
  unsigned char D.28149;
  int D.28150;
  const unsigned char * D.28155;
  unsigned char D.28156;
  int D.28157;
  const unsigned char * D.28158;
  unsigned char D.28159;
  int D.28160;
  gboolean D.28164;
  int D.25182;
  int iftmp.3;
  int D.25181;
  const char[2] * D.28168;
  unsigned char D.28169;
  int D.28170;
  unsigned char D.28171;
  int D.28172;
  const unsigned char * D.28177;
  unsigned char D.28178;
  int D.28179;
  const unsigned char * D.28180;
  unsigned char D.28181;
  int D.28182;
  const unsigned char * D.28187;
  unsigned char D.28188;
  int D.28189;
  const unsigned char * D.28190;
  unsigned char D.28191;
  int D.28192;
  const unsigned char * D.28197;
  unsigned char D.28198;
  int D.28199;
  const unsigned char * D.28200;
  unsigned char D.28201;
  int D.28202;
  struct _IO_FILE * stderr.4;

  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = flag;
      D.28126 = "y";
      D.28127 = MEM[(const unsigned char *)D.28126];
      D.28128 = (int) D.28127;
      D.28129 = *__s2;
      D.28130 = (int) D.28129;
      __result = D.28128 - D.28130;
      {
        if (__s2_len != 0) goto <D.28131>; else goto <D.28132>;
        <D.28131>:
        if (__result == 0) goto <D.28133>; else goto <D.28134>;
        <D.28133>:
        D.28135 = &MEM[(void *)"y" + 1B];
        D.28136 = *D.28135;
        D.28137 = (int) D.28136;
        D.28138 = __s2 + 1;
        D.28139 = *D.28138;
        D.28140 = (int) D.28139;
        __result = D.28137 - D.28140;
        if (__s2_len > 1) goto <D.28141>; else goto <D.28142>;
        <D.28141>:
        if (__result == 0) goto <D.28143>; else goto <D.28144>;
        <D.28143>:
        D.28145 = &MEM[(void *)"y" + 2B];
        D.28146 = *D.28145;
        D.28147 = (int) D.28146;
        D.28148 = __s2 + 2;
        D.28149 = *D.28148;
        D.28150 = (int) D.28149;
        __result = D.28147 - D.28150;
        if (__s2_len > 2) goto <D.28151>; else goto <D.28152>;
        <D.28151>:
        if (__result == 0) goto <D.28153>; else goto <D.28154>;
        <D.28153>:
        D.28155 = &MEM[(void *)"y" + 3B];
        D.28156 = *D.28155;
        D.28157 = (int) D.28156;
        D.28158 = __s2 + 3;
        D.28159 = *D.28158;
        D.28160 = (int) D.28159;
        __result = D.28157 - D.28160;
        <D.28154>:
        <D.28152>:
        <D.28144>:
        <D.28142>:
        <D.28134>:
        <D.28132>:
      }
      D.25172 = __result;
    }
    iftmp.2 = -D.25172;
    goto <D.28161>;
    <D.28125>:
    iftmp.2 = __builtin_strcmp (flag, "y");
    <D.28161>:
    D.25173 = iftmp.2;
  }
  if (D.25173 == 0) goto <D.28162>; else goto <D.28163>;
  <D.28162>:
  D.28164 = 1;
  return D.28164;
  <D.28163>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = flag;
      D.28168 = "n";
      D.28169 = MEM[(const unsigned char *)D.28168];
      D.28170 = (int) D.28169;
      D.28171 = *__s2;
      D.28172 = (int) D.28171;
      __result = D.28170 - D.28172;
      {
        if (__s2_len != 0) goto <D.28173>; else goto <D.28174>;
        <D.28173>:
        if (__result == 0) goto <D.28175>; else goto <D.28176>;
        <D.28175>:
        D.28177 = &MEM[(void *)"n" + 1B];
        D.28178 = *D.28177;
        D.28179 = (int) D.28178;
        D.28180 = __s2 + 1;
        D.28181 = *D.28180;
        D.28182 = (int) D.28181;
        __result = D.28179 - D.28182;
        if (__s2_len > 1) goto <D.28183>; else goto <D.28184>;
        <D.28183>:
        if (__result == 0) goto <D.28185>; else goto <D.28186>;
        <D.28185>:
        D.28187 = &MEM[(void *)"n" + 2B];
        D.28188 = *D.28187;
        D.28189 = (int) D.28188;
        D.28190 = __s2 + 2;
        D.28191 = *D.28190;
        D.28192 = (int) D.28191;
        __result = D.28189 - D.28192;
        if (__s2_len > 2) goto <D.28193>; else goto <D.28194>;
        <D.28193>:
        if (__result == 0) goto <D.28195>; else goto <D.28196>;
        <D.28195>:
        D.28197 = &MEM[(void *)"n" + 3B];
        D.28198 = *D.28197;
        D.28199 = (int) D.28198;
        D.28200 = __s2 + 3;
        D.28201 = *D.28200;
        D.28202 = (int) D.28201;
        __result = D.28199 - D.28202;
        <D.28196>:
        <D.28194>:
        <D.28186>:
        <D.28184>:
        <D.28176>:
        <D.28174>:
      }
      D.25181 = __result;
    }
    iftmp.3 = -D.25181;
    goto <D.28203>;
    <D.28167>:
    iftmp.3 = __builtin_strcmp (flag, "n");
    <D.28203>:
    D.25182 = iftmp.3;
  }
  if (D.25182 == 0) goto <D.28204>; else goto <D.28205>;
  <D.28204>:
  D.28164 = 0;
  return D.28164;
  <D.28205>:
  stderr.4 = stderr;
  fprintf (stderr.4, "debugger-agent: The valid values for the \'%s\' option are \'y\' and \'n\'.\n", option);
  exit (1);
  D.28164 = 0;
  return D.28164;
}


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.28212;
  long int pos.6;
  long int address.7;
  long int D.28215;
  long int D.28216;
  long unsigned int D.28217;
  void * D.28218;
  char * D.28219;
  long unsigned int D.28220;
  sizetype D.28221;
  char * D.28222;
  const char * D.28223;
  int D.28224;
  char * pos;

  pos = __builtin_strchr (address, 58);
  if (pos == 0B) goto <D.28209>; else goto <D.28211>;
  <D.28211>:
  if (pos == address) goto <D.28209>; else goto <D.28210>;
  <D.28209>:
  D.28212 = 1;
  return D.28212;
  <D.28210>:
  pos.6 = (long int) pos;
  address.7 = (long int) address;
  D.28215 = pos.6 - address.7;
  D.28216 = D.28215 + 1;
  D.28217 = (long unsigned int) D.28216;
  D.28218 = monoeg_malloc (D.28217);
  *host = D.28218;
  D.28219 = *host;
  pos.6 = (long int) pos;
  address.7 = (long int) address;
  D.28215 = pos.6 - address.7;
  D.28220 = (long unsigned int) D.28215;
  strncpy (D.28219, address, D.28220);
  D.28219 = *host;
  pos.6 = (long int) pos;
  address.7 = (long int) address;
  D.28215 = pos.6 - address.7;
  D.28221 = (sizetype) D.28215;
  D.28222 = D.28219 + D.28221;
  *D.28222 = 0;
  D.28223 = pos + 1;
  D.28224 = atoi (D.28223);
  *port = D.28224;
  D.28212 = 0;
  return D.28212;
}


strncpy (char * restrict __dest, const char * restrict __src, size_t __len)
{
  char * D.28226;
  long unsigned int D.28227;

  D.28227 = __builtin_object_size (__dest, 1);
  D.28226 = __builtin___strncpy_chk (__dest, __src, __len, D.28227);
  return D.28226;
}


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

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


mono_debugger_agent_init ()
{
  int D.28231;
  struct GPtrArray * event_requests.8;
  struct MonoGHashTable * thread_to_tls.9;
  int D.28236;
  struct MonoGHashTable * tid_to_thread.10;
  int D.28240;
  struct MonoGHashTable * tid_to_thread_obj.11;
  int D.28244;
  struct GPtrArray * pending_assembly_loads.12;
  struct GHashTable * domains.13;
  int log_level.14;
  int embedding.15;
  char * D.28251;
  struct FILE * log_file.16;
  struct FILE * log_file.17;
  struct _IO_FILE * stderr.18;
  int * D.28259;
  int D.28260;
  char * D.28261;
  struct _IO_FILE * stdout.19;
  struct MonoDebugOptions * D.28264;
  struct MonoDebugOptions * D.28265;
  struct MonoDebugOptions * D.28266;
  int D.28267;
  int D.28270;
  struct GSList * D.28273;

  D.28231 = agent_config.enabled;
  if (D.28231 == 0) goto <D.28232>; else goto <D.28233>;
  <D.28232>:
  return;
  <D.28233>:
  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.28236 = mono_gc_is_moving ();
  if (D.28236 == 0) goto <D.28237>; else goto <D.28238>;
  <D.28237>:
  mono_gc_register_root (&thread_to_tls, 8, 0B);
  <D.28238>:
  tid_to_thread.10 = mono_g_hash_table_new_type (0B, 0B, 2);
  tid_to_thread = tid_to_thread.10;
  D.28240 = mono_gc_is_moving ();
  if (D.28240 == 0) goto <D.28241>; else goto <D.28242>;
  <D.28241>:
  mono_gc_register_root (&tid_to_thread, 8, 0B);
  <D.28242>:
  tid_to_thread_obj.11 = mono_g_hash_table_new_type (0B, 0B, 2);
  tid_to_thread_obj = tid_to_thread_obj.11;
  D.28244 = mono_gc_is_moving ();
  if (D.28244 == 0) goto <D.28245>; else goto <D.28246>;
  <D.28245>:
  mono_gc_register_root (&tid_to_thread_obj, 8, 0B);
  <D.28246>:
  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.28251 = agent_config.log_file;
  if (D.28251 != 0B) goto <D.28252>; else goto <D.28253>;
  <D.28252>:
  D.28251 = agent_config.log_file;
  log_file.16 = fopen (D.28251, "w+");
  log_file = log_file.16;
  log_file.17 = log_file;
  if (log_file.17 == 0B) goto <D.28256>; else goto <D.28257>;
  <D.28256>:
  stderr.18 = stderr;
  D.28251 = agent_config.log_file;
  D.28259 = __errno_location ();
  D.28260 = *D.28259;
  D.28261 = strerror (D.28260);
  fprintf (stderr.18, "Unable to create log file \'%s\': %s.\n", D.28251, D.28261);
  exit (1);
  <D.28257>:
  goto <D.28262>;
  <D.28253>:
  stdout.19 = stdout;
  log_file = stdout.19;
  <D.28262>:
  ids_init ();
  objrefs_init ();
  breakpoints_init ();
  suspend_init ();
  D.28264 = mini_get_debug_options ();
  D.28264->gen_seq_points = 1;
  D.28265 = mini_get_debug_options ();
  D.28265->mdb_optimizations = 1;
  mono_disable_optimizations (128);
  D.28266 = mini_get_debug_options ();
  D.28266->load_aot_jit_info_eagerly = 1;
  D.28267 = agent_config.setpgid;
  if (D.28267 != 0) goto <D.28268>; else goto <D.28269>;
  <D.28268>:
  setpgid (0, 0);
  <D.28269>:
  D.28270 = agent_config.onuncaught;
  if (D.28270 == 0) goto <D.28271>; else goto <D.28272>;
  <D.28271>:
  D.28273 = agent_config.onthrow;
  if (D.28273 == 0B) goto <D.28274>; else goto <D.28275>;
  <D.28274>:
  finish_agent_init (1);
  <D.28275>:
  <D.28272>:
}


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.28285;
  struct MonoInternalThread * D.28286;
  struct GPtrArray * event_requests.23;
  void * * D.28288;
  long unsigned int D.28289;
  long unsigned int D.28290;
  void * * D.28291;
  int D.28292;
  void * D.28295;
  unsigned int i.24;
  unsigned int D.28297;
  int i;
  void * stackptr;

  stackptr = __builtin_frame_address (1);
  embedding.20 = embedding;
  if (embedding.20 == 0) goto <D.28277>; else goto <D.28280>;
  <D.28280>:
  ss_req.21 = ss_req;
  if (ss_req.21 == 0B) goto <D.28277>; else goto <D.28282>;
  <D.28282>:
  ss_invoke_addr.22 = ss_invoke_addr;
  if (stackptr != ss_invoke_addr.22) goto <D.28277>; else goto <D.28284>;
  <D.28284>:
  ss_req.21 = ss_req;
  D.28285 = ss_req.21->thread;
  D.28286 = mono_thread_internal_current ();
  if (D.28285 != D.28286) goto <D.28277>; else goto <D.28278>;
  <D.28277>:
  return;
  <D.28278>:
  mono_loader_lock ();
  ss_invoke_addr = 0B;
  i = 0;
  goto <D.26269>;
  <D.26268>:
  {
    struct EventRequest * req;

    event_requests.23 = event_requests;
    D.28288 = event_requests.23->pdata;
    D.28289 = (long unsigned int) i;
    D.28290 = D.28289 * 8;
    D.28291 = D.28288 + D.28290;
    req = *D.28291;
    D.28292 = req->event_kind;
    if (D.28292 == 11) goto <D.28293>; else goto <D.28294>;
    <D.28293>:
    D.28295 = req->info;
    ss_destroy (D.28295);
    event_requests.23 = event_requests;
    i.24 = (unsigned int) i;
    monoeg_g_ptr_array_remove_index_fast (event_requests.23, i.24);
    monoeg_g_free (req);
    goto <D.26267>;
    <D.28294>:
  }
  i = i + 1;
  <D.26269>:
  i.24 = (unsigned int) i;
  event_requests.23 = event_requests;
  D.28297 = event_requests.23->len;
  if (i.24 < D.28297) goto <D.26268>; else goto <D.26267>;
  <D.26267>:
  mono_loader_unlock ();
}


ss_destroy (struct SingleStepReq * req)
{
  struct SingleStepReq * ss_req.25;
  _Bool D.28300;
  long int D.28301;
  long int D.28302;

  ss_req.25 = ss_req;
  D.28300 = ss_req.25 != req;
  D.28301 = (long int) D.28300;
  D.28302 = __builtin_expect (D.28301, 0);
  if (D.28302 != 0) goto <D.28303>; else goto <D.28304>;
  <D.28303>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 5255, "ss_req == req");
  <D.28304>:
  ss_req.25 = ss_req;
  ss_stop (ss_req.25);
  ss_req.25 = ss_req;
  monoeg_g_free (ss_req.25);
  ss_req = 0B;
}


ss_stop (struct SingleStepReq * ss_req)
{
  struct GSList * D.28305;
  void * D.28308;
  int D.28309;

  D.28305 = ss_req->bps;
  if (D.28305 != 0B) goto <D.28306>; else goto <D.28307>;
  <D.28306>:
  {
    struct GSList * l;

    l = ss_req->bps;
    goto <D.26586>;
    <D.26585>:
    D.28308 = l->data;
    clear_breakpoint (D.28308);
    l = l->next;
    <D.26586>:
    if (l != 0B) goto <D.26585>; else goto <D.26587>;
    <D.26587>:
    D.28305 = ss_req->bps;
    monoeg_g_slist_free (D.28305);
    ss_req->bps = 0B;
  }
  <D.28307>:
  D.28309 = ss_req->global;
  if (D.28309 != 0) goto <D.28310>; else goto <D.28311>;
  <D.28310>:
  stop_single_stepping ();
  ss_req->global = 0;
  <D.28311>:
}


clear_breakpoint (struct MonoBreakpoint * bp)
{
  struct GPtrArray * D.28312;
  void * * D.28313;
  long unsigned int D.28314;
  long unsigned int D.28315;
  void * * D.28316;
  unsigned int i.26;
  unsigned int D.28318;
  struct GPtrArray * breakpoints.27;
  int i;

  i = 0;
  goto <D.26409>;
  <D.26408>:
  {
    struct BreakpointInstance * inst;

    D.28312 = bp->children;
    D.28313 = D.28312->pdata;
    D.28314 = (long unsigned int) i;
    D.28315 = D.28314 * 8;
    D.28316 = D.28313 + D.28315;
    inst = *D.28316;
    remove_breakpoint (inst);
    monoeg_g_free (inst);
  }
  i = i + 1;
  <D.26409>:
  i.26 = (unsigned int) i;
  D.28312 = bp->children;
  D.28318 = D.28312->len;
  if (i.26 < D.28318) goto <D.26408>; else goto <D.26410>;
  <D.26410>:
  mono_loader_lock ();
  breakpoints.27 = breakpoints;
  monoeg_g_ptr_array_remove (breakpoints.27, bp);
  mono_loader_unlock ();
  D.28312 = bp->children;
  monoeg_g_ptr_array_free (D.28312, 1);
  monoeg_g_free (bp);
}


remove_breakpoint (struct BreakpointInstance * inst)
{
  struct GHashTable * bp_locs.28;
  void * D.28321;
  long int D.28322;
  int D.28323;
  long int D.28324;
  void * D.28325;
  _Bool D.28326;
  long int D.28327;
  long int D.28328;
  long int D.28333;
  int count;
  struct MonoJitInfo * ji;
  guint8 * ip;

  ji = inst->ji;
  ip = inst->ip;
  mono_loader_lock ();
  bp_locs.28 = bp_locs;
  D.28321 = monoeg_g_hash_table_lookup (bp_locs.28, ip);
  D.28322 = (long int) D.28321;
  count = (int) D.28322;
  bp_locs.28 = bp_locs;
  D.28323 = count + -1;
  D.28324 = (long int) D.28323;
  D.28325 = (void *) D.28324;
  monoeg_g_hash_table_insert_replace (bp_locs.28, ip, D.28325, 0);
  mono_loader_unlock ();
  D.28326 = count <= 0;
  D.28327 = (long int) D.28326;
  D.28328 = __builtin_expect (D.28327, 0);
  if (D.28328 != 0) goto <D.28329>; else goto <D.28330>;
  <D.28329>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 4193, "count > 0");
  <D.28330>:
  if (count == 1) goto <D.28331>; else goto <D.28332>;
  <D.28331>:
  D.28333 = inst->native_offset;
  if (D.28333 != -1) goto <D.28334>; else goto <D.28335>;
  <D.28334>:
  mono_arch_clear_breakpoint (ji, ip);
  <D.28335>:
  <D.28332>:
}


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

  val = InterlockedDecrement (&ss_count);
  if (val == 0) goto <D.28336>; else goto <D.28337>;
  <D.28336>:
  mono_arch_stop_single_stepping ();
  <D.28337>:
  ss_req.29 = ss_req;
  if (ss_req.29 != 0B) goto <D.28339>; else goto <D.28340>;
  <D.28339>:
  ss_invoke_addr = 0B;
  <D.28340>:
}


InterlockedDecrement (volatile gint32 * val)
{
  gint32 D.28341;
  unsigned int D.28342;

  D.28342 = __sync_sub_and_fetch_4 (val, 1);
  D.28341 = (gint32) D.28342;
  return D.28341;
}


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

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


jit_end (struct MonoProfiler * prof, struct MonoMethod * method, struct MonoJitInfo * jinfo, int result)
{
  struct GPtrArray * pending_assembly_loads.31;
  unsigned int D.28348;
  void * * D.28351;
  struct MonoClass * D.28353;

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

    assembly = 0B;
    mono_loader_lock ();
    pending_assembly_loads.31 = pending_assembly_loads;
    D.28348 = pending_assembly_loads.31->len;
    if (D.28348 != 0) goto <D.28349>; else goto <D.28350>;
    <D.28349>:
    pending_assembly_loads.31 = pending_assembly_loads;
    D.28351 = pending_assembly_loads.31->pdata;
    assembly = *D.28351;
    pending_assembly_loads.31 = pending_assembly_loads;
    monoeg_g_ptr_array_remove_index (pending_assembly_loads.31, 0);
    <D.28350>:
    mono_loader_unlock ();
    if (assembly != 0B) goto <D.28352>; else goto <D.26292>;
    <D.28352>:
    process_profiler_event (8, assembly);
  }
  goto <D.26293>;
  <D.26292>:
  D.28353 = method->klass;
  send_type_load (D.28353);
  if (result == 0) goto <D.28354>; else goto <D.28355>;
  <D.28354>:
  add_pending_breakpoints (method, jinfo);
  <D.28355>:
}


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

  try
    {
      ei_arg = 0B;
      if (event == 12) goto <D.28356>; else goto <D.28357>;
      <D.28356>:
      ei.klass = arg;
      ei_arg = &ei;
      <D.28357>:
      mono_loader_lock ();
      events = create_event_list (event, 0B, 0B, ei_arg, &suspend_policy);
      mono_loader_unlock ();
      suspend_policy.32 = suspend_policy;
      process_event (event, arg, 0, 0B, events, suspend_policy.32);
    }
  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.28363;
  void * * D.28364;
  long unsigned int D.28365;
  long unsigned int D.28366;
  void * * D.28367;
  int D.28368;
  unsigned int D.28369;
  <unnamed type> D.28372;
  int D.28375;
  int D.28380;
  struct MonoInternalThread * D.28386;
  struct MonoInternalThread * D.28387;
  struct MonoClass * D.28395;
  int D.28398;
  struct MonoObject * D.28401;
  struct MonoVTable * D.28402;
  struct MonoClass * D.28403;
  int D.28404;
  int D.28413;
  int D.28416;
  int D.28421;
  long unsigned int D.28430;
  long unsigned int D.28431;
  struct MonoAssembly * * D.28432;
  struct MonoAssembly * D.28433;
  struct MonoMethod * D.28434;
  struct MonoClass * D.28435;
  struct MonoImage * D.28436;
  struct MonoAssembly * D.28437;
  struct MonoClass * D.28446;
  struct GPtrArray * source_file_list.33;
  void * * D.28451;
  long unsigned int D.28452;
  long unsigned int D.28453;
  void * * D.28454;
  char * D.28455;
  struct GHashTable * D.28456;
  void * D.28457;
  void * D.28461;
  unsigned int i.34;
  unsigned int D.28465;
  struct MonoType * D.28473;
  struct GHashTable * D.28474;
  void * D.28475;
  <unnamed type> D.28480;
  unsigned int D.28481;
  struct MonoMethod * D.28486;
  short unsigned int D.28487;
  int D.28488;
  int D.28489;
  int D.26126;
  int iftmp.35;
  int D.26125;
  struct MonoMethod * D.28495;
  const char[7] * D.28496;
  unsigned char D.28497;
  int D.28498;
  unsigned char D.28499;
  int D.28500;
  const unsigned char * D.28505;
  unsigned char D.28506;
  int D.28507;
  const unsigned char * D.28508;
  unsigned char D.28509;
  int D.28510;
  const unsigned char * D.28515;
  unsigned char D.28516;
  int D.28517;
  const unsigned char * D.28518;
  unsigned char D.28519;
  int D.28520;
  const unsigned char * D.28525;
  unsigned char D.28526;
  int D.28527;
  const unsigned char * D.28528;
  unsigned char D.28529;
  int D.28530;
  struct MonoMethod * D.28532;
  const char * D.28533;
  unsigned int D.28536;
  struct MonoClass * klass.36;
  struct MonoImage * D.28544;
  struct MonoClass * klass.37;
  _Bool D.28546;
  long int D.28547;
  long int D.28548;
  long unsigned int D.28551;
  long unsigned int D.28552;
  struct MonoMethod * D.28555;
  int D.28558;
  long unsigned int D.28561;
  unsigned int D.28564;
  struct MonoClass * klass.38;
  struct MonoClass * klass.39;
  _Bool D.28573;
  long int D.28574;
  long int D.28575;
  long unsigned int D.28578;
  struct MonoMethod * D.28581;
  int D.28584;
  struct MonoMethod * D.28587;
  struct MonoClass * D.28588;
  int D.28591;
  long unsigned int D.28594;
  int D.28597;
  int D.28600;
  int D.28601;
  int D.28602;
  int D.28603;
  long int D.28604;
  void * D.28605;
  unsigned int i.40;
  unsigned int D.28607;
  int i;
  int j;
  struct GSList * events;

  events = 0B;
  *suspend_policy = 0;
  if (reqs == 0B) goto <D.28359>; else goto <D.28360>;
  <D.28359>:
  reqs = event_requests;
  <D.28360>:
  if (reqs == 0B) goto <D.28361>; else goto <D.28362>;
  <D.28361>:
  D.28363 = 0B;
  return D.28363;
  <D.28362>:
  i = 0;
  goto <D.26135>;
  <D.26134>:
  {
    struct EventRequest * req;

    D.28364 = reqs->pdata;
    D.28365 = (long unsigned int) i;
    D.28366 = D.28365 * 8;
    D.28367 = D.28364 + D.28366;
    req = *D.28367;
    D.28368 = req->event_kind;
    D.28369 = (unsigned int) D.28368;
    if (D.28369 == event) goto <D.28370>; else goto <D.28371>;
    <D.28370>:
    {
      gboolean filtered;

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

        mod = &req->modifiers[j];
        D.28372 = mod->kind;
        if (D.28372 == 1) goto <D.28373>; else goto <D.28374>;
        <D.28373>:
        filtered = 1;
        D.28375 = mod->data.count;
        if (D.28375 > 0) goto <D.28376>; else goto <D.28377>;
        <D.28376>:
        D.28375 = mod->data.count;
        if (D.28375 > 0) goto <D.28378>; else goto <D.28379>;
        <D.28378>:
        D.28375 = mod->data.count;
        D.28380 = D.28375 + -1;
        mod->data.count = D.28380;
        D.28375 = mod->data.count;
        if (D.28375 == 0) goto <D.28381>; else goto <D.28382>;
        <D.28381>:
        filtered = 0;
        <D.28382>:
        <D.28379>:
        <D.28377>:
        goto <D.28383>;
        <D.28374>:
        D.28372 = mod->kind;
        if (D.28372 == 3) goto <D.28384>; else goto <D.28385>;
        <D.28384>:
        D.28386 = mod->data.thread;
        D.28387 = mono_thread_internal_current ();
        if (D.28386 != D.28387) goto <D.28388>; else goto <D.28389>;
        <D.28388>:
        filtered = 1;
        <D.28389>:
        goto <D.28390>;
        <D.28385>:
        D.28372 = mod->kind;
        if (D.28372 == 8) goto <D.28393>; else goto <D.28391>;
        <D.28393>:
        if (ei != 0B) goto <D.28394>; else goto <D.28391>;
        <D.28394>:
        D.28395 = mod->data.exc_class;
        if (D.28395 != 0B) goto <D.28396>; else goto <D.28397>;
        <D.28396>:
        D.28398 = mod->subclasses;
        if (D.28398 != 0) goto <D.28399>; else goto <D.28400>;
        <D.28399>:
        D.28395 = mod->data.exc_class;
        D.28401 = ei->exc;
        D.28402 = D.28401->vtable;
        D.28403 = D.28402->klass;
        D.28404 = mono_class_is_assignable_from (D.28395, D.28403);
        if (D.28404 == 0) goto <D.28405>; else goto <D.28406>;
        <D.28405>:
        filtered = 1;
        <D.28406>:
        <D.28400>:
        <D.28397>:
        D.28395 = mod->data.exc_class;
        if (D.28395 != 0B) goto <D.28407>; else goto <D.28408>;
        <D.28407>:
        D.28398 = mod->subclasses;
        if (D.28398 == 0) goto <D.28409>; else goto <D.28410>;
        <D.28409>:
        D.28395 = mod->data.exc_class;
        D.28401 = ei->exc;
        D.28402 = D.28401->vtable;
        D.28403 = D.28402->klass;
        if (D.28395 != D.28403) goto <D.28411>; else goto <D.28412>;
        <D.28411>:
        filtered = 1;
        <D.28412>:
        <D.28410>:
        <D.28408>:
        D.28413 = ei->caught;
        if (D.28413 != 0) goto <D.28414>; else goto <D.28415>;
        <D.28414>:
        D.28416 = mod->caught;
        if (D.28416 == 0) goto <D.28417>; else goto <D.28418>;
        <D.28417>:
        filtered = 1;
        <D.28418>:
        <D.28415>:
        D.28413 = ei->caught;
        if (D.28413 == 0) goto <D.28419>; else goto <D.28420>;
        <D.28419>:
        D.28421 = mod->uncaught;
        if (D.28421 == 0) goto <D.28422>; else goto <D.28423>;
        <D.28422>:
        filtered = 1;
        <D.28423>:
        <D.28420>:
        goto <D.28392>;
        <D.28391>:
        D.28372 = mod->kind;
        if (D.28372 == 11) goto <D.28426>; else goto <D.28424>;
        <D.28426>:
        if (ji != 0B) goto <D.28427>; else goto <D.28424>;
        <D.28427>:
        {
          int k;
          gboolean found;
          struct MonoAssembly * * assemblies;

          found = 0;
          assemblies = mod->data.assemblies;
          if (assemblies != 0B) goto <D.28428>; else goto <D.28429>;
          <D.28428>:
          k = 0;
          goto <D.26098>;
          <D.26097>:
          D.28430 = (long unsigned int) k;
          D.28431 = D.28430 * 8;
          D.28432 = assemblies + D.28431;
          D.28433 = *D.28432;
          D.28434 = jinfo_get_method (ji);
          D.28435 = D.28434->klass;
          D.28436 = D.28435->image;
          D.28437 = D.28436->assembly;
          if (D.28433 == D.28437) goto <D.28438>; else goto <D.28439>;
          <D.28438>:
          found = 1;
          <D.28439>:
          k = k + 1;
          <D.26098>:
          D.28430 = (long unsigned int) k;
          D.28431 = D.28430 * 8;
          D.28432 = assemblies + D.28431;
          D.28433 = *D.28432;
          if (D.28433 != 0B) goto <D.26097>; else goto <D.26099>;
          <D.26099>:
          <D.28429>:
          if (found == 0) goto <D.28440>; else goto <D.28441>;
          <D.28440>:
          filtered = 1;
          <D.28441>:
        }
        goto <D.28425>;
        <D.28424>:
        D.28372 = mod->kind;
        if (D.28372 == 12) goto <D.28444>; else goto <D.28442>;
        <D.28444>:
        if (ei != 0B) goto <D.28445>; else goto <D.28442>;
        <D.28445>:
        D.28446 = ei->klass;
        if (D.28446 != 0B) goto <D.28447>; else goto <D.28442>;
        <D.28447>:
        {
          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.26115>;
              <D.26114>:
              {
                struct MonoDebugMethodInfo * minfo;

                minfo = mono_debug_lookup_method (method);
                if (minfo != 0B) goto <D.28448>; else goto <D.28449>;
                <D.28448>:
                mono_debug_symfile_get_line_numbers_full (minfo, &source_file, &source_file_list, 0B, 0B, 0B, 0B, 0B);
                i = 0;
                goto <D.26112>;
                <D.26111>:
                source_file_list.33 = source_file_list;
                D.28451 = source_file_list.33->pdata;
                D.28452 = (long unsigned int) i;
                D.28453 = D.28452 * 8;
                D.28454 = D.28451 + D.28453;
                sinfo = *D.28454;
                D.28455 = sinfo->source_file;
                s = strdup_tolower (D.28455);
                D.28456 = mod->data.source_files;
                D.28457 = monoeg_g_hash_table_lookup (D.28456, s);
                if (D.28457 != 0B) goto <D.28458>; else goto <D.28459>;
                <D.28458>:
                found = 1;
                goto <D.28460>;
                <D.28459>:
                {
                  char * s2;
                  char * s3;

                  D.28455 = sinfo->source_file;
                  s2 = monoeg_g_path_get_basename (D.28455);
                  s3 = strdup_tolower (s2);
                  D.28456 = mod->data.source_files;
                  D.28461 = monoeg_g_hash_table_lookup (D.28456, s3);
                  if (D.28461 != 0B) goto <D.28462>; else goto <D.28463>;
                  <D.28462>:
                  found = 1;
                  <D.28463>:
                  monoeg_g_free (s2);
                  monoeg_g_free (s3);
                }
                <D.28460>:
                monoeg_g_free (s);
                i = i + 1;
                <D.26112>:
                i.34 = (unsigned int) i;
                source_file_list.33 = source_file_list;
                D.28465 = source_file_list.33->len;
                if (i.34 < D.28465) goto <D.26111>; else goto <D.26113>;
                <D.26113>:
                source_file_list.33 = source_file_list;
                monoeg_g_ptr_array_free (source_file_list.33, 1);
                <D.28449>:
              }
              <D.26115>:
              D.28446 = ei->klass;
              method = mono_class_get_methods (D.28446, &iter);
              if (method != 0B) goto <D.26114>; else goto <D.26116>;
              <D.26116>:
              if (found == 0) goto <D.28466>; else goto <D.28467>;
              <D.28466>:
              filtered = 1;
              <D.28467>:
            }
          finally
            {
              iter = {CLOBBER};
              source_file = {CLOBBER};
              source_file_list = {CLOBBER};
            }
        }
        goto <D.28443>;
        <D.28442>:
        D.28372 = mod->kind;
        if (D.28372 == 13) goto <D.28470>; else goto <D.28468>;
        <D.28470>:
        if (ei != 0B) goto <D.28471>; else goto <D.28468>;
        <D.28471>:
        D.28446 = ei->klass;
        if (D.28446 != 0B) goto <D.28472>; else goto <D.28468>;
        <D.28472>:
        {
          char * s;

          D.28446 = ei->klass;
          D.28473 = &D.28446->byval_arg;
          s = mono_type_full_name (D.28473);
          D.28474 = mod->data.type_names;
          D.28475 = monoeg_g_hash_table_lookup (D.28474, s);
          if (D.28475 == 0B) goto <D.28476>; else goto <D.28477>;
          <D.28476>:
          filtered = 1;
          <D.28477>:
          monoeg_g_free (s);
        }
        goto <D.28469>;
        <D.28468>:
        D.28372 = mod->kind;
        if (D.28372 == 10) goto <D.28478>; else goto <D.28479>;
        <D.28478>:
        D.28480 = mod->data.filter;
        D.28481 = D.28480 & 1;
        if (D.28481 != 0) goto <D.28482>; else goto <D.28483>;
        <D.28482>:
        if (ji != 0B) goto <D.28484>; else goto <D.28485>;
        <D.28484>:
        D.28486 = jinfo_get_method (ji);
        D.28487 = D.28486->flags;
        D.28488 = (int) D.28487;
        D.28489 = D.28488 & 2048;
        if (D.28489 != 0) goto <D.28490>; else goto <D.28491>;
        <D.28490>:
        {
          size_t __s1_len;
          size_t __s2_len;

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

            D.28495 = jinfo_get_method (ji);
            __s2 = D.28495->name;
            D.28496 = ".cctor";
            D.28497 = MEM[(const unsigned char *)D.28496];
            D.28498 = (int) D.28497;
            D.28499 = *__s2;
            D.28500 = (int) D.28499;
            __result = D.28498 - D.28500;
            {
              if (__s2_len != 0) goto <D.28501>; else goto <D.28502>;
              <D.28501>:
              if (__result == 0) goto <D.28503>; else goto <D.28504>;
              <D.28503>:
              D.28505 = &MEM[(void *)".cctor" + 1B];
              D.28506 = *D.28505;
              D.28507 = (int) D.28506;
              D.28508 = __s2 + 1;
              D.28509 = *D.28508;
              D.28510 = (int) D.28509;
              __result = D.28507 - D.28510;
              if (__s2_len > 1) goto <D.28511>; else goto <D.28512>;
              <D.28511>:
              if (__result == 0) goto <D.28513>; else goto <D.28514>;
              <D.28513>:
              D.28515 = &MEM[(void *)".cctor" + 2B];
              D.28516 = *D.28515;
              D.28517 = (int) D.28516;
              D.28518 = __s2 + 2;
              D.28519 = *D.28518;
              D.28520 = (int) D.28519;
              __result = D.28517 - D.28520;
              if (__s2_len > 2) goto <D.28521>; else goto <D.28522>;
              <D.28521>:
              if (__result == 0) goto <D.28523>; else goto <D.28524>;
              <D.28523>:
              D.28525 = &MEM[(void *)".cctor" + 3B];
              D.28526 = *D.28525;
              D.28527 = (int) D.28526;
              D.28528 = __s2 + 3;
              D.28529 = *D.28528;
              D.28530 = (int) D.28529;
              __result = D.28527 - D.28530;
              <D.28524>:
              <D.28522>:
              <D.28514>:
              <D.28512>:
              <D.28504>:
              <D.28502>:
            }
            D.26125 = __result;
          }
          iftmp.35 = -D.26125;
          goto <D.28531>;
          <D.28494>:
          D.28532 = jinfo_get_method (ji);
          D.28533 = D.28532->name;
          iftmp.35 = __builtin_strcmp (D.28533, ".cctor");
          <D.28531>:
          D.26126 = iftmp.35;
        }
        if (D.26126 == 0) goto <D.28534>; else goto <D.28535>;
        <D.28534>:
        filtered = 1;
        <D.28535>:
        <D.28491>:
        <D.28485>:
        <D.28483>:
        D.28480 = mod->data.filter;
        D.28536 = D.28480 & 2;
        if (D.28536 != 0) goto <D.28537>; else goto <D.28538>;
        <D.28537>:
        if (ji != 0B) goto <D.28539>; else goto <D.28540>;
        <D.28539>:
        {
          struct MonoCustomAttrInfo * ainfo;
          static struct MonoClass * klass;

          klass.36 = klass;
          if (klass.36 == 0B) goto <D.28542>; else goto <D.28543>;
          <D.28542>:
          D.28544 = mono_defaults.corlib;
          klass.37 = mono_class_from_name (D.28544, "System.Diagnostics", "DebuggerHiddenAttribute");
          klass = klass.37;
          klass.36 = klass;
          D.28546 = klass.36 == 0B;
          D.28547 = (long int) D.28546;
          D.28548 = __builtin_expect (D.28547, 0);
          if (D.28548 != 0) goto <D.28549>; else goto <D.28550>;
          <D.28549>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 3454, "klass");
          <D.28550>:
          <D.28543>:
          D.28551 = BIT_FIELD_REF <*ji, 64, 256>;
          D.28552 = D.28551 & 4194304;
          if (D.28552 == 0) goto <D.28553>; else goto <D.28554>;
          <D.28553>:
          D.28555 = jinfo_get_method (ji);
          ainfo = mono_custom_attrs_from_method (D.28555);
          if (ainfo != 0B) goto <D.28556>; else goto <D.28557>;
          <D.28556>:
          klass.36 = klass;
          D.28558 = mono_custom_attrs_has_attr (ainfo, klass.36);
          if (D.28558 != 0) goto <D.28559>; else goto <D.28560>;
          <D.28559>:
          ji->dbg_hidden = -1;
          <D.28560>:
          mono_custom_attrs_free (ainfo);
          <D.28557>:
          ji->dbg_hidden_inited = -1;
          <D.28554>:
          D.28551 = BIT_FIELD_REF <*ji, 64, 256>;
          D.28561 = D.28551 & 8388608;
          if (D.28561 != 0) goto <D.28562>; else goto <D.28563>;
          <D.28562>:
          filtered = 1;
          <D.28563>:
        }
        <D.28540>:
        <D.28538>:
        D.28480 = mod->data.filter;
        D.28564 = D.28480 & 4;
        if (D.28564 != 0) goto <D.28565>; else goto <D.28566>;
        <D.28565>:
        if (ji != 0B) goto <D.28567>; else goto <D.28568>;
        <D.28567>:
        {
          struct MonoCustomAttrInfo * ainfo;
          static struct MonoClass * klass;

          klass.38 = klass;
          if (klass.38 == 0B) goto <D.28570>; else goto <D.28571>;
          <D.28570>:
          D.28544 = mono_defaults.corlib;
          klass.39 = mono_class_from_name (D.28544, "System.Diagnostics", "DebuggerStepThroughAttribute");
          klass = klass.39;
          klass.38 = klass;
          D.28573 = klass.38 == 0B;
          D.28574 = (long int) D.28573;
          D.28575 = __builtin_expect (D.28574, 0);
          if (D.28575 != 0) goto <D.28576>; else goto <D.28577>;
          <D.28576>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 3474, "klass");
          <D.28577>:
          <D.28571>:
          D.28551 = BIT_FIELD_REF <*ji, 64, 256>;
          D.28578 = D.28551 & 33554432;
          if (D.28578 == 0) goto <D.28579>; else goto <D.28580>;
          <D.28579>:
          D.28581 = jinfo_get_method (ji);
          ainfo = mono_custom_attrs_from_method (D.28581);
          if (ainfo != 0B) goto <D.28582>; else goto <D.28583>;
          <D.28582>:
          klass.38 = klass;
          D.28584 = mono_custom_attrs_has_attr (ainfo, klass.38);
          if (D.28584 != 0) goto <D.28585>; else goto <D.28586>;
          <D.28585>:
          ji->dbg_step_through = -1;
          <D.28586>:
          mono_custom_attrs_free (ainfo);
          <D.28583>:
          D.28587 = jinfo_get_method (ji);
          D.28588 = D.28587->klass;
          ainfo = mono_custom_attrs_from_class (D.28588);
          if (ainfo != 0B) goto <D.28589>; else goto <D.28590>;
          <D.28589>:
          klass.38 = klass;
          D.28591 = mono_custom_attrs_has_attr (ainfo, klass.38);
          if (D.28591 != 0) goto <D.28592>; else goto <D.28593>;
          <D.28592>:
          ji->dbg_step_through = -1;
          <D.28593>:
          mono_custom_attrs_free (ainfo);
          <D.28590>:
          ji->dbg_step_through_inited = -1;
          <D.28580>:
          D.28551 = BIT_FIELD_REF <*ji, 64, 256>;
          D.28594 = D.28551 & 67108864;
          if (D.28594 != 0) goto <D.28595>; else goto <D.28596>;
          <D.28595>:
          filtered = 1;
          <D.28596>:
        }
        <D.28568>:
        <D.28566>:
        <D.28479>:
        <D.28469>:
        <D.28443>:
        <D.28425>:
        <D.28392>:
        <D.28390>:
        <D.28383>:
      }
      j = j + 1;
      <D.26132>:
      D.28597 = req->nmodifiers;
      if (D.28597 > j) goto <D.26131>; else goto <D.26133>;
      <D.26133>:
      if (filtered == 0) goto <D.28598>; else goto <D.28599>;
      <D.28598>:
      D.28600 = req->suspend_policy;
      D.28601 = *suspend_policy;
      D.28602 = MAX_EXPR <D.28600, D.28601>;
      *suspend_policy = D.28602;
      D.28603 = req->id;
      D.28604 = (long int) D.28603;
      D.28605 = (void *) D.28604;
      events = monoeg_g_slist_append (events, D.28605);
      <D.28599>:
    }
    <D.28371>:
  }
  i = i + 1;
  <D.26135>:
  i.40 = (unsigned int) i;
  D.28607 = reqs->len;
  if (i.40 < D.28607) goto <D.26134>; else goto <D.26136>;
  <D.26136>:
  if (event == 0) goto <D.28608>; else goto <D.28609>;
  <D.28608>:
  events = monoeg_g_slist_append (events, 0B);
  <D.28609>:
  if (event == 1) goto <D.28610>; else goto <D.28611>;
  <D.28610>:
  events = monoeg_g_slist_append (events, 0B);
  <D.28611>:
  D.28363 = events;
  return D.28363;
}


strdup_tolower (char * s)
{
  int D.26077;
  char D.28615;
  int D.28616;
  int D.28617;
  const int iftmp.41;
  unsigned int __c.42;
  unsigned int D.28622;
  const __int32_t * * D.28625;
  const __int32_t * D.28626;
  long unsigned int D.28627;
  long unsigned int D.28628;
  const __int32_t * D.28629;
  long unsigned int D.28633;
  long unsigned int D.28634;
  const __int32_t * D.28635;
  char D.28636;
  char * D.28637;
  char * s2;
  char * p;

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

    {
      if (0 != 0) goto <D.28613>; else goto <D.28614>;
      <D.28613>:
      D.28615 = *p;
      D.28616 = (int) D.28615;
      D.28617 = __builtin_constant_p (D.28616);
      if (D.28617 != 0) goto <D.28618>; else goto <D.28619>;
      <D.28618>:
      {
        int __c;

        D.28615 = *p;
        __c = (int) D.28615;
        __c.42 = (unsigned int) __c;
        D.28622 = __c.42 + 128;
        if (D.28622 <= 383) goto <D.28623>; else goto <D.28624>;
        <D.28623>:
        D.28625 = __ctype_tolower_loc ();
        D.28626 = *D.28625;
        D.28627 = (long unsigned int) __c;
        D.28628 = D.28627 * 4;
        D.28629 = D.28626 + D.28628;
        iftmp.41 = *D.28629;
        goto <D.28630>;
        <D.28624>:
        iftmp.41 = __c;
        <D.28630>:
        __res = iftmp.41;
      }
      goto <D.28631>;
      <D.28619>:
      D.28615 = *p;
      D.28616 = (int) D.28615;
      __res = tolower (D.28616);
      <D.28631>:
      goto <D.28632>;
      <D.28614>:
      D.28625 = __ctype_tolower_loc ();
      D.28626 = *D.28625;
      D.28615 = *p;
      D.28633 = (long unsigned int) D.28615;
      D.28634 = D.28633 * 4;
      D.28635 = D.28626 + D.28634;
      __res = *D.28635;
      <D.28632>:
    }
    D.26077 = __res;
  }
  D.28636 = (char) D.26077;
  *p = D.28636;
  p = p + 1;
  <D.26079>:
  D.28615 = *p;
  if (D.28615 != 0) goto <D.26078>; else goto <D.26080>;
  <D.26080>:
  D.28637 = s2;
  return D.28637;
}


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

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


process_event (EventKind event, void * arg, gint32 il_offset, struct MonoContext * ctx, struct GSList * events, int suspend_policy)
{
  int inited.43;
  int log_level.44;
  _Bool D.28645;
  long int D.28646;
  long int D.28647;
  struct FILE * log_file.45;
  const char * D.28651;
  int vm_start_event_sent.46;
  const char * D.28659;
  int vm_death_event_sent.47;
  const char * D.28665;
  int D.28666;
  const char * D.28673;
  int disconnected.48;
  const char * D.28679;
  int D.28685;
  long unsigned int D.28688;
  long unsigned int debugger_thread_id.49;
  long unsigned int D.28694;
  unsigned int D.28699;
  unsigned char D.28700;
  unsigned int nevents.50;
  unsigned char D.28702;
  void * D.28703;
  long int D.28704;
  unsigned int D.28705;
  int ecount.51;
  int ecount.52;
  long unsigned int D.28714;
  struct MonoDomain * D.28715;
  int protocol_version_set.53;
  int major_version.54;
  int minor_version.55;
  int D.28725;
  unsigned int D.28726;
  struct MonoObject * D.28727;
  int D.28728;
  unsigned int D.28729;
  const char * iftmp.56;
  char * D.28731;
  const char * iftmp.57;
  char * D.28736;
  int iftmp.58;
  int D.28743;
  int D.28751;
  const char * D.28762;
  _Bool D.28765;
  long int D.28766;
  long int D.28767;
  long unsigned int D.28770;
  void * D.28771;
  const char * D.28772;
  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.43 = inited;
      if (inited.43 == 0) goto <D.28642>; else goto <D.28643>;
      <D.28642>:
      log_level.44 = log_level;
      D.28645 = log_level.44 > 1;
      D.28646 = (long int) D.28645;
      D.28647 = __builtin_expect (D.28646, 0);
      if (D.28647 != 0) goto <D.28648>; else goto <D.28649>;
      <D.28648>:
      log_file.45 = log_file;
      D.28651 = event_to_string (event);
      fprintf (log_file.45, "Debugger agent not initialized yet: dropping %s\n", D.28651);
      log_file.45 = log_file;
      fflush (log_file.45);
      <D.28649>:
      return;
      <D.28643>:
      vm_start_event_sent.46 = vm_start_event_sent;
      if (vm_start_event_sent.46 == 0) goto <D.28653>; else goto <D.28654>;
      <D.28653>:
      if (event != 0) goto <D.28655>; else goto <D.28656>;
      <D.28655>:
      log_level.44 = log_level;
      D.28645 = log_level.44 > 1;
      D.28646 = (long int) D.28645;
      D.28647 = __builtin_expect (D.28646, 0);
      if (D.28647 != 0) goto <D.28657>; else goto <D.28658>;
      <D.28657>:
      log_file.45 = log_file;
      D.28659 = event_to_string (event);
      fprintf (log_file.45, "VM start event not sent yet: dropping %s\n", D.28659);
      log_file.45 = log_file;
      fflush (log_file.45);
      <D.28658>:
      return;
      <D.28656>:
      <D.28654>:
      vm_death_event_sent.47 = vm_death_event_sent;
      if (vm_death_event_sent.47 != 0) goto <D.28661>; else goto <D.28662>;
      <D.28661>:
      log_level.44 = log_level;
      D.28645 = log_level.44 > 1;
      D.28646 = (long int) D.28645;
      D.28647 = __builtin_expect (D.28646, 0);
      if (D.28647 != 0) goto <D.28663>; else goto <D.28664>;
      <D.28663>:
      log_file.45 = log_file;
      D.28665 = event_to_string (event);
      fprintf (log_file.45, "VM death event has been sent: dropping %s\n", D.28665);
      log_file.45 = log_file;
      fflush (log_file.45);
      <D.28664>:
      return;
      <D.28662>:
      D.28666 = mono_runtime_is_shutting_down ();
      if (D.28666 != 0) goto <D.28667>; else goto <D.28668>;
      <D.28667>:
      if (event != 1) goto <D.28669>; else goto <D.28670>;
      <D.28669>:
      log_level.44 = log_level;
      D.28645 = log_level.44 > 1;
      D.28646 = (long int) D.28645;
      D.28647 = __builtin_expect (D.28646, 0);
      if (D.28647 != 0) goto <D.28671>; else goto <D.28672>;
      <D.28671>:
      log_file.45 = log_file;
      D.28673 = event_to_string (event);
      fprintf (log_file.45, "Mono runtime is shutting down: dropping %s\n", D.28673);
      log_file.45 = log_file;
      fflush (log_file.45);
      <D.28672>:
      return;
      <D.28670>:
      <D.28668>:
      disconnected.48 = disconnected;
      if (disconnected.48 != 0) goto <D.28675>; else goto <D.28676>;
      <D.28675>:
      log_level.44 = log_level;
      D.28645 = log_level.44 > 1;
      D.28646 = (long int) D.28645;
      D.28647 = __builtin_expect (D.28646, 0);
      if (D.28647 != 0) goto <D.28677>; else goto <D.28678>;
      <D.28677>:
      log_file.45 = log_file;
      D.28679 = event_to_string (event);
      fprintf (log_file.45, "Debugger client is not connected: dropping %s\n", D.28679);
      log_file.45 = log_file;
      fflush (log_file.45);
      <D.28678>:
      return;
      <D.28676>:
      if (event == 14) goto <D.28680>; else goto <D.28681>;
      <D.28680>:
      suspend_policy = 0;
      goto <D.28682>;
      <D.28681>:
      if (events == 0B) goto <D.28683>; else goto <D.28684>;
      <D.28683>:
      return;
      <D.28684>:
      D.28685 = agent_config.defer;
      if (D.28685 != 0) goto <D.28686>; else goto <D.28687>;
      <D.28686>:
      D.28688 = GetCurrentThreadId ();
      debugger_thread_id.49 = debugger_thread_id;
      if (D.28688 == debugger_thread_id.49) goto <D.28690>; else goto <D.28691>;
      <D.28690>:
      suspend_policy = 0;
      thread = mono_thread_get_main ();
      goto <D.28692>;
      <D.28691>:
      thread = mono_thread_current ();
      <D.28692>:
      goto <D.28693>;
      <D.28687>:
      D.28694 = GetCurrentThreadId ();
      debugger_thread_id.49 = debugger_thread_id;
      if (D.28694 == debugger_thread_id.49) goto <D.28695>; else goto <D.28696>;
      <D.28695>:
      if (event != 1) goto <D.28697>; else goto <D.28698>;
      <D.28697>:
      return;
      <D.28698>:
      <D.28696>:
      <D.28693>:
      <D.28682>:
      D.28699 = monoeg_g_slist_length (events);
      nevents = (int) D.28699;
      buffer_init (&buf, 128);
      D.28700 = (unsigned char) suspend_policy;
      buffer_add_byte (&buf, D.28700);
      nevents.50 = (unsigned int) nevents;
      buffer_add_int (&buf, nevents.50);
      l = events;
      goto <D.26196>;
      <D.26195>:
      D.28702 = (unsigned char) event;
      buffer_add_byte (&buf, D.28702);
      D.28703 = l->data;
      D.28704 = (long int) D.28703;
      D.28705 = (unsigned int) D.28704;
      buffer_add_int (&buf, D.28705);
      ecount.51 = ecount;
      ecount.52 = ecount.51 + 1;
      ecount = ecount.52;
      if (thread == 0B) goto <D.28708>; else goto <D.28709>;
      <D.28708>:
      thread = mono_thread_current ();
      <D.28709>:
      if (event == 0) goto <D.28710>; else goto <D.28711>;
      <D.28710>:
      if (arg != 0B) goto <D.28712>; else goto <D.28713>;
      <D.28712>:
      thread = arg;
      <D.28713>:
      <D.28711>:
      buffer_add_objid (&buf, thread);
      switch (event) <default: <D.26194>, case 0: <D.26186>, case 1: <D.26187>, case 2: <D.26174>, case 3: <D.26175>, case 4: <D.26177>, case 5: <D.26178>, case 6: <D.26179>, case 7: <D.26180>, case 8: <D.26181>, case 9: <D.26182>, case 10: <D.26184>, case 11: <D.26185>, case 12: <D.26183>, case 13: <D.26188>, case 14: <D.26193>, case 15: <D.26190>, case 16: <D.26191>>
      <D.26174>:
      <D.26175>:
      goto <D.26176>;
      <D.26177>:
      <D.26178>:
      buffer_add_domainid (&buf, arg);
      goto <D.26176>;
      <D.26179>:
      <D.26180>:
      buffer_add_methodid (&buf, domain, arg);
      goto <D.26176>;
      <D.26181>:
      <D.26182>:
      buffer_add_assemblyid (&buf, domain, arg);
      goto <D.26176>;
      <D.26183>:
      buffer_add_typeid (&buf, domain, arg);
      goto <D.26176>;
      <D.26184>:
      <D.26185>:
      buffer_add_methodid (&buf, domain, arg);
      D.28714 = (long unsigned int) il_offset;
      buffer_add_long (&buf, D.28714);
      goto <D.26176>;
      <D.26186>:
      D.28715 = mono_get_root_domain ();
      buffer_add_domainid (&buf, D.28715);
      goto <D.26176>;
      <D.26187>:
      protocol_version_set.53 = protocol_version_set;
      if (protocol_version_set.53 != 0) goto <D.28719>; else goto <D.28720>;
      <D.28719>:
      major_version.54 = major_version;
      if (major_version.54 > 2) goto <D.28716>; else goto <D.28722>;
      <D.28722>:
      major_version.54 = major_version;
      if (major_version.54 == 2) goto <D.28723>; else goto <D.28717>;
      <D.28723>:
      minor_version.55 = minor_version;
      if (minor_version.55 > 26) goto <D.28716>; else goto <D.28717>;
      <D.28716>:
      D.28725 = mono_environment_exitcode_get ();
      D.28726 = (unsigned int) D.28725;
      buffer_add_int (&buf, D.28726);
      <D.28717>:
      <D.28720>:
      goto <D.26176>;
      <D.26188>:
      {
        struct EventInfo * ei;

        ei = arg;
        D.28727 = ei->exc;
        buffer_add_objid (&buf, D.28727);
        keepalive_obj = ei->exc;
        goto <D.26176>;
      }
      <D.26190>:
      goto <D.26176>;
      <D.26191>:
      {
        struct EventInfo * ei;

        ei = arg;
        D.28728 = ei->level;
        D.28729 = (unsigned int) D.28728;
        buffer_add_int (&buf, D.28729);
        D.28731 = ei->category;
        if (D.28731 != 0B) goto <D.28732>; else goto <D.28733>;
        <D.28732>:
        iftmp.56 = ei->category;
        goto <D.28734>;
        <D.28733>:
        iftmp.56 = "";
        <D.28734>:
        buffer_add_string (&buf, iftmp.56);
        D.28736 = ei->message;
        if (D.28736 != 0B) goto <D.28737>; else goto <D.28738>;
        <D.28737>:
        iftmp.57 = ei->message;
        goto <D.28739>;
        <D.28738>:
        iftmp.57 = "";
        <D.28739>:
        buffer_add_string (&buf, iftmp.57);
        goto <D.26176>;
      }
      <D.26193>:
      suspend_policy = 0;
      goto <D.26176>;
      <D.26194>:
      monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "debugger-agent.c", 3680);
      <D.26176>:
      l = l->next;
      <D.26196>:
      if (l != 0B) goto <D.26195>; else goto <D.26197>;
      <D.26197>:
      if (event == 0) goto <D.28740>; else goto <D.28741>;
      <D.28740>:
      D.28743 = agent_config.suspend;
      if (D.28743 != 0) goto <D.28744>; else goto <D.28745>;
      <D.28744>:
      iftmp.58 = 2;
      goto <D.28746>;
      <D.28745>:
      iftmp.58 = 0;
      <D.28746>:
      suspend_policy = iftmp.58;
      D.28685 = agent_config.defer;
      if (D.28685 == 0) goto <D.28747>; else goto <D.28748>;
      <D.28747>:
      start_debugger_thread ();
      <D.28748>:
      <D.28741>:
      if (event == 1) goto <D.28749>; else goto <D.28750>;
      <D.28749>:
      vm_death_event_sent = 1;
      suspend_policy = 0;
      <D.28750>:
      D.28751 = mono_runtime_is_shutting_down ();
      if (D.28751 != 0) goto <D.28752>; else goto <D.28753>;
      <D.28752>:
      suspend_policy = 0;
      <D.28753>:
      if (suspend_policy != 0) goto <D.28754>; else goto <D.28755>;
      <D.28754>:
      save_thread_context (ctx);
      suspend_vm ();
      if (keepalive_obj != 0B) goto <D.28756>; else goto <D.28757>;
      <D.28756>:
      get_objref (keepalive_obj);
      <D.28757>:
      <D.28755>:
      send_success = send_packet (64, 100, &buf);
      buffer_free (&buf);
      monoeg_g_slist_free (events);
      events = 0B;
      if (send_success == 0) goto <D.28758>; else goto <D.28759>;
      <D.28758>:
      log_level.44 = log_level;
      D.28645 = log_level.44 > 1;
      D.28646 = (long int) D.28645;
      D.28647 = __builtin_expect (D.28646, 0);
      if (D.28647 != 0) goto <D.28760>; else goto <D.28761>;
      <D.28760>:
      log_file.45 = log_file;
      D.28762 = event_to_string (event);
      fprintf (log_file.45, "Sending command %s failed.\n", D.28762);
      log_file.45 = log_file;
      fflush (log_file.45);
      <D.28761>:
      return;
      <D.28759>:
      if (event == 0) goto <D.28763>; else goto <D.28764>;
      <D.28763>:
      vm_start_event_sent = 1;
      <D.28764>:
      log_level.44 = log_level;
      D.28765 = log_level.44 > 0;
      D.28766 = (long int) D.28765;
      D.28767 = __builtin_expect (D.28766, 0);
      if (D.28767 != 0) goto <D.28768>; else goto <D.28769>;
      <D.28768>:
      log_file.45 = log_file;
      D.28770 = GetCurrentThreadId ();
      D.28771 = (void *) D.28770;
      D.28772 = event_to_string (event);
      ecount.51 = ecount;
      fprintf (log_file.45, "[%p] Sent %d events %s(%d), suspend=%d.\n", D.28771, nevents, D.28772, ecount.51, suspend_policy);
      log_file.45 = log_file;
      fflush (log_file.45);
      <D.28769>:
      switch (suspend_policy) <default: <D.26202>, case 0: <D.26198>, case 1: <D.26201>, case 2: <D.26200>>
      <D.26198>:
      goto <D.26199>;
      <D.26200>:
      suspend_current ();
      goto <D.26199>;
      <D.26201>:
      monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "debugger-agent.c", 3737);
      <D.26202>:
      monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "debugger-agent.c", 3740);
      <D.26199>:
    }
  finally
    {
      buf = {CLOBBER};
    }
}


buffer_init (struct Buffer * buf, int size)
{
  long unsigned int D.28778;
  void * D.28779;
  guint8 * D.28780;
  sizetype D.28781;
  guint8 * D.28782;

  D.28778 = (long unsigned int) size;
  D.28779 = monoeg_malloc (D.28778);
  buf->buf = D.28779;
  D.28780 = buf->buf;
  buf->p = D.28780;
  D.28780 = buf->buf;
  D.28781 = (sizetype) size;
  D.28782 = D.28780 + D.28781;
  buf->end = D.28782;
}


buffer_add_byte (struct Buffer * buf, guint8 val)
{
  guint8 * D.28783;
  guint8 * D.28784;

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


buffer_make_room (struct Buffer * buf, int size)
{
  guint8 * D.28785;
  long int D.28786;
  guint8 * D.28787;
  long int D.28788;
  long int D.28789;
  long int D.28790;
  guint8 * D.28793;
  long int D.28794;
  long int D.28795;
  unsigned int D.28796;
  unsigned int size.59;
  unsigned int D.28798;
  unsigned int D.28799;
  long unsigned int D.28800;
  long int D.28801;
  sizetype D.28802;
  guint8 * D.28803;
  sizetype D.28804;
  guint8 * D.28805;

  D.28785 = buf->end;
  D.28786 = (long int) D.28785;
  D.28787 = buf->p;
  D.28788 = (long int) D.28787;
  D.28789 = D.28786 - D.28788;
  D.28790 = (long int) size;
  if (D.28789 < D.28790) goto <D.28791>; else goto <D.28792>;
  <D.28791>:
  {
    int new_size;
    guint8 * p;

    D.28785 = buf->end;
    D.28786 = (long int) D.28785;
    D.28793 = buf->buf;
    D.28794 = (long int) D.28793;
    D.28795 = D.28786 - D.28794;
    D.28796 = (unsigned int) D.28795;
    size.59 = (unsigned int) size;
    D.28798 = D.28796 + size.59;
    D.28799 = D.28798 + 32;
    new_size = (int) D.28799;
    D.28793 = buf->buf;
    D.28800 = (long unsigned int) new_size;
    p = monoeg_realloc (D.28793, D.28800);
    D.28787 = buf->p;
    D.28788 = (long int) D.28787;
    D.28793 = buf->buf;
    D.28794 = (long int) D.28793;
    D.28801 = D.28788 - D.28794;
    size = (int) D.28801;
    buf->buf = p;
    D.28802 = (sizetype) size;
    D.28803 = p + D.28802;
    buf->p = D.28803;
    D.28793 = buf->buf;
    D.28804 = (sizetype) new_size;
    D.28805 = D.28793 + D.28804;
    buf->end = D.28805;
  }
  <D.28792>:
}


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

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


get_id (struct MonoDomain * domain, IdType type, void * val)
{
  int D.28809;
  union mono_mutex_t * D.28810;
  _Bool D.28813;
  long int D.28814;
  long int D.28815;
  struct GHashTable * D.28818;
  struct GHashTable * D.28821;
  _Bool D.28826;
  long int D.28827;
  long int D.28828;
  struct GPtrArray * D.28831;
  unsigned int D.28832;
  unsigned int D.28833;
  int D.28834;
  _Bool D.28837;
  long int D.28838;
  long int D.28839;
  struct Id * id;
  struct AgentDomainInfo * info;

  if (val == 0B) goto <D.28807>; else goto <D.28808>;
  <D.28807>:
  D.28809 = 0;
  return D.28809;
  <D.28808>:
  mono_loader_lock ();
  {
    int ret;

    D.28810 = &domain->lock.mutex;
    ret = pthread_mutex_lock (D.28810);
    if (ret != 0) goto <D.28811>; else goto <D.28812>;
    <D.28811>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.28812>:
    D.28813 = ret != 0;
    D.28814 = (long int) D.28813;
    D.28815 = __builtin_expect (D.28814, 0);
    if (D.28815 != 0) goto <D.28816>; else goto <D.28817>;
    <D.28816>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 2149, "ret == 0");
    <D.28817>:
  }
  info = get_agent_domain_info (domain);
  D.28818 = info->val_to_id[type];
  if (D.28818 == 0B) goto <D.28819>; else goto <D.28820>;
  <D.28819>:
  D.28821 = monoeg_g_hash_table_new (mono_aligned_addr_hash, 0B);
  info->val_to_id[type] = D.28821;
  <D.28820>:
  D.28818 = info->val_to_id[type];
  id = monoeg_g_hash_table_lookup (D.28818, val);
  if (id != 0B) goto <D.28822>; else goto <D.28823>;
  <D.28822>:
  {
    int ret;

    D.28810 = &domain->lock.mutex;
    ret = pthread_mutex_unlock (D.28810);
    if (ret != 0) goto <D.28824>; else goto <D.28825>;
    <D.28824>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.28825>:
    D.28826 = ret != 0;
    D.28827 = (long int) D.28826;
    D.28828 = __builtin_expect (D.28827, 0);
    if (D.28828 != 0) goto <D.28829>; else goto <D.28830>;
    <D.28829>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 2158, "ret == 0");
    <D.28830>:
  }
  mono_loader_unlock ();
  D.28809 = id->id;
  return D.28809;
  <D.28823>:
  id = monoeg_malloc0 (24);
  D.28831 = ids[type];
  D.28832 = D.28831->len;
  D.28833 = D.28832 + 1;
  D.28834 = (int) D.28833;
  id->id = D.28834;
  id->domain = domain;
  id->data.val = val;
  D.28818 = info->val_to_id[type];
  monoeg_g_hash_table_insert_replace (D.28818, val, id, 0);
  {
    int ret;

    D.28810 = &domain->lock.mutex;
    ret = pthread_mutex_unlock (D.28810);
    if (ret != 0) goto <D.28835>; else goto <D.28836>;
    <D.28835>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.28836>:
    D.28837 = ret != 0;
    D.28838 = (long int) D.28837;
    D.28839 = __builtin_expect (D.28838, 0);
    if (D.28839 != 0) goto <D.28840>; else goto <D.28841>;
    <D.28840>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 2171, "ret == 0");
    <D.28841>:
  }
  D.28831 = ids[type];
  monoeg_g_ptr_array_add (D.28831, id);
  mono_loader_unlock ();
  D.28809 = id->id;
  return D.28809;
}


get_agent_domain_info (struct MonoDomain * domain)
{
  union mono_mutex_t * D.28843;
  _Bool D.28846;
  long int D.28847;
  long int D.28848;
  void * D.28851;
  void * D.28854;
  struct GHashTable * D.28855;
  struct GHashTable * D.28856;
  struct GHashTable * D.28857;
  struct GHashTable * D.28858;
  _Bool D.28861;
  long int D.28862;
  long int D.28863;
  struct AgentDomainInfo * D.28866;
  struct AgentDomainInfo * info;

  info = 0B;
  {
    int ret;

    D.28843 = &domain->lock.mutex;
    ret = pthread_mutex_lock (D.28843);
    if (ret != 0) goto <D.28844>; else goto <D.28845>;
    <D.28844>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.28845>:
    D.28846 = ret != 0;
    D.28847 = (long int) D.28846;
    D.28848 = __builtin_expect (D.28847, 0);
    if (D.28848 != 0) goto <D.28849>; else goto <D.28850>;
    <D.28849>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 2122, "ret == 0");
    <D.28850>:
  }
  D.28851 = domain->runtime_info;
  info = MEM[(struct MonoJitDomainInfo *)D.28851].agent_info;
  if (info == 0B) goto <D.28852>; else goto <D.28853>;
  <D.28852>:
  D.28851 = domain->runtime_info;
  D.28854 = monoeg_malloc0 (88);
  MEM[(struct MonoJitDomainInfo *)D.28851].agent_info = D.28854;
  info = MEM[(struct MonoJitDomainInfo *)D.28851].agent_info;
  D.28855 = monoeg_g_hash_table_new (mono_aligned_addr_hash, 0B);
  info->loaded_classes = D.28855;
  D.28856 = monoeg_g_hash_table_new (mono_aligned_addr_hash, 0B);
  info->source_files = D.28856;
  D.28857 = monoeg_g_hash_table_new (monoeg_g_str_hash, monoeg_g_str_equal);
  info->source_file_to_class = D.28857;
  D.28858 = monoeg_g_hash_table_new (monoeg_g_str_hash, monoeg_g_str_equal);
  info->source_file_to_class_ignorecase = D.28858;
  <D.28853>:
  {
    int ret;

    D.28843 = &domain->lock.mutex;
    ret = pthread_mutex_unlock (D.28843);
    if (ret != 0) goto <D.28859>; else goto <D.28860>;
    <D.28859>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.28860>:
    D.28861 = ret != 0;
    D.28862 = (long int) D.28861;
    D.28863 = __builtin_expect (D.28862, 0);
    if (D.28863 != 0) goto <D.28864>; else goto <D.28865>;
    <D.28864>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 2133, "ret == 0");
    <D.28865>:
  }
  D.28866 = info;
  return D.28866;
}


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

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


buffer_add_typeid (struct Buffer * buf, struct MonoDomain * domain, struct MonoClass * klass)
{
  int log_level.61;
  _Bool D.28870;
  long int D.28871;
  long int D.28872;
  struct MonoType * D.28877;
  long unsigned int D.28878;
  long unsigned int debugger_thread_id.62;
  struct FILE * log_file.63;
  long unsigned int D.28888;
  void * D.28889;

  buffer_add_ptr_id (buf, domain, 2, klass);
  log_level.61 = log_level;
  D.28870 = log_level.61 > 1;
  D.28871 = (long int) D.28870;
  D.28872 = __builtin_expect (D.28871, 0);
  if (D.28872 != 0) goto <D.28873>; else goto <D.28874>;
  <D.28873>:
  if (klass != 0B) goto <D.28875>; else goto <D.28876>;
  <D.28875>:
  {
    char * s;

    D.28877 = &klass->byval_arg;
    s = mono_type_full_name (D.28877);
    D.28878 = GetCurrentThreadId ();
    debugger_thread_id.62 = debugger_thread_id;
    if (D.28878 == debugger_thread_id.62) goto <D.28880>; else goto <D.28881>;
    <D.28880>:
    log_level.61 = log_level;
    D.28870 = log_level.61 > 1;
    D.28871 = (long int) D.28870;
    D.28872 = __builtin_expect (D.28871, 0);
    if (D.28872 != 0) goto <D.28882>; else goto <D.28883>;
    <D.28882>:
    log_file.63 = log_file;
    fprintf (log_file.63, "[dbg]   send class [%s]\n", s);
    log_file.63 = log_file;
    fflush (log_file.63);
    <D.28883>:
    goto <D.28885>;
    <D.28881>:
    log_level.61 = log_level;
    D.28870 = log_level.61 > 1;
    D.28871 = (long int) D.28870;
    D.28872 = __builtin_expect (D.28871, 0);
    if (D.28872 != 0) goto <D.28886>; else goto <D.28887>;
    <D.28886>:
    log_file.63 = log_file;
    D.28888 = GetCurrentThreadId ();
    D.28889 = (void *) D.28888;
    fprintf (log_file.63, "[%p]   send class [%s]\n", D.28889, s);
    log_file.63 = log_file;
    fflush (log_file.63);
    <D.28887>:
    <D.28885>:
    monoeg_g_free (s);
  }
  <D.28876>:
  <D.28874>:
}


buffer_add_methodid (struct Buffer * buf, struct MonoDomain * domain, struct MonoMethod * method)
{
  int log_level.64;
  _Bool D.28891;
  long int D.28892;
  long int D.28893;
  struct FILE * log_file.65;

  buffer_add_ptr_id (buf, domain, 3, method);
  log_level.64 = log_level;
  D.28891 = log_level.64 > 1;
  D.28892 = (long int) D.28891;
  D.28893 = __builtin_expect (D.28892, 0);
  if (D.28893 != 0) goto <D.28894>; else goto <D.28895>;
  <D.28894>:
  if (method != 0B) goto <D.28896>; else goto <D.28897>;
  <D.28896>:
  {
    char * s;

    s = mono_method_full_name (method, 1);
    log_level.64 = log_level;
    D.28891 = log_level.64 > 1;
    D.28892 = (long int) D.28891;
    D.28893 = __builtin_expect (D.28892, 0);
    if (D.28893 != 0) goto <D.28898>; else goto <D.28899>;
    <D.28898>:
    log_file.65 = log_file;
    fprintf (log_file.65, "[dbg]   send method [%s]\n", s);
    log_file.65 = log_file;
    fflush (log_file.65);
    <D.28899>:
    monoeg_g_free (s);
  }
  <D.28897>:
  <D.28895>:
}


buffer_add_long (struct Buffer * buf, guint64 l)
{
  long unsigned int D.28901;
  unsigned int D.28902;
  unsigned int D.28903;

  D.28901 = l >> 32;
  D.28902 = (unsigned int) D.28901;
  buffer_add_int (buf, D.28902);
  D.28903 = (unsigned int) l;
  buffer_add_int (buf, D.28903);
}


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

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


get_objid (struct MonoObject * obj)
{
  int D.28905;
  struct ObjRef * D.28906;

  D.28906 = get_objref (obj);
  D.28905 = D.28906->id;
  return D.28905;
}


buffer_add_int (struct Buffer * buf, guint32 val)
{
  guint8 * D.28908;
  unsigned int D.28909;
  unsigned char D.28910;
  guint8 * D.28911;
  unsigned int D.28912;
  unsigned char D.28913;
  guint8 * D.28914;
  unsigned int D.28915;
  unsigned char D.28916;
  guint8 * D.28917;
  unsigned char D.28918;
  guint8 * D.28919;

  buffer_make_room (buf, 4);
  D.28908 = buf->p;
  D.28909 = val >> 24;
  D.28910 = (unsigned char) D.28909;
  *D.28908 = D.28910;
  D.28908 = buf->p;
  D.28911 = D.28908 + 1;
  D.28912 = val >> 16;
  D.28913 = (unsigned char) D.28912;
  *D.28911 = D.28913;
  D.28908 = buf->p;
  D.28914 = D.28908 + 2;
  D.28915 = val >> 8;
  D.28916 = (unsigned char) D.28915;
  *D.28914 = D.28916;
  D.28908 = buf->p;
  D.28917 = D.28908 + 3;
  D.28918 = (unsigned char) val;
  *D.28917 = D.28918;
  D.28908 = buf->p;
  D.28919 = D.28908 + 4;
  buf->p = D.28919;
}


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

  if (str == 0B) goto <D.28920>; else goto <D.28921>;
  <D.28920>:
  buffer_add_int (buf, 0);
  goto <D.28922>;
  <D.28921>:
  D.28923 = strlen (str);
  len = (int) D.28923;
  len.66 = (unsigned int) len;
  buffer_add_int (buf, len.66);
  buffer_add_data (buf, str, len);
  <D.28922>:
}


buffer_add_data (struct Buffer * buf, guint8 * data, int len)
{
  guint8 * D.28925;
  long unsigned int D.28926;
  sizetype D.28927;
  guint8 * D.28928;

  buffer_make_room (buf, len);
  D.28925 = buf->p;
  D.28926 = (long unsigned int) len;
  memcpy (D.28925, data, D.28926);
  D.28925 = buf->p;
  D.28927 = (sizetype) len;
  D.28928 = D.28925 + D.28927;
  buf->p = D.28928;
}


memcpy (void * restrict __dest, const void * restrict __src, size_t __len)
{
  void * D.28929;
  long unsigned int D.28930;

  D.28930 = __builtin_object_size (__dest, 0);
  D.28929 = __builtin___memcpy_chk (__dest, __src, __len, D.28930);
  return D.28929;
}


start_debugger_thread ()
{
  void * debugger_thread_handle.67;
  void * debugger_thread_handle.68;
  _Bool D.28934;
  long int D.28935;
  long int D.28936;

  debugger_thread_handle.67 = mono_threads_create_thread (debugger_thread, 0B, 0, 0, 0B);
  debugger_thread_handle = debugger_thread_handle.67;
  debugger_thread_handle.68 = debugger_thread_handle;
  D.28934 = debugger_thread_handle.68 == 0B;
  D.28935 = (long int) D.28934;
  D.28936 = __builtin_expect (D.28935, 0);
  if (D.28936 != 0) goto <D.28937>; else goto <D.28938>;
  <D.28937>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 1580, "debugger_thread_handle");
  <D.28938>:
}


debugger_thread (void * arg)
{
  int log_level.69;
  _Bool D.28940;
  long int D.28941;
  long int D.28942;
  struct FILE * log_file.70;
  long unsigned int D.28946;
  void * D.28947;
  long unsigned int debugger_thread_id.71;
  struct MonoDomain * D.28949;
  struct MonoInternalThread * D.28950;
  long unsigned int D.28951;
  long unsigned int D.28952;
  int D.28953;
  int D.28956;
  struct MonoThread * D.28962;
  guint8 * p.72;
  _Bool D.28968;
  long int D.28969;
  long int D.28970;
  <unnamed type> command_set.73;
  const char * D.28980;
  int D.28981;
  long unsigned int D.28982;
  sizetype D.28989;
  sizetype D.28990;
  int err.74;
  unsigned int command.75;
  unsigned int D.29001;
  int vm_death_event_sent.76;
  int D.29014;
  _Bool D.29017;
  long int D.29018;
  long int D.29019;
  guint32 D.29022;
  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.69 = log_level;
      D.28940 = log_level.69 > 0;
      D.28941 = (long int) D.28940;
      D.28942 = __builtin_expect (D.28941, 0);
      if (D.28942 != 0) goto <D.28943>; else goto <D.28944>;
      <D.28943>:
      log_file.70 = log_file;
      D.28946 = GetCurrentThreadId ();
      D.28947 = (void *) D.28946;
      fprintf (log_file.70, "[dbg] Agent thread started, pid=%p\n", D.28947);
      log_file.70 = log_file;
      fflush (log_file.70);
      <D.28944>:
      debugger_thread_id.71 = GetCurrentThreadId ();
      debugger_thread_id = debugger_thread_id.71;
      D.28949 = mono_get_root_domain ();
      mono_jit_thread_attach (D.28949);
      D.28950 = mono_thread_internal_current ();
      D.28951 = D.28950->flags;
      D.28952 = D.28951 | 1;
      D.28950->flags = D.28952;
      mono_set_is_debugger_attached (1);
      D.28953 = agent_config.defer;
      if (D.28953 != 0) goto <D.28954>; else goto <D.28955>;
      <D.28954>:
      D.28956 = wait_for_attach ();
      if (D.28956 == 0) goto <D.28957>; else goto <D.28958>;
      <D.28957>:
      log_level.69 = log_level;
      D.28940 = log_level.69 > 0;
      D.28941 = (long int) D.28940;
      D.28942 = __builtin_expect (D.28941, 0);
      if (D.28942 != 0) goto <D.28959>; else goto <D.28960>;
      <D.28959>:
      log_file.70 = log_file;
      fprintf (log_file.70, "[dbg] Can\'t attach, aborting debugger thread.\n");
      log_file.70 = log_file;
      fflush (log_file.70);
      <D.28960>:
      attach_failed = 1;
      goto <D.28961>;
      <D.28958>:
      D.28962 = mono_thread_get_main ();
      process_profiler_event (0, D.28962);
      <D.28961>:
      <D.28955>:
      goto <D.27956>;
      <D.27955>:
      res = transport_recv (&header, 11);
      if (res != 11) goto <D.28963>; else goto <D.28964>;
      <D.28963>:
      log_level.69 = log_level;
      D.28940 = log_level.69 > 0;
      D.28941 = (long int) D.28940;
      D.28942 = __builtin_expect (D.28941, 0);
      if (D.28942 != 0) goto <D.28965>; else goto <D.28966>;
      <D.28965>:
      log_file.70 = log_file;
      fprintf (log_file.70, "[dbg] transport_recv () returned %d, expected %d.\n", res, 11);
      log_file.70 = log_file;
      fflush (log_file.70);
      <D.28966>:
      goto <D.27938>;
      <D.28964>:
      p = &header;
      end = &MEM[(void *)&header + 11B];
      p.72 = p;
      len = decode_int (p.72, &p, end);
      p.72 = p;
      id = decode_int (p.72, &p, end);
      p.72 = p;
      flags = decode_byte (p.72, &p, end);
      p.72 = p;
      command_set = decode_byte (p.72, &p, end);
      p.72 = p;
      command = decode_byte (p.72, &p, end);
      D.28968 = flags != 0;
      D.28969 = (long int) D.28968;
      D.28970 = __builtin_expect (D.28969, 0);
      if (D.28970 != 0) goto <D.28971>; else goto <D.28972>;
      <D.28971>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 9156, "flags == 0");
      <D.28972>:
      log_level.69 = log_level;
      if (log_level.69 != 0) goto <D.28973>; else goto <D.28974>;
      <D.28973>:
      {
        const char * cmd_str;
        char cmd_num[256];

        try
          {
            command_set.73 = (<unnamed type>) command_set;
            cmd_str = cmd_to_string (command_set.73, command);
            if (cmd_str == 0B) goto <D.28976>; else goto <D.28977>;
            <D.28976>:
            sprintf (&cmd_num, "%d", command);
            cmd_str = &cmd_num;
            <D.28977>:
            log_level.69 = log_level;
            D.28940 = log_level.69 > 0;
            D.28941 = (long int) D.28940;
            D.28942 = __builtin_expect (D.28941, 0);
            if (D.28942 != 0) goto <D.28978>; else goto <D.28979>;
            <D.28978>:
            log_file.70 = log_file;
            command_set.73 = (<unnamed type>) command_set;
            D.28980 = command_set_to_string (command_set.73);
            fprintf (log_file.70, "[dbg] Command %s(%s) [%d].\n", D.28980, cmd_str, id);
            log_file.70 = log_file;
            fflush (log_file.70);
            <D.28979>:
          }
        finally
          {
            cmd_num = {CLOBBER};
          }
      }
      <D.28974>:
      D.28981 = len + -11;
      D.28982 = (long unsigned int) D.28981;
      data = monoeg_malloc (D.28982);
      if (len > 11) goto <D.28983>; else goto <D.28984>;
      <D.28983>:
      D.28981 = len + -11;
      res = transport_recv (data, D.28981);
      D.28981 = len + -11;
      if (D.28981 != res) goto <D.28985>; else goto <D.28986>;
      <D.28985>:
      log_level.69 = log_level;
      D.28940 = log_level.69 > 0;
      D.28941 = (long int) D.28940;
      D.28942 = __builtin_expect (D.28941, 0);
      if (D.28942 != 0) goto <D.28987>; else goto <D.28988>;
      <D.28987>:
      log_file.70 = log_file;
      D.28981 = len + -11;
      fprintf (log_file.70, "[dbg] transport_recv () returned %d, expected %d.\n", res, D.28981);
      log_file.70 = log_file;
      fflush (log_file.70);
      <D.28988>:
      goto <D.27938>;
      <D.28986>:
      <D.28984>:
      p = data;
      D.28989 = (sizetype) len;
      D.28990 = D.28989 + 18446744073709551605;
      end = data + D.28990;
      buffer_init (&buf, 128);
      err = 0;
      no_reply = 0;
      switch (command_set) <default: <D.27954>, case 1: <D.27941>, case 9: <D.27953>, case 10: <D.27952>, case 11: <D.27949>, case 13: <D.27951>, case 15: <D.27943>, case 16: <D.27950>, case 20: <D.27944>, case 21: <D.27945>, case 22: <D.27948>, case 23: <D.27947>, case 24: <D.27946>>
      <D.27941>:
      p.72 = p;
      err = vm_commands (command, id, p.72, end, &buf);
      if (err == 0) goto <D.28991>; else goto <D.28992>;
      <D.28991>:
      if (command == 7) goto <D.28993>; else goto <D.28994>;
      <D.28993>:
      no_reply = 1;
      <D.28994>:
      <D.28992>:
      goto <D.27942>;
      <D.27943>:
      p.72 = p;
      err = event_commands (command, p.72, end, &buf);
      goto <D.27942>;
      <D.27944>:
      p.72 = p;
      err = domain_commands (command, p.72, end, &buf);
      goto <D.27942>;
      <D.27945>:
      p.72 = p;
      err = assembly_commands (command, p.72, end, &buf);
      goto <D.27942>;
      <D.27946>:
      p.72 = p;
      err = module_commands (command, p.72, end, &buf);
      goto <D.27942>;
      <D.27947>:
      p.72 = p;
      err = type_commands (command, p.72, end, &buf);
      goto <D.27942>;
      <D.27948>:
      p.72 = p;
      err = method_commands (command, p.72, end, &buf);
      goto <D.27942>;
      <D.27949>:
      p.72 = p;
      err = thread_commands (command, p.72, end, &buf);
      goto <D.27942>;
      <D.27950>:
      p.72 = p;
      err = frame_commands (command, p.72, end, &buf);
      goto <D.27942>;
      <D.27951>:
      p.72 = p;
      err = array_commands (command, p.72, end, &buf);
      goto <D.27942>;
      <D.27952>:
      p.72 = p;
      err = string_commands (command, p.72, end, &buf);
      goto <D.27942>;
      <D.27953>:
      p.72 = p;
      err = object_commands (command, p.72, end, &buf);
      goto <D.27942>;
      <D.27954>:
      err = 100;
      <D.27942>:
      if (no_reply == 0) goto <D.28995>; else goto <D.28996>;
      <D.28995>:
      err.74 = (int) err;
      send_reply_packet (id, err.74, &buf);
      <D.28996>:
      monoeg_g_free (data);
      buffer_free (&buf);
      if (command_set == 1) goto <D.28998>; else goto <D.28999>;
      <D.28998>:
      command.75 = (unsigned int) command;
      D.29001 = command.75 + 4294967291;
      if (D.29001 <= 1) goto <D.27938>; else goto <D.29002>;
      <D.29002>:
      <D.28999>:
      <D.27956>:
      if (attach_failed == 0) goto <D.27955>; else goto <D.27938>;
      <D.27938>:
      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.69 = log_level;
      D.28940 = log_level.69 > 0;
      D.28941 = (long int) D.28940;
      D.28942 = __builtin_expect (D.28941, 0);
      if (D.28942 != 0) goto <D.29003>; else goto <D.29004>;
      <D.29003>:
      log_file.70 = log_file;
      fprintf (log_file.70, "[dbg] Debugger thread exited.\n");
      log_file.70 = log_file;
      fflush (log_file.70);
      <D.29004>:
      if (attach_failed == 0) goto <D.29005>; else goto <D.29006>;
      <D.29005>:
      if (command_set == 1) goto <D.29007>; else goto <D.29008>;
      <D.29007>:
      if (command == 6) goto <D.29009>; else goto <D.29010>;
      <D.29009>:
      vm_death_event_sent.76 = vm_death_event_sent;
      if (vm_death_event_sent.76 == 0) goto <D.29012>; else goto <D.29013>;
      <D.29012>:
      D.29014 = mono_runtime_is_shutting_down ();
      if (D.29014 == 0) goto <D.29015>; else goto <D.29016>;
      <D.29015>:
      log_level.69 = log_level;
      D.29017 = log_level.69 > 1;
      D.29018 = (long int) D.29017;
      D.29019 = __builtin_expect (D.29018, 0);
      if (D.29019 != 0) goto <D.29020>; else goto <D.29021>;
      <D.29020>:
      log_file.70 = log_file;
      fprintf (log_file.70, "[dbg] Detached - restarting clean debugger thread.\n");
      log_file.70 = log_file;
      fflush (log_file.70);
      <D.29021>:
      start_debugger_thread ();
      <D.29016>:
      <D.29013>:
      <D.29010>:
      <D.29008>:
      <D.29006>:
      D.29022 = 0;
      return D.29022;
    }
  finally
    {
      header = {CLOBBER};
      p = {CLOBBER};
      buf = {CLOBBER};
    }
}


wait_for_attach ()
{
  int listen_fd.77;
  int log_level.78;
  _Bool D.29029;
  long int D.29030;
  long int D.29031;
  struct FILE * log_file.79;
  gboolean D.29035;
  int conn_fd.80;
  int conn_fd.81;
  int D.29044;
  _Bool D.29045;
  int disconnected.82;
  int disconnected.83;

  listen_fd.77 = listen_fd;
  if (listen_fd.77 == -1) goto <D.29026>; else goto <D.29027>;
  <D.29026>:
  log_level.78 = log_level;
  D.29029 = log_level.78 > 0;
  D.29030 = (long int) D.29029;
  D.29031 = __builtin_expect (D.29030, 0);
  if (D.29031 != 0) goto <D.29032>; else goto <D.29033>;
  <D.29032>:
  log_file.79 = log_file;
  fprintf (log_file.79, "[dbg] Invalid listening socket\n");
  log_file.79 = log_file;
  fflush (log_file.79);
  <D.29033>:
  D.29035 = 0;
  return D.29035;
  <D.29027>:
  listen_fd.77 = listen_fd;
  conn_fd.80 = socket_transport_accept (listen_fd.77);
  conn_fd = conn_fd.80;
  log_level.78 = log_level;
  D.29029 = log_level.78 > 0;
  D.29030 = (long int) D.29029;
  D.29031 = __builtin_expect (D.29030, 0);
  if (D.29031 != 0) goto <D.29037>; else goto <D.29038>;
  <D.29037>:
  log_file.79 = log_file;
  conn_fd.81 = conn_fd;
  fprintf (log_file.79, "Accepted connection on %d\n", conn_fd.81);
  log_file.79 = log_file;
  fflush (log_file.79);
  <D.29038>:
  conn_fd.81 = conn_fd;
  if (conn_fd.81 == -1) goto <D.29040>; else goto <D.29041>;
  <D.29040>:
  log_level.78 = log_level;
  D.29029 = log_level.78 > 0;
  D.29030 = (long int) D.29029;
  D.29031 = __builtin_expect (D.29030, 0);
  if (D.29031 != 0) goto <D.29042>; else goto <D.29043>;
  <D.29042>:
  log_file.79 = log_file;
  fprintf (log_file.79, "[dbg] Bad client connection\n");
  log_file.79 = log_file;
  fflush (log_file.79);
  <D.29043>:
  D.29035 = 0;
  return D.29035;
  <D.29041>:
  D.29044 = transport_handshake ();
  D.29045 = D.29044 == 0;
  disconnected.82 = (int) D.29045;
  disconnected = disconnected.82;
  disconnected.83 = disconnected;
  if (disconnected.83 != 0) goto <D.29048>; else goto <D.29049>;
  <D.29048>:
  log_level.78 = log_level;
  D.29029 = log_level.78 > 0;
  D.29030 = (long int) D.29029;
  D.29031 = __builtin_expect (D.29030, 0);
  if (D.29031 != 0) goto <D.29050>; else goto <D.29051>;
  <D.29050>:
  log_file.79 = log_file;
  fprintf (log_file.79, "Transport handshake failed!\n");
  log_file.79 = log_file;
  fflush (log_file.79);
  <D.29051>:
  D.29035 = 0;
  return D.29035;
  <D.29049>:
  D.29035 = 1;
  return D.29035;
}


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.29053;
  int conn_fd.84;
  int conn_fd.85;
  struct _IO_FILE * stderr.86;
  int log_level.87;
  _Bool D.29061;
  long int D.29062;
  long int D.29063;
  struct FILE * log_file.88;
  int D.29067;

  D.29053.__sockaddr__ = 0B;
  conn_fd.84 = accept (socket_fd, D.29053, 0B);
  conn_fd = conn_fd.84;
  conn_fd.85 = conn_fd;
  if (conn_fd.85 == -1) goto <D.29056>; else goto <D.29057>;
  <D.29056>:
  stderr.86 = stderr;
  fprintf (stderr.86, "debugger-agent: Unable to listen on %d\n", socket_fd);
  goto <D.29059>;
  <D.29057>:
  log_level.87 = log_level;
  D.29061 = log_level.87 > 0;
  D.29062 = (long int) D.29061;
  D.29063 = __builtin_expect (D.29062, 0);
  if (D.29063 != 0) goto <D.29064>; else goto <D.29065>;
  <D.29064>:
  log_file.88 = log_file;
  conn_fd.85 = conn_fd;
  fprintf (log_file.88, "Accepted connection from client, connection fd=%d.\n", conn_fd.85);
  log_file.88 = log_file;
  fflush (log_file.88);
  <D.29065>:
  <D.29059>:
  D.29067 = conn_fd;
  return D.29067;
}


transport_handshake ()
{
  long unsigned int D.29069;
  int D.29070;
  int * D.29072;
  int D.29073;
  _Bool D.29074;
  long int D.29075;
  long int D.29076;
  long unsigned int D.29079;
  int D.29080;
  long unsigned int D.29083;
  long unsigned int D.29084;
  char[128] * handshake_msg.89;
  char D.29087;
  _Bool D.29088;
  long unsigned int D.29089;
  int D.29090;
  struct _IO_FILE * stderr.90;
  gboolean D.29092;
  int conn_fd.91;
  _Bool D.29096;
  long int D.29097;
  long int D.29098;
  char handshake_msg[128];
  guint8 buf[128];
  int res;

  try
    {
      disconnected = 1;
      sprintf (&handshake_msg, "DWP-Handshake");
      <D.25479>:
      D.29069 = strlen (&handshake_msg);
      D.29070 = (int) D.29069;
      res = transport_send (&handshake_msg, D.29070);
      if (res == -1) goto <D.29071>; else goto <D.25480>;
      <D.29071>:
      D.29072 = __errno_location ();
      D.29073 = *D.29072;
      if (D.29073 == 4) goto <D.25479>; else goto <D.25480>;
      <D.25480>:
      D.29074 = res == -1;
      D.29075 = (long int) D.29074;
      D.29076 = __builtin_expect (D.29075, 0);
      if (D.29076 != 0) goto <D.29077>; else goto <D.29078>;
      <D.29077>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 1498, "res != -1");
      <D.29078>:
      D.29079 = strlen (&handshake_msg);
      D.29080 = (int) D.29079;
      res = transport_recv (&buf, D.29080);
      D.29083 = (long unsigned int) res;
      D.29084 = strlen (&handshake_msg);
      if (D.29083 != D.29084) goto <D.29081>; else goto <D.29085>;
      <D.29085>:
      handshake_msg.89 = &handshake_msg;
      D.29087 = MEM[(const char *)handshake_msg.89];
      D.29088 = D.29087 != 0;
      D.29089 = (long unsigned int) D.29088;
      D.29090 = memcmp (&buf, &handshake_msg, D.29089);
      if (D.29090 != 0) goto <D.29081>; else goto <D.29082>;
      <D.29081>:
      stderr.90 = stderr;
      fprintf (stderr.90, "debugger-agent: DWP handshake failed.\n");
      D.29092 = 0;
      return D.29092;
      <D.29082>:
      major_version = 2;
      minor_version = 27;
      protocol_version_set = 0;
      conn_fd.91 = conn_fd;
      if (conn_fd.91 != 0) goto <D.29094>; else goto <D.29095>;
      <D.29094>:
      {
        int flag;
        int result;

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


transport_send (void * buf, int len)
{
  int D.29103;
  struct DebuggerTransport * transport.92;
  gboolean (*<T3fb8>) (void *, int) D.29105;

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


set_keepalive ()
{
  int D.29109;
  int conn_fd.93;
  int D.29112;
  long int D.29113;
  int D.29114;
  int D.29115;
  long int D.29116;
  _Bool D.29117;
  long int D.29118;
  long int D.29119;
  struct timeval tv;
  int result;

  try
    {
      D.29109 = agent_config.keepalive;
      if (D.29109 == 0) goto <D.29107>; else goto <D.29110>;
      <D.29110>:
      conn_fd.93 = conn_fd;
      if (conn_fd.93 == 0) goto <D.29107>; else goto <D.29108>;
      <D.29107>:
      return;
      <D.29108>:
      D.29109 = agent_config.keepalive;
      D.29112 = D.29109 / 1000;
      D.29113 = (long int) D.29112;
      tv.tv_sec = D.29113;
      D.29109 = agent_config.keepalive;
      D.29114 = D.29109 % 1000;
      D.29115 = D.29114 * 1000;
      D.29116 = (long int) D.29115;
      tv.tv_usec = D.29116;
      conn_fd.93 = conn_fd;
      result = setsockopt (conn_fd.93, 1, 18, &tv, 16);
      D.29117 = result < 0;
      D.29118 = (long int) D.29117;
      D.29119 = __builtin_expect (D.29118, 0);
      if (D.29119 != 0) goto <D.29120>; else goto <D.29121>;
      <D.29120>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 1126, "result >= 0");
      <D.29121>:
    }
  finally
    {
      tv = {CLOBBER};
    }
}


decode_int (guint8 * buf, guint8 * * endbuf, guint8 * limit)
{
  guint8 * D.29125;
  guint8 * D.29126;
  _Bool D.29127;
  long int D.29128;
  long int D.29129;
  int D.29132;
  unsigned char D.29133;
  int D.29134;
  int D.29135;
  guint8 * D.29136;
  unsigned char D.29137;
  int D.29138;
  int D.29139;
  int D.29140;
  guint8 * D.29141;
  unsigned char D.29142;
  int D.29143;
  int D.29144;
  int D.29145;
  guint8 * D.29146;
  unsigned char D.29147;
  int D.29148;

  D.29125 = buf + 4;
  *endbuf = D.29125;
  D.29126 = *endbuf;
  D.29127 = D.29126 > limit;
  D.29128 = (long int) D.29127;
  D.29129 = __builtin_expect (D.29128, 0);
  if (D.29129 != 0) goto <D.29130>; else goto <D.29131>;
  <D.29130>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 1599, "*endbuf <= limit");
  <D.29131>:
  D.29133 = *buf;
  D.29134 = (int) D.29133;
  D.29135 = D.29134 << 24;
  D.29136 = buf + 1;
  D.29137 = *D.29136;
  D.29138 = (int) D.29137;
  D.29139 = D.29138 << 16;
  D.29140 = D.29135 | D.29139;
  D.29141 = buf + 2;
  D.29142 = *D.29141;
  D.29143 = (int) D.29142;
  D.29144 = D.29143 << 8;
  D.29145 = D.29140 | D.29144;
  D.29146 = buf + 3;
  D.29147 = *D.29146;
  D.29148 = (int) D.29147;
  D.29132 = D.29145 | D.29148;
  return D.29132;
}


decode_byte (guint8 * buf, guint8 * * endbuf, guint8 * limit)
{
  guint8 * D.29150;
  guint8 * D.29151;
  _Bool D.29152;
  long int D.29153;
  long int D.29154;
  int D.29157;
  unsigned char D.29158;

  D.29150 = buf + 1;
  *endbuf = D.29150;
  D.29151 = *endbuf;
  D.29152 = D.29151 > limit;
  D.29153 = (long int) D.29152;
  D.29154 = __builtin_expect (D.29153, 0);
  if (D.29154 != 0) goto <D.29155>; else goto <D.29156>;
  <D.29155>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 1591, "*endbuf <= limit");
  <D.29156>:
  D.29158 = *buf;
  D.29157 = (int) D.29158;
  return D.29157;
}


cmd_to_string (CommandSet set, int command)
{
  const char * D.29160;
  long unsigned int D.29164;
  long unsigned int D.29165;
  sizetype D.29166;
  const char * * D.29167;
  const char * * cmds;
  int cmds_len;

  cmds_len = 0;
  switch (set) <default: <D.27917>, case 1: <D.27903>, case 9: <D.27905>, case 10: <D.27906>, case 11: <D.27907>, case 13: <D.27908>, case 15: <D.27909>, case 16: <D.27910>, case 20: <D.27911>, case 21: <D.27912>, case 22: <D.27913>, case 23: <D.27914>, case 24: <D.27915>, case 64: <D.27916>>
  <D.27903>:
  cmds = &vm_cmds_str;
  cmds_len = 12;
  goto <D.27904>;
  <D.27905>:
  cmds = &object_cmds_str;
  cmds_len = 7;
  goto <D.27904>;
  <D.27906>:
  cmds = &string_cmds_str;
  cmds_len = 3;
  goto <D.27904>;
  <D.27907>:
  cmds = &thread_cmds_str;
  cmds_len = 6;
  goto <D.27904>;
  <D.27908>:
  cmds = &array_cmds_str;
  cmds_len = 3;
  goto <D.27904>;
  <D.27909>:
  cmds = &event_cmds_str;
  cmds_len = 3;
  goto <D.27904>;
  <D.27910>:
  cmds = &stack_frame_cmds_str;
  cmds_len = 3;
  goto <D.27904>;
  <D.27911>:
  cmds = &appdomain_cmds_str;
  cmds_len = 7;
  goto <D.27904>;
  <D.27912>:
  cmds = &assembly_cmds_str;
  cmds_len = 6;
  goto <D.27904>;
  <D.27913>:
  cmds = &method_cmds_str;
  cmds_len = 10;
  goto <D.27904>;
  <D.27914>:
  cmds = &type_cmds_str;
  cmds_len = 18;
  goto <D.27904>;
  <D.27915>:
  cmds = &module_cmds_str;
  cmds_len = 1;
  goto <D.27904>;
  <D.27916>:
  cmds = &event_cmds_str;
  cmds_len = 3;
  goto <D.27904>;
  <D.27917>:
  D.29160 = 0B;
  return D.29160;
  <D.27904>:
  if (command > 0) goto <D.29162>; else goto <D.29161>;
  <D.29162>:
  if (command <= cmds_len) goto <D.29163>; else goto <D.29161>;
  <D.29163>:
  D.29164 = (long unsigned int) command;
  D.29165 = D.29164 * 8;
  D.29166 = D.29165 + 18446744073709551608;
  D.29167 = cmds + D.29166;
  D.29160 = *D.29167;
  return D.29160;
  <D.29161>:
  D.29160 = 0B;
  return D.29160;
}


sprintf (char * restrict __s, const char * restrict __fmt)
{
  int D.29169;
  long unsigned int D.29170;

  D.29170 = __builtin_object_size (__s, 1);
  D.29169 = __builtin___sprintf_chk (__s, 1, D.29170, __fmt, __builtin_va_arg_pack ());
  return D.29169;
}


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

  switch (command_set) <default: <D.27884>, case 1: <D.27871>, case 9: <D.27872>, case 10: <D.27873>, case 11: <D.27874>, case 13: <D.27875>, case 15: <D.27876>, case 16: <D.27877>, case 20: <D.27878>, case 21: <D.27879>, case 22: <D.27880>, case 23: <D.27881>, case 24: <D.27882>, case 64: <D.27883>>
  <D.27871>:
  D.29172 = "VM";
  return D.29172;
  <D.27872>:
  D.29172 = "OBJECT_REF";
  return D.29172;
  <D.27873>:
  D.29172 = "STRING_REF";
  return D.29172;
  <D.27874>:
  D.29172 = "THREAD";
  return D.29172;
  <D.27875>:
  D.29172 = "ARRAY_REF";
  return D.29172;
  <D.27876>:
  D.29172 = "EVENT_REQUEST";
  return D.29172;
  <D.27877>:
  D.29172 = "STACK_FRAME";
  return D.29172;
  <D.27878>:
  D.29172 = "APPDOMAIN";
  return D.29172;
  <D.27879>:
  D.29172 = "ASSEMBLY";
  return D.29172;
  <D.27880>:
  D.29172 = "METHOD";
  return D.29172;
  <D.27881>:
  D.29172 = "TYPE";
  return D.29172;
  <D.27882>:
  D.29172 = "MODULE";
  return D.29172;
  <D.27883>:
  D.29172 = "EVENT";
  return D.29172;
  <D.27884>:
  D.29172 = "";
  return D.29172;
}


transport_recv (void * buf, int len)
{
  int D.29174;
  struct DebuggerTransport * transport.94;
  int (*<T3fb9>) (void *, int) D.29176;

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


vm_commands (int command, int id, guint8 * p, guint8 * end, struct Buffer * buf)
{
  guint8 * p.95;
  int major_version.96;
  int minor_version.97;
  int log_level.98;
  _Bool D.29182;
  long int D.29183;
  long int D.29184;
  struct FILE * log_file.99;
  int major_version.100;
  int minor_version.101;
  struct MonoGHashTable * tid_to_thread_obj.102;
  unsigned int D.29191;
  int suspend_count.103;
  ErrorCode D.29195;
  struct GPtrArray * event_requests.104;
  void * * D.29197;
  int D.29198;
  int D.29199;
  unsigned int D.29200;
  int D.29201;
  int D.29202;
  struct MonoImage * D.29203;
  struct MonoGHashTable * tid_to_thread.105;
  struct MonoGHashTable * thread_to_tls.106;
  void * D.29212;
  void * D.29213;
  void * D.29214;
  struct InvokeData * D.29215;
  int D.29216;
  <unnamed type> D.29224;
  int D.29232;
  struct MonoThread * thread.107;
  struct _MonoInternalThread * D.29236;
  _Bool D.29237;
  long int D.29238;
  long int D.29239;
  int D.29242;
  struct InvokeData * D.29245;
  void * D.29248;
  long int end.108;
  long int p.109;
  long int D.29251;
  long unsigned int D.29252;
  void * D.29253;
  guint8 * D.29254;
  long unsigned int D.29255;
  sizetype D.29256;
  guint8 * D.29257;
  unsigned int suspend_count.110;
  int D.29259;
  <unnamed type> D.29263;
  struct MonoThread * thread.111;
  struct _MonoInternalThread * D.29267;
  _Bool D.29268;
  long int D.29269;
  long int D.29270;
  int D.29273;
  struct InvokeData * D.29278;
  int D.29280;
  struct GHashTable * domains.112;
  struct MonoDomain * domain.113;
  void * D.29283;
  struct GHashTable * D.29284;
  struct GHashTable * D.29285;
  struct MonoClass * klass.114;
  void * D.29287;
  void * * D.29290;
  long unsigned int D.29291;
  long unsigned int D.29292;
  void * * D.29293;
  struct GHashTable * D.29294;
  gchar * D.29297;
  struct GHashTable * D.29299;
  gchar * D.29302;
  unsigned int i.115;
  unsigned int D.29305;
  int D.29306;
  void * klass.116;
  int D.29311;
  unsigned int D.29312;
  void * * D.29313;
  void * * D.29314;
  void * D.29315;
  void * * D.29316;
  void * * D.29317;
  void * D.29318;
  int D.29319;
  struct MonoDomain * domain.117;
  union mono_mutex_t * D.29323;
  _Bool D.29326;
  long int D.29327;
  long int D.29328;
  struct MonoImage * D.29331;
  struct MonoClass * D.29336;
  _Bool D.29339;
  long int D.29340;
  long int D.29341;
  int D.29344;
  unsigned int D.29345;
  void * * D.29346;
  long unsigned int D.29347;
  long unsigned int D.29348;
  void * * D.29349;
  void * D.29350;
  void * * D.29351;
  void * * D.29352;
  void * D.29353;
  unsigned int i.118;

  switch (command) <default: <D.27223>, case 1: <D.27111>, case 2: <D.27116>, case 3: <D.27117>, case 4: <D.27118>, case 5: <D.27127>, case 6: <D.27119>, case 7: <D.27144>, case 8: <D.27115>, case 9: <D.27157>, case 10: <D.27163>, case 11: <D.27165>, case 12: <D.27199>, case 13: <D.27145>>
  <D.27111>:
  {
    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.27114>;
  }
  <D.27115>:
  p.95 = p;
  major_version.96 = decode_int (p.95, &p, end);
  major_version = major_version.96;
  p.95 = p;
  minor_version.97 = decode_int (p.95, &p, end);
  minor_version = minor_version.97;
  protocol_version_set = 1;
  log_level.98 = log_level;
  D.29182 = log_level.98 > 0;
  D.29183 = (long int) D.29182;
  D.29184 = __builtin_expect (D.29183, 0);
  if (D.29184 != 0) goto <D.29185>; else goto <D.29186>;
  <D.29185>:
  log_file.99 = log_file;
  major_version.100 = major_version;
  minor_version.101 = minor_version;
  fprintf (log_file.99, "[dbg] Protocol version %d.%d, client protocol version %d.%d.\n", 2, 27, major_version.100, minor_version.101);
  log_file.99 = log_file;
  fflush (log_file.99);
  <D.29186>:
  goto <D.27114>;
  <D.27116>:
  mono_loader_lock ();
  tid_to_thread_obj.102 = tid_to_thread_obj;
  D.29191 = mono_g_hash_table_size (tid_to_thread_obj.102);
  buffer_add_int (buf, D.29191);
  tid_to_thread_obj.102 = tid_to_thread_obj;
  mono_g_hash_table_foreach (tid_to_thread_obj.102, add_thread, buf);
  mono_loader_unlock ();
  goto <D.27114>;
  <D.27117>:
  suspend_vm ();
  wait_for_suspend ();
  goto <D.27114>;
  <D.27118>:
  suspend_count.103 = suspend_count;
  if (suspend_count.103 == 0) goto <D.29193>; else goto <D.29194>;
  <D.29193>:
  D.29195 = 101;
  return D.29195;
  <D.29194>:
  resume_vm ();
  clear_suspended_objs ();
  goto <D.27114>;
  <D.27119>:
  mono_loader_lock ();
  goto <D.27122>;
  <D.27121>:
  {
    struct EventRequest * req;

    event_requests.104 = event_requests;
    D.29197 = event_requests.104->pdata;
    req = *D.29197;
    D.29198 = req->id;
    D.29199 = req->event_kind;
    clear_event_request (D.29198, D.29199);
  }
  <D.27122>:
  event_requests.104 = event_requests;
  D.29200 = event_requests.104->len;
  if (D.29200 != 0) goto <D.27121>; else goto <D.27123>;
  <D.27123>:
  mono_loader_unlock ();
  goto <D.27125>;
  <D.27124>:
  resume_vm ();
  <D.27125>:
  suspend_count.103 = suspend_count;
  if (suspend_count.103 > 0) goto <D.27124>; else goto <D.27126>;
  <D.27126>:
  disconnected = 1;
  vm_start_event_sent = 0;
  goto <D.27114>;
  <D.27127>:
  {
    struct MonoInternalThread * thread;
    struct DebuggerTlsData * tls;
    struct MonoClass * env_class;
    struct MonoMethod * exit_method;
    void * * args;
    int exit_code;

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

      event_requests.104 = event_requests;
      D.29197 = event_requests.104->pdata;
      req = *D.29197;
      D.29201 = req->id;
      D.29202 = req->event_kind;
      clear_event_request (D.29201, D.29202);
    }
    <D.27136>:
    event_requests.104 = event_requests;
    D.29200 = event_requests.104->len;
    if (D.29200 != 0) goto <D.27135>; else goto <D.27137>;
    <D.27137>:
    mono_loader_unlock ();
    suspend_vm ();
    wait_for_suspend ();
    D.29203 = mono_defaults.corlib;
    env_class = mono_class_from_name (D.29203, "System", "Environment");
    if (env_class != 0B) goto <D.29204>; else goto <D.29205>;
    <D.29204>:
    exit_method = mono_class_get_method_from_name (env_class, "Exit", 1);
    <D.29205>:
    mono_loader_lock ();
    tid_to_thread.105 = tid_to_thread;
    thread = mono_g_hash_table_find (tid_to_thread.105, is_really_suspended, 0B);
    mono_loader_unlock ();
    if (thread != 0B) goto <D.29209>; else goto <D.29207>;
    <D.29209>:
    if (exit_method != 0B) goto <D.29210>; else goto <D.29207>;
    <D.29210>:
    mono_loader_lock ();
    thread_to_tls.106 = thread_to_tls;
    tls = mono_g_hash_table_lookup (thread_to_tls.106, thread);
    mono_loader_unlock ();
    args = monoeg_malloc0 (8);
    D.29212 = monoeg_malloc (4);
    *args = D.29212;
    D.29213 = *args;
    MEM[(int *)D.29213] = exit_code;
    D.29214 = monoeg_malloc0 (376);
    tls->pending_invoke = D.29214;
    D.29215 = tls->pending_invoke;
    D.29215->method = exit_method;
    D.29215 = tls->pending_invoke;
    D.29215->args = args;
    D.29215 = tls->pending_invoke;
    D.29215->nmethods = 1;
    goto <D.27139>;
    <D.27138>:
    resume_vm ();
    <D.27139>:
    suspend_count.103 = suspend_count;
    if (suspend_count.103 > 0) goto <D.27138>; else goto <D.27140>;
    <D.27140>:
    goto <D.29208>;
    <D.29207>:
    goto <D.27142>;
    <D.27141>:
    resume_vm ();
    <D.27142>:
    suspend_count.103 = suspend_count;
    if (suspend_count.103 > 0) goto <D.27141>; else goto <D.27143>;
    <D.27143>:
    D.29216 = mono_runtime_try_shutdown ();
    if (D.29216 == 0) goto <D.27114>; else goto <D.29217>;
    <D.29217>:
    mono_environment_exitcode_set (exit_code);
    log_level.98 = log_level;
    D.29182 = log_level.98 > 0;
    D.29183 = (long int) D.29182;
    D.29184 = __builtin_expect (D.29183, 0);
    if (D.29184 != 0) goto <D.29218>; else goto <D.29219>;
    <D.29218>:
    log_file.99 = log_file;
    fprintf (log_file.99, "Suspending all threads...\n");
    log_file.99 = log_file;
    fflush (log_file.99);
    <D.29219>:
    mono_thread_suspend_all_other_threads ();
    log_level.98 = log_level;
    D.29182 = log_level.98 > 0;
    D.29183 = (long int) D.29182;
    D.29184 = __builtin_expect (D.29183, 0);
    if (D.29184 != 0) goto <D.29220>; else goto <D.29221>;
    <D.29220>:
    log_file.99 = log_file;
    fprintf (log_file.99, "Shutting down the runtime...\n");
    log_file.99 = log_file;
    fflush (log_file.99);
    <D.29221>:
    mono_runtime_quit ();
    transport_close2 ();
    log_level.98 = log_level;
    D.29182 = log_level.98 > 0;
    D.29183 = (long int) D.29182;
    D.29184 = __builtin_expect (D.29183, 0);
    if (D.29184 != 0) goto <D.29222>; else goto <D.29223>;
    <D.29222>:
    log_file.99 = log_file;
    fprintf (log_file.99, "Exiting...\n");
    log_file.99 = log_file;
    fflush (log_file.99);
    <D.29223>:
    exit (exit_code);
    <D.29208>:
    goto <D.27114>;
  }
  <D.27144>:
  <D.27145>:
  {
    int objid;
    struct MonoThread * thread;
    struct DebuggerTlsData * tls;
    int i;
    int count;
    int err;
    int flags;
    int nmethods;

    try
      {
        p.95 = p;
        objid = decode_objid (p.95, &p, end);
        D.29224 = get_object (objid, &thread);
        err = (int) D.29224;
        if (err != 0) goto <D.29225>; else goto <D.29226>;
        <D.29225>:
        D.29195 = (ErrorCode) err;
        return D.29195;
        <D.29226>:
        p.95 = p;
        flags = decode_int (p.95, &p, end);
        if (command == 13) goto <D.29227>; else goto <D.29228>;
        <D.29227>:
        p.95 = p;
        nmethods = decode_int (p.95, &p, end);
        goto <D.29229>;
        <D.29228>:
        nmethods = 1;
        <D.29229>:
        suspend_count.103 = suspend_count;
        if (suspend_count.103 != 0) goto <D.29230>; else goto <D.29231>;
        <D.29230>:
        wait_for_suspend ();
        <D.29231>:
        D.29232 = is_suspended ();
        if (D.29232 == 0) goto <D.29233>; else goto <D.29234>;
        <D.29233>:
        D.29195 = 101;
        return D.29195;
        <D.29234>:
        mono_loader_lock ();
        thread_to_tls.106 = thread_to_tls;
        thread.107 = thread;
        D.29236 = thread.107->internal_thread;
        tls = mono_g_hash_table_lookup (thread_to_tls.106, D.29236);
        mono_loader_unlock ();
        D.29237 = tls == 0B;
        D.29238 = (long int) D.29237;
        D.29239 = __builtin_expect (D.29238, 0);
        if (D.29239 != 0) goto <D.29240>; else goto <D.29241>;
        <D.29240>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 6722, "tls");
        <D.29241>:
        D.29242 = tls->really_suspended;
        if (D.29242 == 0) goto <D.29243>; else goto <D.29244>;
        <D.29243>:
        D.29195 = 101;
        return D.29195;
        <D.29244>:
        D.29245 = tls->pending_invoke;
        if (D.29245 != 0B) goto <D.29246>; else goto <D.29247>;
        <D.29246>:
        D.29195 = 101;
        return D.29195;
        <D.29247>:
        D.29248 = monoeg_malloc0 (376);
        tls->pending_invoke = D.29248;
        D.29245 = tls->pending_invoke;
        D.29245->id = id;
        D.29245 = tls->pending_invoke;
        D.29245->flags = flags;
        D.29245 = tls->pending_invoke;
        end.108 = (long int) end;
        p.95 = p;
        p.109 = (long int) p.95;
        D.29251 = end.108 - p.109;
        D.29252 = (long unsigned int) D.29251;
        D.29253 = monoeg_malloc (D.29252);
        D.29245->p = D.29253;
        D.29245 = tls->pending_invoke;
        D.29254 = D.29245->p;
        p.95 = p;
        end.108 = (long int) end;
        p.95 = p;
        p.109 = (long int) p.95;
        D.29251 = end.108 - p.109;
        D.29255 = (long unsigned int) D.29251;
        memcpy (D.29254, p.95, D.29255);
        D.29245 = tls->pending_invoke;
        D.29245 = tls->pending_invoke;
        D.29254 = D.29245->p;
        end.108 = (long int) end;
        p.95 = p;
        p.109 = (long int) p.95;
        D.29251 = end.108 - p.109;
        D.29256 = (sizetype) D.29251;
        D.29257 = D.29254 + D.29256;
        D.29245->endp = D.29257;
        D.29245 = tls->pending_invoke;
        suspend_count.103 = suspend_count;
        suspend_count.110 = (unsigned int) suspend_count.103;
        D.29245->suspend_count = suspend_count.110;
        D.29245 = tls->pending_invoke;
        D.29245->nmethods = nmethods;
        D.29259 = flags & 2;
        if (D.29259 != 0) goto <D.29260>; else goto <D.29261>;
        <D.29260>:
        thread.107 = thread;
        D.29236 = thread.107->internal_thread;
        resume_thread (D.29236);
        goto <D.29262>;
        <D.29261>:
        count = suspend_count;
        i = 0;
        goto <D.27155>;
        <D.27154>:
        resume_vm ();
        i = i + 1;
        <D.27155>:
        if (i < count) goto <D.27154>; else goto <D.27156>;
        <D.27156>:
        <D.29262>:
        goto <D.27114>;
      }
    finally
      {
        thread = {CLOBBER};
      }
  }
  <D.27157>:
  {
    int objid;
    struct MonoThread * thread;
    struct DebuggerTlsData * tls;
    int invoke_id;
    int err;

    try
      {
        p.95 = p;
        objid = decode_objid (p.95, &p, end);
        D.29263 = get_object (objid, &thread);
        err = (int) D.29263;
        if (err != 0) goto <D.29264>; else goto <D.29265>;
        <D.29264>:
        D.29195 = (ErrorCode) err;
        return D.29195;
        <D.29265>:
        p.95 = p;
        invoke_id = decode_int (p.95, &p, end);
        mono_loader_lock ();
        thread_to_tls.106 = thread_to_tls;
        thread.111 = thread;
        D.29267 = thread.111->internal_thread;
        tls = mono_g_hash_table_lookup (thread_to_tls.106, D.29267);
        D.29268 = tls == 0B;
        D.29269 = (long int) D.29268;
        D.29270 = __builtin_expect (D.29269, 0);
        if (D.29270 != 0) goto <D.29271>; else goto <D.29272>;
        <D.29271>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 6767, "tls");
        <D.29272>:
        D.29273 = tls->abort_requested;
        if (D.29273 != 0) goto <D.29274>; else goto <D.29275>;
        <D.29274>:
        mono_loader_unlock ();
        goto <D.27114>;
        <D.29275>:
        D.29278 = tls->invoke;
        if (D.29278 == 0B) goto <D.29276>; else goto <D.29279>;
        <D.29279>:
        D.29278 = tls->invoke;
        D.29280 = D.29278->id;
        if (D.29280 != invoke_id) goto <D.29276>; else goto <D.29277>;
        <D.29276>:
        mono_loader_unlock ();
        D.29195 = 104;
        return D.29195;
        <D.29277>:
        tls->abort_requested = 1;
        thread.111 = thread;
        D.29267 = thread.111->internal_thread;
        ves_icall_System_Threading_Thread_Abort (D.29267, 0B);
        mono_loader_unlock ();
        goto <D.27114>;
      }
    finally
      {
        thread = {CLOBBER};
      }
  }
  <D.27163>:
  {
    int timeout;

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

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

          domain.113 = domain;
          D.29283 = domain.113->runtime_info;
          info = MEM[(struct MonoJitDomainInfo *)D.29283].agent_info;
          D.29284 = info->loaded_classes;
          monoeg_g_hash_table_iter_init (&kiter, D.29284);
          goto <D.27187>;
          <D.27186>:
          D.29285 = info->source_files;
          klass.114 = klass;
          D.29287 = monoeg_g_hash_table_lookup (D.29285, klass.114);
          if (D.29287 == 0B) goto <D.29288>; else goto <D.29289>;
          <D.29288>:
          klass.114 = klass;
          files = get_source_files_for_type (klass.114);
          D.29285 = info->source_files;
          klass.114 = klass;
          monoeg_g_hash_table_insert_replace (D.29285, klass.114, files, 0);
          i = 0;
          goto <D.27184>;
          <D.27183>:
          {
            char * s;
            char * s2;
            char * s3;

            D.29290 = files->pdata;
            D.29291 = (long unsigned int) i;
            D.29292 = D.29291 * 8;
            D.29293 = D.29290 + D.29292;
            s = *D.29293;
            s2 = monoeg_g_path_get_basename (s);
            D.29294 = info->source_file_to_class;
            class_list = monoeg_g_hash_table_lookup (D.29294, s2);
            if (class_list == 0B) goto <D.29295>; else goto <D.29296>;
            <D.29295>:
            klass.114 = klass;
            class_list = monoeg_g_slist_prepend (class_list, klass.114);
            D.29294 = info->source_file_to_class;
            D.29297 = monoeg_strdup (s2);
            monoeg_g_hash_table_insert_replace (D.29294, D.29297, class_list, 0);
            goto <D.29298>;
            <D.29296>:
            klass.114 = klass;
            class_list = monoeg_g_slist_prepend (class_list, klass.114);
            D.29294 = info->source_file_to_class;
            monoeg_g_hash_table_insert_replace (D.29294, s2, class_list, 0);
            <D.29298>:
            s3 = strdup_tolower (s2);
            D.29299 = info->source_file_to_class_ignorecase;
            class_list = monoeg_g_hash_table_lookup (D.29299, s3);
            if (class_list == 0B) goto <D.29300>; else goto <D.29301>;
            <D.29300>:
            klass.114 = klass;
            class_list = monoeg_g_slist_prepend (class_list, klass.114);
            D.29299 = info->source_file_to_class_ignorecase;
            D.29302 = monoeg_strdup (s3);
            monoeg_g_hash_table_insert_replace (D.29299, D.29302, class_list, 0);
            goto <D.29303>;
            <D.29301>:
            klass.114 = klass;
            class_list = monoeg_g_slist_prepend (class_list, klass.114);
            D.29299 = info->source_file_to_class_ignorecase;
            monoeg_g_hash_table_insert_replace (D.29299, s3, class_list, 0);
            <D.29303>:
            monoeg_g_free (s2);
            monoeg_g_free (s3);
          }
          i = i + 1;
          <D.27184>:
          i.115 = (unsigned int) i;
          D.29305 = files->len;
          if (i.115 < D.29305) goto <D.27183>; else goto <D.27185>;
          <D.27185>:
          <D.29289>:
          <D.27187>:
          D.29306 = monoeg_g_hash_table_iter_next (&kiter, 0B, &klass);
          if (D.29306 != 0) goto <D.27186>; else goto <D.27188>;
          <D.27188>:
          if (ignore_case != 0) goto <D.29307>; else goto <D.29308>;
          <D.29307>:
          {
            char * s;

            s = strdup_tolower (basename);
            D.29299 = info->source_file_to_class_ignorecase;
            class_list = monoeg_g_hash_table_lookup (D.29299, s);
            monoeg_g_free (s);
          }
          goto <D.29309>;
          <D.29308>:
          D.29294 = info->source_file_to_class;
          class_list = monoeg_g_hash_table_lookup (D.29294, basename);
          <D.29309>:
          l = class_list;
          goto <D.27191>;
          <D.27190>:
          klass.116 = l->data;
          klass = klass.116;
          klass.114 = klass;
          monoeg_g_ptr_array_add (res_classes, klass.114);
          domain.113 = domain;
          monoeg_g_ptr_array_add (res_domains, domain.113);
          l = l->next;
          <D.27191>:
          if (l != 0B) goto <D.27190>; else goto <D.27192>;
          <D.27192>:
        }
        <D.27194>:
        D.29311 = monoeg_g_hash_table_iter_next (&iter, 0B, &domain);
        if (D.29311 != 0) goto <D.27193>; else goto <D.27195>;
        <D.27195>:
        mono_loader_unlock ();
        monoeg_g_free (fname);
        monoeg_g_free (basename);
        D.29312 = res_classes->len;
        buffer_add_int (buf, D.29312);
        i = 0;
        goto <D.27197>;
        <D.27196>:
        D.29313 = res_domains->pdata;
        D.29291 = (long unsigned int) i;
        D.29292 = D.29291 * 8;
        D.29314 = D.29313 + D.29292;
        D.29315 = *D.29314;
        D.29316 = res_classes->pdata;
        D.29291 = (long unsigned int) i;
        D.29292 = D.29291 * 8;
        D.29317 = D.29316 + D.29292;
        D.29318 = *D.29317;
        buffer_add_typeid (buf, D.29315, D.29318);
        i = i + 1;
        <D.27197>:
        i.115 = (unsigned int) i;
        D.29312 = res_classes->len;
        if (i.115 < D.29312) goto <D.27196>; else goto <D.27198>;
        <D.27198>:
        monoeg_g_ptr_array_free (res_classes, 1);
        monoeg_g_ptr_array_free (res_domains, 1);
        goto <D.27114>;
      }
    finally
      {
        iter = {CLOBBER};
        kiter = {CLOBBER};
        domain = {CLOBBER};
        klass = {CLOBBER};
      }
  }
  <D.27199>:
  {
    struct GHashTableIter iter;
    struct MonoDomain * domain;
    int i;
    char * name;
    gboolean ignore_case;
    struct GPtrArray * res_classes;
    struct GPtrArray * res_domains;
    struct MonoTypeNameParse info;

    try
      {
        p.95 = p;
        name = decode_string (p.95, &p, end);
        p.95 = p;
        ignore_case = decode_byte (p.95, &p, end);
        D.29319 = mono_reflection_parse_type (name, &info);
        if (D.29319 == 0) goto <D.29320>; else goto <D.29321>;
        <D.29320>:
        monoeg_g_free (name);
        mono_reflection_free_type_info (&info);
        D.29195 = 102;
        return D.29195;
        <D.29321>:
        res_classes = monoeg_g_ptr_array_new ();
        res_domains = monoeg_g_ptr_array_new ();
        mono_loader_lock ();
        domains.112 = domains;
        monoeg_g_hash_table_iter_init (&iter, domains.112);
        goto <D.27218>;
        <D.27217>:
        {
          struct MonoAssembly * ass;
          gboolean type_resolve;
          struct MonoType * t;
          struct GSList * tmp;

          try
            {
              {
                int ret;

                domain.117 = domain;
                D.29323 = &domain.117->assemblies_lock.mutex;
                ret = pthread_mutex_lock (D.29323);
                if (ret != 0) goto <D.29324>; else goto <D.29325>;
                <D.29324>:
                monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
                <D.29325>:
                D.29326 = ret != 0;
                D.29327 = (long int) D.29326;
                D.29328 = __builtin_expect (D.29327, 0);
                if (D.29328 != 0) goto <D.29329>; else goto <D.29330>;
                <D.29329>:
                monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 6927, "ret == 0");
                <D.29330>:
              }
              domain.117 = domain;
              tmp = domain.117->domain_assemblies;
              goto <D.27214>;
              <D.27213>:
              ass = tmp->data;
              D.29331 = ass->image;
              if (D.29331 != 0B) goto <D.29332>; else goto <D.29333>;
              <D.29332>:
              type_resolve = 1;
              D.29331 = ass->image;
              t = mono_reflection_get_type (D.29331, &info, ignore_case, &type_resolve);
              if (t != 0B) goto <D.29334>; else goto <D.29335>;
              <D.29334>:
              D.29336 = mono_type_get_class (t);
              monoeg_g_ptr_array_add (res_classes, D.29336);
              domain.117 = domain;
              monoeg_g_ptr_array_add (res_domains, domain.117);
              <D.29335>:
              <D.29333>:
              tmp = tmp->next;
              <D.27214>:
              if (tmp != 0B) goto <D.27213>; else goto <D.27215>;
              <D.27215>:
              {
                int ret;

                domain.117 = domain;
                D.29323 = &domain.117->assemblies_lock.mutex;
                ret = pthread_mutex_unlock (D.29323);
                if (ret != 0) goto <D.29337>; else goto <D.29338>;
                <D.29337>:
                monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
                <D.29338>:
                D.29339 = ret != 0;
                D.29340 = (long int) D.29339;
                D.29341 = __builtin_expect (D.29340, 0);
                if (D.29341 != 0) goto <D.29342>; else goto <D.29343>;
                <D.29342>:
                monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 6940, "ret == 0");
                <D.29343>:
              }
            }
          finally
            {
              type_resolve = {CLOBBER};
            }
        }
        <D.27218>:
        D.29344 = monoeg_g_hash_table_iter_next (&iter, 0B, &domain);
        if (D.29344 != 0) goto <D.27217>; else goto <D.27219>;
        <D.27219>:
        mono_loader_unlock ();
        monoeg_g_free (name);
        mono_reflection_free_type_info (&info);
        D.29345 = res_classes->len;
        buffer_add_int (buf, D.29345);
        i = 0;
        goto <D.27221>;
        <D.27220>:
        D.29346 = res_domains->pdata;
        D.29347 = (long unsigned int) i;
        D.29348 = D.29347 * 8;
        D.29349 = D.29346 + D.29348;
        D.29350 = *D.29349;
        D.29351 = res_classes->pdata;
        D.29347 = (long unsigned int) i;
        D.29348 = D.29347 * 8;
        D.29352 = D.29351 + D.29348;
        D.29353 = *D.29352;
        buffer_add_typeid (buf, D.29350, D.29353);
        i = i + 1;
        <D.27221>:
        i.118 = (unsigned int) i;
        D.29345 = res_classes->len;
        if (i.118 < D.29345) goto <D.27220>; else goto <D.27222>;
        <D.27222>:
        monoeg_g_ptr_array_free (res_classes, 1);
        monoeg_g_ptr_array_free (res_domains, 1);
        goto <D.27114>;
      }
    finally
      {
        iter = {CLOBBER};
        domain = {CLOBBER};
        info = {CLOBBER};
      }
  }
  <D.27223>:
  D.29195 = 100;
  return D.29195;
  <D.27114>:
  D.29195 = 0;
  return D.29195;
}


is_really_suspended (void * key, void * value, void * user_data)
{
  struct MonoGHashTable * thread_to_tls.119;
  _Bool D.29364;
  long int D.29365;
  long int D.29366;
  gboolean D.29369;
  struct MonoThread * thread;
  struct DebuggerTlsData * tls;
  gboolean res;

  thread = value;
  mono_loader_lock ();
  thread_to_tls.119 = thread_to_tls;
  tls = mono_g_hash_table_lookup (thread_to_tls.119, thread);
  D.29364 = tls == 0B;
  D.29365 = (long int) D.29364;
  D.29366 = __builtin_expect (D.29365, 0);
  if (D.29366 != 0) goto <D.29367>; else goto <D.29368>;
  <D.29367>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 6512, "tls");
  <D.29368>:
  res = tls->really_suspended;
  mono_loader_unlock ();
  D.29369 = res;
  return D.29369;
}


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

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


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

  D.29372 = 1;
  return D.29372;
}


clear_event_request (int req_id, int etype)
{
  struct GPtrArray * event_requests.121;
  void * * D.29375;
  long unsigned int D.29376;
  long unsigned int D.29377;
  void * * D.29378;
  int D.29379;
  int D.29382;
  void * D.29387;
  unsigned int i.122;
  unsigned int D.29395;
  int i;

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

    event_requests.121 = event_requests;
    D.29375 = event_requests.121->pdata;
    D.29376 = (long unsigned int) i;
    D.29377 = D.29376 * 8;
    D.29378 = D.29375 + D.29377;
    req = *D.29378;
    D.29379 = req->id;
    if (D.29379 == req_id) goto <D.29380>; else goto <D.29381>;
    <D.29380>:
    D.29382 = req->event_kind;
    if (D.29382 == etype) goto <D.29383>; else goto <D.29384>;
    <D.29383>:
    D.29382 = req->event_kind;
    if (D.29382 == 10) goto <D.29385>; else goto <D.29386>;
    <D.29385>:
    D.29387 = req->info;
    clear_breakpoint (D.29387);
    <D.29386>:
    D.29382 = req->event_kind;
    if (D.29382 == 11) goto <D.29388>; else goto <D.29389>;
    <D.29388>:
    D.29387 = req->info;
    ss_destroy (D.29387);
    <D.29389>:
    D.29382 = req->event_kind;
    if (D.29382 == 6) goto <D.29390>; else goto <D.29391>;
    <D.29390>:
    D.29387 = req->info;
    clear_breakpoint (D.29387);
    <D.29391>:
    D.29382 = req->event_kind;
    if (D.29382 == 7) goto <D.29392>; else goto <D.29393>;
    <D.29392>:
    D.29387 = req->info;
    clear_breakpoint (D.29387);
    <D.29393>:
    event_requests.121 = event_requests;
    i.122 = (unsigned int) i;
    monoeg_g_ptr_array_remove_index_fast (event_requests.121, i.122);
    monoeg_g_free (req);
    goto <D.26957>;
    <D.29384>:
    <D.29381>:
  }
  i = i + 1;
  <D.26959>:
  i.122 = (unsigned int) i;
  event_requests.121 = event_requests;
  D.29395 = event_requests.121->len;
  if (i.122 < D.29395) goto <D.26958>; else goto <D.26957>;
  <D.26957>:
  mono_loader_unlock ();
}


transport_close2 ()
{
  struct DebuggerTransport * transport.123;
  void (*<T887>) (void) D.29397;

  transport.123 = transport;
  D.29397 = transport.123->close2;
  D.29397 ();
}


wait_for_suspend ()
{
  struct MonoGHashTable * thread_to_tls.124;
  unsigned int D.29399;
  int log_level.125;
  _Bool D.29402;
  long int D.29403;
  long int D.29404;
  struct FILE * log_file.126;
  _Bool D.29408;
  long int D.29409;
  long int D.29410;
  int nthreads;
  int nwait;
  int err;
  gboolean waited;

  waited = 0;
  mono_loader_lock ();
  thread_to_tls.124 = thread_to_tls;
  D.29399 = mono_g_hash_table_size (thread_to_tls.124);
  nthreads = (int) D.29399;
  mono_loader_unlock ();
  <D.25964>:
  nwait = count_threads_to_wait_for ();
  if (nwait != 0) goto <D.29400>; else goto <D.25963>;
  <D.29400>:
  log_level.125 = log_level;
  D.29402 = log_level.125 > 0;
  D.29403 = (long int) D.29402;
  D.29404 = __builtin_expect (D.29403, 0);
  if (D.29404 != 0) goto <D.29405>; else goto <D.29406>;
  <D.29405>:
  log_file.126 = log_file;
  fprintf (log_file.126, "Waiting for %d(%d) threads to suspend...\n", nwait, nthreads);
  log_file.126 = log_file;
  fflush (log_file.126);
  <D.29406>:
  err = mono_sem_wait (&suspend_sem, 0);
  D.29408 = err != 0;
  D.29409 = (long int) D.29408;
  D.29410 = __builtin_expect (D.29409, 0);
  if (D.29410 != 0) goto <D.29411>; else goto <D.29412>;
  <D.29411>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 2962, "err == 0");
  <D.29412>:
  waited = 1;
  goto <D.25964>;
  <D.25963>:
  if (waited != 0) goto <D.29413>; else goto <D.29414>;
  <D.29413>:
  log_level.125 = log_level;
  D.29402 = log_level.125 > 0;
  D.29403 = (long int) D.29402;
  D.29404 = __builtin_expect (D.29403, 0);
  if (D.29404 != 0) goto <D.29415>; else goto <D.29416>;
  <D.29415>:
  log_file.126 = log_file;
  fprintf (log_file.126, "%d threads suspended.\n", nthreads);
  log_file.126 = log_file;
  fflush (log_file.126);
  <D.29416>:
  <D.29414>:
}


count_threads_to_wait_for ()
{
  struct MonoGHashTable * thread_to_tls.127;
  int D.29418;
  int count;

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


count_thread (void * key, void * value, void * user_data)
{
  int D.29421;
  int D.29424;
  int D.29427;
  int D.29428;
  struct DebuggerTlsData * tls;

  tls = value;
  D.29421 = tls->suspended;
  if (D.29421 == 0) goto <D.29422>; else goto <D.29423>;
  <D.29422>:
  D.29424 = tls->terminated;
  if (D.29424 == 0) goto <D.29425>; else goto <D.29426>;
  <D.29425>:
  D.29427 = MEM[(int *)user_data];
  D.29428 = D.29427 + 1;
  MEM[(int *)user_data] = D.29428;
  <D.29426>:
  <D.29423>:
}


is_suspended ()
{
  gboolean D.29429;
  int D.29430;
  _Bool D.29431;

  D.29430 = count_threads_to_wait_for ();
  D.29431 = D.29430 == 0;
  D.29429 = (gboolean) D.29431;
  return D.29429;
}


resume_thread (struct MonoInternalThread * thread)
{
  long unsigned int D.29433;
  long unsigned int debugger_thread_id.128;
  _Bool D.29435;
  long int D.29436;
  long int D.29437;
  struct MonoGHashTable * thread_to_tls.129;
  _Bool D.29441;
  long int D.29442;
  long int D.29443;
  int suspend_count.130;
  _Bool D.29447;
  long int D.29448;
  long int D.29449;
  int log_level.131;
  _Bool D.29453;
  long int D.29454;
  long int D.29455;
  struct FILE * log_file.132;
  long unsigned int D.29459;
  void * D.29460;
  unsigned int D.29461;
  unsigned int suspend_count.133;
  unsigned int D.29463;
  _Bool D.29464;
  long int D.29465;
  long int D.29466;
  int err;
  struct DebuggerTlsData * tls;

  D.29433 = GetCurrentThreadId ();
  debugger_thread_id.128 = debugger_thread_id;
  D.29435 = D.29433 != debugger_thread_id.128;
  D.29436 = (long int) D.29435;
  D.29437 = __builtin_expect (D.29436, 0);
  if (D.29437 != 0) goto <D.29438>; else goto <D.29439>;
  <D.29438>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 2796, "debugger_thread_id == GetCurrentThreadId ()");
  <D.29439>:
  mono_loader_lock ();
  thread_to_tls.129 = thread_to_tls;
  tls = mono_g_hash_table_lookup (thread_to_tls.129, thread);
  D.29441 = tls == 0B;
  D.29442 = (long int) D.29441;
  D.29443 = __builtin_expect (D.29442, 0);
  if (D.29443 != 0) goto <D.29444>; else goto <D.29445>;
  <D.29444>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 2801, "tls");
  <D.29445>:
  pthread_mutex_lock (&suspend_mutex);
  suspend_count.130 = suspend_count;
  D.29447 = suspend_count.130 <= 0;
  D.29448 = (long int) D.29447;
  D.29449 = __builtin_expect (D.29448, 0);
  if (D.29449 != 0) goto <D.29450>; else goto <D.29451>;
  <D.29450>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 2805, "suspend_count > 0");
  <D.29451>:
  log_level.131 = log_level;
  D.29453 = log_level.131 > 0;
  D.29454 = (long int) D.29453;
  D.29455 = __builtin_expect (D.29454, 0);
  if (D.29455 != 0) goto <D.29456>; else goto <D.29457>;
  <D.29456>:
  log_file.132 = log_file;
  D.29459 = thread->tid;
  D.29460 = (void *) D.29459;
  fprintf (log_file.132, "[%p] Resuming thread...\n", D.29460);
  log_file.132 = log_file;
  fflush (log_file.132);
  <D.29457>:
  D.29461 = tls->resume_count;
  suspend_count.130 = suspend_count;
  suspend_count.133 = (unsigned int) suspend_count.130;
  D.29463 = D.29461 + suspend_count.133;
  tls->resume_count = D.29463;
  err = pthread_cond_broadcast (&suspend_cond);
  D.29464 = err != 0;
  D.29465 = (long int) D.29464;
  D.29466 = __builtin_expect (D.29465, 0);
  if (D.29466 != 0) goto <D.29467>; else goto <D.29468>;
  <D.29467>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 2816, "err == 0");
  <D.29468>:
  pthread_mutex_unlock (&suspend_mutex);
  mono_loader_unlock ();
}


resume_vm ()
{
  long unsigned int D.29469;
  long unsigned int debugger_thread_id.134;
  _Bool D.29471;
  long int D.29472;
  long int D.29473;
  int suspend_count.135;
  _Bool D.29477;
  long int D.29478;
  long int D.29479;
  int suspend_count.136;
  int log_level.137;
  _Bool D.29484;
  long int D.29485;
  long int D.29486;
  struct FILE * log_file.138;
  long unsigned int D.29490;
  void * D.29491;
  struct MonoGHashTable * thread_to_tls.139;
  _Bool D.29495;
  long int D.29496;
  long int D.29497;
  int err;

  D.29469 = GetCurrentThreadId ();
  debugger_thread_id.134 = debugger_thread_id;
  D.29471 = D.29469 != debugger_thread_id.134;
  D.29472 = (long int) D.29471;
  D.29473 = __builtin_expect (D.29472, 0);
  if (D.29473 != 0) goto <D.29474>; else goto <D.29475>;
  <D.29474>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 2755, "debugger_thread_id == GetCurrentThreadId ()");
  <D.29475>:
  mono_loader_lock ();
  pthread_mutex_lock (&suspend_mutex);
  suspend_count.135 = suspend_count;
  D.29477 = suspend_count.135 <= 0;
  D.29478 = (long int) D.29477;
  D.29479 = __builtin_expect (D.29478, 0);
  if (D.29479 != 0) goto <D.29480>; else goto <D.29481>;
  <D.29480>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 2761, "suspend_count > 0");
  <D.29481>:
  suspend_count.135 = suspend_count;
  suspend_count.136 = suspend_count.135 + -1;
  suspend_count = suspend_count.136;
  log_level.137 = log_level;
  D.29484 = log_level.137 > 0;
  D.29485 = (long int) D.29484;
  D.29486 = __builtin_expect (D.29485, 0);
  if (D.29486 != 0) goto <D.29487>; else goto <D.29488>;
  <D.29487>:
  log_file.138 = log_file;
  D.29490 = GetCurrentThreadId ();
  D.29491 = (void *) D.29490;
  suspend_count.135 = suspend_count;
  fprintf (log_file.138, "[%p] Resuming vm, suspend count=%d...\n", D.29491, suspend_count.135);
  log_file.138 = log_file;
  fflush (log_file.138);
  <D.29488>:
  suspend_count.135 = suspend_count;
  if (suspend_count.135 == 0) goto <D.29492>; else goto <D.29493>;
  <D.29492>:
  stop_single_stepping ();
  thread_to_tls.139 = thread_to_tls;
  mono_g_hash_table_foreach (thread_to_tls.139, reset_native_thread_suspend_state, 0B);
  <D.29493>:
  err = pthread_cond_broadcast (&suspend_cond);
  D.29495 = err != 0;
  D.29496 = (long int) D.29495;
  D.29497 = __builtin_expect (D.29496, 0);
  if (D.29497 != 0) goto <D.29498>; else goto <D.29499>;
  <D.29498>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 2774, "err == 0");
  <D.29499>:
  pthread_mutex_unlock (&suspend_mutex);
  suspend_count.135 = suspend_count;
  if (suspend_count.135 == 0) goto <D.29500>; else goto <D.29501>;
  <D.29500>:
  mono_thread_pool_resume ();
  <D.29501>:
  mono_loader_unlock ();
}


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

  tls = value;
  D.29502 = tls->really_suspended;
  if (D.29502 == 0) goto <D.29503>; else goto <D.29504>;
  <D.29503>:
  D.29505 = tls->suspended;
  if (D.29505 != 0) goto <D.29506>; else goto <D.29507>;
  <D.29506>:
  tls->suspended = 0;
  tls->context.valid = 0;
  tls->async_state.valid = 0;
  invalidate_frames (tls);
  <D.29507>:
  <D.29504>:
}


invalidate_frames (struct DebuggerTlsData * tls)
{
  unsigned int debugger_tls_id.140;
  _Bool D.29511;
  long int D.29512;
  long int D.29513;
  struct StackFrame * * D.29516;
  long unsigned int D.29517;
  long unsigned int D.29518;
  struct StackFrame * * D.29519;
  struct StackFrame * D.29520;
  struct MonoDebugMethodJitInfo * D.29521;
  int D.29524;
  int i;

  if (tls == 0B) goto <D.29508>; else goto <D.29509>;
  <D.29508>:
  debugger_tls_id.140 = debugger_tls_id;
  tls = pthread_getspecific (debugger_tls_id.140);
  <D.29509>:
  D.29511 = tls == 0B;
  D.29512 = (long int) D.29511;
  D.29513 = __builtin_expect (D.29512, 0);
  if (D.29513 != 0) goto <D.29514>; else goto <D.29515>;
  <D.29514>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 2831, "tls");
  <D.29515>:
  i = 0;
  goto <D.25936>;
  <D.25935>:
  D.29516 = tls->frames;
  D.29517 = (long unsigned int) i;
  D.29518 = D.29517 * 8;
  D.29519 = D.29516 + D.29518;
  D.29520 = *D.29519;
  D.29521 = D.29520->jit;
  if (D.29521 != 0B) goto <D.29522>; else goto <D.29523>;
  <D.29522>:
  D.29516 = tls->frames;
  D.29517 = (long unsigned int) i;
  D.29518 = D.29517 * 8;
  D.29519 = D.29516 + D.29518;
  D.29520 = *D.29519;
  D.29521 = D.29520->jit;
  mono_debug_free_method_jit_info (D.29521);
  <D.29523>:
  D.29516 = tls->frames;
  D.29517 = (long unsigned int) i;
  D.29518 = D.29517 * 8;
  D.29519 = D.29516 + D.29518;
  D.29520 = *D.29519;
  monoeg_g_free (D.29520);
  i = i + 1;
  <D.25936>:
  D.29524 = tls->frame_count;
  if (D.29524 > i) goto <D.25935>; else goto <D.25937>;
  <D.25937>:
  D.29516 = tls->frames;
  monoeg_g_free (D.29516);
  tls->frame_count = 0;
  tls->frames = 0B;
}


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

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


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

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


get_object (int objid, struct MonoObject * * obj)
{
  <unnamed type> D.29529;
  ErrorCode D.29532;
  struct MonoObject * D.29533;
  int err;

  D.29529 = get_object_allow_null (objid, obj);
  err = (int) D.29529;
  if (err != 0) goto <D.29530>; else goto <D.29531>;
  <D.29530>:
  D.29532 = (ErrorCode) err;
  return D.29532;
  <D.29531>:
  D.29533 = *obj;
  if (D.29533 == 0B) goto <D.29534>; else goto <D.29535>;
  <D.29534>:
  D.29532 = 20;
  return D.29532;
  <D.29535>:
  D.29532 = 0;
  return D.29532;
}


get_object_allow_null (int objid, struct MonoObject * * obj)
{
  ErrorCode D.29539;
  struct GHashTable * objrefs.141;
  long int D.29543;
  const void * D.29544;
  unsigned int D.29547;
  struct MonoObject * D.29548;
  struct MonoObject * D.29549;
  struct ObjRef * ref;

  if (objid == 0) goto <D.29537>; else goto <D.29538>;
  <D.29537>:
  *obj = 0B;
  D.29539 = 0;
  return D.29539;
  <D.29538>:
  objrefs.141 = objrefs;
  if (objrefs.141 == 0B) goto <D.29541>; else goto <D.29542>;
  <D.29541>:
  D.29539 = 20;
  return D.29539;
  <D.29542>:
  mono_loader_lock ();
  objrefs.141 = objrefs;
  D.29543 = (long int) objid;
  D.29544 = (const void *) D.29543;
  ref = monoeg_g_hash_table_lookup (objrefs.141, D.29544);
  if (ref != 0B) goto <D.29545>; else goto <D.29546>;
  <D.29545>:
  D.29547 = ref->handle;
  D.29548 = mono_gchandle_get_target (D.29547);
  *obj = D.29548;
  mono_loader_unlock ();
  D.29549 = *obj;
  if (D.29549 == 0B) goto <D.29550>; else goto <D.29551>;
  <D.29550>:
  D.29539 = 20;
  return D.29539;
  <D.29551>:
  D.29539 = 0;
  return D.29539;
  <D.29546>:
  mono_loader_unlock ();
  D.29539 = 20;
  return D.29539;
}


get_source_files_for_type (struct MonoClass * klass)
{
  struct GPtrArray * source_file_list.142;
  void * * D.29556;
  long unsigned int D.29557;
  long unsigned int D.29558;
  void * * D.29559;
  int D.27094;
  void * * D.29560;
  long unsigned int D.29561;
  long unsigned int D.29562;
  void * * D.29563;
  void * D.29564;
  char * D.29565;
  unsigned int i.143;
  unsigned int D.29568;
  gchar * D.29571;
  unsigned int j.144;
  unsigned int D.29573;
  struct GPtrArray * D.29574;
  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.27102>;
      <D.27101>:
      {
        struct MonoDebugMethodInfo * minfo;
        struct GPtrArray * source_file_list;

        try
          {
            minfo = mono_debug_lookup_method (method);
            if (minfo != 0B) goto <D.29553>; else goto <D.29554>;
            <D.29553>:
            mono_debug_symfile_get_line_numbers_full (minfo, 0B, &source_file_list, 0B, 0B, 0B, 0B, 0B);
            j = 0;
            goto <D.27099>;
            <D.27098>:
            source_file_list.142 = source_file_list;
            D.29556 = source_file_list.142->pdata;
            D.29557 = (long unsigned int) j;
            D.29558 = D.29557 * 8;
            D.29559 = D.29556 + D.29558;
            sinfo = *D.29559;
            i = 0;
            goto <D.27097>;
            <D.27096>:
            {
              size_t __s1_len;
              size_t __s2_len;

              D.29560 = files->pdata;
              D.29561 = (long unsigned int) i;
              D.29562 = D.29561 * 8;
              D.29563 = D.29560 + D.29562;
              D.29564 = *D.29563;
              D.29565 = sinfo->source_file;
              D.27094 = __builtin_strcmp (D.29564, D.29565);
            }
            if (D.27094 == 0) goto <D.27095>; else goto <D.29566>;
            <D.29566>:
            i = i + 1;
            <D.27097>:
            i.143 = (unsigned int) i;
            D.29568 = files->len;
            if (i.143 < D.29568) goto <D.27096>; else goto <D.27095>;
            <D.27095>:
            i.143 = (unsigned int) i;
            D.29568 = files->len;
            if (i.143 == D.29568) goto <D.29569>; else goto <D.29570>;
            <D.29569>:
            D.29565 = sinfo->source_file;
            D.29571 = monoeg_strdup (D.29565);
            monoeg_g_ptr_array_add (files, D.29571);
            <D.29570>:
            j = j + 1;
            <D.27099>:
            j.144 = (unsigned int) j;
            source_file_list.142 = source_file_list;
            D.29573 = source_file_list.142->len;
            if (j.144 < D.29573) goto <D.27098>; else goto <D.27100>;
            <D.27100>:
            source_file_list.142 = source_file_list;
            monoeg_g_ptr_array_free (source_file_list.142, 1);
            <D.29554>:
          }
        finally
          {
            source_file_list = {CLOBBER};
          }
      }
      <D.27102>:
      method = mono_class_get_methods (klass, &iter);
      if (method != 0B) goto <D.27101>; else goto <D.27103>;
      <D.27103>:
      D.29574 = files;
      return D.29574;
    }
  finally
    {
      iter = {CLOBBER};
    }
}


decode_string (guint8 * buf, guint8 * * endbuf, guint8 * limit)
{
  guint8 * buf.145;
  char * D.29580;
  int D.29581;
  long unsigned int D.29582;
  _Bool D.29583;
  long int D.29584;
  long int D.29585;
  long unsigned int D.29588;
  sizetype D.29589;
  char * D.29590;
  guint8 * buf.146;
  int len;
  char * s;

  buf.145 = buf;
  len = decode_int (buf.145, &buf, limit);
  if (len < 0) goto <D.29578>; else goto <D.29579>;
  <D.29578>:
  buf.145 = buf;
  *endbuf = buf.145;
  D.29580 = 0B;
  return D.29580;
  <D.29579>:
  D.29581 = len + 1;
  D.29582 = (long unsigned int) D.29581;
  s = monoeg_malloc (D.29582);
  D.29583 = s == 0B;
  D.29584 = (long int) D.29583;
  D.29585 = __builtin_expect (D.29584, 0);
  if (D.29585 != 0) goto <D.29586>; else goto <D.29587>;
  <D.29586>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 1633, "s");
  <D.29587>:
  buf.145 = buf;
  D.29588 = (long unsigned int) len;
  memcpy (s, buf.145, D.29588);
  D.29589 = (sizetype) len;
  D.29590 = s + D.29589;
  *D.29590 = 0;
  buf.145 = buf;
  D.29589 = (sizetype) len;
  buf.146 = buf.145 + D.29589;
  buf = buf.146;
  buf.145 = buf;
  *endbuf = buf.145;
  D.29580 = s;
  return D.29580;
}


event_commands (int command, guint8 * p, guint8 * end, struct Buffer * buf)
{
  guint8 * p.147;
  long unsigned int D.29594;
  long unsigned int D.29595;
  long unsigned int D.29596;
  int D.29597;
  <unnamed type> mod.148;
  int D.29601;
  int err.149;
  ErrorCode D.29608;
  int protocol_version_set.150;
  int major_version.151;
  int minor_version.152;
  <unnamed type> filter.153;
  <unnamed type> D.29627;
  unsigned int D.29628;
  unsigned int D.29631;
  struct MonoInternalThread * * D.29635;
  <unnamed type> D.29636;
  int err.154;
  int D.29645;
  int D.29646;
  int D.29653;
  int log_level.155;
  _Bool D.29655;
  long int D.29656;
  long int D.29657;
  struct FILE * log_file.156;
  const char * iftmp.157;
  const char * iftmp.158;
  int D.29666;
  const char * iftmp.159;
  int D.29671;
  const char * iftmp.160;
  int D.29676;
  struct MonoClass * D.29682;
  int D.29683;
  long unsigned int D.29689;
  long unsigned int D.29690;
  void * D.29691;
  struct MonoAssembly * * D.29692;
  long unsigned int D.29693;
  long unsigned int D.29694;
  struct MonoAssembly * * D.29695;
  struct MonoAssembly * D.29696;
  struct GHashTable * D.29702;
  struct GHashTable * D.29705;
  struct GHashTable * D.29709;
  struct GHashTable * D.29712;
  int D.29714;
  _Bool D.29717;
  long int D.29718;
  long int D.29719;
  struct MonoBreakpoint * D.29722;
  int D.29723;
  const char * D.29728;
  _Bool D.29732;
  long int D.29733;
  long int D.29734;
  <unnamed type> D.29737;
  int err.161;
  struct MonoThread * step_thread.162;
  struct _MonoInternalThread * D.29742;
  <unnamed type> size.163;
  <unnamed type> depth.164;
  <unnamed type> D.29745;
  int err.165;
  struct MonoBreakpoint * D.29752;
  struct MonoBreakpoint * D.29756;
  int D.29764;
  struct GPtrArray * event_requests.166;
  int D.29768;
  struct GHashTable * domains.167;
  struct MonoGHashTable * tid_to_thread.168;
  int D.29773;
  unsigned int D.29774;
  void * * D.29775;
  long unsigned int D.29776;
  long unsigned int D.29777;
  void * * D.29778;
  int D.29779;
  void * D.29782;
  unsigned int i.169;
  unsigned int D.29785;
  int err;
  struct MonoError error;

  try
    {
      switch (command) <default: <D.27287>, case 1: <D.27232>, case 2: <D.27278>, case 3: <D.27281>>
      <D.27232>:
      {
        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.147 = p;
            event_kind = decode_byte (p.147, &p, end);
            p.147 = p;
            suspend_policy = decode_byte (p.147, &p, end);
            p.147 = p;
            nmodifiers = decode_byte (p.147, &p, end);
            D.29594 = (long unsigned int) nmodifiers;
            D.29595 = D.29594 * 32;
            D.29596 = D.29595 + 24;
            req = monoeg_malloc0 (D.29596);
            D.29597 = InterlockedIncrement (&event_request_id);
            req->id = D.29597;
            req->event_kind = event_kind;
            req->suspend_policy = suspend_policy;
            req->nmodifiers = nmodifiers;
            method = 0B;
            i = 0;
            goto <D.27269>;
            <D.27268>:
            p.147 = p;
            mod = decode_byte (p.147, &p, end);
            mod.148 = (<unnamed type>) mod;
            req->modifiers[i].kind = mod.148;
            if (mod == 1) goto <D.29599>; else goto <D.29600>;
            <D.29599>:
            p.147 = p;
            D.29601 = decode_int (p.147, &p, end);
            req->modifiers[i].data.count = D.29601;
            goto <D.29602>;
            <D.29600>:
            if (mod == 7) goto <D.29603>; else goto <D.29604>;
            <D.29603>:
            p.147 = p;
            method = decode_methodid (p.147, &p, end, &domain, &err);
            err.149 = err;
            if (err.149 != 0) goto <D.29606>; else goto <D.29607>;
            <D.29606>:
            err.149 = err;
            D.29608 = (ErrorCode) err.149;
            return D.29608;
            <D.29607>:
            p.147 = p;
            location = decode_long (p.147, &p, end);
            goto <D.29609>;
            <D.29604>:
            if (mod == 10) goto <D.29610>; else goto <D.29611>;
            <D.29610>:
            p.147 = p;
            step_thread_id = decode_id (p.147, &p, end);
            p.147 = p;
            size = decode_int (p.147, &p, end);
            p.147 = p;
            depth = decode_int (p.147, &p, end);
            protocol_version_set.150 = protocol_version_set;
            if (protocol_version_set.150 != 0) goto <D.29615>; else goto <D.29616>;
            <D.29615>:
            major_version.151 = major_version;
            if (major_version.151 > 2) goto <D.29612>; else goto <D.29618>;
            <D.29618>:
            major_version.151 = major_version;
            if (major_version.151 == 2) goto <D.29619>; else goto <D.29613>;
            <D.29619>:
            minor_version.152 = minor_version;
            if (minor_version.152 > 15) goto <D.29612>; else goto <D.29613>;
            <D.29612>:
            p.147 = p;
            filter = decode_int (p.147, &p, end);
            <D.29613>:
            <D.29616>:
            filter.153 = (<unnamed type>) filter;
            req->modifiers[i].data.filter = filter.153;
            protocol_version_set.150 = protocol_version_set;
            if (protocol_version_set.150 == 0) goto <D.29622>; else goto <D.29624>;
            <D.29624>:
            major_version.151 = major_version;
            if (major_version.151 <= 2) goto <D.29625>; else goto <D.29623>;
            <D.29625>:
            major_version.151 = major_version;
            if (major_version.151 != 2) goto <D.29622>; else goto <D.29626>;
            <D.29626>:
            minor_version.152 = minor_version;
            if (minor_version.152 <= 25) goto <D.29622>; else goto <D.29623>;
            <D.29622>:
            D.29627 = req->modifiers[i].data.filter;
            D.29628 = D.29627 & 2;
            if (D.29628 != 0) goto <D.29629>; else goto <D.29630>;
            <D.29629>:
            D.29627 = req->modifiers[i].data.filter;
            D.29631 = D.29627 | 4;
            req->modifiers[i].data.filter = D.29631;
            <D.29630>:
            <D.29623>:
            goto <D.29632>;
            <D.29611>:
            if (mod == 3) goto <D.29633>; else goto <D.29634>;
            <D.29633>:
            {
              int id;

              p.147 = p;
              id = decode_id (p.147, &p, end);
              D.29635 = &req->modifiers[i].data.thread;
              D.29636 = get_object (id, D.29635);
              err.154 = (int) D.29636;
              err = err.154;
              err.149 = err;
              if (err.149 != 0) goto <D.29638>; else goto <D.29639>;
              <D.29638>:
              monoeg_g_free (req);
              err.149 = err;
              D.29608 = (ErrorCode) err.149;
              return D.29608;
              <D.29639>:
            }
            goto <D.29640>;
            <D.29634>:
            if (mod == 8) goto <D.29641>; else goto <D.29642>;
            <D.29641>:
            {
              struct MonoClass * exc_class;

              p.147 = p;
              exc_class = decode_typeid (p.147, &p, end, &domain, &err);
              err.149 = err;
              if (err.149 != 0) goto <D.29643>; else goto <D.29644>;
              <D.29643>:
              err.149 = err;
              D.29608 = (ErrorCode) err.149;
              return D.29608;
              <D.29644>:
              p.147 = p;
              D.29645 = decode_byte (p.147, &p, end);
              req->modifiers[i].caught = D.29645;
              p.147 = p;
              D.29646 = decode_byte (p.147, &p, end);
              req->modifiers[i].uncaught = D.29646;
              protocol_version_set.150 = protocol_version_set;
              if (protocol_version_set.150 != 0) goto <D.29650>; else goto <D.29647>;
              <D.29650>:
              major_version.151 = major_version;
              if (major_version.151 > 2) goto <D.29648>; else goto <D.29651>;
              <D.29651>:
              major_version.151 = major_version;
              if (major_version.151 == 2) goto <D.29652>; else goto <D.29647>;
              <D.29652>:
              minor_version.152 = minor_version;
              if (minor_version.152 > 24) goto <D.29648>; else goto <D.29647>;
              <D.29648>:
              p.147 = p;
              D.29653 = decode_byte (p.147, &p, end);
              req->modifiers[i].subclasses = D.29653;
              goto <D.29649>;
              <D.29647>:
              req->modifiers[i].subclasses = 1;
              <D.29649>:
              log_level.155 = log_level;
              D.29655 = log_level.155 > 0;
              D.29656 = (long int) D.29655;
              D.29657 = __builtin_expect (D.29656, 0);
              if (D.29657 != 0) goto <D.29658>; else goto <D.29659>;
              <D.29658>:
              log_file.156 = log_file;
              if (exc_class != 0B) goto <D.29662>; else goto <D.29663>;
              <D.29662>:
              iftmp.157 = exc_class->name;
              goto <D.29664>;
              <D.29663>:
              iftmp.157 = "all";
              <D.29664>:
              D.29666 = req->modifiers[i].caught;
              if (D.29666 != 0) goto <D.29667>; else goto <D.29668>;
              <D.29667>:
              iftmp.158 = ", caught";
              goto <D.29669>;
              <D.29668>:
              iftmp.158 = "";
              <D.29669>:
              D.29671 = req->modifiers[i].uncaught;
              if (D.29671 != 0) goto <D.29672>; else goto <D.29673>;
              <D.29672>:
              iftmp.159 = ", uncaught";
              goto <D.29674>;
              <D.29673>:
              iftmp.159 = "";
              <D.29674>:
              D.29676 = req->modifiers[i].subclasses;
              if (D.29676 != 0) goto <D.29677>; else goto <D.29678>;
              <D.29677>:
              iftmp.160 = ", include-subclasses";
              goto <D.29679>;
              <D.29678>:
              iftmp.160 = "";
              <D.29679>:
              fprintf (log_file.156, "[dbg] \tEXCEPTION_ONLY filter (%s%s%s%s).\n", iftmp.157, iftmp.158, iftmp.159, iftmp.160);
              log_file.156 = log_file;
              fflush (log_file.156);
              <D.29659>:
              if (exc_class != 0B) goto <D.29680>; else goto <D.29681>;
              <D.29680>:
              req->modifiers[i].data.exc_class = exc_class;
              D.29682 = mono_defaults.exception_class;
              D.29683 = mono_class_is_assignable_from (D.29682, exc_class);
              if (D.29683 == 0) goto <D.29684>; else goto <D.29685>;
              <D.29684>:
              monoeg_g_free (req);
              D.29608 = 102;
              return D.29608;
              <D.29685>:
              <D.29681>:
            }
            goto <D.29686>;
            <D.29642>:
            if (mod == 11) goto <D.29687>; else goto <D.29688>;
            <D.29687>:
            {
              int n;
              int j;

              p.147 = p;
              n = decode_int (p.147, &p, end);
              D.29689 = (long unsigned int) n;
              D.29690 = D.29689 * 8;
              D.29691 = monoeg_malloc0 (D.29690);
              req->modifiers[i].data.assemblies = D.29691;
              j = 0;
              goto <D.27253>;
              <D.27252>:
              D.29692 = req->modifiers[i].data.assemblies;
              D.29693 = (long unsigned int) j;
              D.29694 = D.29693 * 8;
              D.29695 = D.29692 + D.29694;
              p.147 = p;
              D.29696 = decode_assemblyid (p.147, &p, end, &domain, &err);
              *D.29695 = D.29696;
              err.149 = err;
              if (err.149 != 0) goto <D.29697>; else goto <D.29698>;
              <D.29697>:
              D.29692 = req->modifiers[i].data.assemblies;
              monoeg_g_free (D.29692);
              err.149 = err;
              D.29608 = (ErrorCode) err.149;
              return D.29608;
              <D.29698>:
              j = j + 1;
              <D.27253>:
              if (j < n) goto <D.27252>; else goto <D.27254>;
              <D.27254>:
            }
            goto <D.29699>;
            <D.29688>:
            if (mod == 12) goto <D.29700>; else goto <D.29701>;
            <D.29700>:
            {
              int n;
              int j;

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

                p.147 = p;
                s = decode_string (p.147, &p, end);
                if (s != 0B) goto <D.29703>; else goto <D.29704>;
                <D.29703>:
                s2 = strdup_tolower (s);
                D.29705 = modifier->data.source_files;
                monoeg_g_hash_table_insert_replace (D.29705, s2, s2, 0);
                monoeg_g_free (s);
                <D.29704>:
              }
              j = j + 1;
              <D.27260>:
              if (j < n) goto <D.27259>; else goto <D.27261>;
              <D.27261>:
            }
            goto <D.29706>;
            <D.29701>:
            if (mod == 13) goto <D.29707>; else goto <D.29708>;
            <D.29707>:
            {
              int n;
              int j;

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

                p.147 = p;
                s = decode_string (p.147, &p, end);
                if (s != 0B) goto <D.29710>; else goto <D.29711>;
                <D.29710>:
                D.29712 = modifier->data.type_names;
                monoeg_g_hash_table_insert_replace (D.29712, s, s, 0);
                <D.29711>:
              }
              j = j + 1;
              <D.27266>:
              if (j < n) goto <D.27265>; else goto <D.27267>;
              <D.27267>:
            }
            goto <D.29713>;
            <D.29708>:
            monoeg_g_free (req);
            D.29608 = 100;
            return D.29608;
            <D.29713>:
            <D.29706>:
            <D.29699>:
            <D.29686>:
            <D.29640>:
            <D.29632>:
            <D.29609>:
            <D.29602>:
            i = i + 1;
            <D.27269>:
            if (i < nmodifiers) goto <D.27268>; else goto <D.27270>;
            <D.27270>:
            D.29714 = req->event_kind;
            if (D.29714 == 10) goto <D.29715>; else goto <D.29716>;
            <D.29715>:
            D.29717 = method == 0B;
            D.29718 = (long int) D.29717;
            D.29719 = __builtin_expect (D.29718, 0);
            if (D.29719 != 0) goto <D.29720>; else goto <D.29721>;
            <D.29720>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 7086, "method");
            <D.29721>:
            D.29722 = set_breakpoint (method, location, req, &error);
            req->info = D.29722;
            D.29723 = mono_error_ok (&error);
            if (D.29723 == 0) goto <D.29724>; else goto <D.29725>;
            <D.29724>:
            monoeg_g_free (req);
            log_level.155 = log_level;
            D.29655 = log_level.155 > 0;
            D.29656 = (long int) D.29655;
            D.29657 = __builtin_expect (D.29656, 0);
            if (D.29657 != 0) goto <D.29726>; else goto <D.29727>;
            <D.29726>:
            log_file.156 = log_file;
            D.29728 = mono_error_get_message (&error);
            fprintf (log_file.156, "[dbg] Failed to set breakpoint: %s\n", D.29728);
            log_file.156 = log_file;
            fflush (log_file.156);
            <D.29727>:
            mono_error_cleanup (&error);
            D.29608 = 106;
            return D.29608;
            <D.29725>:
            goto <D.29729>;
            <D.29716>:
            D.29714 = req->event_kind;
            if (D.29714 == 11) goto <D.29730>; else goto <D.29731>;
            <D.29730>:
            D.29732 = step_thread_id == 0;
            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", 7096, "step_thread_id");
            <D.29736>:
            D.29737 = get_object (step_thread_id, &step_thread);
            err.161 = (int) D.29737;
            err = err.161;
            err.149 = err;
            if (err.149 != 0) goto <D.29739>; else goto <D.29740>;
            <D.29739>:
            monoeg_g_free (req);
            err.149 = err;
            D.29608 = (ErrorCode) err.149;
            return D.29608;
            <D.29740>:
            step_thread.162 = step_thread;
            D.29742 = step_thread.162->internal_thread;
            size.163 = (<unnamed type>) size;
            depth.164 = (<unnamed type>) depth;
            D.29745 = ss_create (D.29742, size.163, depth.164, req);
            err.165 = (int) D.29745;
            err = err.165;
            err.149 = err;
            if (err.149 != 0) goto <D.29747>; else goto <D.29748>;
            <D.29747>:
            monoeg_g_free (req);
            err.149 = err;
            D.29608 = (ErrorCode) err.149;
            return D.29608;
            <D.29748>:
            goto <D.29749>;
            <D.29731>:
            D.29714 = req->event_kind;
            if (D.29714 == 6) goto <D.29750>; else goto <D.29751>;
            <D.29750>:
            D.29752 = set_breakpoint (0B, -1, req, 0B);
            req->info = D.29752;
            goto <D.29753>;
            <D.29751>:
            D.29714 = req->event_kind;
            if (D.29714 == 7) goto <D.29754>; else goto <D.29755>;
            <D.29754>:
            D.29756 = set_breakpoint (0B, 16777215, req, 0B);
            req->info = D.29756;
            goto <D.29757>;
            <D.29755>:
            D.29714 = req->event_kind;
            if (D.29714 == 13) goto <D.29758>; else goto <D.29759>;
            <D.29758>:
            goto <D.29760>;
            <D.29759>:
            D.29714 = req->event_kind;
            if (D.29714 == 12) goto <D.29761>; else goto <D.29762>;
            <D.29761>:
            goto <D.29763>;
            <D.29762>:
            D.29764 = req->nmodifiers;
            if (D.29764 != 0) goto <D.29765>; else goto <D.29766>;
            <D.29765>:
            monoeg_g_free (req);
            D.29608 = 100;
            return D.29608;
            <D.29766>:
            <D.29763>:
            <D.29760>:
            <D.29757>:
            <D.29753>:
            <D.29749>:
            <D.29729>:
            mono_loader_lock ();
            event_requests.166 = event_requests;
            monoeg_g_ptr_array_add (event_requests.166, req);
            D.29768 = agent_config.defer;
            if (D.29768 != 0) goto <D.29769>; else goto <D.29770>;
            <D.29769>:
            D.29714 = req->event_kind;
            switch (D.29714) <default: <D.27276>, case 2: <D.27274>, case 4: <D.27271>, case 8: <D.27273>, case 12: <D.27275>>
            <D.27271>:
            domains.167 = domains;
            monoeg_g_hash_table_foreach (domains.167, emit_appdomain_load, 0B);
            goto <D.27272>;
            <D.27273>:
            mono_assembly_foreach (emit_assembly_load, 0B);
            goto <D.27272>;
            <D.27274>:
            tid_to_thread.168 = tid_to_thread;
            mono_g_hash_table_foreach (tid_to_thread.168, emit_thread_start, 0B);
            goto <D.27272>;
            <D.27275>:
            mono_domain_foreach (send_types_for_domain, 0B);
            goto <D.27272>;
            <D.27276>:
            goto <D.27272>;
            <D.27272>:
            <D.29770>:
            mono_loader_unlock ();
            D.29773 = req->id;
            D.29774 = (unsigned int) D.29773;
            buffer_add_int (buf, D.29774);
            goto <D.27277>;
          }
        finally
          {
            step_thread = {CLOBBER};
            domain = {CLOBBER};
          }
      }
      <D.27278>:
      {
        int etype;
        int req_id;

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

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

          event_requests.166 = event_requests;
          D.29775 = event_requests.166->pdata;
          D.29776 = (long unsigned int) i;
          D.29777 = D.29776 * 8;
          D.29778 = D.29775 + D.29777;
          req = *D.29778;
          D.29779 = req->event_kind;
          if (D.29779 == 10) goto <D.29780>; else goto <D.29781>;
          <D.29780>:
          D.29782 = req->info;
          clear_breakpoint (D.29782);
          event_requests.166 = event_requests;
          i.169 = (unsigned int) i;
          monoeg_g_ptr_array_remove_index_fast (event_requests.166, i.169);
          monoeg_g_free (req);
          goto <D.29784>;
          <D.29781>:
          i = i + 1;
          <D.29784>:
        }
        <D.27285>:
        i.169 = (unsigned int) i;
        event_requests.166 = event_requests;
        D.29785 = event_requests.166->len;
        if (i.169 < D.29785) goto <D.27284>; else goto <D.27286>;
        <D.27286>:
        mono_loader_unlock ();
        goto <D.27277>;
      }
      <D.27287>:
      D.29608 = 100;
      return D.29608;
      <D.27277>:
      D.29608 = 0;
      return D.29608;
    }
  finally
    {
      err = {CLOBBER};
      error = {CLOBBER};
    }
}


send_types_for_domain (struct MonoDomain * domain, void * user_data)
{
  union mono_mutex_t * D.29791;
  _Bool D.29794;
  long int D.29795;
  long int D.29796;
  _Bool D.29799;
  long int D.29800;
  long int D.29801;
  struct GHashTable * D.29804;
  _Bool D.29807;
  long int D.29808;
  long int D.29809;
  struct AgentDomainInfo * info;

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

    D.29791 = &domain->lock.mutex;
    ret = pthread_mutex_lock (D.29791);
    if (ret != 0) goto <D.29792>; else goto <D.29793>;
    <D.29792>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.29793>:
    D.29794 = ret != 0;
    D.29795 = (long int) D.29794;
    D.29796 = __builtin_expect (D.29795, 0);
    if (D.29796 != 0) goto <D.29797>; else goto <D.29798>;
    <D.29797>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 4009, "ret == 0");
    <D.29798>:
  }
  info = get_agent_domain_info (domain);
  D.29799 = info == 0B;
  D.29800 = (long int) D.29799;
  D.29801 = __builtin_expect (D.29800, 0);
  if (D.29801 != 0) goto <D.29802>; else goto <D.29803>;
  <D.29802>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 4011, "info");
  <D.29803>:
  D.29804 = info->loaded_classes;
  monoeg_g_hash_table_foreach (D.29804, emit_type_load, 0B);
  {
    int ret;

    D.29791 = &domain->lock.mutex;
    ret = pthread_mutex_unlock (D.29791);
    if (ret != 0) goto <D.29805>; else goto <D.29806>;
    <D.29805>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.29806>:
    D.29807 = ret != 0;
    D.29808 = (long int) D.29807;
    D.29809 = __builtin_expect (D.29808, 0);
    if (D.29809 != 0) goto <D.29810>; else goto <D.29811>;
    <D.29810>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 4013, "ret == 0");
    <D.29811>:
  }
  mono_loader_unlock ();
}


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


emit_thread_start (void * key, void * value, void * user_data)
{
  long int key.170;
  int D.29813;
  long unsigned int D.29814;
  long unsigned int debugger_thread_id.171;

  key.170 = (long int) key;
  D.29813 = (int) key.170;
  D.29814 = (long unsigned int) D.29813;
  debugger_thread_id.171 = debugger_thread_id;
  if (D.29814 != debugger_thread_id.171) goto <D.29816>; else goto <D.29817>;
  <D.29816>:
  process_profiler_event (2, value);
  <D.29817>:
}


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.29818;
  struct GHashTable * D.29819;

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


InterlockedIncrement (volatile gint32 * val)
{
  gint32 D.29820;
  unsigned int D.29821;

  D.29821 = __sync_add_and_fetch_4 (val, 1);
  D.29820 = (gint32) D.29821;
  return D.29820;
}


decode_methodid (guint8 * buf, guint8 * * endbuf, guint8 * limit, struct MonoDomain * * domain, int * err)
{
  int log_level.172;
  _Bool D.29824;
  long int D.29825;
  long int D.29826;
  struct FILE * log_file.173;
  struct MonoMethod * D.29834;
  struct MonoMethod * m;

  m = decode_ptr_id (buf, endbuf, limit, 3, domain, err);
  log_level.172 = log_level;
  D.29824 = log_level.172 > 1;
  D.29825 = (long int) D.29824;
  D.29826 = __builtin_expect (D.29825, 0);
  if (D.29826 != 0) goto <D.29827>; else goto <D.29828>;
  <D.29827>:
  if (m != 0B) goto <D.29829>; else goto <D.29830>;
  <D.29829>:
  {
    char * s;

    s = mono_method_full_name (m, 1);
    log_level.172 = log_level;
    D.29824 = log_level.172 > 1;
    D.29825 = (long int) D.29824;
    D.29826 = __builtin_expect (D.29825, 0);
    if (D.29826 != 0) goto <D.29831>; else goto <D.29832>;
    <D.29831>:
    log_file.173 = log_file;
    fprintf (log_file.173, "[dbg]   recv method [%s]\n", s);
    log_file.173 = log_file;
    fflush (log_file.173);
    <D.29832>:
    monoeg_g_free (s);
  }
  <D.29830>:
  <D.29828>:
  D.29834 = m;
  return D.29834;
}


decode_ptr_id (guint8 * buf, guint8 * * endbuf, guint8 * limit, IdType type, struct MonoDomain * * domain, int * err)
{
  void * D.29840;
  int iftmp.174;
  unsigned int id.175;
  struct GPtrArray * D.29847;
  unsigned int D.29848;
  _Bool D.29849;
  long int D.29850;
  long int D.29851;
  void * * D.29854;
  long unsigned int D.29855;
  long unsigned int D.29856;
  sizetype D.29857;
  void * * D.29858;
  struct MonoDomain * D.29859;
  struct Id * res;
  int id;

  id = decode_id (buf, endbuf, limit);
  *err = 0;
  if (domain != 0B) goto <D.29836>; else goto <D.29837>;
  <D.29836>:
  *domain = 0B;
  <D.29837>:
  if (id == 0) goto <D.29838>; else goto <D.29839>;
  <D.29838>:
  D.29840 = 0B;
  return D.29840;
  <D.29839>:
  mono_loader_lock ();
  if (id <= 0) goto <D.29842>; else goto <D.29845>;
  <D.29845>:
  id.175 = (unsigned int) id;
  D.29847 = ids[type];
  D.29848 = D.29847->len;
  if (id.175 > D.29848) goto <D.29842>; else goto <D.29843>;
  <D.29842>:
  iftmp.174 = 1;
  goto <D.29844>;
  <D.29843>:
  iftmp.174 = 0;
  <D.29844>:
  D.29849 = iftmp.174 != 0;
  D.29850 = (long int) D.29849;
  D.29851 = __builtin_expect (D.29850, 0);
  if (D.29851 != 0) goto <D.29852>; else goto <D.29853>;
  <D.29852>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 2196, "id > 0 && id <= ids [type]->len");
  <D.29853>:
  D.29847 = ids[type];
  D.29854 = D.29847->pdata;
  D.29855 = (long unsigned int) id;
  D.29856 = D.29855 * 8;
  D.29857 = D.29856 + 18446744073709551608;
  D.29858 = D.29854 + D.29857;
  res = *D.29858;
  mono_loader_unlock ();
  D.29859 = res->domain;
  if (D.29859 == 0B) goto <D.29860>; else goto <D.29861>;
  <D.29860>:
  *err = 103;
  D.29840 = 0B;
  return D.29840;
  <D.29861>:
  if (domain != 0B) goto <D.29862>; else goto <D.29863>;
  <D.29862>:
  D.29859 = res->domain;
  *domain = D.29859;
  <D.29863>:
  D.29840 = res->data.val;
  return D.29840;
}


decode_long (guint8 * buf, guint8 * * endbuf, guint8 * limit)
{
  guint8 * buf.176;
  int D.29866;
  int D.29867;
  gint64 D.29868;
  long unsigned int D.29869;
  long unsigned int D.29870;
  long unsigned int D.29871;
  long unsigned int D.29872;
  guint32 high;
  guint32 low;

  buf.176 = buf;
  D.29866 = decode_int (buf.176, &buf, limit);
  high = (guint32) D.29866;
  buf.176 = buf;
  D.29867 = decode_int (buf.176, &buf, limit);
  low = (guint32) D.29867;
  buf.176 = buf;
  *endbuf = buf.176;
  D.29869 = (long unsigned int) high;
  D.29870 = D.29869 << 32;
  D.29871 = (long unsigned int) low;
  D.29872 = D.29870 | D.29871;
  D.29868 = (gint64) D.29872;
  return D.29868;
}


decode_typeid (guint8 * buf, guint8 * * endbuf, guint8 * limit, struct MonoDomain * * domain, int * err)
{
  int log_level.177;
  _Bool D.29875;
  long int D.29876;
  long int D.29877;
  struct MonoType * D.29882;
  struct FILE * log_file.178;
  struct MonoClass * D.29886;
  struct MonoClass * klass;

  klass = decode_ptr_id (buf, endbuf, limit, 2, domain, err);
  log_level.177 = log_level;
  D.29875 = log_level.177 > 1;
  D.29876 = (long int) D.29875;
  D.29877 = __builtin_expect (D.29876, 0);
  if (D.29877 != 0) goto <D.29878>; else goto <D.29879>;
  <D.29878>:
  if (klass != 0B) goto <D.29880>; else goto <D.29881>;
  <D.29880>:
  {
    char * s;

    D.29882 = &klass->byval_arg;
    s = mono_type_full_name (D.29882);
    log_level.177 = log_level;
    D.29875 = log_level.177 > 1;
    D.29876 = (long int) D.29875;
    D.29877 = __builtin_expect (D.29876, 0);
    if (D.29877 != 0) goto <D.29883>; else goto <D.29884>;
    <D.29883>:
    log_file.178 = log_file;
    fprintf (log_file.178, "[dbg]   recv class [%s]\n", s);
    log_file.178 = log_file;
    fflush (log_file.178);
    <D.29884>:
    monoeg_g_free (s);
  }
  <D.29881>:
  <D.29879>:
  D.29886 = klass;
  return D.29886;
}


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

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


ss_create (struct MonoInternalThread * thread, StepSize size, StepDepth depth, struct EventRequest * req)
{
  int suspend_count.179;
  ErrorCode D.29893;
  struct SingleStepReq * ss_req.180;
  int log_level.181;
  _Bool D.29898;
  long int D.29899;
  long int D.29900;
  struct FILE * log_file.182;
  _Bool D.29904;
  long int D.29905;
  long int D.29906;
  const char * D.29909;
  void * ss_req.183;
  struct MonoGHashTable * thread_to_tls.184;
  _Bool D.29912;
  long int D.29913;
  long int D.29914;
  int D.29917;
  _Bool D.29918;
  long int D.29919;
  long int D.29920;
  long unsigned int D.29923;
  void * D.29924;
  void * D.29925;
  int D.29926;
  void * D.29929;
  void * D.29930;
  struct MonoContext * D.29931;
  _Bool D.29932;
  long int D.29933;
  long int D.29934;
  <unnamed type> D.29937;
  _Bool D.29938;
  long int D.29939;
  long int D.29940;
  struct MonoDomain * D.29943;
  struct MonoMethod * D.29944;
  int D.29945;
  _Bool D.29948;
  long int D.29949;
  long int D.29950;
  <unnamed type> D.29955;
  int D.29958;
  struct StackFrame * * D.29961;
  struct MonoMethod * D.29962;
  unsigned int D.29965;
  unsigned int D.29970;
  int D.29971;
  unsigned int D.29978;
  struct MonoDomain * D.29981;
  struct MonoMethod * D.29982;
  unsigned int D.29983;
  int D.29984;
  struct MonoSeqPointInfo * info.185;
  struct MonoContext * D.29990;
  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.179 = suspend_count;
      if (suspend_count.179 == 0) goto <D.29891>; else goto <D.29892>;
      <D.29891>:
      D.29893 = 101;
      return D.29893;
      <D.29892>:
      wait_for_suspend ();
      ss_req.180 = ss_req;
      if (ss_req.180 != 0B) goto <D.29895>; else goto <D.29896>;
      <D.29895>:
      log_level.181 = log_level;
      D.29898 = log_level.181 >= 0;
      D.29899 = (long int) D.29898;
      D.29900 = __builtin_expect (D.29899, 0);
      if (D.29900 != 0) goto <D.29901>; else goto <D.29902>;
      <D.29901>:
      log_file.182 = log_file;
      fprintf (log_file.182, "Received a single step request while the previous one was still active.\n");
      log_file.182 = log_file;
      fflush (log_file.182);
      <D.29902>:
      D.29893 = 100;
      return D.29893;
      <D.29896>:
      log_level.181 = log_level;
      D.29904 = log_level.181 > 0;
      D.29905 = (long int) D.29904;
      D.29906 = __builtin_expect (D.29905, 0);
      if (D.29906 != 0) goto <D.29907>; else goto <D.29908>;
      <D.29907>:
      log_file.182 = log_file;
      D.29909 = ss_depth_to_string (depth);
      fprintf (log_file.182, "[dbg] Starting single step of thread %p (depth=%s).\n", thread, D.29909);
      log_file.182 = log_file;
      fflush (log_file.182);
      <D.29908>:
      ss_req.183 = monoeg_malloc0 (80);
      ss_req = ss_req.183;
      ss_req.180 = ss_req;
      ss_req.180->req = req;
      ss_req.180 = ss_req;
      ss_req.180->thread = thread;
      ss_req.180 = ss_req;
      ss_req.180->size = size;
      ss_req.180 = ss_req;
      ss_req.180->depth = depth;
      ss_req.180 = ss_req;
      req->info = ss_req.180;
      mono_loader_lock ();
      thread_to_tls.184 = thread_to_tls;
      tls = mono_g_hash_table_lookup (thread_to_tls.184, thread);
      mono_loader_unlock ();
      D.29912 = tls == 0B;
      D.29913 = (long int) D.29912;
      D.29914 = __builtin_expect (D.29913, 0);
      if (D.29914 != 0) goto <D.29915>; else goto <D.29916>;
      <D.29915>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 5168, "tls");
      <D.29916>:
      D.29917 = tls->context.valid;
      D.29918 = D.29917 == 0;
      D.29919 = (long int) D.29918;
      D.29920 = __builtin_expect (D.29919, 0);
      if (D.29920 != 0) goto <D.29921>; else goto <D.29922>;
      <D.29921>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 5169, "tls->context.valid");
      <D.29922>:
      ss_req.180 = ss_req;
      ss_req.180 = ss_req;
      D.29923 = tls->context.ctx.sc_sp;
      D.29924 = (void *) D.29923;
      ss_req.180->last_sp = D.29924;
      D.29925 = ss_req.180->last_sp;
      ss_req.180->start_sp = D.29925;
      D.29926 = tls->catch_state.valid;
      if (D.29926 != 0) goto <D.29927>; else goto <D.29928>;
      <D.29927>:
      {
        gboolean res;
        struct StackFrameInfo frame;
        struct MonoContext new_ctx;
        struct MonoLMF * lmf;

        try
          {
            lmf = 0B;
            D.29929 = tls->catch_state.unwind_data[0];
            D.29930 = thread->jit_data;
            D.29931 = &tls->catch_state.ctx;
            res = mono_find_jit_info_ext (D.29929, D.29930, 0B, D.29931, &new_ctx, 0B, &lmf, 0B, &frame);
            D.29932 = res == 0;
            D.29933 = (long int) D.29932;
            D.29934 = __builtin_expect (D.29933, 0);
            if (D.29934 != 0) goto <D.29935>; else goto <D.29936>;
            <D.29935>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 5184, "res");
            <D.29936>:
            D.29937 = frame.type;
            D.29938 = D.29937 != 0;
            D.29939 = (long int) D.29938;
            D.29940 = __builtin_expect (D.29939, 0);
            if (D.29940 != 0) goto <D.29941>; else goto <D.29942>;
            <D.29941>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 5185, "frame.type == FRAME_TYPE_MANAGED");
            <D.29942>:
            D.29943 = frame.domain;
            D.29944 = frame.method;
            D.29945 = frame.native_offset;
            sp = find_next_seq_point_for_native_offset (D.29943, D.29944, D.29945, &info);
            if (sp == 0B) goto <D.29946>; else goto <D.29947>;
            <D.29946>:
            D.29944 = frame.method;
            no_seq_points_found (D.29944);
            <D.29947>:
            D.29948 = sp == 0B;
            D.29949 = (long int) D.29948;
            D.29950 = __builtin_expect (D.29949, 0);
            if (D.29950 != 0) goto <D.29951>; else goto <D.29952>;
            <D.29951>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 5194, "sp");
            <D.29952>:
            method = frame.method;
            step_to_catch = 1;
            ss_req.180 = ss_req;
            ss_req.180->last_sp = 0B;
          }
        finally
          {
            frame = {CLOBBER};
            new_ctx = {CLOBBER};
            lmf = {CLOBBER};
          }
      }
      <D.29928>:
      if (step_to_catch == 0) goto <D.29953>; else goto <D.29954>;
      <D.29953>:
      ss_req.180 = ss_req;
      D.29955 = ss_req.180->size;
      if (D.29955 == 1) goto <D.29956>; else goto <D.29957>;
      <D.29956>:
      {
        struct StackFrame * frame;

        compute_frame_info (thread, tls);
        D.29958 = tls->frame_count;
        if (D.29958 != 0) goto <D.29959>; else goto <D.29960>;
        <D.29959>:
        D.29961 = tls->frames;
        frame = *D.29961;
        ss_req.180 = ss_req;
        D.29962 = frame->method;
        ss_req.180->last_method = D.29962;
        ss_req.180 = ss_req;
        ss_req.180->last_line = -1;
        D.29962 = frame->method;
        minfo = mono_debug_lookup_method (D.29962);
        if (minfo != 0B) goto <D.29963>; else goto <D.29964>;
        <D.29963>:
        D.29965 = frame->il_offset;
        if (D.29965 != 4294967295) goto <D.29966>; else goto <D.29967>;
        <D.29966>:
        {
          struct MonoDebugSourceLocation * loc;

          D.29965 = frame->il_offset;
          loc = mono_debug_symfile_lookup_location (minfo, D.29965);
          if (loc != 0B) goto <D.29968>; else goto <D.29969>;
          <D.29968>:
          ss_req.180 = ss_req;
          D.29970 = loc->row;
          D.29971 = (int) D.29970;
          ss_req.180->last_line = D.29971;
          monoeg_g_free (loc);
          <D.29969>:
        }
        <D.29967>:
        <D.29964>:
        <D.29960>:
      }
      <D.29957>:
      <D.29954>:
      if (step_to_catch == 0) goto <D.29972>; else goto <D.29973>;
      <D.29972>:
      {
        struct StackFrame * frame;

        compute_frame_info (thread, tls);
        D.29958 = tls->frame_count;
        if (D.29958 != 0) goto <D.29974>; else goto <D.29975>;
        <D.29974>:
        D.29961 = tls->frames;
        frame = *D.29961;
        if (method == 0B) goto <D.29976>; else goto <D.29977>;
        <D.29976>:
        D.29978 = frame->il_offset;
        if (D.29978 != 4294967295) goto <D.29979>; else goto <D.29980>;
        <D.29979>:
        D.29981 = frame->domain;
        D.29982 = frame->method;
        D.29983 = frame->native_offset;
        D.29984 = (int) D.29983;
        sp = find_prev_seq_point_for_native_offset (D.29981, D.29982, D.29984, &info);
        if (sp == 0B) goto <D.29985>; else goto <D.29986>;
        <D.29985>:
        D.29982 = frame->method;
        no_seq_points_found (D.29982);
        <D.29986>:
        D.29948 = sp == 0B;
        D.29949 = (long int) D.29948;
        D.29950 = __builtin_expect (D.29949, 0);
        if (D.29950 != 0) goto <D.29987>; else goto <D.29988>;
        <D.29987>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 5240, "sp");
        <D.29988>:
        method = frame->method;
        <D.29980>:
        <D.29977>:
        <D.29975>:
      }
      <D.29973>:
      ss_req.180 = ss_req;
      info.185 = info;
      D.29990 = &tls->context.ctx;
      ss_start (ss_req.180, method, sp, info.185, D.29990, tls, step_to_catch);
      D.29893 = 0;
      return D.29893;
    }
  finally
    {
      info = {CLOBBER};
    }
}


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

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


find_next_seq_point_for_native_offset (struct MonoDomain * domain, struct MonoMethod * method, gint32 native_offset, struct MonoSeqPointInfo * * info)
{
  struct SeqPoint * D.29999;
  _Bool D.30000;
  long int D.30001;
  long int D.30002;
  int D.30007;
  int D.30010;
  struct MonoSeqPointInfo * seq_points;
  int i;

  seq_points = get_seq_points (domain, method);
  if (seq_points == 0B) goto <D.29995>; else goto <D.29996>;
  <D.29995>:
  if (info != 0B) goto <D.29997>; else goto <D.29998>;
  <D.29997>:
  *info = 0B;
  <D.29998>:
  D.29999 = 0B;
  return D.29999;
  <D.29996>:
  D.30000 = seq_points == 0B;
  D.30001 = (long int) D.30000;
  D.30002 = __builtin_expect (D.30001, 0);
  if (D.30002 != 0) goto <D.30003>; else goto <D.30004>;
  <D.30003>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 3028, "seq_points");
  <D.30004>:
  if (info != 0B) goto <D.30005>; else goto <D.30006>;
  <D.30005>:
  *info = seq_points;
  <D.30006>:
  i = 0;
  goto <D.25987>;
  <D.25986>:
  D.30007 = seq_points->seq_points[i].native_offset;
  if (D.30007 >= native_offset) goto <D.30008>; else goto <D.30009>;
  <D.30008>:
  D.29999 = &seq_points->seq_points[i];
  return D.29999;
  <D.30009>:
  i = i + 1;
  <D.25987>:
  D.30010 = seq_points->len;
  if (D.30010 > i) goto <D.25986>; else goto <D.25988>;
  <D.25988>:
  D.29999 = 0B;
  return D.29999;
}


get_seq_points (struct MonoDomain * domain, struct MonoMethod * method)
{
  union mono_mutex_t * D.30012;
  _Bool D.30015;
  long int D.30016;
  long int D.30017;
  void * D.30020;
  struct GHashTable * D.30021;
  long unsigned int D.30024;
  long unsigned int D.30025;
  struct MonoMethod * D.30028;
  struct MonoMethod * D.30031;
  _Bool D.30034;
  long int D.30035;
  long int D.30036;
  struct MonoSeqPointInfo * D.30039;
  struct MonoSeqPointInfo * seq_points;

  {
    int ret;

    D.30012 = &domain->lock.mutex;
    ret = pthread_mutex_lock (D.30012);
    if (ret != 0) goto <D.30013>; else goto <D.30014>;
    <D.30013>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.30014>:
    D.30015 = ret != 0;
    D.30016 = (long int) D.30015;
    D.30017 = __builtin_expect (D.30016, 0);
    if (D.30017 != 0) goto <D.30018>; else goto <D.30019>;
    <D.30018>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 2989, "ret == 0");
    <D.30019>:
  }
  D.30020 = domain->runtime_info;
  D.30021 = MEM[(struct MonoJitDomainInfo *)D.30020].seq_points;
  seq_points = monoeg_g_hash_table_lookup (D.30021, method);
  if (seq_points == 0B) goto <D.30022>; else goto <D.30023>;
  <D.30022>:
  D.30024 = BIT_FIELD_REF <*method, 64, 256>;
  D.30025 = D.30024 & 4096;
  if (D.30025 != 0) goto <D.30026>; else goto <D.30027>;
  <D.30026>:
  D.30020 = domain->runtime_info;
  D.30021 = MEM[(struct MonoJitDomainInfo *)D.30020].seq_points;
  D.30028 = mono_method_get_declaring_generic_method (method);
  seq_points = monoeg_g_hash_table_lookup (D.30021, D.30028);
  if (seq_points == 0B) goto <D.30029>; else goto <D.30030>;
  <D.30029>:
  D.30020 = domain->runtime_info;
  D.30021 = MEM[(struct MonoJitDomainInfo *)D.30020].seq_points;
  D.30031 = mini_get_shared_method (method);
  seq_points = monoeg_g_hash_table_lookup (D.30021, D.30031);
  <D.30030>:
  <D.30027>:
  <D.30023>:
  {
    int ret;

    D.30012 = &domain->lock.mutex;
    ret = pthread_mutex_unlock (D.30012);
    if (ret != 0) goto <D.30032>; else goto <D.30033>;
    <D.30032>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.30033>:
    D.30034 = ret != 0;
    D.30035 = (long int) D.30034;
    D.30036 = __builtin_expect (D.30035, 0);
    if (D.30036 != 0) goto <D.30037>; else goto <D.30038>;
    <D.30037>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 2997, "ret == 0");
    <D.30038>:
  }
  D.30039 = seq_points;
  return D.30039;
}


compute_frame_info (struct MonoInternalThread * thread, struct DebuggerTlsData * tls)
{
  struct StackFrame * * D.30041;
  int D.30044;
  int log_level.186;
  _Bool D.30048;
  long int D.30049;
  long int D.30050;
  struct FILE * log_file.187;
  long unsigned int D.30054;
  long int D.30055;
  int D.30056;
  int D.30061;
  int D.30063;
  struct StackFrameInfo * D.30065;
  struct MonoThreadUnwindState * D.30066;
  int D.30067;
  int D.30070;
  struct MonoThreadUnwindState * D.30073;
  struct MonoThreadUnwindState * D.30074;
  struct GSList * D.30079;
  unsigned int D.30080;
  long unsigned int D.30081;
  long unsigned int D.30082;
  long unsigned int D.30083;
  long unsigned int D.30084;
  struct StackFrame * * D.30085;
  struct StackFrame * D.30086;
  long unsigned int D.30087;
  void * D.30088;
  long unsigned int D.30089;
  void * D.30090;
  int D.30093;
  int D.30094;
  int D.30097;
  int findex.188;
  long unsigned int D.30099;
  long unsigned int D.30100;
  struct StackFrame * * D.30101;
  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.30041 = tls->frames;
      if (D.30041 != 0B) goto <D.30042>; else goto <D.30043>;
      <D.30042>:
      D.30044 = tls->frames_up_to_date;
      if (D.30044 != 0) goto <D.30045>; else goto <D.30046>;
      <D.30045>:
      return;
      <D.30046>:
      <D.30043>:
      log_level.186 = log_level;
      D.30048 = log_level.186 > 0;
      D.30049 = (long int) D.30048;
      D.30050 = __builtin_expect (D.30049, 0);
      if (D.30050 != 0) goto <D.30051>; else goto <D.30052>;
      <D.30051>:
      log_file.187 = log_file;
      D.30054 = thread->tid;
      D.30055 = (long int) D.30054;
      fprintf (log_file.187, "Frames for %p(tid=%lx):\n", thread, D.30055);
      log_file.187 = log_file;
      fflush (log_file.187);
      <D.30052>:
      user_data.tls = tls;
      user_data.frames = 0B;
      D.30056 = tls->terminated;
      if (D.30056 != 0) goto <D.30057>; else goto <D.30058>;
      <D.30057>:
      tls->frame_count = 0;
      return;
      <D.30058>:
      D.30061 = tls->really_suspended;
      if (D.30061 == 0) goto <D.30062>; else goto <D.30059>;
      <D.30062>:
      D.30063 = tls->async_state.valid;
      if (D.30063 != 0) goto <D.30064>; else goto <D.30059>;
      <D.30064>:
      D.30065 = &tls->async_last_frame;
      process_frame (D.30065, 0B, &user_data);
      D.30066 = &tls->async_state;
      mono_walk_stack_with_state (process_frame, D.30066, opts, &user_data);
      goto <D.30060>;
      <D.30059>:
      D.30067 = tls->filter_state.valid;
      if (D.30067 != 0) goto <D.30068>; else goto <D.30069>;
      <D.30068>:
      D.30070 = tls->context.valid;
      if (D.30070 != 0) goto <D.30071>; else goto <D.30072>;
      <D.30071>:
      D.30073 = &tls->context;
      mono_walk_stack_with_state (process_filter_frame, D.30073, opts, &user_data);
      <D.30072>:
      D.30074 = &tls->filter_state;
      mono_walk_stack_with_state (process_frame, D.30074, opts, &user_data);
      goto <D.30075>;
      <D.30069>:
      D.30070 = tls->context.valid;
      if (D.30070 != 0) goto <D.30076>; else goto <D.30077>;
      <D.30076>:
      D.30073 = &tls->context;
      mono_walk_stack_with_state (process_frame, D.30073, opts, &user_data);
      goto <D.30078>;
      <D.30077>:
      tls->frame_count = 0;
      return;
      <D.30078>:
      <D.30075>:
      <D.30060>:
      D.30079 = user_data.frames;
      D.30080 = monoeg_g_slist_length (D.30079);
      new_frame_count = (int) D.30080;
      D.30081 = (long unsigned int) new_frame_count;
      D.30082 = D.30081 * 8;
      new_frames = monoeg_malloc0 (D.30082);
      findex = 0;
      tmp = user_data.frames;
      goto <D.26049>;
      <D.26048>:
      f = tmp->data;
      i = 0;
      goto <D.26047>;
      <D.26046>:
      D.30041 = tls->frames;
      D.30083 = (long unsigned int) i;
      D.30084 = D.30083 * 8;
      D.30085 = D.30041 + D.30084;
      D.30086 = *D.30085;
      D.30087 = D.30086->ctx.sc_sp;
      D.30088 = (void *) D.30087;
      D.30089 = f->ctx.sc_sp;
      D.30090 = (void *) D.30089;
      if (D.30088 == D.30090) goto <D.30091>; else goto <D.30092>;
      <D.30091>:
      D.30041 = tls->frames;
      D.30083 = (long unsigned int) i;
      D.30084 = D.30083 * 8;
      D.30085 = D.30041 + D.30084;
      D.30086 = *D.30085;
      D.30093 = D.30086->id;
      f->id = D.30093;
      goto <D.26045>;
      <D.30092>:
      i = i + 1;
      <D.26047>:
      D.30094 = tls->frame_count;
      if (D.30094 > i) goto <D.26046>; else goto <D.26045>;
      <D.26045>:
      D.30094 = tls->frame_count;
      if (D.30094 <= i) goto <D.30095>; else goto <D.30096>;
      <D.30095>:
      D.30097 = InterlockedIncrement (&frame_id);
      f->id = D.30097;
      <D.30096>:
      findex.188 = findex;
      findex = findex.188 + 1;
      D.30099 = (long unsigned int) findex.188;
      D.30100 = D.30099 * 8;
      D.30101 = new_frames + D.30100;
      *D.30101 = f;
      tmp = tmp->next;
      <D.26049>:
      if (tmp != 0B) goto <D.26048>; else goto <D.26050>;
      <D.26050>:
      D.30079 = user_data.frames;
      monoeg_g_slist_free (D.30079);
      invalidate_frames (tls);
      tls->frames = new_frames;
      tls->frame_count = new_frame_count;
      tls->frames_up_to_date = 1;
    }
  finally
    {
      user_data = {CLOBBER};
    }
}


process_filter_frame (struct StackFrameInfo * info, struct MonoContext * ctx, void * user_data)
{
  long unsigned int D.30105;
  void * D.30106;
  struct DebuggerTlsData * D.30107;
  long unsigned int D.30108;
  void * D.30109;
  gboolean D.30112;
  struct ComputeFramesUserData * ud;

  ud = user_data;
  D.30105 = ctx->sc_sp;
  D.30106 = (void *) D.30105;
  D.30107 = ud->tls;
  D.30108 = D.30107->filter_state.ctx.sc_sp;
  D.30109 = (void *) D.30108;
  if (D.30106 >= D.30109) goto <D.30110>; else goto <D.30111>;
  <D.30110>:
  D.30112 = 1;
  return D.30112;
  <D.30111>:
  D.30112 = process_frame (info, ctx, user_data);
  return D.30112;
}


process_frame (struct StackFrameInfo * info, struct MonoContext * ctx, void * user_data)
{
  <unnamed type> D.30114;
  struct GSList * D.30119;
  struct GSList * D.30122;
  void * D.30123;
  int D.30124;
  int D.30125;
  gboolean D.30126;
  struct MonoJitInfo * D.30127;
  long unsigned int D.30136;
  long unsigned int D.30137;
  int D.30140;
  struct MonoDomain * D.30145;
  int D.30146;
  int D.30149;
  unsigned int D.30152;
  int D.30153;
  int log_level.189;
  _Bool D.30155;
  long int D.30156;
  long int D.30157;
  struct FILE * log_file.190;
  char * D.30161;
  int D.30162;
  int protocol_version_set.191;
  int major_version.192;
  int minor_version.193;
  unsigned int D.30175;
  unsigned int D.30176;
  mgreg_t * * D.30177;
  mgreg_t *[32] * D.30180;
  struct GSList * D.30183;
  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.30114 = info->type;
  if (D.30114 != 0) goto <D.30115>; else goto <D.30116>;
  <D.30115>:
  D.30114 = info->type;
  if (D.30114 == 1) goto <D.30117>; else goto <D.30118>;
  <D.30117>:
  D.30119 = ud->frames;
  if (D.30119 != 0B) goto <D.30120>; else goto <D.30121>;
  <D.30120>:
  D.30119 = ud->frames;
  D.30122 = monoeg_g_slist_last (D.30119);
  D.30123 = D.30122->data;
  D.30124 = MEM[(struct StackFrame *)D.30123].flags;
  D.30125 = D.30124 | 1;
  MEM[(struct StackFrame *)D.30123].flags = D.30125;
  <D.30121>:
  <D.30118>:
  D.30126 = 0;
  return D.30126;
  <D.30116>:
  D.30127 = info->ji;
  if (D.30127 != 0B) goto <D.30128>; else goto <D.30129>;
  <D.30128>:
  D.30127 = info->ji;
  method = jinfo_get_method (D.30127);
  goto <D.30130>;
  <D.30129>:
  method = info->method;
  <D.30130>:
  actual_method = info->actual_method;
  api_method = method;
  if (method == 0B) goto <D.30131>; else goto <D.30132>;
  <D.30131>:
  D.30126 = 0;
  return D.30126;
  <D.30132>:
  if (method == 0B) goto <D.30133>; else goto <D.30135>;
  <D.30135>:
  D.30136 = BIT_FIELD_REF <*method, 64, 256>;
  D.30137 = D.30136 & 124;
  if (D.30137 != 0) goto <D.30138>; else goto <D.30134>;
  <D.30138>:
  D.30136 = BIT_FIELD_REF <*method, 64, 256>;
  D.30137 = D.30136 & 124;
  if (D.30137 != 68) goto <D.30139>; else goto <D.30134>;
  <D.30139>:
  D.30136 = BIT_FIELD_REF <*method, 64, 256>;
  D.30137 = D.30136 & 124;
  if (D.30137 != 24) goto <D.30133>; else goto <D.30134>;
  <D.30133>:
  D.30126 = 0;
  return D.30126;
  <D.30134>:
  D.30140 = info->il_offset;
  if (D.30140 == -1) goto <D.30141>; else goto <D.30142>;
  <D.30141>:
  D.30119 = ud->frames;
  if (D.30119 == 0B) goto <D.30143>; else goto <D.30144>;
  <D.30143>:
  D.30145 = info->domain;
  D.30146 = info->native_offset;
  sp = find_prev_seq_point_for_native_offset (D.30145, method, D.30146, 0B);
  if (sp != 0B) goto <D.30147>; else goto <D.30148>;
  <D.30147>:
  D.30149 = sp->il_offset;
  info->il_offset = D.30149;
  <D.30148>:
  <D.30144>:
  D.30140 = info->il_offset;
  if (D.30140 == -1) goto <D.30150>; else goto <D.30151>;
  <D.30150>:
  D.30145 = info->domain;
  D.30146 = info->native_offset;
  D.30152 = (unsigned int) D.30146;
  D.30153 = mono_debug_il_offset_from_address (method, D.30145, D.30152);
  info->il_offset = D.30153;
  <D.30151>:
  <D.30142>:
  log_level.189 = log_level;
  D.30155 = log_level.189 > 0;
  D.30156 = (long int) D.30155;
  D.30157 = __builtin_expect (D.30156, 0);
  if (D.30157 != 0) goto <D.30158>; else goto <D.30159>;
  <D.30158>:
  log_file.190 = log_file;
  D.30161 = mono_method_full_name (method, 1);
  D.30140 = info->il_offset;
  D.30146 = info->native_offset;
  D.30162 = info->managed;
  fprintf (log_file.190, "\tFrame: %s:%x(%x) %d\n", D.30161, D.30140, D.30146, D.30162);
  log_file.190 = log_file;
  fflush (log_file.190);
  <D.30159>:
  D.30136 = BIT_FIELD_REF <*method, 64, 256>;
  D.30137 = D.30136 & 124;
  if (D.30137 == 24) goto <D.30163>; else goto <D.30164>;
  <D.30163>:
  protocol_version_set.191 = protocol_version_set;
  if (protocol_version_set.191 == 0) goto <D.30165>; else goto <D.30168>;
  <D.30168>:
  major_version.192 = major_version;
  if (major_version.192 <= 2) goto <D.30170>; else goto <D.30166>;
  <D.30170>:
  major_version.192 = major_version;
  if (major_version.192 != 2) goto <D.30165>; else goto <D.30171>;
  <D.30171>:
  minor_version.193 = minor_version;
  if (minor_version.193 <= 16) goto <D.30165>; else goto <D.30166>;
  <D.30165>:
  D.30126 = 0;
  return D.30126;
  <D.30166>:
  api_method = mono_marshal_method_from_wrapper (method);
  if (api_method == 0B) goto <D.30173>; else goto <D.30174>;
  <D.30173>:
  D.30126 = 0;
  return D.30126;
  <D.30174>:
  actual_method = api_method;
  flags = flags | 2;
  <D.30164>:
  frame = monoeg_malloc0 (648);
  frame->method = method;
  frame->actual_method = actual_method;
  frame->api_method = api_method;
  D.30140 = info->il_offset;
  D.30175 = (unsigned int) D.30140;
  frame->il_offset = D.30175;
  D.30146 = info->native_offset;
  D.30176 = (unsigned int) D.30146;
  frame->native_offset = D.30176;
  frame->flags = flags;
  D.30127 = info->ji;
  frame->ji = D.30127;
  D.30177 = info->reg_locations;
  if (D.30177 != 0B) goto <D.30178>; else goto <D.30179>;
  <D.30178>:
  D.30180 = &frame->reg_locations;
  D.30177 = info->reg_locations;
  memcpy (D.30180, D.30177, 256);
  <D.30179>:
  if (ctx != 0B) goto <D.30181>; else goto <D.30182>;
  <D.30181>:
  frame->ctx = *ctx;
  frame->has_ctx = 1;
  <D.30182>:
  D.30145 = info->domain;
  frame->domain = D.30145;
  D.30119 = ud->frames;
  D.30183 = monoeg_g_slist_append (D.30119, frame);
  ud->frames = D.30183;
  D.30126 = 0;
  return D.30126;
}


find_prev_seq_point_for_native_offset (struct MonoDomain * domain, struct MonoMethod * method, gint32 native_offset, struct MonoSeqPointInfo * * info)
{
  struct SeqPoint * D.30189;
  int D.30190;
  int D.30191;
  struct MonoSeqPointInfo * seq_points;
  int i;

  seq_points = get_seq_points (domain, method);
  if (info != 0B) goto <D.30185>; else goto <D.30186>;
  <D.30185>:
  *info = seq_points;
  <D.30186>:
  if (seq_points == 0B) goto <D.30187>; else goto <D.30188>;
  <D.30187>:
  D.30189 = 0B;
  return D.30189;
  <D.30188>:
  D.30190 = seq_points->len;
  i = D.30190 + -1;
  goto <D.25998>;
  <D.25997>:
  D.30191 = seq_points->seq_points[i].native_offset;
  if (D.30191 <= native_offset) goto <D.30192>; else goto <D.30193>;
  <D.30192>:
  D.30189 = &seq_points->seq_points[i];
  return D.30189;
  <D.30193>:
  i = i + -1;
  <D.25998>:
  if (i >= 0) goto <D.25997>; else goto <D.25999>;
  <D.25999>:
  D.30189 = 0B;
  return D.30189;
}


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

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


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

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


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.30200;
  long int D.30201;
  struct EventRequest * D.30202;
  struct GSList * D.30203;
  struct GSList * D.30204;
  int D.30209;
  <unnamed type> D.30211;
  int D.30215;
  struct MonoThreadUnwindState * D.30218;
  struct MonoInternalThread * D.30219;
  struct StackFrame * * D.30222;
  long unsigned int D.30223;
  long unsigned int D.30224;
  struct StackFrame * * D.30225;
  struct MonoDomain * D.30226;
  struct MonoMethod * D.30227;
  unsigned int D.30228;
  int D.30229;
  int D.30233;
  struct MonoDomain * D.30239;
  struct MonoMethod * D.30240;
  unsigned int D.30241;
  int D.30242;
  struct MonoSeqPointInfo * info.194;
  int * D.30251;
  long unsigned int D.30252;
  long unsigned int D.30253;
  int * D.30254;
  int D.30255;
  int D.30256;
  long int D.30257;
  struct GSList * D.30258;
  int D.30261;
  long unsigned int D.30264;
  struct StackFrame * * D.30265;
  struct MonoJitInfo * D.30266;
  struct MonoDomain * D.30269;
  struct MonoMethod * D.30270;
  void * D.30271;
  long int D.30272;
  void * D.30273;
  long int D.30274;
  long int D.30275;
  int D.30276;
  struct GSList * D.30279;
  <unnamed-unsigned:15> D.30280;
  int D.30281;
  int log_level.195;
  _Bool D.30287;
  long int D.30288;
  long int D.30289;
  struct FILE * log_file.196;
  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.30198>; else goto <D.30199>;
  <D.30198>:
  D.30200 = sp->il_offset;
  D.30201 = (long int) D.30200;
  D.30202 = ss_req->req;
  bp = set_breakpoint (method, D.30201, D.30202, 0B);
  D.30203 = ss_req->bps;
  D.30204 = monoeg_g_slist_append (D.30203, bp);
  ss_req->bps = D.30204;
  goto <D.30205>;
  <D.30199>:
  frame_index = 1;
  if (sp == 0B) goto <D.30206>; else goto <D.30208>;
  <D.30208>:
  D.30209 = sp->next_len;
  if (D.30209 == 0) goto <D.30206>; else goto <D.30210>;
  <D.30210>:
  D.30211 = ss_req->depth;
  if (D.30211 == 2) goto <D.30206>; else goto <D.30212>;
  <D.30212>:
  D.30211 = ss_req->depth;
  if (D.30211 == 1) goto <D.30206>; else goto <D.30207>;
  <D.30206>:
  if (ctx != 0B) goto <D.30213>; else goto <D.30214>;
  <D.30213>:
  D.30215 = tls->context.valid;
  if (D.30215 == 0) goto <D.30216>; else goto <D.30217>;
  <D.30216>:
  D.30218 = &tls->context;
  mono_thread_state_init_from_monoctx (D.30218, ctx);
  <D.30217>:
  D.30219 = tls->thread;
  compute_frame_info (D.30219, tls);
  <D.30214>:
  <D.30207>:
  D.30211 = ss_req->depth;
  if (D.30211 == 2) goto <D.30220>; else goto <D.30221>;
  <D.30220>:
  goto <D.26606>;
  <D.26605>:
  {
    struct StackFrame * frame;

    D.30222 = tls->frames;
    D.30223 = (long unsigned int) frame_index;
    D.30224 = D.30223 * 8;
    D.30225 = D.30222 + D.30224;
    frame = *D.30225;
    method = frame->method;
    D.30226 = frame->domain;
    D.30227 = frame->method;
    D.30228 = frame->native_offset;
    D.30229 = (int) D.30228;
    sp = find_prev_seq_point_for_native_offset (D.30226, D.30227, D.30229, &info);
    frame_index = frame_index + 1;
    if (sp != 0B) goto <D.30230>; else goto <D.30231>;
    <D.30230>:
    D.30209 = sp->next_len;
    if (D.30209 != 0) goto <D.26604>; else goto <D.30232>;
    <D.30232>:
    <D.30231>:
  }
  <D.26606>:
  D.30233 = tls->frame_count;
  if (D.30233 > frame_index) goto <D.26605>; else goto <D.26604>;
  <D.26604>:
  goto <D.30234>;
  <D.30221>:
  if (sp != 0B) goto <D.30235>; else goto <D.30236>;
  <D.30235>:
  D.30209 = sp->next_len;
  if (D.30209 == 0) goto <D.30237>; else goto <D.30238>;
  <D.30237>:
  sp = 0B;
  goto <D.26610>;
  <D.26609>:
  {
    struct StackFrame * frame;

    D.30222 = tls->frames;
    D.30223 = (long unsigned int) frame_index;
    D.30224 = D.30223 * 8;
    D.30225 = D.30222 + D.30224;
    frame = *D.30225;
    method = frame->method;
    D.30239 = frame->domain;
    D.30240 = frame->method;
    D.30241 = frame->native_offset;
    D.30242 = (int) D.30241;
    sp = find_prev_seq_point_for_native_offset (D.30239, D.30240, D.30242, &info);
    if (sp != 0B) goto <D.30243>; else goto <D.30244>;
    <D.30243>:
    D.30209 = sp->next_len;
    if (D.30209 != 0) goto <D.26608>; else goto <D.30245>;
    <D.30245>:
    <D.30244>:
    sp = 0B;
    frame_index = frame_index + 1;
  }
  <D.26610>:
  D.30233 = tls->frame_count;
  if (D.30233 > frame_index) goto <D.26609>; else goto <D.26608>;
  <D.26608>:
  <D.30238>:
  <D.30236>:
  <D.30234>:
  if (sp != 0B) goto <D.30246>; else goto <D.30247>;
  <D.30246>:
  D.30209 = sp->next_len;
  if (D.30209 > 0) goto <D.30248>; else goto <D.30249>;
  <D.30248>:
  i = 0;
  goto <D.26612>;
  <D.26611>:
  info.194 = info;
  D.30251 = sp->next;
  D.30252 = (long unsigned int) i;
  D.30253 = D.30252 * 4;
  D.30254 = D.30251 + D.30253;
  D.30255 = *D.30254;
  next_sp = &info.194->seq_points[D.30255];
  D.30256 = next_sp->il_offset;
  D.30257 = (long int) D.30256;
  D.30202 = ss_req->req;
  bp = set_breakpoint (method, D.30257, D.30202, 0B);
  D.30203 = ss_req->bps;
  D.30258 = monoeg_g_slist_append (D.30203, bp);
  ss_req->bps = D.30258;
  i = i + 1;
  <D.26612>:
  D.30209 = sp->next_len;
  if (D.30209 > i) goto <D.26611>; else goto <D.26613>;
  <D.26613>:
  <D.30249>:
  <D.30247>:
  D.30211 = ss_req->depth;
  if (D.30211 == 1) goto <D.30259>; else goto <D.30260>;
  <D.30259>:
  D.30261 = ss_req->nframes;
  if (D.30261 == 0) goto <D.30262>; else goto <D.30263>;
  <D.30262>:
  D.30233 = tls->frame_count;
  ss_req->nframes = D.30233;
  <D.30263>:
  i = 0;
  goto <D.26621>;
  <D.26620>:
  {
    struct StackFrame * frame;

    D.30222 = tls->frames;
    D.30252 = (long unsigned int) i;
    D.30264 = D.30252 * 8;
    D.30265 = D.30222 + D.30264;
    frame = *D.30265;
    D.30266 = frame->ji;
    if (D.30266 != 0B) goto <D.30267>; else goto <D.30268>;
    <D.30267>:
    {
      struct MonoJitInfo * jinfo;

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

        ei = &jinfo->clauses[j];
        D.30269 = frame->domain;
        D.30270 = frame->method;
        D.30271 = ei->handler_start;
        D.30272 = (long int) D.30271;
        D.30273 = jinfo->code_start;
        D.30274 = (long int) D.30273;
        D.30275 = D.30272 - D.30274;
        D.30276 = (int) D.30275;
        sp = find_next_seq_point_for_native_offset (D.30269, D.30270, D.30276, 0B);
        if (sp != 0B) goto <D.30277>; else goto <D.30278>;
        <D.30277>:
        D.30270 = frame->method;
        D.30200 = sp->il_offset;
        D.30201 = (long int) D.30200;
        D.30202 = ss_req->req;
        bp = set_breakpoint (D.30270, D.30201, D.30202, 0B);
        D.30203 = ss_req->bps;
        D.30279 = monoeg_g_slist_append (D.30203, bp);
        ss_req->bps = D.30279;
        <D.30278>:
      }
      j = j + 1;
      <D.26618>:
      D.30280 = jinfo->num_clauses;
      D.30281 = (int) D.30280;
      if (D.30281 > j) goto <D.26617>; else goto <D.26619>;
      <D.26619>:
    }
    <D.30268>:
  }
  i = i + 1;
  <D.26621>:
  D.30233 = tls->frame_count;
  if (D.30233 > i) goto <D.26620>; else goto <D.26622>;
  <D.26622>:
  <D.30260>:
  D.30211 = ss_req->depth;
  if (D.30211 == 0) goto <D.30282>; else goto <D.30283>;
  <D.30282>:
  enable_global = 1;
  <D.30283>:
  tls->context.valid = 0;
  tls->async_state.valid = 0;
  invalidate_frames (tls);
  <D.30205>:
  if (enable_global != 0) goto <D.30284>; else goto <D.30285>;
  <D.30284>:
  log_level.195 = log_level;
  D.30287 = log_level.195 > 0;
  D.30288 = (long int) D.30287;
  D.30289 = __builtin_expect (D.30288, 0);
  if (D.30289 != 0) goto <D.30290>; else goto <D.30291>;
  <D.30290>:
  log_file.196 = log_file;
  fprintf (log_file.196, "[dbg] Turning on global single stepping.\n");
  log_file.196 = log_file;
  fflush (log_file.196);
  <D.30291>:
  ss_req->global = 1;
  start_single_stepping ();
  goto <D.30293>;
  <D.30285>:
  D.30203 = ss_req->bps;
  if (D.30203 == 0B) goto <D.30294>; else goto <D.30295>;
  <D.30294>:
  log_level.195 = log_level;
  D.30287 = log_level.195 > 0;
  D.30288 = (long int) D.30287;
  D.30289 = __builtin_expect (D.30288, 0);
  if (D.30289 != 0) goto <D.30296>; else goto <D.30297>;
  <D.30296>:
  log_file.196 = log_file;
  fprintf (log_file.196, "[dbg] Turning on global single stepping.\n");
  log_file.196 = log_file;
  fflush (log_file.196);
  <D.30297>:
  ss_req->global = 1;
  start_single_stepping ();
  goto <D.30298>;
  <D.30295>:
  ss_req->global = 0;
  <D.30298>:
  <D.30293>:
}


start_single_stepping ()
{
  struct SingleStepReq * ss_req.197;
  void * ss_invoke_addr.198;
  struct MonoGHashTable * thread_to_tls.199;
  struct MonoInternalThread * D.30308;
  void * ss_invoke_addr.200;
  int val;

  val = InterlockedIncrement (&ss_count);
  if (val == 1) goto <D.30299>; else goto <D.30300>;
  <D.30299>:
  mono_arch_start_single_stepping ();
  <D.30300>:
  ss_req.197 = ss_req;
  if (ss_req.197 != 0B) goto <D.30302>; else goto <D.30303>;
  <D.30302>:
  ss_invoke_addr.198 = ss_invoke_addr;
  if (ss_invoke_addr.198 == 0B) goto <D.30305>; else goto <D.30306>;
  <D.30305>:
  {
    struct DebuggerTlsData * tls;

    mono_loader_lock ();
    thread_to_tls.199 = thread_to_tls;
    ss_req.197 = ss_req;
    D.30308 = ss_req.197->thread;
    tls = mono_g_hash_table_lookup (thread_to_tls.199, D.30308);
    ss_invoke_addr.200 = tls->invoke_addr;
    ss_invoke_addr = ss_invoke_addr.200;
    mono_loader_unlock ();
  }
  <D.30306>:
  <D.30303>:
}


set_breakpoint (struct MonoMethod * method, long int il_offset, struct EventRequest * req, struct MonoError * error)
{
  struct GPtrArray * D.30312;
  int log_level.201;
  _Bool D.30314;
  long int D.30315;
  long int D.30316;
  struct FILE * log_file.202;
  const char * iftmp.203;
  int D.30321;
  const char * iftmp.204;
  int D.30329;
  struct GHashTable * domains.205;
  struct MonoDomain * domain.206;
  union mono_mutex_t * D.30332;
  _Bool D.30335;
  long int D.30336;
  long int D.30337;
  void * D.30340;
  struct GHashTable * D.30341;
  struct MonoMethod * m.207;
  int D.30343;
  struct MonoSeqPointInfo * seq_points.208;
  int D.30347;
  _Bool D.30350;
  long int D.30351;
  long int D.30352;
  int D.30355;
  struct GPtrArray * breakpoints.209;
  int D.30359;
  struct MonoBreakpoint * D.30362;
  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.30310>; else goto <D.30311>;
      <D.30310>:
      mono_error_init (error);
      <D.30311>:
      bp = monoeg_malloc0 (32);
      bp->method = method;
      bp->il_offset = il_offset;
      bp->req = req;
      D.30312 = monoeg_g_ptr_array_new ();
      bp->children = D.30312;
      log_level.201 = log_level;
      D.30314 = log_level.201 > 0;
      D.30315 = (long int) D.30314;
      D.30316 = __builtin_expect (D.30315, 0);
      if (D.30316 != 0) goto <D.30317>; else goto <D.30318>;
      <D.30317>:
      log_file.202 = log_file;
      D.30321 = req->event_kind;
      if (D.30321 == 11) goto <D.30322>; else goto <D.30323>;
      <D.30322>:
      iftmp.203 = "single step ";
      goto <D.30324>;
      <D.30323>:
      iftmp.203 = "";
      <D.30324>:
      if (method != 0B) goto <D.30326>; else goto <D.30327>;
      <D.30326>:
      iftmp.204 = mono_method_full_name (method, 1);
      goto <D.30328>;
      <D.30327>:
      iftmp.204 = "<all>";
      <D.30328>:
      D.30329 = (int) il_offset;
      fprintf (log_file.202, "[dbg] Setting %sbreakpoint at %s:0x%x.\n", iftmp.203, iftmp.204, D.30329);
      log_file.202 = log_file;
      fflush (log_file.202);
      <D.30318>:
      mono_loader_lock ();
      domains.205 = domains;
      monoeg_g_hash_table_iter_init (&iter, domains.205);
      goto <D.26401>;
      <D.26400>:
      {
        int ret;

        domain.206 = domain;
        D.30332 = &domain.206->lock.mutex;
        ret = pthread_mutex_lock (D.30332);
        if (ret != 0) goto <D.30333>; else goto <D.30334>;
        <D.30333>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
        <D.30334>:
        D.30335 = ret != 0;
        D.30336 = (long int) D.30335;
        D.30337 = __builtin_expect (D.30336, 0);
        if (D.30337 != 0) goto <D.30338>; else goto <D.30339>;
        <D.30338>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 4353, "ret == 0");
        <D.30339>:
      }
      domain.206 = domain;
      D.30340 = domain.206->runtime_info;
      D.30341 = MEM[(struct MonoJitDomainInfo *)D.30340].seq_points;
      monoeg_g_hash_table_iter_init (&iter2, D.30341);
      goto <D.26397>;
      <D.26396>:
      m.207 = m;
      D.30343 = bp_matches_method (bp, m.207);
      if (D.30343 != 0) goto <D.30344>; else goto <D.30345>;
      <D.30344>:
      domain.206 = domain;
      m.207 = m;
      seq_points.208 = seq_points;
      set_bp_in_method (domain.206, m.207, seq_points.208, bp, error);
      <D.30345>:
      <D.26397>:
      D.30347 = monoeg_g_hash_table_iter_next (&iter2, &m, &seq_points);
      if (D.30347 != 0) goto <D.26396>; else goto <D.26398>;
      <D.26398>:
      {
        int ret;

        domain.206 = domain;
        D.30332 = &domain.206->lock.mutex;
        ret = pthread_mutex_unlock (D.30332);
        if (ret != 0) goto <D.30348>; else goto <D.30349>;
        <D.30348>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.30349>:
        D.30350 = ret != 0;
        D.30351 = (long int) D.30350;
        D.30352 = __builtin_expect (D.30351, 0);
        if (D.30352 != 0) goto <D.30353>; else goto <D.30354>;
        <D.30353>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 4361, "ret == 0");
        <D.30354>:
      }
      <D.26401>:
      D.30355 = monoeg_g_hash_table_iter_next (&iter, &domain, 0B);
      if (D.30355 != 0) goto <D.26400>; else goto <D.26402>;
      <D.26402>:
      mono_loader_unlock ();
      mono_loader_lock ();
      breakpoints.209 = breakpoints;
      monoeg_g_ptr_array_add (breakpoints.209, bp);
      mono_loader_unlock ();
      if (error != 0B) goto <D.30357>; else goto <D.30358>;
      <D.30357>:
      D.30359 = mono_error_ok (error);
      if (D.30359 == 0) goto <D.30360>; else goto <D.30361>;
      <D.30360>:
      clear_breakpoint (bp);
      D.30362 = 0B;
      return D.30362;
      <D.30361>:
      <D.30358>:
      D.30362 = bp;
      return D.30362;
    }
  finally
    {
      iter = {CLOBBER};
      iter2 = {CLOBBER};
      domain = {CLOBBER};
      m = {CLOBBER};
      seq_points = {CLOBBER};
    }
}


bp_matches_method (struct MonoBreakpoint * bp, struct MonoMethod * method)
{
  struct MonoMethod * D.30365;
  gboolean D.30368;
  long unsigned int D.30371;
  long unsigned int D.30372;
  struct MonoMethod * D.30375;
  long unsigned int D.30378;
  long unsigned int D.30379;
  struct MonoMethod * D.30384;
  struct MonoMethod * D.30385;
  struct MonoGenericInst * D.30388;
  struct MonoGenericInst * D.30389;
  struct MonoGenericInst * D.30392;
  long unsigned int D.30395;
  long unsigned int D.30396;
  unsigned char D.30399;
  <unnamed-unsigned:22> D.30402;
  int D.30403;
  int i;

  D.30365 = bp->method;
  if (D.30365 == 0B) goto <D.30366>; else goto <D.30367>;
  <D.30366>:
  D.30368 = 1;
  return D.30368;
  <D.30367>:
  D.30365 = bp->method;
  if (D.30365 == method) goto <D.30369>; else goto <D.30370>;
  <D.30369>:
  D.30368 = 1;
  return D.30368;
  <D.30370>:
  D.30371 = BIT_FIELD_REF <*method, 64, 256>;
  D.30372 = D.30371 & 4096;
  if (D.30372 != 0) goto <D.30373>; else goto <D.30374>;
  <D.30373>:
  D.30375 = MEM[(struct MonoMethodInflated *)method].declaring;
  D.30365 = bp->method;
  if (D.30375 == D.30365) goto <D.30376>; else goto <D.30377>;
  <D.30376>:
  D.30368 = 1;
  return D.30368;
  <D.30377>:
  <D.30374>:
  D.30365 = bp->method;
  D.30378 = BIT_FIELD_REF <*D.30365, 64, 256>;
  D.30379 = D.30378 & 4096;
  if (D.30379 != 0) goto <D.30380>; else goto <D.30381>;
  <D.30380>:
  D.30371 = BIT_FIELD_REF <*method, 64, 256>;
  D.30372 = D.30371 & 4096;
  if (D.30372 != 0) goto <D.30382>; else goto <D.30383>;
  <D.30382>:
  {
    struct MonoMethodInflated * bpimethod;
    struct MonoMethodInflated * imethod;

    bpimethod = bp->method;
    imethod = method;
    D.30384 = bpimethod->declaring;
    D.30385 = imethod->declaring;
    if (D.30384 == D.30385) goto <D.30386>; else goto <D.30387>;
    <D.30386>:
    D.30388 = bpimethod->context.class_inst;
    D.30389 = imethod->context.class_inst;
    if (D.30388 == D.30389) goto <D.30390>; else goto <D.30391>;
    <D.30390>:
    D.30392 = bpimethod->context.method_inst;
    if (D.30392 != 0B) goto <D.30393>; else goto <D.30394>;
    <D.30393>:
    D.30392 = bpimethod->context.method_inst;
    D.30395 = BIT_FIELD_REF <*D.30392, 64, 0>;
    D.30396 = D.30395 & 18014398509481984;
    if (D.30396 != 0) goto <D.30397>; else goto <D.30398>;
    <D.30397>:
    i = 0;
    goto <D.26349>;
    <D.26348>:
    {
      struct MonoType * t1;

      D.30392 = bpimethod->context.method_inst;
      t1 = D.30392->type_argv[i];
      D.30399 = t1->type;
      if (D.30399 != 30) goto <D.30400>; else goto <D.30401>;
      <D.30400>:
      D.30368 = 0;
      return D.30368;
      <D.30401>:
    }
    i = i + 1;
    <D.26349>:
    D.30392 = bpimethod->context.method_inst;
    D.30402 = D.30392->type_argc;
    D.30403 = (int) D.30402;
    if (D.30403 > i) goto <D.26348>; else goto <D.26350>;
    <D.26350>:
    D.30368 = 1;
    return D.30368;
    <D.30398>:
    <D.30394>:
    <D.30391>:
    <D.30387>:
  }
  <D.30383>:
  <D.30381>:
  D.30368 = 0;
  return D.30368;
}


set_bp_in_method (struct MonoDomain * domain, struct MonoMethod * method, struct MonoSeqPointInfo * seq_points, struct MonoBreakpoint * bp, struct MonoError * error)
{
  _Bool D.30409;
  long int D.30410;
  long int D.30411;
  struct MonoJitInfo * ji.210;
  struct MonoJitInfo * ji.211;
  _Bool D.30416;
  long int D.30417;
  long int D.30418;
  void * code;
  struct MonoJitInfo * ji;

  try
    {
      if (error != 0B) goto <D.30405>; else goto <D.30406>;
      <D.30405>:
      mono_error_init (error);
      <D.30406>:
      code = mono_jit_find_compiled_method_with_jit_info (domain, method, &ji);
      if (code == 0B) goto <D.30407>; else goto <D.30408>;
      <D.30407>:
      code = mono_aot_get_method (domain, method);
      D.30409 = code == 0B;
      D.30410 = (long int) D.30409;
      D.30411 = __builtin_expect (D.30410, 0);
      if (D.30411 != 0) goto <D.30412>; else goto <D.30413>;
      <D.30412>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 4301, "code");
      <D.30413>:
      ji.210 = mono_jit_info_table_find (domain, code);
      ji = ji.210;
      ji.211 = ji;
      D.30416 = ji.211 == 0B;
      D.30417 = (long int) D.30416;
      D.30418 = __builtin_expect (D.30417, 0);
      if (D.30418 != 0) goto <D.30419>; else goto <D.30420>;
      <D.30419>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 4303, "ji");
      <D.30420>:
      <D.30408>:
      D.30409 = code == 0B;
      D.30410 = (long int) D.30409;
      D.30411 = __builtin_expect (D.30410, 0);
      if (D.30411 != 0) goto <D.30421>; else goto <D.30422>;
      <D.30421>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 4305, "code");
      <D.30422>:
      ji.211 = ji;
      insert_breakpoint (seq_points, domain, ji.211, 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.30425;
  long int D.30426;
  long int D.30427;
  int D.30429;
  int D.30436;
  long int D.30437;
  struct MonoMethod * D.30441;
  char * D.30442;
  int log_level.212;
  _Bool D.30444;
  long int D.30445;
  long int D.30446;
  struct FILE * log_file.213;
  int D.30450;
  int D.30453;
  long int D.30454;
  void * D.30455;
  sizetype D.30456;
  guint8 * D.30457;
  struct GPtrArray * D.30458;
  struct GHashTable * bp_locs.214;
  guint8 * D.30460;
  void * D.30461;
  long int D.30462;
  int D.30463;
  long int D.30464;
  void * D.30465;
  int D.30470;
  struct MonoMethod * D.30476;
  char * D.30477;
  int i;
  int count;
  struct BreakpointInstance * inst;
  struct SeqPoint * sp;

  sp = 0B;
  if (error != 0B) goto <D.30423>; else goto <D.30424>;
  <D.30423>:
  mono_error_init (error);
  <D.30424>:
  i = 0;
  goto <D.26326>;
  <D.26325>:
  sp = &seq_points->seq_points[i];
  D.30425 = sp->il_offset;
  D.30426 = (long int) D.30425;
  D.30427 = bp->il_offset;
  if (D.30426 == D.30427) goto <D.26324>; else goto <D.30428>;
  <D.30428>:
  i = i + 1;
  <D.26326>:
  D.30429 = seq_points->len;
  if (D.30429 > i) goto <D.26325>; else goto <D.26324>;
  <D.26324>:
  D.30429 = seq_points->len;
  if (D.30429 == i) goto <D.30430>; else goto <D.30431>;
  <D.30430>:
  i = 0;
  goto <D.26329>;
  <D.26328>:
  sp = &seq_points->seq_points[i];
  D.30425 = sp->il_offset;
  if (D.30425 != -1) goto <D.30432>; else goto <D.30433>;
  <D.30432>:
  D.30425 = sp->il_offset;
  if (D.30425 != 16777215) goto <D.30434>; else goto <D.30435>;
  <D.30434>:
  D.30425 = sp->il_offset;
  D.30436 = D.30425 + 1;
  D.30437 = (long int) D.30436;
  D.30427 = bp->il_offset;
  if (D.30437 == D.30427) goto <D.26327>; else goto <D.30438>;
  <D.30438>:
  <D.30435>:
  <D.30433>:
  i = i + 1;
  <D.26329>:
  D.30429 = seq_points->len;
  if (D.30429 > i) goto <D.26328>; else goto <D.26327>;
  <D.26327>:
  <D.30431>:
  D.30429 = seq_points->len;
  if (D.30429 == i) goto <D.30439>; else goto <D.30440>;
  <D.30439>:
  {
    char * s;

    D.30441 = jinfo_get_method (ji);
    D.30442 = mono_method_full_name (D.30441, 1);
    D.30427 = bp->il_offset;
    D.30429 = seq_points->len;
    s = monoeg_g_strdup_printf ("Unable to insert breakpoint at %s:%d, seq_points=%d\n", D.30442, D.30427, D.30429);
    i = 0;
    goto <D.26332>;
    <D.26331>:
    log_level.212 = log_level;
    D.30444 = log_level.212 > 0;
    D.30445 = (long int) D.30444;
    D.30446 = __builtin_expect (D.30445, 0);
    if (D.30446 != 0) goto <D.30447>; else goto <D.30448>;
    <D.30447>:
    log_file.213 = log_file;
    D.30450 = seq_points->seq_points[i].il_offset;
    fprintf (log_file.213, "%d\n", D.30450);
    log_file.213 = log_file;
    fflush (log_file.213);
    <D.30448>:
    i = i + 1;
    <D.26332>:
    D.30429 = seq_points->len;
    if (D.30429 > i) goto <D.26331>; else goto <D.26333>;
    <D.26333>:
    if (error != 0B) goto <D.30451>; else goto <D.30452>;
    <D.30451>:
    mono_error_set_error (error, 9, "%s", s);
    monoeg_g_log (0B, 16, "%s", s);
    monoeg_g_free (s);
    return;
    <D.30452>:
    monoeg_g_log (0B, 16, "%s", s);
    monoeg_g_free (s);
    return;
  }
  <D.30440>:
  inst = monoeg_malloc0 (48);
  inst->sp = sp;
  D.30453 = sp->native_offset;
  D.30454 = (long int) D.30453;
  inst->native_offset = D.30454;
  D.30455 = ji->code_start;
  D.30453 = sp->native_offset;
  D.30456 = (sizetype) D.30453;
  D.30457 = D.30455 + D.30456;
  inst->ip = D.30457;
  inst->ji = ji;
  inst->domain = domain;
  mono_loader_lock ();
  D.30458 = bp->children;
  monoeg_g_ptr_array_add (D.30458, inst);
  bp_locs.214 = bp_locs;
  D.30460 = inst->ip;
  D.30461 = monoeg_g_hash_table_lookup (bp_locs.214, D.30460);
  D.30462 = (long int) D.30461;
  count = (int) D.30462;
  bp_locs.214 = bp_locs;
  D.30460 = inst->ip;
  D.30463 = count + 1;
  D.30464 = (long int) D.30463;
  D.30465 = (void *) D.30464;
  monoeg_g_hash_table_insert_replace (bp_locs.214, D.30460, D.30465, 0);
  mono_loader_unlock ();
  D.30453 = sp->native_offset;
  if (D.30453 == -1) goto <D.30466>; else goto <D.30467>;
  <D.30466>:
  log_level.212 = log_level;
  D.30444 = log_level.212 > 0;
  D.30445 = (long int) D.30444;
  D.30446 = __builtin_expect (D.30445, 0);
  if (D.30446 != 0) goto <D.30468>; else goto <D.30469>;
  <D.30468>:
  log_file.213 = log_file;
  D.30427 = bp->il_offset;
  D.30470 = (int) D.30427;
  fprintf (log_file.213, "[dbg] Attempting to insert seq point at dead IL offset %d, ignoring.\n", D.30470);
  log_file.213 = log_file;
  fflush (log_file.213);
  <D.30469>:
  goto <D.30471>;
  <D.30467>:
  if (count == 0) goto <D.30472>; else goto <D.30473>;
  <D.30472>:
  D.30460 = inst->ip;
  mono_arch_set_breakpoint (ji, D.30460);
  <D.30473>:
  <D.30471>:
  log_level.212 = log_level;
  D.30444 = log_level.212 > 0;
  D.30445 = (long int) D.30444;
  D.30446 = __builtin_expect (D.30445, 0);
  if (D.30446 != 0) goto <D.30474>; else goto <D.30475>;
  <D.30474>:
  log_file.213 = log_file;
  D.30476 = jinfo_get_method (ji);
  D.30477 = mono_method_full_name (D.30476, 1);
  D.30425 = sp->il_offset;
  fprintf (log_file.213, "[dbg] Inserted breakpoint at %s:0x%x.\n", D.30477, D.30425);
  log_file.213 = log_file;
  fflush (log_file.213);
  <D.30475>:
}


domain_commands (int command, guint8 * p, guint8 * end, struct Buffer * buf)
{
  struct MonoDomain * D.30479;
  guint8 * p.215;
  int err.216;
  ErrorCode D.30484;
  char * D.30485;
  unsigned int count.217;
  struct MonoAssembly * D.30491;
  struct MonoAppDomain * D.30494;
  struct MonoVTable * D.30495;
  struct MonoClass * D.30496;
  struct MonoImage * D.30497;
  struct MonoAssembly * D.30498;
  struct MonoDomain * domain2.218;
  _Bool D.30506;
  long int D.30507;
  long int D.30508;
  struct MonoType * D.30511;
  void * D.30512;
  <unnamed type> D.30513;
  int err.219;
  int err;
  struct MonoDomain * domain;

  try
    {
      switch (command) <default: <D.27318>, case 1: <D.27296>, case 2: <D.27298>, case 3: <D.27299>, case 4: <D.27309>, case 5: <D.27311>, case 6: <D.27310>, case 7: <D.27314>>
      <D.27296>:
      D.30479 = mono_get_root_domain ();
      buffer_add_domainid (buf, D.30479);
      goto <D.27297>;
      <D.27298>:
      p.215 = p;
      domain = decode_domainid (p.215, &p, end, 0B, &err);
      err.216 = err;
      if (err.216 != 0) goto <D.30482>; else goto <D.30483>;
      <D.30482>:
      err.216 = err;
      D.30484 = (ErrorCode) err.216;
      return D.30484;
      <D.30483>:
      D.30485 = domain->friendly_name;
      buffer_add_string (buf, D.30485);
      goto <D.27297>;
      <D.27299>:
      {
        struct GSList * tmp;
        struct MonoAssembly * ass;
        int count;

        p.215 = p;
        domain = decode_domainid (p.215, &p, end, 0B, &err);
        err.216 = err;
        if (err.216 != 0) goto <D.30486>; else goto <D.30487>;
        <D.30486>:
        err.216 = err;
        D.30484 = (ErrorCode) err.216;
        return D.30484;
        <D.30487>:
        mono_loader_lock ();
        count = 0;
        tmp = domain->domain_assemblies;
        goto <D.27304>;
        <D.27303>:
        count = count + 1;
        tmp = tmp->next;
        <D.27304>:
        if (tmp != 0B) goto <D.27303>; else goto <D.27305>;
        <D.27305>:
        count.217 = (unsigned int) count;
        buffer_add_int (buf, count.217);
        tmp = domain->domain_assemblies;
        goto <D.27307>;
        <D.27306>:
        ass = tmp->data;
        buffer_add_assemblyid (buf, domain, ass);
        tmp = tmp->next;
        <D.27307>:
        if (tmp != 0B) goto <D.27306>; else goto <D.27308>;
        <D.27308>:
        mono_loader_unlock ();
        goto <D.27297>;
      }
      <D.27309>:
      p.215 = p;
      domain = decode_domainid (p.215, &p, end, 0B, &err);
      err.216 = err;
      if (err.216 != 0) goto <D.30489>; else goto <D.30490>;
      <D.30489>:
      err.216 = err;
      D.30484 = (ErrorCode) err.216;
      return D.30484;
      <D.30490>:
      D.30491 = domain->entry_assembly;
      buffer_add_assemblyid (buf, domain, D.30491);
      goto <D.27297>;
      <D.27310>:
      p.215 = p;
      domain = decode_domainid (p.215, &p, end, 0B, &err);
      err.216 = err;
      if (err.216 != 0) goto <D.30492>; else goto <D.30493>;
      <D.30492>:
      err.216 = err;
      D.30484 = (ErrorCode) err.216;
      return D.30484;
      <D.30493>:
      D.30494 = domain->domain;
      D.30495 = D.30494->mbr.obj.vtable;
      D.30496 = D.30495->klass;
      D.30497 = D.30496->image;
      D.30498 = D.30497->assembly;
      buffer_add_assemblyid (buf, domain, D.30498);
      goto <D.27297>;
      <D.27311>:
      {
        char * s;
        struct MonoString * o;

        p.215 = p;
        domain = decode_domainid (p.215, &p, end, 0B, &err);
        err.216 = err;
        if (err.216 != 0) goto <D.30499>; else goto <D.30500>;
        <D.30499>:
        err.216 = err;
        D.30484 = (ErrorCode) err.216;
        return D.30484;
        <D.30500>:
        p.215 = p;
        s = decode_string (p.215, &p, end);
        o = mono_string_new (domain, s);
        buffer_add_objid (buf, o);
        goto <D.27297>;
      }
      <D.27314>:
      {
        struct MonoClass * klass;
        struct MonoDomain * domain2;
        struct MonoObject * o;

        try
          {
            p.215 = p;
            domain = decode_domainid (p.215, &p, end, 0B, &err);
            err.216 = err;
            if (err.216 != 0) goto <D.30501>; else goto <D.30502>;
            <D.30501>:
            err.216 = err;
            D.30484 = (ErrorCode) err.216;
            return D.30484;
            <D.30502>:
            p.215 = p;
            klass = decode_typeid (p.215, &p, end, &domain2, &err);
            err.216 = err;
            if (err.216 != 0) goto <D.30503>; else goto <D.30504>;
            <D.30503>:
            err.216 = err;
            D.30484 = (ErrorCode) err.216;
            return D.30484;
            <D.30504>:
            domain2.218 = domain2;
            D.30506 = domain != domain2.218;
            D.30507 = (long int) D.30506;
            D.30508 = __builtin_expect (D.30507, 0);
            if (D.30508 != 0) goto <D.30509>; else goto <D.30510>;
            <D.30509>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 7271, "domain == domain2");
            <D.30510>:
            o = mono_object_new (domain, klass);
            D.30511 = &klass->byval_arg;
            D.30512 = mono_object_unbox (o);
            p.215 = p;
            D.30513 = decode_value (D.30511, domain, D.30512, p.215, &p, end);
            err.219 = (int) D.30513;
            err = err.219;
            err.216 = err;
            if (err.216 != 0) goto <D.30515>; else goto <D.30516>;
            <D.30515>:
            err.216 = err;
            D.30484 = (ErrorCode) err.216;
            return D.30484;
            <D.30516>:
            buffer_add_objid (buf, o);
            goto <D.27297>;
          }
        finally
          {
            domain2 = {CLOBBER};
          }
      }
      <D.27318>:
      D.30484 = 100;
      return D.30484;
      <D.27297>:
      D.30484 = 0;
      return D.30484;
    }
  finally
    {
      err = {CLOBBER};
    }
}


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

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


decode_value (struct MonoType * t, struct MonoDomain * domain, guint8 * addr, guint8 * buf, guint8 * * endbuf, guint8 * limit)
{
  guint8 * buf.220;
  unsigned char D.30524;
  struct MonoClass * D.30527;
  int D.30528;
  struct MonoGenericClass * D.30531;
  struct MonoGenericInst * D.30532;
  <unnamed type> D.30533;
  ErrorCode D.30536;
  unsigned char D.30537;
  int D.30538;
  struct MonoClass * D.30541;
  int D.30542;
  long unsigned int D.30543;
  <unnamed type> D.30544;
  struct MonoClass * D.30547;
  struct MonoObject * D.30548;
  struct MonoClass * D.30549;
  struct MonoClass * D.30552;
  int err;
  int type;

  buf.220 = buf;
  type = decode_byte (buf.220, &buf, limit);
  D.30524 = t->type;
  if (D.30524 == 21) goto <D.30525>; else goto <D.30526>;
  <D.30525>:
  D.30527 = mono_class_from_mono_type (t);
  D.30528 = mono_class_is_nullable (D.30527);
  if (D.30528 != 0) goto <D.30529>; else goto <D.30530>;
  <D.30529>:
  {
    struct MonoType * targ;
    guint8 * nullable_buf;

    D.30531 = t->data.generic_class;
    D.30532 = D.30531->context.class_inst;
    targ = D.30532->type_argv[0];
    buf.220 = buf;
    D.30533 = decode_value_internal (t, type, domain, addr, buf.220, endbuf, limit);
    err = (int) D.30533;
    if (err == 0) goto <D.30534>; else goto <D.30535>;
    <D.30534>:
    D.30536 = (ErrorCode) err;
    return D.30536;
    <D.30535>:
    D.30537 = targ->type;
    D.30538 = (int) D.30537;
    if (D.30538 == type) goto <D.30539>; else goto <D.30540>;
    <D.30539>:
    D.30541 = mono_class_from_mono_type (targ);
    D.30542 = mono_class_instance_size (D.30541);
    D.30543 = (long unsigned int) D.30542;
    nullable_buf = monoeg_malloc (D.30543);
    buf.220 = buf;
    D.30544 = decode_value_internal (targ, type, domain, nullable_buf, buf.220, endbuf, limit);
    err = (int) D.30544;
    if (err != 0) goto <D.30545>; else goto <D.30546>;
    <D.30545>:
    monoeg_g_free (nullable_buf);
    D.30536 = (ErrorCode) err;
    return D.30536;
    <D.30546>:
    D.30547 = mono_class_from_mono_type (targ);
    D.30548 = mono_value_box (domain, D.30547, nullable_buf);
    D.30549 = mono_class_from_mono_type (t);
    mono_nullable_init (addr, D.30548, D.30549);
    monoeg_g_free (nullable_buf);
    buf.220 = buf;
    *endbuf = buf.220;
    D.30536 = 0;
    return D.30536;
    <D.30540>:
    if (type == 240) goto <D.30550>; else goto <D.30551>;
    <D.30550>:
    D.30552 = mono_class_from_mono_type (t);
    mono_nullable_init (addr, 0B, D.30552);
    buf.220 = buf;
    *endbuf = buf.220;
    D.30536 = 0;
    return D.30536;
    <D.30551>:
  }
  <D.30530>:
  <D.30526>:
  buf.220 = buf;
  D.30536 = decode_value_internal (t, type, domain, addr, buf.220, endbuf, limit);
  return D.30536;
}


decode_value_internal (struct MonoType * t, int type, struct MonoDomain * domain, guint8 * addr, guint8 * buf, guint8 * * endbuf, guint8 * limit)
{
  unsigned char D.30559;
  int D.30560;
  int D.30563;
  int log_level.221;
  _Bool D.30571;
  long int D.30572;
  long int D.30573;
  struct FILE * log_file.222;
  long unsigned int D.30577;
  void * D.30578;
  ErrorCode D.30579;
  guint8 * buf.223;
  int D.30581;
  unsigned char D.30582;
  int D.30583;
  short unsigned int D.30584;
  int D.30585;
  signed char D.30586;
  int D.30587;
  unsigned char D.30588;
  int D.30589;
  short int D.30590;
  int D.30591;
  short unsigned int D.30592;
  int D.30593;
  int D.30594;
  unsigned int D.30595;
  long int D.30596;
  long int D.30597;
  long unsigned int D.30598;
  int D.30599;
  unsigned int D.30600;
  long int D.30601;
  long unsigned int D.30602;
  _Bool D.30603;
  long int D.30604;
  long int D.30605;
  long int D.30608;
  int D.30609;
  _Bool D.30610;
  long int D.30611;
  long int D.30612;
  <unnamed type> D.30615;
  int err.224;
  int err.225;
  int D.30620;
  <unnamed type> D.30625;
  struct MonoObject * obj.226;
  int D.30631;
  char * D.30636;
  struct MonoVTable * D.30637;
  struct MonoClass * D.30638;
  const char * D.30639;
  struct MonoDomain * D.30642;
  long unsigned int D.30655;
  _Bool D.30656;
  long int D.30657;
  long int D.30658;
  <unnamed type> D.30661;
  int err.227;
  struct MonoDomain * d.228;
  struct MonoObject * D.30666;
  long unsigned int D.30670;
  void * D.30671;
  int err;
  void handle_vtype = <<< error >>>;
  void handle_ref = <<< error >>>;

  try
    {
      D.30559 = t->type;
      D.30560 = (int) D.30559;
      if (D.30560 != type) goto <D.30561>; else goto <D.30562>;
      <D.30561>:
      D.30563 = mono_type_is_reference (t);
      if (D.30563 == 0) goto <D.30564>; else goto <D.30565>;
      <D.30564>:
      D.30559 = t->type;
      if (D.30559 != 24) goto <D.30558>; else goto <D.30566>;
      <D.30566>:
      if (type != 17) goto <D.30558>; else goto <D.30555>;
      <D.30558>:
      D.30559 = t->type;
      if (D.30559 != 25) goto <D.30557>; else goto <D.30567>;
      <D.30567>:
      if (type != 17) goto <D.30557>; else goto <D.30555>;
      <D.30557>:
      D.30559 = t->type;
      if (D.30559 != 15) goto <D.30556>; else goto <D.30568>;
      <D.30568>:
      if (type != 10) goto <D.30556>; else goto <D.30555>;
      <D.30556>:
      D.30559 = t->type;
      if (D.30559 != 21) goto <D.30554>; else goto <D.30569>;
      <D.30569>:
      if (type != 17) goto <D.30554>; else goto <D.30555>;
      <D.30554>:
      {
        char * name;

        name = mono_type_full_name (t);
        log_level.221 = log_level;
        D.30571 = log_level.221 > 0;
        D.30572 = (long int) D.30571;
        D.30573 = __builtin_expect (D.30572, 0);
        if (D.30573 != 0) goto <D.30574>; else goto <D.30575>;
        <D.30574>:
        log_file.222 = log_file;
        D.30577 = GetCurrentThreadId ();
        D.30578 = (void *) D.30577;
        fprintf (log_file.222, "[%p] Expected value of type %s, got 0x%0x.\n", D.30578, name, type);
        log_file.222 = log_file;
        fflush (log_file.222);
        <D.30575>:
        monoeg_g_free (name);
        D.30579 = 102;
        return D.30579;
      }
      <D.30555>:
      <D.30565>:
      <D.30562>:
      D.30559 = t->type;
      D.30560 = (int) D.30559;
      switch (D.30560) <default: <D.26881>, case 2: <D.26861>, case 3: <D.26863>, case 4: <D.26864>, case 5: <D.26865>, case 6: <D.26866>, case 7: <D.26867>, case 8: <D.26868>, case 9: <D.26869>, case 10: <D.26870>, case 11: <D.26871>, case 12: <D.26872>, case 13: <D.26873>, case 15: <D.26874>, case 17: <D.26880>, case 21: <D.26875>, case 24: <D.26878>, case 25: <D.26879>>
      <D.26861>:
      buf.223 = buf;
      D.30581 = decode_int (buf.223, &buf, limit);
      D.30582 = (unsigned char) D.30581;
      *addr = D.30582;
      goto <D.26862>;
      <D.26863>:
      buf.223 = buf;
      D.30583 = decode_int (buf.223, &buf, limit);
      D.30584 = (short unsigned int) D.30583;
      MEM[(gunichar2 *)addr] = D.30584;
      goto <D.26862>;
      <D.26864>:
      buf.223 = buf;
      D.30585 = decode_int (buf.223, &buf, limit);
      D.30586 = (signed char) D.30585;
      MEM[(gint8 *)addr] = D.30586;
      goto <D.26862>;
      <D.26865>:
      buf.223 = buf;
      D.30587 = decode_int (buf.223, &buf, limit);
      D.30588 = (unsigned char) D.30587;
      *addr = D.30588;
      goto <D.26862>;
      <D.26866>:
      buf.223 = buf;
      D.30589 = decode_int (buf.223, &buf, limit);
      D.30590 = (short int) D.30589;
      MEM[(gint16 *)addr] = D.30590;
      goto <D.26862>;
      <D.26867>:
      buf.223 = buf;
      D.30591 = decode_int (buf.223, &buf, limit);
      D.30592 = (short unsigned int) D.30591;
      MEM[(guint16 *)addr] = D.30592;
      goto <D.26862>;
      <D.26868>:
      buf.223 = buf;
      D.30593 = decode_int (buf.223, &buf, limit);
      MEM[(gint32 *)addr] = D.30593;
      goto <D.26862>;
      <D.26869>:
      buf.223 = buf;
      D.30594 = decode_int (buf.223, &buf, limit);
      D.30595 = (unsigned int) D.30594;
      MEM[(guint32 *)addr] = D.30595;
      goto <D.26862>;
      <D.26870>:
      buf.223 = buf;
      D.30596 = decode_long (buf.223, &buf, limit);
      MEM[(gint64 *)addr] = D.30596;
      goto <D.26862>;
      <D.26871>:
      buf.223 = buf;
      D.30597 = decode_long (buf.223, &buf, limit);
      D.30598 = (long unsigned int) D.30597;
      MEM[(guint64 *)addr] = D.30598;
      goto <D.26862>;
      <D.26872>:
      buf.223 = buf;
      D.30599 = decode_int (buf.223, &buf, limit);
      D.30600 = (unsigned int) D.30599;
      MEM[(guint32 *)addr] = D.30600;
      goto <D.26862>;
      <D.26873>:
      buf.223 = buf;
      D.30601 = decode_long (buf.223, &buf, limit);
      D.30602 = (long unsigned int) D.30601;
      MEM[(guint64 *)addr] = D.30602;
      goto <D.26862>;
      <D.26874>:
      D.30603 = type != 10;
      D.30604 = (long int) D.30603;
      D.30605 = __builtin_expect (D.30604, 0);
      if (D.30605 != 0) goto <D.30606>; else goto <D.30607>;
      <D.30606>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 5775, "type == MONO_TYPE_I8");
      <D.30607>:
      buf.223 = buf;
      D.30608 = decode_long (buf.223, &buf, limit);
      MEM[(gssize *)addr] = D.30608;
      goto <D.26862>;
      <D.26875>:
      D.30609 = mono_type_is_struct (t);
      if (D.30609 != 0) goto handle_vtype; else goto handle_ref;
      <D.26878>:
      <D.26879>:
      D.30610 = type != 17;
      D.30611 = (long int) D.30610;
      D.30612 = __builtin_expect (D.30611, 0);
      if (D.30612 != 0) goto <D.30613>; else goto <D.30614>;
      <D.30613>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 5789, "type == MONO_TYPE_VALUETYPE");
      <D.30614>:
      handle_vtype:
      <D.26880>:
      buf.223 = buf;
      D.30615 = decode_vtype (t, domain, addr, buf.223, &buf, limit);
      err.224 = (int) D.30615;
      err = err.224;
      err.225 = err;
      if (err.225 != 0) goto <D.30618>; else goto <D.30619>;
      <D.30618>:
      err.225 = err;
      D.30579 = (ErrorCode) err.225;
      return D.30579;
      <D.30619>:
      goto <D.26862>;
      handle_ref:
      <D.26881>:
      D.30620 = mono_type_is_reference (t);
      if (D.30620 != 0) goto <D.30621>; else goto <D.30622>;
      <D.30621>:
      if (type == 28) goto <D.30623>; else goto <D.30624>;
      <D.30623>:
      {
        int objid;
        int err;
        struct MonoObject * obj;

        try
          {
            buf.223 = buf;
            objid = decode_objid (buf.223, &buf, limit);
            D.30625 = get_object (objid, &obj);
            err = (int) D.30625;
            if (err != 0) goto <D.30626>; else goto <D.30627>;
            <D.30626>:
            D.30579 = (ErrorCode) err;
            return D.30579;
            <D.30627>:
            obj.226 = obj;
            if (obj.226 != 0B) goto <D.30629>; else goto <D.30630>;
            <D.30629>:
            obj.226 = obj;
            D.30631 = obj_is_of_type (obj.226, t);
            if (D.30631 == 0) goto <D.30632>; else goto <D.30633>;
            <D.30632>:
            log_level.221 = log_level;
            D.30571 = log_level.221 > 0;
            D.30572 = (long int) D.30571;
            D.30573 = __builtin_expect (D.30572, 0);
            if (D.30573 != 0) goto <D.30634>; else goto <D.30635>;
            <D.30634>:
            log_file.222 = log_file;
            D.30636 = mono_type_full_name (t);
            obj.226 = obj;
            D.30637 = obj.226->vtable;
            D.30638 = D.30637->klass;
            D.30639 = D.30638->name;
            fprintf (log_file.222, "Expected type \'%s\', got \'%s\'\n", D.30636, D.30639);
            log_file.222 = log_file;
            fflush (log_file.222);
            <D.30635>:
            D.30579 = 102;
            return D.30579;
            <D.30633>:
            <D.30630>:
            obj.226 = obj;
            if (obj.226 != 0B) goto <D.30640>; else goto <D.30641>;
            <D.30640>:
            obj.226 = obj;
            D.30637 = obj.226->vtable;
            D.30642 = D.30637->domain;
            if (D.30642 != domain) goto <D.30643>; else goto <D.30644>;
            <D.30643>:
            D.30579 = 102;
            return D.30579;
            <D.30644>:
            <D.30641>:
            obj.226 = obj;
            mono_gc_wbarrier_generic_store (addr, obj.226);
          }
        finally
          {
            obj = {CLOBBER};
          }
      }
      goto <D.30645>;
      <D.30624>:
      if (type == 240) goto <D.30646>; else goto <D.30647>;
      <D.30646>:
      MEM[(struct MonoObject * *)addr] = 0B;
      goto <D.30648>;
      <D.30647>:
      if (type == 17) goto <D.30649>; else goto <D.30650>;
      <D.30649>:
      {
        guint8 * buf2;
        gboolean is_enum;
        struct MonoClass * klass;
        struct MonoDomain * d;
        guint8 * vtype_buf;
        int vtype_buf_size;

        try
          {
            buf2 = buf;
            buf.223 = buf;
            is_enum = decode_byte (buf.223, &buf, limit);
            if (is_enum != 0) goto <D.30651>; else goto <D.30652>;
            <D.30651>:
            D.30579 = 100;
            return D.30579;
            <D.30652>:
            buf.223 = buf;
            klass = decode_typeid (buf.223, &buf, limit, &d, &err);
            err.225 = err;
            if (err.225 != 0) goto <D.30653>; else goto <D.30654>;
            <D.30653>:
            err.225 = err;
            D.30579 = (ErrorCode) err.225;
            return D.30579;
            <D.30654>:
            vtype_buf_size = mono_class_value_size (klass, 0B);
            D.30655 = (long unsigned int) vtype_buf_size;
            vtype_buf = monoeg_malloc0 (D.30655);
            D.30656 = vtype_buf == 0B;
            D.30657 = (long int) D.30656;
            D.30658 = __builtin_expect (D.30657, 0);
            if (D.30658 != 0) goto <D.30659>; else goto <D.30660>;
            <D.30659>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 5845, "vtype_buf");
            <D.30660>:
            buf = buf2;
            buf.223 = buf;
            D.30661 = decode_vtype (0B, domain, vtype_buf, buf.223, &buf, limit);
            err.227 = (int) D.30661;
            err = err.227;
            err.225 = err;
            if (err.225 != 0) goto <D.30663>; else goto <D.30664>;
            <D.30663>:
            monoeg_g_free (vtype_buf);
            err.225 = err;
            D.30579 = (ErrorCode) err.225;
            return D.30579;
            <D.30664>:
            d.228 = d;
            D.30666 = mono_value_box (d.228, klass, vtype_buf);
            MEM[(struct MonoObject * *)addr] = D.30666;
            monoeg_g_free (vtype_buf);
          }
        finally
          {
            d = {CLOBBER};
          }
      }
      goto <D.30667>;
      <D.30650>:
      {
        char * name;

        name = mono_type_full_name (t);
        log_level.221 = log_level;
        D.30571 = log_level.221 > 0;
        D.30572 = (long int) D.30571;
        D.30573 = __builtin_expect (D.30572, 0);
        if (D.30573 != 0) goto <D.30668>; else goto <D.30669>;
        <D.30668>:
        log_file.222 = log_file;
        D.30670 = GetCurrentThreadId ();
        D.30671 = (void *) D.30670;
        fprintf (log_file.222, "[%p] Expected value of type %s, got 0x%0x.\n", D.30671, name, type);
        log_file.222 = log_file;
        fflush (log_file.222);
        <D.30669>:
        monoeg_g_free (name);
        D.30579 = 102;
        return D.30579;
      }
      <D.30667>:
      <D.30648>:
      <D.30645>:
      goto <D.30672>;
      <D.30622>:
      monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "debugger-agent.c", 5862);
      <D.30672>:
      goto <D.26862>;
      <D.26862>:
      buf.223 = buf;
      *endbuf = buf.223;
      D.30579 = 0;
      return D.30579;
    }
  finally
    {
      err = {CLOBBER};
    }
}


obj_is_of_type (struct MonoObject * obj, struct MonoType * t)
{
  struct MonoVTable * D.30679;
  struct MonoClass * D.30680;
  int D.30681;
  struct MonoClass * D.30684;
  struct MonoRemoteClass * D.30687;
  struct MonoClass * D.30688;
  int D.30689;
  gboolean D.30692;
  struct MonoClass * klass;

  D.30679 = obj->vtable;
  klass = D.30679->klass;
  D.30680 = mono_class_from_mono_type (t);
  D.30681 = mono_class_is_assignable_from (D.30680, klass);
  if (D.30681 == 0) goto <D.30682>; else goto <D.30683>;
  <D.30682>:
  D.30684 = mono_defaults.transparent_proxy_class;
  if (D.30684 == klass) goto <D.30685>; else goto <D.30686>;
  <D.30685>:
  D.30687 = MEM[(struct MonoTransparentProxy *)obj].remote_class;
  klass = D.30687->proxy_class;
  D.30688 = mono_class_from_mono_type (t);
  D.30689 = mono_class_is_assignable_from (D.30688, klass);
  if (D.30689 != 0) goto <D.30690>; else goto <D.30691>;
  <D.30690>:
  D.30692 = 1;
  return D.30692;
  <D.30691>:
  <D.30686>:
  D.30692 = 0;
  return D.30692;
  <D.30683>:
  D.30692 = 1;
  return D.30692;
}


decode_vtype (struct MonoType * t, struct MonoDomain * domain, guint8 * addr, guint8 * buf, guint8 * * endbuf, guint8 * limit)
{
  guint8 * buf.229;
  ErrorCode D.30697;
  int err.230;
  struct MonoClass * D.30703;
  struct MonoType * D.30706;
  int log_level.231;
  _Bool D.30708;
  long int D.30709;
  long int D.30710;
  struct FILE * log_file.232;
  long unsigned int D.30714;
  void * D.30715;
  struct MonoType * D.30716;
  short unsigned int D.30717;
  int D.30718;
  int D.30719;
  int D.30722;
  int D.26847;
  int iftmp.233;
  int D.26846;
  const char[9] * D.30728;
  unsigned char D.30729;
  int D.30730;
  unsigned char D.30731;
  int D.30732;
  const unsigned char * D.30737;
  unsigned char D.30738;
  int D.30739;
  const unsigned char * D.30740;
  unsigned char D.30741;
  int D.30742;
  const unsigned char * D.30747;
  unsigned char D.30748;
  int D.30749;
  const unsigned char * D.30750;
  unsigned char D.30751;
  int D.30752;
  const unsigned char * D.30757;
  unsigned char D.30758;
  int D.30759;
  const unsigned char * D.30760;
  unsigned char D.30761;
  int D.30762;
  const char * D.30764;
  int D.30767;
  sizetype D.30768;
  sizetype D.30769;
  guint8 * D.30770;
  <unnamed type> D.30771;
  int err.234;
  _Bool D.30775;
  long int D.30776;
  long int D.30777;
  gboolean is_enum;
  struct MonoClass * klass;
  struct MonoClassField * f;
  int nfields;
  void * iter;
  struct MonoDomain * d;
  int err;

  try
    {
      iter = 0B;
      buf.229 = buf;
      is_enum = decode_byte (buf.229, &buf, limit);
      if (is_enum != 0) goto <D.30695>; else goto <D.30696>;
      <D.30695>:
      D.30697 = 100;
      return D.30697;
      <D.30696>:
      buf.229 = buf;
      klass = decode_typeid (buf.229, &buf, limit, &d, &err);
      err.230 = err;
      if (err.230 != 0) goto <D.30699>; else goto <D.30700>;
      <D.30699>:
      err.230 = err;
      D.30697 = (ErrorCode) err.230;
      return D.30697;
      <D.30700>:
      if (t != 0B) goto <D.30701>; else goto <D.30702>;
      <D.30701>:
      D.30703 = mono_class_from_mono_type (t);
      if (D.30703 != klass) goto <D.30704>; else goto <D.30705>;
      <D.30704>:
      {
        char * name;
        char * name2;

        name = mono_type_full_name (t);
        D.30706 = &klass->byval_arg;
        name2 = mono_type_full_name (D.30706);
        log_level.231 = log_level;
        D.30708 = log_level.231 > 0;
        D.30709 = (long int) D.30708;
        D.30710 = __builtin_expect (D.30709, 0);
        if (D.30710 != 0) goto <D.30711>; else goto <D.30712>;
        <D.30711>:
        log_file.232 = log_file;
        D.30714 = GetCurrentThreadId ();
        D.30715 = (void *) D.30714;
        fprintf (log_file.232, "[%p] Expected value of type %s, got %s.\n", D.30715, name, name2);
        log_file.232 = log_file;
        fflush (log_file.232);
        <D.30712>:
        monoeg_g_free (name);
        monoeg_g_free (name2);
        D.30697 = 102;
        return D.30697;
      }
      <D.30705>:
      <D.30702>:
      buf.229 = buf;
      nfields = decode_int (buf.229, &buf, limit);
      goto <D.26838>;
      <D.26848>:
      D.30716 = f->type;
      D.30717 = D.30716->attrs;
      D.30718 = (int) D.30717;
      D.30719 = D.30718 & 16;
      if (D.30719 != 0) goto <D.30720>; else goto <D.30721>;
      <D.30720>:
      // predicted unlikely by continue predictor.
      goto <D.26838>;
      <D.30721>:
      D.30716 = f->type;
      D.30717 = D.30716->attrs;
      D.30718 = (int) D.30717;
      D.30722 = D.30718 & 1536;
      if (D.30722 != 0) goto <D.30723>; else goto <D.30724>;
      <D.30723>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          __s2 = mono_field_get_name (f);
          D.30728 = "_Deleted";
          D.30729 = MEM[(const unsigned char *)D.30728];
          D.30730 = (int) D.30729;
          D.30731 = *__s2;
          D.30732 = (int) D.30731;
          __result = D.30730 - D.30732;
          {
            if (__s2_len != 0) goto <D.30733>; else goto <D.30734>;
            <D.30733>:
            if (__result == 0) goto <D.30735>; else goto <D.30736>;
            <D.30735>:
            D.30737 = &MEM[(void *)"_Deleted" + 1B];
            D.30738 = *D.30737;
            D.30739 = (int) D.30738;
            D.30740 = __s2 + 1;
            D.30741 = *D.30740;
            D.30742 = (int) D.30741;
            __result = D.30739 - D.30742;
            if (__s2_len > 1) goto <D.30743>; else goto <D.30744>;
            <D.30743>:
            if (__result == 0) goto <D.30745>; else goto <D.30746>;
            <D.30745>:
            D.30747 = &MEM[(void *)"_Deleted" + 2B];
            D.30748 = *D.30747;
            D.30749 = (int) D.30748;
            D.30750 = __s2 + 2;
            D.30751 = *D.30750;
            D.30752 = (int) D.30751;
            __result = D.30749 - D.30752;
            if (__s2_len > 2) goto <D.30753>; else goto <D.30754>;
            <D.30753>:
            if (__result == 0) goto <D.30755>; else goto <D.30756>;
            <D.30755>:
            D.30757 = &MEM[(void *)"_Deleted" + 3B];
            D.30758 = *D.30757;
            D.30759 = (int) D.30758;
            D.30760 = __s2 + 3;
            D.30761 = *D.30760;
            D.30762 = (int) D.30761;
            __result = D.30759 - D.30762;
            <D.30756>:
            <D.30754>:
            <D.30746>:
            <D.30744>:
            <D.30736>:
            <D.30734>:
          }
          D.26846 = __result;
        }
        iftmp.233 = -D.26846;
        goto <D.30763>;
        <D.30727>:
        D.30764 = mono_field_get_name (f);
        iftmp.233 = __builtin_strcmp (D.30764, "_Deleted");
        <D.30763>:
        D.26847 = iftmp.233;
      }
      if (D.26847 == 0) goto <D.30765>; else goto <D.30766>;
      <D.30765>:
      // predicted unlikely by continue predictor.
      goto <D.26838>;
      <D.30766>:
      <D.30724>:
      D.30716 = f->type;
      D.30767 = f->offset;
      D.30768 = (sizetype) D.30767;
      D.30769 = D.30768 + 18446744073709551600;
      D.30770 = addr + D.30769;
      buf.229 = buf;
      D.30771 = decode_value (D.30716, domain, D.30770, buf.229, &buf, limit);
      err.234 = (int) D.30771;
      err = err.234;
      err.230 = err;
      if (err.230 != 0) goto <D.30773>; else goto <D.30774>;
      <D.30773>:
      err.230 = err;
      D.30697 = (ErrorCode) err.230;
      return D.30697;
      <D.30774>:
      nfields = nfields + -1;
      <D.26838>:
      f = mono_class_get_fields (klass, &iter);
      if (f != 0B) goto <D.26848>; else goto <D.26849>;
      <D.26849>:
      D.30775 = nfields != 0;
      D.30776 = (long int) D.30775;
      D.30777 = __builtin_expect (D.30776, 0);
      if (D.30777 != 0) goto <D.30778>; else goto <D.30779>;
      <D.30778>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 5713, "nfields == 0");
      <D.30779>:
      buf.229 = buf;
      *endbuf = buf.229;
      D.30697 = 0;
      return D.30697;
    }
  finally
    {
      iter = {CLOBBER};
      d = {CLOBBER};
      err = {CLOBBER};
    }
}


assembly_commands (int command, guint8 * p, guint8 * end, struct Buffer * buf)
{
  guint8 * p.235;
  int err.236;
  ErrorCode D.30786;
  struct MonoImage * D.30787;
  const char * D.30788;
  long unsigned int D.30789;
  long unsigned int D.30790;
  struct MonoDomain * domain.237;
  _Bool D.30798;
  long int D.30799;
  long int D.30800;
  int D.30803;
  const char * D.30807;
  struct MonoClass * iftmp.238;
  const char * D.30814;
  short unsigned int D.30815;
  int D.30816;
  short unsigned int D.30817;
  int D.30818;
  short unsigned int D.30819;
  int D.30820;
  short unsigned int D.30821;
  int D.30822;
  const char * iftmp.239;
  const char * D.30826;
  char D.30828;
  const char * iftmp.240;
  unsigned char D.30831;
  const char * iftmp.241;
  unsigned int D.30836;
  unsigned int D.30837;
  int err;
  struct MonoAssembly * ass;
  struct MonoDomain * domain;

  try
    {
      p.235 = p;
      ass = decode_assemblyid (p.235, &p, end, &domain, &err);
      err.236 = err;
      if (err.236 != 0) goto <D.30784>; else goto <D.30785>;
      <D.30784>:
      err.236 = err;
      D.30786 = (ErrorCode) err.236;
      return D.30786;
      <D.30785>:
      switch (command) <default: <D.27347>, case 1: <D.27328>, case 2: <D.27330>, case 3: <D.27333>, case 4: <D.27334>, case 5: <D.27336>, case 6: <D.27344>>
      <D.27328>:
      D.30787 = ass->image;
      D.30788 = mono_image_get_filename (D.30787);
      buffer_add_string (buf, D.30788);
      goto <D.27329>;
      <D.27330>:
      {
        guint32 token;
        struct MonoMethod * m;

        D.30787 = ass->image;
        D.30789 = BIT_FIELD_REF <*D.30787, 64, 192>;
        D.30790 = D.30789 & 34359738368;
        if (D.30790 != 0) goto <D.30791>; else goto <D.30792>;
        <D.30791>:
        buffer_add_id (buf, 0);
        goto <D.30793>;
        <D.30792>:
        D.30787 = ass->image;
        token = mono_image_get_entry_point (D.30787);
        if (token == 0) goto <D.30794>; else goto <D.30795>;
        <D.30794>:
        buffer_add_id (buf, 0);
        goto <D.30796>;
        <D.30795>:
        D.30787 = ass->image;
        m = mono_get_method (D.30787, token, 0B);
        domain.237 = domain;
        buffer_add_methodid (buf, domain.237, m);
        <D.30796>:
        <D.30793>:
        goto <D.27329>;
      }
      <D.27333>:
      domain.237 = domain;
      D.30787 = ass->image;
      buffer_add_moduleid (buf, domain.237, D.30787);
      goto <D.27329>;
      <D.27334>:
      {
        struct MonoObject * o;

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

        try
          {
            p.235 = p;
            s = decode_string (p.235, &p, end);
            p.235 = p;
            ignorecase = decode_byte (p.235, &p, end);
            d = mono_domain_get ();
            domain.237 = domain;
            res = mono_domain_set (domain.237, 0);
            D.30798 = res == 0;
            D.30799 = (long int) D.30798;
            D.30800 = __builtin_expect (D.30799, 0);
            if (D.30800 != 0) goto <D.30801>; else goto <D.30802>;
            <D.30801>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 7341, "res");
            <D.30802>:
            D.30803 = mono_reflection_parse_type (s, &info);
            if (D.30803 == 0) goto <D.30804>; else goto <D.30805>;
            <D.30804>:
            t = 0B;
            goto <D.30806>;
            <D.30805>:
            D.30807 = info.assembly.name;
            if (D.30807 != 0B) goto <D.30808>; else goto <D.30809>;
            <D.30808>:
            monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "debugger-agent.c", 7347);
            <D.30809>:
            D.30787 = ass->image;
            t = mono_reflection_get_type (D.30787, &info, ignorecase, &type_resolve);
            <D.30806>:
            domain.237 = domain;
            if (t != 0B) goto <D.30811>; else goto <D.30812>;
            <D.30811>:
            iftmp.238 = mono_class_from_mono_type (t);
            goto <D.30813>;
            <D.30812>:
            iftmp.238 = 0B;
            <D.30813>:
            buffer_add_typeid (buf, domain.237, iftmp.238);
            mono_reflection_free_type_info (&info);
            monoeg_g_free (s);
            mono_domain_set (d, 1);
            goto <D.27329>;
          }
        finally
          {
            info = {CLOBBER};
            type_resolve = {CLOBBER};
          }
      }
      <D.27344>:
      {
        gchar * name;
        struct MonoAssembly * mass;

        mass = ass;
        D.30814 = mass->aname.name;
        D.30815 = mass->aname.major;
        D.30816 = (int) D.30815;
        D.30817 = mass->aname.minor;
        D.30818 = (int) D.30817;
        D.30819 = mass->aname.build;
        D.30820 = (int) D.30819;
        D.30821 = mass->aname.revision;
        D.30822 = (int) D.30821;
        D.30826 = mass->aname.culture;
        if (D.30826 != 0B) goto <D.30827>; else goto <D.30824>;
        <D.30827>:
        D.30826 = mass->aname.culture;
        D.30828 = *D.30826;
        if (D.30828 != 0) goto <D.30829>; else goto <D.30824>;
        <D.30829>:
        iftmp.239 = mass->aname.culture;
        goto <D.30825>;
        <D.30824>:
        iftmp.239 = "neutral";
        <D.30825>:
        D.30831 = mass->aname.public_key_token[0];
        if (D.30831 != 0) goto <D.30832>; else goto <D.30833>;
        <D.30832>:
        iftmp.240 = &mass->aname.public_key_token;
        goto <D.30834>;
        <D.30833>:
        iftmp.240 = "null";
        <D.30834>:
        D.30836 = mass->aname.flags;
        D.30837 = D.30836 & 256;
        if (D.30837 != 0) goto <D.30838>; else goto <D.30839>;
        <D.30838>:
        iftmp.241 = ", Retargetable=Yes";
        goto <D.30840>;
        <D.30839>:
        iftmp.241 = "";
        <D.30840>:
        name = monoeg_g_strdup_printf ("%s, Version=%d.%d.%d.%d, Culture=%s, PublicKeyToken=%s%s", D.30814, D.30816, D.30818, D.30820, D.30822, iftmp.239, iftmp.240, iftmp.241);
        buffer_add_string (buf, name);
        monoeg_g_free (name);
        goto <D.27329>;
      }
      <D.27347>:
      D.30786 = 100;
      return D.30786;
      <D.27329>:
      D.30786 = 0;
      return D.30786;
    }
  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.242;
  char * D.30845;
  const char * D.30846;
  const char * D.30847;
  struct MonoDomain * domain.243;
  struct MonoAssembly * D.30849;
  ErrorCode D.30850;
  int err;
  struct MonoDomain * domain;

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

        p.242 = p;
        image = decode_moduleid (p.242, &p, end, &domain, &err);
        D.30845 = image->name;
        basename = monoeg_g_path_get_basename (D.30845);
        buffer_add_string (buf, basename);
        D.30846 = image->module_name;
        buffer_add_string (buf, D.30846);
        D.30845 = image->name;
        buffer_add_string (buf, D.30845);
        D.30847 = mono_image_get_guid (image);
        buffer_add_string (buf, D.30847);
        domain.243 = domain;
        D.30849 = image->assembly;
        buffer_add_assemblyid (buf, domain.243, D.30849);
        monoeg_g_free (basename);
        goto <D.27359>;
      }
      <D.27360>:
      D.30850 = 100;
      return D.30850;
      <D.27359>:
      D.30850 = 0;
      return D.30850;
    }
  finally
    {
      err = {CLOBBER};
      domain = {CLOBBER};
    }
}


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

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


type_commands (int command, guint8 * p, guint8 * end, struct Buffer * buf)
{
  guint8 * p.244;
  int err.245;
  ErrorCode D.30859;
  struct MonoDomain * domain.246;
  <unnamed type> D.30861;
  int err.247;
  struct MonoClass * klass;
  struct MonoDomain * old_domain;
  struct MonoDomain * domain;
  int err;

  try
    {
      p.244 = p;
      klass = decode_typeid (p.244, &p, end, &domain, &err);
      err.245 = err;
      if (err.245 != 0) goto <D.30857>; else goto <D.30858>;
      <D.30857>:
      err.245 = err;
      D.30859 = (ErrorCode) err.245;
      return D.30859;
      <D.30858>:
      old_domain = mono_domain_get ();
      domain.246 = domain;
      mono_domain_set (domain.246, 1);
      domain.246 = domain;
      p.244 = p;
      D.30861 = type_commands_internal (command, klass, domain.246, p.244, end, buf);
      err.247 = (int) D.30861;
      err = err.247;
      mono_domain_set (old_domain, 1);
      err.245 = err;
      D.30859 = (ErrorCode) err.245;
      return D.30859;
    }
  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.30865;
  const char * D.30866;
  struct MonoType * D.30867;
  struct MonoImage * D.30868;
  struct MonoAssembly * D.30869;
  struct MonoClass * D.30870;
  unsigned char D.30874;
  unsigned char D.30876;
  struct MonoClass * D.30877;
  unsigned int D.30878;
  unsigned int D.30879;
  unsigned char D.30882;
  long unsigned int D.30887;
  long unsigned int D.30888;
  unsigned char D.30891;
  long unsigned int D.30896;
  long unsigned int D.30897;
  struct MonoGenericContainer * D.30900;
  struct MonoGenericClass * D.30906;
  unsigned int nnested.248;
  int protocol_version_set.249;
  int major_version.250;
  int minor_version.251;
  struct MonoClass * D.30922;
  <unnamed-unsigned:22> D.30932;
  unsigned int count.252;
  struct MonoType * D.30934;
  struct MonoClass * D.30935;
  <unnamed-signed:31> D.30939;
  struct MonoGenericParamFull * D.30940;
  long unsigned int D.30941;
  long unsigned int D.30942;
  struct MonoGenericParam * D.30943;
  unsigned int nmethods.253;
  _Bool D.30946;
  long int D.30947;
  long int D.30948;
  unsigned int nfields.254;
  const char * D.30952;
  struct MonoType * D.30953;
  struct MonoClass * D.30954;
  short unsigned int D.30955;
  unsigned int D.30956;
  _Bool D.30957;
  long int D.30958;
  long int D.30959;
  unsigned int nprops.255;
  const char * D.30963;
  struct MonoMethod * D.30964;
  struct MonoMethod * D.30965;
  unsigned int D.30966;
  _Bool D.30967;
  long int D.30968;
  long int D.30969;
  guint8 * p.256;
  int err.257;
  ErrorCode D.30976;
  <unnamed type> D.30987;
  struct MonoThread * thread_obj.258;
  struct MonoType * D.30993;
  short unsigned int D.30994;
  int D.30995;
  int D.30996;
  struct MonoClass * D.31004;
  struct MonoClass * D.31009;
  int D.31010;
  long unsigned int D.31011;
  struct MonoInternalThread * iftmp.259;
  struct MonoType * D.31018;
  short unsigned int D.31019;
  int D.31020;
  int D.31021;
  int D.31024;
  struct MonoClass * D.31027;
  struct MonoClass * D.31032;
  int D.31033;
  long unsigned int D.31034;
  <unnamed type> D.31035;
  int err.260;
  int D.31039;
  void * D.31042;
  unsigned int D.31044;
  void * * D.31045;
  long unsigned int D.31046;
  long unsigned int D.31047;
  void * * D.31048;
  unsigned int i.261;
  int D.31055;
  unsigned int flags.262;
  unsigned int D.31060;
  int D.31061;
  _Bool D.31062;
  int D.31063;
  unsigned int D.31066;
  void * * D.31067;
  long unsigned int D.31068;
  long unsigned int D.31069;
  void * * D.31070;
  unsigned int i.263;
  int D.31072;
  int D.31075;
  unsigned int D.31078;
  struct MonoClass * iface.264;
  int D.31080;
  unsigned int nmethods.265;
  struct MonoMethod * * D.31086;
  int D.31087;
  long unsigned int D.31088;
  long unsigned int D.31089;
  struct MonoMethod * * D.31090;
  struct MonoMethod * D.31091;
  long unsigned int D.31094;
  long unsigned int D.31095;
  _Bool D.31096;
  unsigned int D.31097;
  struct MonoClass * nested;
  struct MonoType * type;
  void * iter;
  guint8 b;
  int err;
  int nnested;
  char * name;

  try
    {
      switch (command) <default: <D.27567>, case 1: <D.27422>, case 2: <D.27441>, case 3: <D.27449>, case 4: <D.27476>, case 5: <D.27510>, case 6: <D.27512>, case 7: <D.27496>, case 8: <D.27521>, case 9: <D.27457>, case 10: <D.27465>, case 11: <D.27468>, case 12: <D.27472>, case 13: <D.27513>, case 14: <D.27477>, case 15: <D.27523>, case 16: <D.27533>, case 17: <D.27546>, case 18: <D.27565>>
      <D.27422>:
      D.30865 = klass->name_space;
      buffer_add_string (buf, D.30865);
      D.30866 = klass->name;
      buffer_add_string (buf, D.30866);
      D.30867 = &klass->byval_arg;
      name = mono_type_get_name_full (D.30867, 2);
      buffer_add_string (buf, name);
      monoeg_g_free (name);
      D.30868 = klass->image;
      D.30869 = D.30868->assembly;
      buffer_add_assemblyid (buf, domain, D.30869);
      D.30868 = klass->image;
      buffer_add_moduleid (buf, domain, D.30868);
      D.30870 = klass->parent;
      buffer_add_typeid (buf, domain, D.30870);
      D.30874 = klass->rank;
      if (D.30874 != 0) goto <D.30871>; else goto <D.30875>;
      <D.30875>:
      D.30876 = klass->byval_arg.type;
      if (D.30876 == 15) goto <D.30871>; else goto <D.30872>;
      <D.30871>:
      D.30877 = klass->element_class;
      buffer_add_typeid (buf, domain, D.30877);
      goto <D.30873>;
      <D.30872>:
      buffer_add_id (buf, 0);
      <D.30873>:
      D.30878 = klass->type_token;
      buffer_add_int (buf, D.30878);
      D.30874 = klass->rank;
      buffer_add_byte (buf, D.30874);
      D.30879 = klass->flags;
      buffer_add_int (buf, D.30879);
      b = 0;
      type = &klass->byval_arg;
      if (0 != 0) goto <D.30880>; else goto <D.30881>;
      <D.30880>:
      b = b | 1;
      <D.30881>:
      D.30882 = type->type;
      if (D.30882 == 15) goto <D.30883>; else goto <D.30884>;
      <D.30883>:
      b = b | 2;
      <D.30884>:
      D.30887 = BIT_FIELD_REF <*type, 64, 64>;
      D.30888 = D.30887 & 1073741824;
      if (D.30888 == 0) goto <D.30889>; else goto <D.30890>;
      <D.30889>:
      D.30882 = type->type;
      D.30891 = D.30882 + 254;
      if (D.30891 <= 11) goto <D.30885>; else goto <D.30892>;
      <D.30892>:
      D.30882 = type->type;
      if (D.30882 == 24) goto <D.30885>; else goto <D.30893>;
      <D.30893>:
      D.30882 = type->type;
      if (D.30882 == 25) goto <D.30885>; else goto <D.30886>;
      <D.30885>:
      b = b | 4;
      <D.30886>:
      <D.30890>:
      D.30882 = type->type;
      if (D.30882 == 17) goto <D.30894>; else goto <D.30895>;
      <D.30894>:
      b = b | 8;
      <D.30895>:
      D.30896 = BIT_FIELD_REF <*klass, 64, 256>;
      D.30897 = D.30896 & 16;
      if (D.30897 != 0) goto <D.30898>; else goto <D.30899>;
      <D.30898>:
      b = b | 16;
      <D.30899>:
      D.30900 = klass->generic_container;
      if (D.30900 != 0B) goto <D.30901>; else goto <D.30902>;
      <D.30901>:
      b = b | 32;
      <D.30902>:
      D.30900 = klass->generic_container;
      if (D.30900 != 0B) goto <D.30903>; else goto <D.30905>;
      <D.30905>:
      D.30906 = klass->generic_class;
      if (D.30906 != 0B) goto <D.30903>; else goto <D.30904>;
      <D.30903>:
      b = b | 64;
      <D.30904>:
      buffer_add_byte (buf, b);
      nnested = 0;
      iter = 0B;
      goto <D.27424>;
      <D.27423>:
      nnested = nnested + 1;
      <D.27424>:
      nested = mono_class_get_nested_types (klass, &iter);
      if (nested != 0B) goto <D.27423>; else goto <D.27425>;
      <D.27425>:
      nnested.248 = (unsigned int) nnested;
      buffer_add_int (buf, nnested.248);
      iter = 0B;
      goto <D.27427>;
      <D.27426>:
      buffer_add_typeid (buf, domain, nested);
      <D.27427>:
      nested = mono_class_get_nested_types (klass, &iter);
      if (nested != 0B) goto <D.27426>; else goto <D.27428>;
      <D.27428>:
      protocol_version_set.249 = protocol_version_set;
      if (protocol_version_set.249 != 0) goto <D.30911>; else goto <D.30912>;
      <D.30911>:
      major_version.250 = major_version;
      if (major_version.250 > 2) goto <D.30908>; else goto <D.30914>;
      <D.30914>:
      major_version.250 = major_version;
      if (major_version.250 == 2) goto <D.30915>; else goto <D.30909>;
      <D.30915>:
      minor_version.251 = minor_version;
      if (minor_version.251 > 11) goto <D.30908>; else goto <D.30909>;
      <D.30908>:
      D.30900 = klass->generic_container;
      if (D.30900 != 0B) goto <D.30917>; else goto <D.30918>;
      <D.30917>:
      buffer_add_typeid (buf, domain, klass);
      goto <D.30919>;
      <D.30918>:
      D.30906 = klass->generic_class;
      if (D.30906 != 0B) goto <D.30920>; else goto <D.30921>;
      <D.30920>:
      D.30906 = klass->generic_class;
      D.30922 = D.30906->container_class;
      buffer_add_typeid (buf, domain, D.30922);
      goto <D.30923>;
      <D.30921>:
      buffer_add_id (buf, 0);
      <D.30923>:
      <D.30919>:
      <D.30909>:
      <D.30912>:
      protocol_version_set.249 = protocol_version_set;
      if (protocol_version_set.249 != 0) goto <D.30926>; else goto <D.30927>;
      <D.30926>:
      major_version.250 = major_version;
      if (major_version.250 > 2) goto <D.30924>; else goto <D.30928>;
      <D.30928>:
      major_version.250 = major_version;
      if (major_version.250 == 2) goto <D.30929>; else goto <D.30925>;
      <D.30929>:
      minor_version.251 = minor_version;
      if (minor_version.251 > 14) goto <D.30924>; else goto <D.30925>;
      <D.30924>:
      {
        int count;
        int i;

        D.30906 = klass->generic_class;
        if (D.30906 != 0B) goto <D.30930>; else goto <D.30931>;
        <D.30930>:
        {
          struct MonoGenericInst * inst;

          D.30906 = klass->generic_class;
          inst = D.30906->context.class_inst;
          D.30932 = inst->type_argc;
          count = (int) D.30932;
          count.252 = (unsigned int) count;
          buffer_add_int (buf, count.252);
          i = 0;
          goto <D.27433>;
          <D.27432>:
          D.30934 = inst->type_argv[i];
          D.30935 = mono_class_from_mono_type (D.30934);
          buffer_add_typeid (buf, domain, D.30935);
          i = i + 1;
          <D.27433>:
          if (i < count) goto <D.27432>; else goto <D.27434>;
          <D.27434>:
        }
        goto <D.30936>;
        <D.30931>:
        D.30900 = klass->generic_container;
        if (D.30900 != 0B) goto <D.30937>; else goto <D.30938>;
        <D.30937>:
        {
          struct MonoGenericContainer * container;
          struct MonoClass * pklass;

          container = klass->generic_container;
          D.30939 = container->type_argc;
          count = (int) D.30939;
          count.252 = (unsigned int) count;
          buffer_add_int (buf, count.252);
          i = 0;
          goto <D.27438>;
          <D.27437>:
          D.30940 = container->type_params;
          D.30941 = (long unsigned int) i;
          D.30942 = D.30941 * 56;
          D.30943 = D.30940 + D.30942;
          D.30868 = klass->image;
          pklass = mono_class_from_generic_parameter (D.30943, D.30868, 0);
          buffer_add_typeid (buf, domain, pklass);
          i = i + 1;
          <D.27438>:
          if (i < count) goto <D.27437>; else goto <D.27439>;
          <D.27439>:
        }
        goto <D.30944>;
        <D.30938>:
        buffer_add_int (buf, 0);
        <D.30944>:
        <D.30936>:
      }
      <D.30925>:
      <D.30927>:
      goto <D.27440>;
      <D.27441>:
      {
        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.253 = (unsigned int) nmethods;
            buffer_add_int (buf, nmethods.253);
            goto <D.27447>;
            <D.27446>:
            buffer_add_methodid (buf, domain, m);
            i = i + 1;
            <D.27447>:
            m = mono_class_get_methods (klass, &iter);
            if (m != 0B) goto <D.27446>; else goto <D.27448>;
            <D.27448>:
            D.30946 = i != nmethods;
            D.30947 = (long int) D.30946;
            D.30948 = __builtin_expect (D.30947, 0);
            if (D.30948 != 0) goto <D.30949>; else goto <D.30950>;
            <D.30949>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 7618, "i == nmethods");
            <D.30950>:
            goto <D.27440>;
          }
        finally
          {
            iter = {CLOBBER};
          }
      }
      <D.27449>:
      {
        int nfields;
        int i;
        void * iter;
        struct MonoClassField * f;

        try
          {
            i = 0;
            iter = 0B;
            nfields = mono_class_num_fields (klass);
            nfields.254 = (unsigned int) nfields;
            buffer_add_int (buf, nfields.254);
            goto <D.27455>;
            <D.27454>:
            buffer_add_fieldid (buf, domain, f);
            D.30952 = f->name;
            buffer_add_string (buf, D.30952);
            D.30953 = f->type;
            D.30954 = mono_class_from_mono_type (D.30953);
            buffer_add_typeid (buf, domain, D.30954);
            D.30953 = f->type;
            D.30955 = D.30953->attrs;
            D.30956 = (unsigned int) D.30955;
            buffer_add_int (buf, D.30956);
            i = i + 1;
            <D.27455>:
            f = mono_class_get_fields (klass, &iter);
            if (f != 0B) goto <D.27454>; else goto <D.27456>;
            <D.27456>:
            D.30957 = i != nfields;
            D.30958 = (long int) D.30957;
            D.30959 = __builtin_expect (D.30958, 0);
            if (D.30959 != 0) goto <D.30960>; else goto <D.30961>;
            <D.30960>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 7638, "i == nfields");
            <D.30961>:
            goto <D.27440>;
          }
        finally
          {
            iter = {CLOBBER};
          }
      }
      <D.27457>:
      {
        int nprops;
        int i;
        void * iter;
        struct MonoProperty * p;

        try
          {
            i = 0;
            iter = 0B;
            nprops = mono_class_num_properties (klass);
            nprops.255 = (unsigned int) nprops;
            buffer_add_int (buf, nprops.255);
            goto <D.27463>;
            <D.27462>:
            buffer_add_propertyid (buf, domain, p);
            D.30963 = p->name;
            buffer_add_string (buf, D.30963);
            D.30964 = p->get;
            buffer_add_methodid (buf, domain, D.30964);
            D.30965 = p->set;
            buffer_add_methodid (buf, domain, D.30965);
            D.30966 = p->attrs;
            buffer_add_int (buf, D.30966);
            i = i + 1;
            <D.27463>:
            p = mono_class_get_properties (klass, &iter);
            if (p != 0B) goto <D.27462>; else goto <D.27464>;
            <D.27464>:
            D.30967 = i != nprops;
            D.30968 = (long int) D.30967;
            D.30969 = __builtin_expect (D.30968, 0);
            if (D.30969 != 0) goto <D.30970>; else goto <D.30971>;
            <D.30970>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 7659, "i == nprops");
            <D.30971>:
            goto <D.27440>;
          }
        finally
          {
            iter = {CLOBBER};
          }
      }
      <D.27465>:
      {
        struct MonoClass * attr_klass;
        struct MonoCustomAttrInfo * cinfo;

        p.256 = p;
        attr_klass = decode_typeid (p.256, &p, end, 0B, &err);
        err.257 = err;
        if (err.257 != 0) goto <D.30974>; else goto <D.30975>;
        <D.30974>:
        err.257 = err;
        D.30976 = (ErrorCode) err.257;
        return D.30976;
        <D.30975>:
        cinfo = mono_custom_attrs_from_class (klass);
        D.30868 = klass->image;
        buffer_add_cattrs (buf, domain, D.30868, attr_klass, cinfo);
        goto <D.27440>;
      }
      <D.27468>:
      {
        struct MonoClass * attr_klass;
        struct MonoCustomAttrInfo * cinfo;
        struct MonoClassField * field;

        p.256 = p;
        field = decode_fieldid (p.256, &p, end, 0B, &err);
        err.257 = err;
        if (err.257 != 0) goto <D.30977>; else goto <D.30978>;
        <D.30977>:
        err.257 = err;
        D.30976 = (ErrorCode) err.257;
        return D.30976;
        <D.30978>:
        p.256 = p;
        attr_klass = decode_typeid (p.256, &p, end, 0B, &err);
        err.257 = err;
        if (err.257 != 0) goto <D.30979>; else goto <D.30980>;
        <D.30979>:
        err.257 = err;
        D.30976 = (ErrorCode) err.257;
        return D.30976;
        <D.30980>:
        cinfo = mono_custom_attrs_from_field (klass, field);
        D.30868 = klass->image;
        buffer_add_cattrs (buf, domain, D.30868, attr_klass, cinfo);
        goto <D.27440>;
      }
      <D.27472>:
      {
        struct MonoClass * attr_klass;
        struct MonoCustomAttrInfo * cinfo;
        struct MonoProperty * prop;

        p.256 = p;
        prop = decode_propertyid (p.256, &p, end, 0B, &err);
        err.257 = err;
        if (err.257 != 0) goto <D.30981>; else goto <D.30982>;
        <D.30981>:
        err.257 = err;
        D.30976 = (ErrorCode) err.257;
        return D.30976;
        <D.30982>:
        p.256 = p;
        attr_klass = decode_typeid (p.256, &p, end, 0B, &err);
        err.257 = err;
        if (err.257 != 0) goto <D.30983>; else goto <D.30984>;
        <D.30983>:
        err.257 = err;
        D.30976 = (ErrorCode) err.257;
        return D.30976;
        <D.30984>:
        cinfo = mono_custom_attrs_from_property (klass, prop);
        D.30868 = klass->image;
        buffer_add_cattrs (buf, domain, D.30868, attr_klass, cinfo);
        goto <D.27440>;
      }
      <D.27476>:
      <D.27477>:
      {
        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.30985>; else goto <D.30986>;
            <D.30985>:
            {
              int objid;
              int err;

              p.256 = p;
              objid = decode_objid (p.256, &p, end);
              D.30987 = get_object (objid, &thread_obj);
              err = (int) D.30987;
              if (err != 0) goto <D.30988>; else goto <D.30989>;
              <D.30988>:
              D.30976 = (ErrorCode) err;
              return D.30976;
              <D.30989>:
              thread_obj.258 = thread_obj;
              thread = thread_obj.258->internal_thread;
            }
            <D.30986>:
            p.256 = p;
            len = decode_int (p.256, &p, end);
            i = 0;
            goto <D.27494>;
            <D.27493>:
            p.256 = p;
            f = decode_fieldid (p.256, &p, end, 0B, &err);
            err.257 = err;
            if (err.257 != 0) goto <D.30991>; else goto <D.30992>;
            <D.30991>:
            err.257 = err;
            D.30976 = (ErrorCode) err.257;
            return D.30976;
            <D.30992>:
            D.30993 = f->type;
            D.30994 = D.30993->attrs;
            D.30995 = (int) D.30994;
            D.30996 = D.30995 & 16;
            if (D.30996 == 0) goto <D.30997>; else goto <D.30998>;
            <D.30997>:
            D.30976 = 25;
            return D.30976;
            <D.30998>:
            special_static_type = mono_class_field_get_special_static_type (f);
            if (special_static_type != 0) goto <D.30999>; else goto <D.31000>;
            <D.30999>:
            if (thread == 0B) goto <D.31001>; else goto <D.31003>;
            <D.31003>:
            if (special_static_type != 1) goto <D.31001>; else goto <D.31002>;
            <D.31001>:
            D.30976 = 25;
            return D.30976;
            <D.31002>:
            <D.31000>:
            found = 0;
            k = klass;
            goto <D.27492>;
            <D.27491>:
            D.31004 = f->parent;
            if (D.31004 == k) goto <D.31005>; else goto <D.31006>;
            <D.31005>:
            found = 1;
            goto <D.27490>;
            <D.31006>:
            k = k->parent;
            <D.27492>:
            if (k != 0B) goto <D.27491>; else goto <D.27490>;
            <D.27490>:
            if (found == 0) goto <D.31007>; else goto <D.31008>;
            <D.31007>:
            D.30976 = 25;
            return D.30976;
            <D.31008>:
            D.31004 = f->parent;
            vtable = mono_class_vtable (domain, D.31004);
            D.30993 = f->type;
            D.31009 = mono_class_from_mono_type (D.30993);
            D.31010 = mono_class_instance_size (D.31009);
            D.31011 = (long unsigned int) D.31010;
            val = monoeg_malloc (D.31011);
            if (thread == 0B) goto <D.31013>; else goto <D.31014>;
            <D.31013>:
            iftmp.259 = mono_thread_internal_current ();
            goto <D.31015>;
            <D.31014>:
            iftmp.259 = thread;
            <D.31015>:
            mono_field_static_get_value_for_thread (iftmp.259, vtable, f, val);
            D.30993 = f->type;
            buffer_add_value (buf, D.30993, val, domain);
            monoeg_g_free (val);
            i = i + 1;
            <D.27494>:
            if (i < len) goto <D.27493>; else goto <D.27495>;
            <D.27495>:
            goto <D.27440>;
          }
        finally
          {
            thread_obj = {CLOBBER};
          }
      }
      <D.27496>:
      {
        guint8 * val;
        struct MonoClassField * f;
        struct MonoVTable * vtable;
        struct MonoClass * k;
        int len;
        int i;
        gboolean found;

        p.256 = p;
        len = decode_int (p.256, &p, end);
        i = 0;
        goto <D.27508>;
        <D.27507>:
        p.256 = p;
        f = decode_fieldid (p.256, &p, end, 0B, &err);
        err.257 = err;
        if (err.257 != 0) goto <D.31016>; else goto <D.31017>;
        <D.31016>:
        err.257 = err;
        D.30976 = (ErrorCode) err.257;
        return D.30976;
        <D.31017>:
        D.31018 = f->type;
        D.31019 = D.31018->attrs;
        D.31020 = (int) D.31019;
        D.31021 = D.31020 & 16;
        if (D.31021 == 0) goto <D.31022>; else goto <D.31023>;
        <D.31022>:
        D.30976 = 25;
        return D.30976;
        <D.31023>:
        D.31024 = mono_class_field_is_special_static (f);
        if (D.31024 != 0) goto <D.31025>; else goto <D.31026>;
        <D.31025>:
        D.30976 = 25;
        return D.30976;
        <D.31026>:
        found = 0;
        k = klass;
        goto <D.27506>;
        <D.27505>:
        D.31027 = f->parent;
        if (D.31027 == k) goto <D.31028>; else goto <D.31029>;
        <D.31028>:
        found = 1;
        goto <D.27504>;
        <D.31029>:
        k = k->parent;
        <D.27506>:
        if (k != 0B) goto <D.27505>; else goto <D.27504>;
        <D.27504>:
        if (found == 0) goto <D.31030>; else goto <D.31031>;
        <D.31030>:
        D.30976 = 25;
        return D.30976;
        <D.31031>:
        D.31027 = f->parent;
        vtable = mono_class_vtable (domain, D.31027);
        D.31018 = f->type;
        D.31032 = mono_class_from_mono_type (D.31018);
        D.31033 = mono_class_instance_size (D.31032);
        D.31034 = (long unsigned int) D.31033;
        val = monoeg_malloc (D.31034);
        D.31018 = f->type;
        p.256 = p;
        D.31035 = decode_value (D.31018, domain, val, p.256, &p, end);
        err.260 = (int) D.31035;
        err = err.260;
        err.257 = err;
        if (err.257 != 0) goto <D.31037>; else goto <D.31038>;
        <D.31037>:
        monoeg_g_free (val);
        err.257 = err;
        D.30976 = (ErrorCode) err.257;
        return D.30976;
        <D.31038>:
        D.31018 = f->type;
        D.31039 = mono_type_is_reference (D.31018);
        if (D.31039 != 0) goto <D.31040>; else goto <D.31041>;
        <D.31040>:
        D.31042 = MEM[(void * *)val];
        mono_field_static_set_value (vtable, f, D.31042);
        goto <D.31043>;
        <D.31041>:
        mono_field_static_set_value (vtable, f, val);
        <D.31043>:
        monoeg_g_free (val);
        i = i + 1;
        <D.27508>:
        if (i < len) goto <D.27507>; else goto <D.27509>;
        <D.27509>:
        goto <D.27440>;
      }
      <D.27510>:
      {
        struct MonoObject * o;

        D.30867 = &klass->byval_arg;
        o = mono_type_get_object (domain, D.30867);
        buffer_add_objid (buf, o);
        goto <D.27440>;
      }
      <D.27512>:
      <D.27513>:
      {
        char * source_file;
        char * base;
        struct GPtrArray * files;
        int i;

        files = get_source_files_for_type (klass);
        D.31044 = files->len;
        buffer_add_int (buf, D.31044);
        i = 0;
        goto <D.27519>;
        <D.27518>:
        D.31045 = files->pdata;
        D.31046 = (long unsigned int) i;
        D.31047 = D.31046 * 8;
        D.31048 = D.31045 + D.31047;
        source_file = *D.31048;
        if (command == 13) goto <D.31049>; else goto <D.31050>;
        <D.31049>:
        buffer_add_string (buf, source_file);
        goto <D.31051>;
        <D.31050>:
        base = monoeg_g_path_get_basename (source_file);
        buffer_add_string (buf, base);
        monoeg_g_free (base);
        <D.31051>:
        monoeg_g_free (source_file);
        i = i + 1;
        <D.27519>:
        i.261 = (unsigned int) i;
        D.31044 = files->len;
        if (i.261 < D.31044) goto <D.27518>; else goto <D.27520>;
        <D.27520>:
        monoeg_g_ptr_array_free (files, 1);
        goto <D.27440>;
      }
      <D.27521>:
      {
        struct MonoClass * oklass;

        p.256 = p;
        oklass = decode_typeid (p.256, &p, end, 0B, &err);
        err.257 = err;
        if (err.257 != 0) goto <D.31053>; else goto <D.31054>;
        <D.31053>:
        err.257 = err;
        D.30976 = (ErrorCode) err.257;
        return D.30976;
        <D.31054>:
        D.31055 = mono_class_is_assignable_from (klass, oklass);
        if (D.31055 != 0) goto <D.31056>; else goto <D.31057>;
        <D.31056>:
        buffer_add_byte (buf, 1);
        goto <D.31058>;
        <D.31057>:
        buffer_add_byte (buf, 0);
        <D.31058>:
        goto <D.27440>;
      }
      <D.27523>:
      {
        char * name;
        int i;
        int flags;
        struct MonoException * ex;
        struct GPtrArray * array;

        try
          {
            p.256 = p;
            name = decode_string (p.256, &p, end);
            p.256 = p;
            flags = decode_int (p.256, &p, end);
            ex = 0B;
            flags.262 = (unsigned int) flags;
            D.31060 = flags.262 & 2415919103;
            D.31061 = flags & 1879048192;
            D.31062 = D.31061 != 0;
            D.31063 = (int) D.31062;
            array = mono_class_get_methods_by_name (klass, name, D.31060, D.31063, 1, &ex);
            if (array == 0B) goto <D.31064>; else goto <D.31065>;
            <D.31064>:
            D.30976 = 200;
            return D.30976;
            <D.31065>:
            D.31066 = array->len;
            buffer_add_int (buf, D.31066);
            i = 0;
            goto <D.27531>;
            <D.27530>:
            {
              struct MonoMethod * method;

              D.31067 = array->pdata;
              D.31068 = (long unsigned int) i;
              D.31069 = D.31068 * 8;
              D.31070 = D.31067 + D.31069;
              method = *D.31070;
              buffer_add_methodid (buf, domain, method);
            }
            i = i + 1;
            <D.27531>:
            i.263 = (unsigned int) i;
            D.31066 = array->len;
            if (i.263 < D.31066) goto <D.27530>; else goto <D.27532>;
            <D.27532>:
            monoeg_g_ptr_array_free (array, 1);
            monoeg_g_free (name);
            goto <D.27440>;
          }
        finally
          {
            ex = {CLOBBER};
          }
      }
      <D.27533>:
      {
        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.27541>;
            <D.27540>:
            mono_class_setup_interfaces (parent, &error);
            D.31072 = mono_error_ok (&error);
            if (D.31072 == 0) goto <D.31073>; else goto <D.31074>;
            <D.31073>:
            D.30976 = 200;
            return D.30976;
            <D.31074>:
            collect_interfaces (parent, iface_hash, &error);
            D.31075 = mono_error_ok (&error);
            if (D.31075 == 0) goto <D.31076>; else goto <D.31077>;
            <D.31076>:
            D.30976 = 200;
            return D.30976;
            <D.31077>:
            parent = parent->parent;
            <D.27541>:
            if (parent != 0B) goto <D.27540>; else goto <D.27542>;
            <D.27542>:
            D.31078 = monoeg_g_hash_table_size (iface_hash);
            buffer_add_int (buf, D.31078);
            monoeg_g_hash_table_iter_init (&iter, iface_hash);
            goto <D.27544>;
            <D.27543>:
            iface.264 = iface;
            buffer_add_typeid (buf, domain, iface.264);
            <D.27544>:
            D.31080 = monoeg_g_hash_table_iter_next (&iter, 0B, &iface);
            if (D.31080 != 0) goto <D.27543>; else goto <D.27545>;
            <D.27545>:
            monoeg_g_hash_table_destroy (iface_hash);
            goto <D.27440>;
          }
        finally
          {
            error = {CLOBBER};
            iface = {CLOBBER};
            iter = {CLOBBER};
          }
      }
      <D.27546>:
      {
        int tindex;
        int ioffset;
        gboolean variance_used;
        struct MonoClass * iclass;
        int len;
        int nmethods;
        int i;
        void * iter;
        struct MonoMethod * method;

        try
          {
            p.256 = p;
            len = decode_int (p.256, &p, end);
            mono_class_setup_vtable (klass);
            tindex = 0;
            goto <D.27563>;
            <D.27562>:
            p.256 = p;
            iclass = decode_typeid (p.256, &p, end, 0B, &err);
            err.257 = err;
            if (err.257 != 0) goto <D.31081>; else goto <D.31082>;
            <D.31081>:
            err.257 = err;
            D.30976 = (ErrorCode) err.257;
            return D.30976;
            <D.31082>:
            ioffset = mono_class_interface_offset_with_variance (klass, iclass, &variance_used);
            if (ioffset == -1) goto <D.31083>; else goto <D.31084>;
            <D.31083>:
            D.30976 = 102;
            return D.30976;
            <D.31084>:
            nmethods = mono_class_num_methods (iclass);
            nmethods.265 = (unsigned int) nmethods;
            buffer_add_int (buf, nmethods.265);
            iter = 0B;
            goto <D.27557>;
            <D.27556>:
            buffer_add_methodid (buf, domain, method);
            <D.27557>:
            method = mono_class_get_methods (iclass, &iter);
            if (method != 0B) goto <D.27556>; else goto <D.27558>;
            <D.27558>:
            i = 0;
            goto <D.27560>;
            <D.27559>:
            D.31086 = klass->vtable;
            D.31087 = i + ioffset;
            D.31088 = (long unsigned int) D.31087;
            D.31089 = D.31088 * 8;
            D.31090 = D.31086 + D.31089;
            D.31091 = *D.31090;
            buffer_add_methodid (buf, domain, D.31091);
            i = i + 1;
            <D.27560>:
            if (i < nmethods) goto <D.27559>; else goto <D.27561>;
            <D.27561>:
            tindex = tindex + 1;
            <D.27563>:
            if (tindex < len) goto <D.27562>; else goto <D.27564>;
            <D.27564>:
            goto <D.27440>;
          }
        finally
          {
            variance_used = {CLOBBER};
            iter = {CLOBBER};
          }
      }
      <D.27565>:
      {
        struct MonoVTable * vtable;

        vtable = mono_class_vtable (domain, klass);
        if (vtable != 0B) goto <D.31092>; else goto <D.31093>;
        <D.31092>:
        D.31094 = BIT_FIELD_REF <*vtable, 64, 320>;
        D.31095 = D.31094 & 100663296;
        D.31096 = D.31095 != 0;
        D.31097 = (unsigned int) D.31096;
        buffer_add_int (buf, D.31097);
        goto <D.31098>;
        <D.31093>:
        buffer_add_int (buf, 0);
        <D.31098>:
        goto <D.27440>;
      }
      <D.27567>:
      D.30976 = 100;
      return D.30976;
      <D.27440>:
      D.30976 = 0;
      return D.30976;
    }
  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.31112;

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


buffer_add_cattrs (struct Buffer * buf, struct MonoDomain * domain, struct MonoImage * image, struct MonoClass * attr_klass, struct MonoCustomAttrInfo * cinfo)
{
  struct MonoMethod * D.31119;
  struct MonoClass * D.31120;
  int D.31121;
  int D.31122;
  unsigned int nattrs.266;
  struct MonoMethod * D.31127;
  struct MonoClass * D.31128;
  int D.31129;
  const mono_byte * D.31130;
  unsigned int D.31131;
  int D.31132;
  _Bool D.31133;
  long int D.31134;
  long int D.31135;
  struct MonoArray * typed_args.267;
  long unsigned int D.31141;
  unsigned int D.31142;
  long unsigned int D.31143;
  char * D.31144;
  struct MonoMethodSignature * D.31145;
  long unsigned int D.31146;
  struct MonoArray * named_args.268;
  long unsigned int D.31151;
  unsigned int D.31152;
  char * D.31153;
  struct CattrNamedArg * arginfo.269;
  long unsigned int D.31155;
  long unsigned int D.31156;
  struct CattrNamedArg * D.31157;
  struct MonoProperty * D.31158;
  struct MonoClassField * D.31162;
  struct MonoType * D.31166;
  long unsigned int D.31167;
  int i;
  int j;
  int nattrs;

  nattrs = 0;
  if (cinfo == 0B) goto <D.31114>; else goto <D.31115>;
  <D.31114>:
  buffer_add_int (buf, 0);
  return;
  <D.31115>:
  i = 0;
  goto <D.27378>;
  <D.27377>:
  if (attr_klass == 0B) goto <D.31116>; else goto <D.31118>;
  <D.31118>:
  D.31119 = cinfo->attrs[i].ctor;
  D.31120 = D.31119->klass;
  D.31121 = mono_class_has_parent (D.31120, attr_klass);
  if (D.31121 != 0) goto <D.31116>; else goto <D.31117>;
  <D.31116>:
  nattrs = nattrs + 1;
  <D.31117>:
  i = i + 1;
  <D.27378>:
  D.31122 = cinfo->num_attrs;
  if (D.31122 > i) goto <D.27377>; else goto <D.27379>;
  <D.27379>:
  nattrs.266 = (unsigned int) nattrs;
  buffer_add_int (buf, nattrs.266);
  i = 0;
  goto <D.27395>;
  <D.27394>:
  {
    struct MonoCustomAttrEntry * attr;

    attr = &cinfo->attrs[i];
    if (attr_klass == 0B) goto <D.31124>; else goto <D.31126>;
    <D.31126>:
    D.31127 = attr->ctor;
    D.31128 = D.31127->klass;
    D.31129 = mono_class_has_parent (D.31128, attr_klass);
    if (D.31129 != 0) goto <D.31124>; else goto <D.31125>;
    <D.31124>:
    {
      struct MonoArray * typed_args;
      struct MonoArray * named_args;
      struct MonoType * t;
      struct CattrNamedArg * arginfo;
      struct MonoError error;

      try
        {
          arginfo = 0B;
          D.31127 = attr->ctor;
          D.31130 = attr->data;
          D.31131 = attr->data_size;
          mono_reflection_create_custom_attr_data_args (image, D.31127, D.31130, D.31131, &typed_args, &named_args, &arginfo, &error);
          D.31132 = mono_error_ok (&error);
          D.31133 = D.31132 == 0;
          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", 7448, "mono_error_ok (&error)");
          <D.31137>:
          D.31127 = attr->ctor;
          buffer_add_methodid (buf, domain, D.31127);
          typed_args.267 = typed_args;
          if (typed_args.267 != 0B) goto <D.31139>; else goto <D.31140>;
          <D.31139>:
          typed_args.267 = typed_args;
          D.31141 = mono_array_length (typed_args.267);
          D.31142 = (unsigned int) D.31141;
          buffer_add_int (buf, D.31142);
          j = 0;
          goto <D.27388>;
          <D.27387>:
          {
            struct MonoObject * val;

            typed_args.267 = typed_args;
            D.31143 = (long unsigned int) j;
            D.31144 = mono_array_addr_with_size (typed_args.267, 8, D.31143);
            val = MEM[(struct MonoObject * *)D.31144];
            D.31127 = attr->ctor;
            D.31145 = mono_method_signature (D.31127);
            t = D.31145->params[j];
            buffer_add_cattr_arg (buf, t, domain, val);
          }
          j = j + 1;
          <D.27388>:
          D.31143 = (long unsigned int) j;
          typed_args.267 = typed_args;
          D.31146 = mono_array_length (typed_args.267);
          if (D.31143 < D.31146) goto <D.27387>; else goto <D.27389>;
          <D.27389>:
          goto <D.31147>;
          <D.31140>:
          buffer_add_int (buf, 0);
          <D.31147>:
          named_args.268 = named_args;
          if (named_args.268 != 0B) goto <D.31149>; else goto <D.31150>;
          <D.31149>:
          named_args.268 = named_args;
          D.31151 = mono_array_length (named_args.268);
          D.31152 = (unsigned int) D.31151;
          buffer_add_int (buf, D.31152);
          j = 0;
          goto <D.27392>;
          <D.27391>:
          {
            struct MonoObject * val;

            named_args.268 = named_args;
            D.31143 = (long unsigned int) j;
            D.31153 = mono_array_addr_with_size (named_args.268, 8, D.31143);
            val = MEM[(struct MonoObject * *)D.31153];
            arginfo.269 = arginfo;
            D.31155 = (long unsigned int) j;
            D.31156 = D.31155 * 24;
            D.31157 = arginfo.269 + D.31156;
            D.31158 = D.31157->prop;
            if (D.31158 != 0B) goto <D.31159>; else goto <D.31160>;
            <D.31159>:
            buffer_add_byte (buf, 84);
            arginfo.269 = arginfo;
            D.31155 = (long unsigned int) j;
            D.31156 = D.31155 * 24;
            D.31157 = arginfo.269 + D.31156;
            D.31158 = D.31157->prop;
            buffer_add_propertyid (buf, domain, D.31158);
            goto <D.31161>;
            <D.31160>:
            arginfo.269 = arginfo;
            D.31155 = (long unsigned int) j;
            D.31156 = D.31155 * 24;
            D.31157 = arginfo.269 + D.31156;
            D.31162 = D.31157->field;
            if (D.31162 != 0B) goto <D.31163>; else goto <D.31164>;
            <D.31163>:
            buffer_add_byte (buf, 83);
            arginfo.269 = arginfo;
            D.31155 = (long unsigned int) j;
            D.31156 = D.31155 * 24;
            D.31157 = arginfo.269 + D.31156;
            D.31162 = D.31157->field;
            buffer_add_fieldid (buf, domain, D.31162);
            goto <D.31165>;
            <D.31164>:
            monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "debugger-agent.c", 7480);
            <D.31165>:
            <D.31161>:
            arginfo.269 = arginfo;
            D.31155 = (long unsigned int) j;
            D.31156 = D.31155 * 24;
            D.31157 = arginfo.269 + D.31156;
            D.31166 = D.31157->type;
            buffer_add_cattr_arg (buf, D.31166, domain, val);
          }
          j = j + 1;
          <D.27392>:
          D.31143 = (long unsigned int) j;
          named_args.268 = named_args;
          D.31167 = mono_array_length (named_args.268);
          if (D.31143 < D.31167) goto <D.27391>; else goto <D.27393>;
          <D.27393>:
          goto <D.31168>;
          <D.31150>:
          buffer_add_int (buf, 0);
          <D.31168>:
          arginfo.269 = arginfo;
          monoeg_g_free (arginfo.269);
        }
      finally
        {
          typed_args = {CLOBBER};
          named_args = {CLOBBER};
          arginfo = {CLOBBER};
          error = {CLOBBER};
        }
    }
    <D.31125>:
  }
  i = i + 1;
  <D.27395>:
  D.31122 = cinfo->num_attrs;
  if (D.31122 > i) goto <D.27394>; else goto <D.27396>;
  <D.27396>:
}


mono_class_has_parent (struct MonoClass * klass, struct MonoClass * parent)
{
  struct MonoClass * * D.31170;
  _Bool D.31171;
  long int D.31172;
  long int D.31173;
  struct MonoClass * * D.31176;
  _Bool D.31177;
  long int D.31178;
  long int D.31179;
  gboolean D.31182;

  D.31170 = klass->supertypes;
  D.31171 = D.31170 == 0B;
  D.31172 = (long int) D.31171;
  D.31173 = __builtin_expect (D.31172, 0);
  if (D.31173 != 0) goto <D.31174>; else goto <D.31175>;
  <D.31174>:
  mono_class_setup_supertypes (klass);
  <D.31175>:
  D.31176 = parent->supertypes;
  D.31177 = D.31176 == 0B;
  D.31178 = (long int) D.31177;
  D.31179 = __builtin_expect (D.31178, 0);
  if (D.31179 != 0) goto <D.31180>; else goto <D.31181>;
  <D.31180>:
  mono_class_setup_supertypes (parent);
  <D.31181>:
  D.31182 = mono_class_has_parent_fast (klass, parent);
  return D.31182;
}


mono_class_has_parent_fast (struct MonoClass * klass, struct MonoClass * parent)
{
  gboolean D.31184;
  int iftmp.270;
  short unsigned int D.31188;
  short unsigned int D.31189;
  struct MonoClass * * D.31191;
  long unsigned int D.31192;
  long unsigned int D.31193;
  sizetype D.31194;
  struct MonoClass * * D.31195;
  struct MonoClass * D.31196;

  D.31188 = klass->idepth;
  D.31189 = parent->idepth;
  if (D.31188 >= D.31189) goto <D.31190>; else goto <D.31186>;
  <D.31190>:
  D.31191 = klass->supertypes;
  D.31189 = parent->idepth;
  D.31192 = (long unsigned int) D.31189;
  D.31193 = D.31192 * 8;
  D.31194 = D.31193 + 18446744073709551608;
  D.31195 = D.31191 + D.31194;
  D.31196 = *D.31195;
  if (D.31196 == parent) goto <D.31197>; else goto <D.31186>;
  <D.31197>:
  iftmp.270 = 1;
  goto <D.31187>;
  <D.31186>:
  iftmp.270 = 0;
  <D.31187>:
  D.31184 = iftmp.270;
  return D.31184;
}


buffer_add_cattr_arg (struct Buffer * buf, struct MonoType * t, struct MonoDomain * domain, struct MonoObject * val)
{
  struct MonoObject * val.271;
  struct MonoVTable * D.31203;
  struct MonoClass * D.31204;
  struct MonoClass * D.31205;
  struct MonoType * D.31207;
  struct MonoClass * D.31208;
  int D.31209;
  void * D.31213;

  val.271 = val;
  if (val.271 != 0B) goto <D.31202>; else goto <D.31199>;
  <D.31202>:
  val.271 = val;
  D.31203 = val.271->vtable;
  D.31204 = D.31203->klass;
  D.31205 = mono_defaults.monotype_class;
  if (D.31204 == D.31205) goto <D.31206>; else goto <D.31199>;
  <D.31206>:
  buffer_add_byte (buf, 241);
  val.271 = val;
  D.31207 = MEM[(struct MonoReflectionType *)val.271].type;
  D.31208 = mono_class_from_mono_type (D.31207);
  buffer_add_typeid (buf, domain, D.31208);
  goto <D.31200>;
  <D.31199>:
  D.31209 = mono_type_is_reference (t);
  if (D.31209 != 0) goto <D.31210>; else goto <D.31211>;
  <D.31210>:
  buffer_add_value (buf, t, &val, domain);
  goto <D.31212>;
  <D.31211>:
  val.271 = val;
  D.31213 = mono_object_unbox (val.271);
  buffer_add_value (buf, t, D.31213, domain);
  <D.31212>:
  <D.31200>:
}


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


buffer_add_value_full (struct Buffer * buf, struct MonoType * t, void * addr, struct MonoDomain * domain, gboolean as_vtype)
{
  long unsigned int D.31214;
  long unsigned int D.31215;
  void * D.31218;
  _Bool D.31221;
  long int D.31222;
  long int D.31223;
  unsigned char D.31228;
  int D.31229;
  signed char D.31230;
  unsigned int D.31231;
  short int D.31232;
  unsigned int D.31233;
  int D.31234;
  unsigned int D.31235;
  long int D.31236;
  long unsigned int D.31237;
  long unsigned int val.272;
  struct MonoVTable * D.31242;
  struct MonoClass * D.31243;
  long unsigned int D.31244;
  long unsigned int D.31245;
  unsigned char D.31248;
  unsigned char D.31251;
  <unnamed-unsigned:1> D.31256;
  unsigned char D.31257;
  struct MonoType * D.31258;
  short unsigned int D.31259;
  int D.31260;
  int D.31261;
  int D.31264;
  int D.26786;
  int iftmp.273;
  int D.26785;
  const char[9] * D.31270;
  unsigned char D.31271;
  int D.31272;
  unsigned char D.31273;
  int D.31274;
  const unsigned char * D.31279;
  unsigned char D.31280;
  int D.31281;
  const unsigned char * D.31282;
  unsigned char D.31283;
  int D.31284;
  const unsigned char * D.31289;
  unsigned char D.31290;
  int D.31291;
  const unsigned char * D.31292;
  unsigned char D.31293;
  int D.31294;
  const unsigned char * D.31299;
  unsigned char D.31300;
  int D.31301;
  const unsigned char * D.31302;
  unsigned char D.31303;
  int D.31304;
  const char * D.31306;
  unsigned int nfields.274;
  int D.26798;
  int iftmp.275;
  int D.26797;
  unsigned char D.31317;
  int D.31318;
  const unsigned char * D.31323;
  unsigned char D.31324;
  int D.31325;
  const unsigned char * D.31330;
  unsigned char D.31331;
  int D.31332;
  const unsigned char * D.31337;
  unsigned char D.31338;
  int D.31339;
  const char * D.31341;
  int D.31344;
  sizetype D.31345;
  sizetype D.31346;
  void * D.31347;
  int D.31348;
  struct MonoObject * obj;
  void handle_vtype = <<< error >>>;
  void handle_ref = <<< error >>>;

  D.31214 = BIT_FIELD_REF <*t, 64, 64>;
  D.31215 = D.31214 & 1073741824;
  if (D.31215 != 0) goto <D.31216>; else goto <D.31217>;
  <D.31216>:
  D.31218 = MEM[(void * *)addr];
  if (D.31218 == 0B) goto <D.31219>; else goto <D.31220>;
  <D.31219>:
  buffer_add_byte (buf, 240);
  return;
  <D.31220>:
  D.31218 = MEM[(void * *)addr];
  D.31221 = D.31218 == 0B;
  D.31222 = (long int) D.31221;
  D.31223 = __builtin_expect (D.31222, 0);
  if (D.31223 != 0) goto <D.31224>; else goto <D.31225>;
  <D.31224>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 5513, "*(void**)addr");
  <D.31225>:
  addr = MEM[(void * *)addr];
  <D.31217>:
  if (as_vtype != 0) goto <D.31226>; else goto <D.31227>;
  <D.31226>:
  D.31228 = t->type;
  D.31229 = (int) D.31228;
  switch (D.31229) <default: <D.26746>, case 2: <D.26730>, case 3: <D.26733>, case 4: <D.26731>, case 5: <D.26732>, case 6: <D.26734>, case 7: <D.26735>, case 8: <D.26736>, case 9: <D.26737>, case 10: <D.26739>, case 11: <D.26740>, case 12: <D.26738>, case 13: <D.26741>, case 15: <D.26744>, case 24: <D.26742>, case 25: <D.26743>>
  <D.26730>:
  <D.26731>:
  <D.26732>:
  <D.26733>:
  <D.26734>:
  <D.26735>:
  <D.26736>:
  <D.26737>:
  <D.26738>:
  <D.26739>:
  <D.26740>:
  <D.26741>:
  <D.26742>:
  <D.26743>:
  <D.26744>:
  goto handle_vtype;
  <D.26746>:
  goto <D.26747>;
  <D.26747>:
  <D.31227>:
  D.31228 = t->type;
  D.31229 = (int) D.31228;
  switch (D.31229) <default: <D.26802>, case 1: <D.26748>, case 2: <D.26750>, case 3: <D.26753>, case 4: <D.26751>, case 5: <D.26752>, case 6: <D.26754>, case 7: <D.26755>, case 8: <D.26756>, case 9: <D.26757>, case 10: <D.26759>, case 11: <D.26760>, case 12: <D.26758>, case 13: <D.26761>, case 14: <D.26767>, case 15: <D.26764>, case 17: <D.26772>, case 18: <D.26770>, case 20: <D.26771>, case 21: <D.26801>, case 24: <D.26762>, case 25: <D.26763>, case 28: <D.26769>, case 29: <D.26768>>
  <D.26748>:
  D.31228 = t->type;
  buffer_add_byte (buf, D.31228);
  goto <D.26749>;
  <D.26750>:
  <D.26751>:
  <D.26752>:
  D.31228 = t->type;
  buffer_add_byte (buf, D.31228);
  D.31230 = MEM[(gint8 *)addr];
  D.31231 = (unsigned int) D.31230;
  buffer_add_int (buf, D.31231);
  goto <D.26749>;
  <D.26753>:
  <D.26754>:
  <D.26755>:
  D.31228 = t->type;
  buffer_add_byte (buf, D.31228);
  D.31232 = MEM[(gint16 *)addr];
  D.31233 = (unsigned int) D.31232;
  buffer_add_int (buf, D.31233);
  goto <D.26749>;
  <D.26756>:
  <D.26757>:
  <D.26758>:
  D.31228 = t->type;
  buffer_add_byte (buf, D.31228);
  D.31234 = MEM[(gint32 *)addr];
  D.31235 = (unsigned int) D.31234;
  buffer_add_int (buf, D.31235);
  goto <D.26749>;
  <D.26759>:
  <D.26760>:
  <D.26761>:
  D.31228 = t->type;
  buffer_add_byte (buf, D.31228);
  D.31236 = MEM[(gint64 *)addr];
  D.31237 = (long unsigned int) D.31236;
  buffer_add_long (buf, D.31237);
  goto <D.26749>;
  <D.26762>:
  <D.26763>:
  goto handle_vtype;
  <D.26764>:
  {
    gssize val;

    val = MEM[(gssize *)addr];
    D.31228 = t->type;
    buffer_add_byte (buf, D.31228);
    val.272 = (long unsigned int) val;
    buffer_add_long (buf, val.272);
    goto <D.26749>;
  }
  handle_ref:
  <D.26767>:
  <D.26768>:
  <D.26769>:
  <D.26770>:
  <D.26771>:
  obj = MEM[(struct MonoObject * *)addr];
  if (obj == 0B) goto <D.31239>; else goto <D.31240>;
  <D.31239>:
  buffer_add_byte (buf, 240);
  goto <D.31241>;
  <D.31240>:
  D.31242 = obj->vtable;
  D.31243 = D.31242->klass;
  D.31244 = BIT_FIELD_REF <*D.31243, 64, 256>;
  D.31245 = D.31244 & 8;
  if (D.31245 != 0) goto <D.31246>; else goto <D.31247>;
  <D.31246>:
  D.31242 = obj->vtable;
  D.31243 = D.31242->klass;
  t = &D.31243->byval_arg;
  addr = mono_object_unbox (obj);
  goto handle_vtype;
  <D.31247>:
  D.31242 = obj->vtable;
  D.31243 = D.31242->klass;
  D.31248 = D.31243->rank;
  if (D.31248 != 0) goto <D.31249>; else goto <D.31250>;
  <D.31249>:
  D.31242 = obj->vtable;
  D.31243 = D.31242->klass;
  D.31251 = D.31243->byval_arg.type;
  buffer_add_byte (buf, D.31251);
  goto <D.31252>;
  <D.31250>:
  D.31242 = obj->vtable;
  D.31243 = D.31242->klass;
  D.31251 = D.31243->byval_arg.type;
  if (D.31251 == 21) goto <D.31253>; else goto <D.31254>;
  <D.31253>:
  buffer_add_byte (buf, 18);
  goto <D.31255>;
  <D.31254>:
  D.31242 = obj->vtable;
  D.31243 = D.31242->klass;
  D.31251 = D.31243->byval_arg.type;
  buffer_add_byte (buf, D.31251);
  <D.31255>:
  <D.31252>:
  buffer_add_objid (buf, obj);
  <D.31241>:
  goto <D.26749>;
  handle_vtype:
  <D.26772>:
  {
    int nfields;
    void * iter;
    struct MonoClassField * f;
    struct MonoClass * klass;

    try
      {
        klass = mono_class_from_mono_type (t);
        buffer_add_byte (buf, 17);
        D.31256 = klass->enumtype;
        D.31257 = (unsigned char) D.31256;
        buffer_add_byte (buf, D.31257);
        buffer_add_typeid (buf, domain, klass);
        nfields = 0;
        iter = 0B;
        goto <D.26777>;
        <D.26787>:
        D.31258 = f->type;
        D.31259 = D.31258->attrs;
        D.31260 = (int) D.31259;
        D.31261 = D.31260 & 16;
        if (D.31261 != 0) goto <D.31262>; else goto <D.31263>;
        <D.31262>:
        // predicted unlikely by continue predictor.
        goto <D.26777>;
        <D.31263>:
        D.31258 = f->type;
        D.31259 = D.31258->attrs;
        D.31260 = (int) D.31259;
        D.31264 = D.31260 & 1536;
        if (D.31264 != 0) goto <D.31265>; else goto <D.31266>;
        <D.31265>:
        {
          size_t __s1_len;
          size_t __s2_len;

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

            __s2 = mono_field_get_name (f);
            D.31270 = "_Deleted";
            D.31271 = MEM[(const unsigned char *)D.31270];
            D.31272 = (int) D.31271;
            D.31273 = *__s2;
            D.31274 = (int) D.31273;
            __result = D.31272 - D.31274;
            {
              if (__s2_len != 0) goto <D.31275>; else goto <D.31276>;
              <D.31275>:
              if (__result == 0) goto <D.31277>; else goto <D.31278>;
              <D.31277>:
              D.31279 = &MEM[(void *)"_Deleted" + 1B];
              D.31280 = *D.31279;
              D.31281 = (int) D.31280;
              D.31282 = __s2 + 1;
              D.31283 = *D.31282;
              D.31284 = (int) D.31283;
              __result = D.31281 - D.31284;
              if (__s2_len > 1) goto <D.31285>; else goto <D.31286>;
              <D.31285>:
              if (__result == 0) goto <D.31287>; else goto <D.31288>;
              <D.31287>:
              D.31289 = &MEM[(void *)"_Deleted" + 2B];
              D.31290 = *D.31289;
              D.31291 = (int) D.31290;
              D.31292 = __s2 + 2;
              D.31293 = *D.31292;
              D.31294 = (int) D.31293;
              __result = D.31291 - D.31294;
              if (__s2_len > 2) goto <D.31295>; else goto <D.31296>;
              <D.31295>:
              if (__result == 0) goto <D.31297>; else goto <D.31298>;
              <D.31297>:
              D.31299 = &MEM[(void *)"_Deleted" + 3B];
              D.31300 = *D.31299;
              D.31301 = (int) D.31300;
              D.31302 = __s2 + 3;
              D.31303 = *D.31302;
              D.31304 = (int) D.31303;
              __result = D.31301 - D.31304;
              <D.31298>:
              <D.31296>:
              <D.31288>:
              <D.31286>:
              <D.31278>:
              <D.31276>:
            }
            D.26785 = __result;
          }
          iftmp.273 = -D.26785;
          goto <D.31305>;
          <D.31269>:
          D.31306 = mono_field_get_name (f);
          iftmp.273 = __builtin_strcmp (D.31306, "_Deleted");
          <D.31305>:
          D.26786 = iftmp.273;
        }
        if (D.26786 == 0) goto <D.31307>; else goto <D.31308>;
        <D.31307>:
        // predicted unlikely by continue predictor.
        goto <D.26777>;
        <D.31308>:
        <D.31266>:
        nfields = nfields + 1;
        <D.26777>:
        f = mono_class_get_fields (klass, &iter);
        if (f != 0B) goto <D.26787>; else goto <D.26788>;
        <D.26788>:
        nfields.274 = (unsigned int) nfields;
        buffer_add_int (buf, nfields.274);
        iter = 0B;
        goto <D.26789>;
        <D.26799>:
        D.31258 = f->type;
        D.31259 = D.31258->attrs;
        D.31260 = (int) D.31259;
        D.31261 = D.31260 & 16;
        if (D.31261 != 0) goto <D.31310>; else goto <D.31311>;
        <D.31310>:
        // predicted unlikely by continue predictor.
        goto <D.26789>;
        <D.31311>:
        D.31258 = f->type;
        D.31259 = D.31258->attrs;
        D.31260 = (int) D.31259;
        D.31264 = D.31260 & 1536;
        if (D.31264 != 0) goto <D.31312>; else goto <D.31313>;
        <D.31312>:
        {
          size_t __s1_len;
          size_t __s2_len;

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

            __s2 = mono_field_get_name (f);
            D.31270 = "_Deleted";
            D.31271 = MEM[(const unsigned char *)D.31270];
            D.31272 = (int) D.31271;
            D.31317 = *__s2;
            D.31318 = (int) D.31317;
            __result = D.31272 - D.31318;
            {
              if (__s2_len != 0) goto <D.31319>; else goto <D.31320>;
              <D.31319>:
              if (__result == 0) goto <D.31321>; else goto <D.31322>;
              <D.31321>:
              D.31279 = &MEM[(void *)"_Deleted" + 1B];
              D.31280 = *D.31279;
              D.31281 = (int) D.31280;
              D.31323 = __s2 + 1;
              D.31324 = *D.31323;
              D.31325 = (int) D.31324;
              __result = D.31281 - D.31325;
              if (__s2_len > 1) goto <D.31326>; else goto <D.31327>;
              <D.31326>:
              if (__result == 0) goto <D.31328>; else goto <D.31329>;
              <D.31328>:
              D.31289 = &MEM[(void *)"_Deleted" + 2B];
              D.31290 = *D.31289;
              D.31291 = (int) D.31290;
              D.31330 = __s2 + 2;
              D.31331 = *D.31330;
              D.31332 = (int) D.31331;
              __result = D.31291 - D.31332;
              if (__s2_len > 2) goto <D.31333>; else goto <D.31334>;
              <D.31333>:
              if (__result == 0) goto <D.31335>; else goto <D.31336>;
              <D.31335>:
              D.31299 = &MEM[(void *)"_Deleted" + 3B];
              D.31300 = *D.31299;
              D.31301 = (int) D.31300;
              D.31337 = __s2 + 3;
              D.31338 = *D.31337;
              D.31339 = (int) D.31338;
              __result = D.31301 - D.31339;
              <D.31336>:
              <D.31334>:
              <D.31329>:
              <D.31327>:
              <D.31322>:
              <D.31320>:
            }
            D.26797 = __result;
          }
          iftmp.275 = -D.26797;
          goto <D.31340>;
          <D.31316>:
          D.31341 = mono_field_get_name (f);
          iftmp.275 = __builtin_strcmp (D.31341, "_Deleted");
          <D.31340>:
          D.26798 = iftmp.275;
        }
        if (D.26798 == 0) goto <D.31342>; else goto <D.31343>;
        <D.31342>:
        // predicted unlikely by continue predictor.
        goto <D.26789>;
        <D.31343>:
        <D.31313>:
        D.31258 = f->type;
        D.31344 = f->offset;
        D.31345 = (sizetype) D.31344;
        D.31346 = D.31345 + 18446744073709551600;
        D.31347 = addr + D.31346;
        buffer_add_value_full (buf, D.31258, D.31347, domain, 0);
        <D.26789>:
        f = mono_class_get_fields (klass, &iter);
        if (f != 0B) goto <D.26799>; else goto <D.26800>;
        <D.26800>:
        goto <D.26749>;
      }
    finally
      {
        iter = {CLOBBER};
      }
  }
  <D.26801>:
  D.31348 = mono_type_generic_inst_is_valuetype (t);
  if (D.31348 != 0) goto handle_vtype; else goto handle_ref;
  <D.26802>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "debugger-agent.c", 5645);
  <D.26749>:
}


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

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


collect_interfaces (struct MonoClass * klass, struct GHashTable * ifaces, struct MonoError * error)
{
  int D.31354;
  struct MonoClass * * D.31357;
  long unsigned int D.31358;
  long unsigned int D.31359;
  struct MonoClass * * D.31360;
  int D.31361;
  short unsigned int D.31364;
  int D.31365;
  int i;
  struct MonoClass * ic;

  mono_class_setup_interfaces (klass, error);
  D.31354 = mono_error_ok (error);
  if (D.31354 == 0) goto <D.31355>; else goto <D.31356>;
  <D.31355>:
  return;
  <D.31356>:
  i = 0;
  goto <D.27405>;
  <D.27404>:
  D.31357 = klass->interfaces;
  D.31358 = (long unsigned int) i;
  D.31359 = D.31358 * 8;
  D.31360 = D.31357 + D.31359;
  ic = *D.31360;
  monoeg_g_hash_table_insert_replace (ifaces, ic, ic, 0);
  collect_interfaces (ic, ifaces, error);
  D.31361 = mono_error_ok (error);
  if (D.31361 == 0) goto <D.31362>; else goto <D.31363>;
  <D.31362>:
  return;
  <D.31363>:
  i = i + 1;
  <D.27405>:
  D.31364 = klass->interface_count;
  D.31365 = (int) D.31364;
  if (D.31365 > i) goto <D.27404>; else goto <D.27406>;
  <D.27406>:
}


method_commands (int command, guint8 * p, guint8 * end, struct Buffer * buf)
{
  guint8 * p.276;
  int err.277;
  ErrorCode D.31371;
  struct MonoDomain * domain.278;
  <unnamed type> D.31373;
  int err.279;
  int err;
  struct MonoDomain * old_domain;
  struct MonoDomain * domain;
  struct MonoMethod * method;

  try
    {
      p.276 = p;
      method = decode_methodid (p.276, &p, end, &domain, &err);
      err.277 = err;
      if (err.277 != 0) goto <D.31369>; else goto <D.31370>;
      <D.31369>:
      err.277 = err;
      D.31371 = (ErrorCode) err.277;
      return D.31371;
      <D.31370>:
      old_domain = mono_domain_get ();
      domain.278 = domain;
      mono_domain_set (domain.278, 1);
      domain.278 = domain;
      p.276 = p;
      D.31373 = method_commands_internal (command, method, domain.278, p.276, end, buf);
      err.279 = (int) D.31373;
      err = err.279;
      mono_domain_set (old_domain, 1);
      err.277 = err;
      D.31371 = (ErrorCode) err.277;
      return D.31371;
    }
  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.31377;
  struct MonoClass * D.31378;
  unsigned int D.31383;
  int protocol_version_set.280;
  int major_version.281;
  int minor_version.282;
  struct GPtrArray * source_file_list.283;
  unsigned int D.31394;
  void * * D.31395;
  long unsigned int D.31396;
  long unsigned int D.31397;
  void * * D.31398;
  char * D.31399;
  guint8 * D.31405;
  sizetype D.31406;
  guint8 * D.31407;
  unsigned char D.31408;
  unsigned int i.284;
  char * source_file.285;
  int n_il_offsets.286;
  unsigned int n_il_offsets.287;
  int log_level.288;
  _Bool D.31414;
  long int D.31415;
  long int D.31416;
  struct FILE * log_file.289;
  char * D.31420;
  int * source_files.290;
  long unsigned int D.31422;
  int * D.31423;
  int D.31424;
  long unsigned int D.31427;
  long unsigned int D.31428;
  void * * D.31429;
  int * il_offsets.291;
  int * D.31433;
  int D.31434;
  int * line_numbers.292;
  int * D.31436;
  int D.31437;
  int iftmp.293;
  int * column_numbers.294;
  int * D.31442;
  unsigned int D.31444;
  unsigned int D.31445;
  unsigned int D.31452;
  guint32 iftmp.295;
  int D.31462;
  <unnamed-unsigned:6> D.31464;
  unsigned int D.31465;
  short unsigned int D.31466;
  unsigned int D.31467;
  short unsigned int D.31468;
  unsigned int D.31469;
  struct MonoType * D.31470;
  struct MonoClass * D.31471;
  struct MonoType * D.31472;
  struct MonoClass * D.31473;
  long unsigned int D.31474;
  long unsigned int D.31475;
  long unsigned int D.31476;
  long unsigned int D.31477;
  char * * D.31478;
  char * D.31479;
  ErrorCode D.31482;
  short unsigned int D.31483;
  unsigned int D.31484;
  struct MonoType * D.31485;
  struct MonoClass * D.31486;
  int D.31487;
  struct MonoDebugLocalVar * D.31491;
  long unsigned int D.31492;
  long unsigned int D.31493;
  struct MonoDebugLocalVar * D.31494;
  int D.31495;
  char * D.31499;
  struct MonoDebugCodeBlock * D.31505;
  int D.31507;
  unsigned int D.31508;
  int D.31509;
  unsigned int D.31510;
  short unsigned int D.31513;
  unsigned int D.31514;
  short unsigned int D.31515;
  unsigned int D.31516;
  unsigned int D.31517;
  long unsigned int D.31524;
  long unsigned int D.31525;
  struct MonoMethodSignature * D.31528;
  short unsigned int D.31529;
  long unsigned int D.31532;
  struct MonoGenericInst * D.31538;
  struct MonoGenericContext * D.31541;
  struct MonoGenericContext * D.31544;
  struct MonoMethodSignature * D.31552;
  short unsigned int D.31553;
  long unsigned int D.31556;
  struct MonoGenericContext * D.31559;
  <unnamed-unsigned:22> D.31562;
  unsigned int count.296;
  struct MonoType * D.31564;
  struct MonoClass * D.31565;
  struct MonoMethodSignature * D.31570;
  short unsigned int D.31571;
  struct MonoGenericParamFull * D.31572;
  long unsigned int D.31573;
  long unsigned int D.31574;
  struct MonoImage * D.31575;
  const unsigned char * D.31587;
  sizetype D.31588;
  const unsigned char * D.31589;
  unsigned char D.31590;
  unsigned int i.297;
  <unnamed-unsigned:15> D.31597;
  unsigned int D.31598;
  struct MonoExceptionClause * D.31599;
  long unsigned int D.31600;
  long unsigned int D.31601;
  unsigned int D.31602;
  unsigned int D.31603;
  unsigned int D.31604;
  unsigned int D.31605;
  unsigned int D.31606;
  struct MonoClass * D.31609;
  unsigned int D.31613;
  int D.31614;
  guint8 * p.298;
  int D.31616;
  unsigned int D.31617;
  unsigned int D.31618;
  _Bool D.31619;
  long int D.31620;
  long int D.31621;
  long unsigned int D.31624;
  unsigned int D.31627;
  void * handle_class.299;
  struct MonoClass * handle_class.300;
  _Bool D.31633;
  long int D.31634;
  long int D.31635;
  struct MonoClass * D.31638;
  struct MonoClass * D.31644;
  struct MonoClass * D.31646;
  struct MonoClass * D.31650;
  struct MonoClass * D.31654;
  int err.301;
  long unsigned int D.31661;
  long unsigned int D.31662;
  struct MonoDomain * d.302;
  long unsigned int D.31668;
  long unsigned int D.31669;
  struct MonoType * * D.31670;
  struct MonoType * D.31671;
  struct MonoGenericInst * iftmp.303;
  struct MonoGenericClass * D.31673;
  int D.31677;
  struct MonoMethodHeader * header;
  int err;

  try
    {
      switch (command) <default: <D.27695>, case 1: <D.27588>, case 2: <D.27590>, case 3: <D.27591>, case 4: <D.27614>, case 5: <D.27624>, case 6: <D.27644>, case 7: <D.27661>, case 8: <D.27670>, case 9: <D.27680>, case 10: <D.27683>>
      <D.27588>:
      D.31377 = method->name;
      buffer_add_string (buf, D.31377);
      goto <D.27589>;
      <D.27590>:
      D.31378 = method->klass;
      buffer_add_typeid (buf, domain, D.31378);
      goto <D.27589>;
      <D.27591>:
      {
        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.31379>; else goto <D.31380>;
            <D.31379>:
            buffer_add_int (buf, 0);
            buffer_add_string (buf, "");
            buffer_add_int (buf, 0);
            goto <D.27589>;
            <D.31380>:
            minfo = mono_debug_lookup_method (method);
            if (minfo == 0B) goto <D.31381>; else goto <D.31382>;
            <D.31381>:
            D.31383 = header->code_size;
            buffer_add_int (buf, D.31383);
            buffer_add_string (buf, "");
            buffer_add_int (buf, 0);
            mono_metadata_free_mh (header);
            goto <D.27589>;
            <D.31382>:
            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.31383 = header->code_size;
            buffer_add_int (buf, D.31383);
            protocol_version_set.280 = protocol_version_set;
            if (protocol_version_set.280 != 0) goto <D.31388>; else goto <D.31384>;
            <D.31388>:
            major_version.281 = major_version;
            if (major_version.281 > 2) goto <D.31385>; else goto <D.31390>;
            <D.31390>:
            major_version.281 = major_version;
            if (major_version.281 == 2) goto <D.31391>; else goto <D.31384>;
            <D.31391>:
            minor_version.282 = minor_version;
            if (minor_version.282 > 12) goto <D.31385>; else goto <D.31384>;
            <D.31385>:
            source_file_list.283 = source_file_list;
            D.31394 = source_file_list.283->len;
            buffer_add_int (buf, D.31394);
            i = 0;
            goto <D.27607>;
            <D.27606>:
            {
              struct MonoDebugSourceInfo * sinfo;

              source_file_list.283 = source_file_list;
              D.31395 = source_file_list.283->pdata;
              D.31396 = (long unsigned int) i;
              D.31397 = D.31396 * 8;
              D.31398 = D.31395 + D.31397;
              sinfo = *D.31398;
              D.31399 = sinfo->source_file;
              buffer_add_string (buf, D.31399);
              protocol_version_set.280 = protocol_version_set;
              if (protocol_version_set.280 != 0) goto <D.31401>; else goto <D.31402>;
              <D.31401>:
              major_version.281 = major_version;
              if (major_version.281 > 2) goto <D.31400>; else goto <D.31403>;
              <D.31403>:
              major_version.281 = major_version;
              if (major_version.281 == 2) goto <D.31404>; else goto <D.27605>;
              <D.31404>:
              minor_version.282 = minor_version;
              if (minor_version.282 > 13) goto <D.31400>; else goto <D.27605>;
              <D.31400>:
              j = 0;
              goto <D.27604>;
              <D.27603>:
              D.31405 = sinfo->hash;
              D.31406 = (sizetype) j;
              D.31407 = D.31405 + D.31406;
              D.31408 = *D.31407;
              buffer_add_byte (buf, D.31408);
              j = j + 1;
              <D.27604>:
              if (j <= 15) goto <D.27603>; else goto <D.27605>;
              <D.27605>:
              <D.31402>:
            }
            i = i + 1;
            <D.27607>:
            i.284 = (unsigned int) i;
            source_file_list.283 = source_file_list;
            D.31394 = source_file_list.283->len;
            if (i.284 < D.31394) goto <D.27606>; else goto <D.27608>;
            <D.27608>:
            goto <D.31386>;
            <D.31384>:
            source_file.285 = source_file;
            buffer_add_string (buf, source_file.285);
            <D.31386>:
            n_il_offsets.286 = n_il_offsets;
            n_il_offsets.287 = (unsigned int) n_il_offsets.286;
            buffer_add_int (buf, n_il_offsets.287);
            log_level.288 = log_level;
            D.31414 = log_level.288 > 9;
            D.31415 = (long int) D.31414;
            D.31416 = __builtin_expect (D.31415, 0);
            if (D.31416 != 0) goto <D.31417>; else goto <D.31418>;
            <D.31417>:
            log_file.289 = log_file;
            D.31420 = mono_method_full_name (method, 1);
            fprintf (log_file.289, "Line number table for method %s:\n", D.31420);
            log_file.289 = log_file;
            fflush (log_file.289);
            <D.31418>:
            i = 0;
            goto <D.27612>;
            <D.27611>:
            {
              const char * srcfile;

              srcfile = "";
              source_files.290 = source_files;
              D.31396 = (long unsigned int) i;
              D.31422 = D.31396 * 4;
              D.31423 = source_files.290 + D.31422;
              D.31424 = *D.31423;
              if (D.31424 != -1) goto <D.31425>; else goto <D.31426>;
              <D.31425>:
              {
                struct MonoDebugSourceInfo * sinfo;

                source_file_list.283 = source_file_list;
                D.31395 = source_file_list.283->pdata;
                source_files.290 = source_files;
                D.31396 = (long unsigned int) i;
                D.31422 = D.31396 * 4;
                D.31423 = source_files.290 + D.31422;
                D.31424 = *D.31423;
                D.31427 = (long unsigned int) D.31424;
                D.31428 = D.31427 * 8;
                D.31429 = D.31395 + D.31428;
                sinfo = *D.31429;
                srcfile = sinfo->source_file;
              }
              <D.31426>:
              log_level.288 = log_level;
              D.31414 = log_level.288 > 9;
              D.31415 = (long int) D.31414;
              D.31416 = __builtin_expect (D.31415, 0);
              if (D.31416 != 0) goto <D.31430>; else goto <D.31431>;
              <D.31430>:
              log_file.289 = log_file;
              il_offsets.291 = il_offsets;
              D.31396 = (long unsigned int) i;
              D.31422 = D.31396 * 4;
              D.31433 = il_offsets.291 + D.31422;
              D.31434 = *D.31433;
              line_numbers.292 = line_numbers;
              D.31396 = (long unsigned int) i;
              D.31422 = D.31396 * 4;
              D.31436 = line_numbers.292 + D.31422;
              D.31437 = *D.31436;
              column_numbers.294 = column_numbers;
              if (column_numbers.294 != 0B) goto <D.31440>; else goto <D.31441>;
              <D.31440>:
              column_numbers.294 = column_numbers;
              D.31396 = (long unsigned int) i;
              D.31422 = D.31396 * 4;
              D.31442 = column_numbers.294 + D.31422;
              iftmp.293 = *D.31442;
              goto <D.31443>;
              <D.31441>:
              iftmp.293 = -1;
              <D.31443>:
              fprintf (log_file.289, "IL%x -> %s:%d %d\n", D.31434, srcfile, D.31437, iftmp.293);
              log_file.289 = log_file;
              fflush (log_file.289);
              <D.31431>:
              il_offsets.291 = il_offsets;
              D.31396 = (long unsigned int) i;
              D.31422 = D.31396 * 4;
              D.31433 = il_offsets.291 + D.31422;
              D.31434 = *D.31433;
              D.31444 = (unsigned int) D.31434;
              buffer_add_int (buf, D.31444);
              line_numbers.292 = line_numbers;
              D.31396 = (long unsigned int) i;
              D.31422 = D.31396 * 4;
              D.31436 = line_numbers.292 + D.31422;
              D.31437 = *D.31436;
              D.31445 = (unsigned int) D.31437;
              buffer_add_int (buf, D.31445);
              protocol_version_set.280 = protocol_version_set;
              if (protocol_version_set.280 != 0) goto <D.31448>; else goto <D.31449>;
              <D.31448>:
              major_version.281 = major_version;
              if (major_version.281 > 2) goto <D.31446>; else goto <D.31450>;
              <D.31450>:
              major_version.281 = major_version;
              if (major_version.281 == 2) goto <D.31451>; else goto <D.31447>;
              <D.31451>:
              minor_version.282 = minor_version;
              if (minor_version.282 > 12) goto <D.31446>; else goto <D.31447>;
              <D.31446>:
              source_files.290 = source_files;
              D.31396 = (long unsigned int) i;
              D.31422 = D.31396 * 4;
              D.31423 = source_files.290 + D.31422;
              D.31424 = *D.31423;
              D.31452 = (unsigned int) D.31424;
              buffer_add_int (buf, D.31452);
              <D.31447>:
              <D.31449>:
              protocol_version_set.280 = protocol_version_set;
              if (protocol_version_set.280 != 0) goto <D.31455>; else goto <D.31456>;
              <D.31455>:
              major_version.281 = major_version;
              if (major_version.281 > 2) goto <D.31453>; else goto <D.31457>;
              <D.31457>:
              major_version.281 = major_version;
              if (major_version.281 == 2) goto <D.31458>; else goto <D.31454>;
              <D.31458>:
              minor_version.282 = minor_version;
              if (minor_version.282 > 18) goto <D.31453>; else goto <D.31454>;
              <D.31453>:
              column_numbers.294 = column_numbers;
              if (column_numbers.294 != 0B) goto <D.31460>; else goto <D.31461>;
              <D.31460>:
              column_numbers.294 = column_numbers;
              D.31396 = (long unsigned int) i;
              D.31422 = D.31396 * 4;
              D.31442 = column_numbers.294 + D.31422;
              D.31462 = *D.31442;
              iftmp.295 = (guint32) D.31462;
              goto <D.31463>;
              <D.31461>:
              iftmp.295 = 4294967295;
              <D.31463>:
              buffer_add_int (buf, iftmp.295);
              <D.31454>:
              <D.31456>:
            }
            i = i + 1;
            <D.27612>:
            n_il_offsets.286 = n_il_offsets;
            if (i < n_il_offsets.286) goto <D.27611>; else goto <D.27613>;
            <D.27613>:
            source_file.285 = source_file;
            monoeg_g_free (source_file.285);
            il_offsets.291 = il_offsets;
            monoeg_g_free (il_offsets.291);
            line_numbers.292 = line_numbers;
            monoeg_g_free (line_numbers.292);
            source_files.290 = source_files;
            monoeg_g_free (source_files.290);
            source_file_list.283 = source_file_list;
            monoeg_g_ptr_array_free (source_file_list.283, 1);
            mono_metadata_free_mh (header);
            goto <D.27589>;
          }
        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.27614>:
      {
        struct MonoMethodSignature * sig;
        guint32 i;
        char * * names;

        sig = mono_method_signature (method);
        D.31464 = sig->call_convention;
        D.31465 = (unsigned int) D.31464;
        buffer_add_int (buf, D.31465);
        D.31466 = sig->param_count;
        D.31467 = (unsigned int) D.31466;
        buffer_add_int (buf, D.31467);
        D.31468 = sig->generic_param_count;
        D.31469 = (unsigned int) D.31468;
        buffer_add_int (buf, D.31469);
        D.31470 = sig->ret;
        D.31471 = mono_class_from_mono_type (D.31470);
        buffer_add_typeid (buf, domain, D.31471);
        i = 0;
        goto <D.27619>;
        <D.27618>:
        D.31472 = sig->params[i];
        D.31473 = mono_class_from_mono_type (D.31472);
        buffer_add_typeid (buf, domain, D.31473);
        i = i + 1;
        <D.27619>:
        D.31466 = sig->param_count;
        D.31467 = (unsigned int) D.31466;
        if (D.31467 > i) goto <D.27618>; else goto <D.27620>;
        <D.27620>:
        D.31466 = sig->param_count;
        D.31474 = (long unsigned int) D.31466;
        D.31475 = D.31474 * 8;
        names = monoeg_malloc (D.31475);
        mono_method_get_param_names (method, names);
        i = 0;
        goto <D.27622>;
        <D.27621>:
        D.31476 = (long unsigned int) i;
        D.31477 = D.31476 * 8;
        D.31478 = names + D.31477;
        D.31479 = *D.31478;
        buffer_add_string (buf, D.31479);
        i = i + 1;
        <D.27622>:
        D.31466 = sig->param_count;
        D.31467 = (unsigned int) D.31466;
        if (D.31467 > i) goto <D.27621>; else goto <D.27623>;
        <D.27623>:
        monoeg_g_free (names);
        goto <D.27589>;
      }
      <D.27624>:
      {
        int i;
        int j;
        int num_locals;
        struct MonoDebugLocalsInfo * locals;

        header = mono_method_get_header (method);
        if (header == 0B) goto <D.31480>; else goto <D.31481>;
        <D.31480>:
        D.31482 = 102;
        return D.31482;
        <D.31481>:
        D.31483 = header->num_locals;
        D.31484 = (unsigned int) D.31483;
        buffer_add_int (buf, D.31484);
        i = 0;
        goto <D.27630>;
        <D.27629>:
        D.31485 = header->locals[i];
        D.31486 = mono_class_from_mono_type (D.31485);
        buffer_add_typeid (buf, domain, D.31486);
        i = i + 1;
        <D.27630>:
        D.31483 = header->num_locals;
        D.31487 = (int) D.31483;
        if (D.31487 > i) goto <D.27629>; else goto <D.27631>;
        <D.27631>:
        locals = mono_debug_lookup_locals (method);
        if (locals != 0B) goto <D.31488>; else goto <D.31489>;
        <D.31488>:
        num_locals = locals->num_locals;
        goto <D.31490>;
        <D.31489>:
        num_locals = 0;
        <D.31490>:
        i = 0;
        goto <D.27636>;
        <D.27635>:
        j = 0;
        goto <D.27634>;
        <D.27633>:
        D.31491 = locals->locals;
        D.31492 = (long unsigned int) j;
        D.31493 = D.31492 * 24;
        D.31494 = D.31491 + D.31493;
        D.31495 = D.31494->index;
        if (D.31495 == i) goto <D.27632>; else goto <D.31496>;
        <D.31496>:
        j = j + 1;
        <D.27634>:
        if (j < num_locals) goto <D.27633>; else goto <D.27632>;
        <D.27632>:
        if (j < num_locals) goto <D.31497>; else goto <D.31498>;
        <D.31497>:
        D.31491 = locals->locals;
        D.31492 = (long unsigned int) j;
        D.31493 = D.31492 * 24;
        D.31494 = D.31491 + D.31493;
        D.31499 = D.31494->name;
        buffer_add_string (buf, D.31499);
        goto <D.31500>;
        <D.31498>:
        buffer_add_string (buf, "");
        <D.31500>:
        i = i + 1;
        <D.27636>:
        D.31483 = header->num_locals;
        D.31487 = (int) D.31483;
        if (D.31487 > i) goto <D.27635>; else goto <D.27637>;
        <D.27637>:
        i = 0;
        goto <D.27642>;
        <D.27641>:
        j = 0;
        goto <D.27640>;
        <D.27639>:
        D.31491 = locals->locals;
        D.31492 = (long unsigned int) j;
        D.31493 = D.31492 * 24;
        D.31494 = D.31491 + D.31493;
        D.31495 = D.31494->index;
        if (D.31495 == i) goto <D.27638>; else goto <D.31501>;
        <D.31501>:
        j = j + 1;
        <D.27640>:
        if (j < num_locals) goto <D.27639>; else goto <D.27638>;
        <D.27638>:
        if (j < num_locals) goto <D.31504>; else goto <D.31502>;
        <D.31504>:
        D.31491 = locals->locals;
        D.31492 = (long unsigned int) j;
        D.31493 = D.31492 * 24;
        D.31494 = D.31491 + D.31493;
        D.31505 = D.31494->block;
        if (D.31505 != 0B) goto <D.31506>; else goto <D.31502>;
        <D.31506>:
        D.31491 = locals->locals;
        D.31492 = (long unsigned int) j;
        D.31493 = D.31492 * 24;
        D.31494 = D.31491 + D.31493;
        D.31505 = D.31494->block;
        D.31507 = D.31505->start_offset;
        D.31508 = (unsigned int) D.31507;
        buffer_add_int (buf, D.31508);
        D.31491 = locals->locals;
        D.31492 = (long unsigned int) j;
        D.31493 = D.31492 * 24;
        D.31494 = D.31491 + D.31493;
        D.31505 = D.31494->block;
        D.31509 = D.31505->end_offset;
        D.31510 = (unsigned int) D.31509;
        buffer_add_int (buf, D.31510);
        goto <D.31503>;
        <D.31502>:
        buffer_add_int (buf, 0);
        D.31383 = header->code_size;
        buffer_add_int (buf, D.31383);
        <D.31503>:
        i = i + 1;
        <D.27642>:
        D.31483 = header->num_locals;
        D.31487 = (int) D.31483;
        if (D.31487 > i) goto <D.27641>; else goto <D.27643>;
        <D.27643>:
        mono_metadata_free_mh (header);
        if (locals != 0B) goto <D.31511>; else goto <D.31512>;
        <D.31511>:
        mono_debug_symfile_free_locals (locals);
        <D.31512>:
        goto <D.27589>;
      }
      <D.27644>:
      D.31513 = method->flags;
      D.31514 = (unsigned int) D.31513;
      buffer_add_int (buf, D.31514);
      D.31515 = method->iflags;
      D.31516 = (unsigned int) D.31515;
      buffer_add_int (buf, D.31516);
      D.31517 = method->token;
      buffer_add_int (buf, D.31517);
      protocol_version_set.280 = protocol_version_set;
      if (protocol_version_set.280 != 0) goto <D.31520>; else goto <D.31521>;
      <D.31520>:
      major_version.281 = major_version;
      if (major_version.281 > 2) goto <D.31518>; else goto <D.31522>;
      <D.31522>:
      major_version.281 = major_version;
      if (major_version.281 == 2) goto <D.31523>; else goto <D.31519>;
      <D.31523>:
      minor_version.282 = minor_version;
      if (minor_version.282 > 11) goto <D.31518>; else goto <D.31519>;
      <D.31518>:
      {
        guint8 attrs;

        attrs = 0;
        D.31524 = BIT_FIELD_REF <*method, 64, 256>;
        D.31525 = D.31524 & 2048;
        if (D.31525 != 0) goto <D.31526>; else goto <D.31527>;
        <D.31526>:
        attrs = attrs | 1;
        <D.31527>:
        D.31528 = mono_method_signature (method);
        D.31529 = D.31528->generic_param_count;
        if (D.31529 != 0) goto <D.31530>; else goto <D.31531>;
        <D.31530>:
        attrs = attrs | 2;
        <D.31531>:
        buffer_add_byte (buf, attrs);
        D.31524 = BIT_FIELD_REF <*method, 64, 256>;
        D.31532 = D.31524 & 6144;
        if (D.31532 != 0) goto <D.31533>; else goto <D.31534>;
        <D.31533>:
        {
          struct MonoMethod * result;

          D.31524 = BIT_FIELD_REF <*method, 64, 256>;
          D.31525 = D.31524 & 2048;
          if (D.31525 != 0) goto <D.31535>; else goto <D.31536>;
          <D.31535>:
          result = method;
          goto <D.31537>;
          <D.31536>:
          {
            struct MonoMethodInflated * imethod;

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

              klass = MEM[(struct MonoMethod *)imethod].klass;
              D.31541 = mono_class_get_context (klass);
              if (D.31541 != 0B) goto <D.31542>; else goto <D.31543>;
              <D.31542>:
              D.31544 = mono_class_get_context (klass);
              result = mono_class_inflate_generic_method_full (result, klass, D.31544);
              <D.31543>:
            }
            <D.31540>:
          }
          <D.31537>:
          buffer_add_methodid (buf, domain, result);
        }
        goto <D.31545>;
        <D.31534>:
        buffer_add_id (buf, 0);
        <D.31545>:
        protocol_version_set.280 = protocol_version_set;
        if (protocol_version_set.280 != 0) goto <D.31548>; else goto <D.31549>;
        <D.31548>:
        major_version.281 = major_version;
        if (major_version.281 > 2) goto <D.31546>; else goto <D.31550>;
        <D.31550>:
        major_version.281 = major_version;
        if (major_version.281 == 2) goto <D.31551>; else goto <D.31547>;
        <D.31551>:
        minor_version.282 = minor_version;
        if (minor_version.282 > 14) goto <D.31546>; else goto <D.31547>;
        <D.31546>:
        D.31552 = mono_method_signature (method);
        D.31553 = D.31552->generic_param_count;
        if (D.31553 != 0) goto <D.31554>; else goto <D.31555>;
        <D.31554>:
        {
          int count;
          int i;

          D.31524 = BIT_FIELD_REF <*method, 64, 256>;
          D.31556 = D.31524 & 4096;
          if (D.31556 != 0) goto <D.31557>; else goto <D.31558>;
          <D.31557>:
          {
            struct MonoGenericInst * inst;

            D.31559 = mono_method_get_context (method);
            inst = D.31559->method_inst;
            if (inst != 0B) goto <D.31560>; else goto <D.31561>;
            <D.31560>:
            D.31562 = inst->type_argc;
            count = (int) D.31562;
            count.296 = (unsigned int) count;
            buffer_add_int (buf, count.296);
            i = 0;
            goto <D.27653>;
            <D.27652>:
            D.31564 = inst->type_argv[i];
            D.31565 = mono_class_from_mono_type (D.31564);
            buffer_add_typeid (buf, domain, D.31565);
            i = i + 1;
            <D.27653>:
            if (i < count) goto <D.27652>; else goto <D.27654>;
            <D.27654>:
            goto <D.31566>;
            <D.31561>:
            buffer_add_int (buf, 0);
            <D.31566>:
          }
          goto <D.31567>;
          <D.31558>:
          D.31524 = BIT_FIELD_REF <*method, 64, 256>;
          D.31525 = D.31524 & 2048;
          if (D.31525 != 0) goto <D.31568>; else goto <D.31569>;
          <D.31568>:
          {
            struct MonoGenericContainer * container;

            container = mono_method_get_generic_container (method);
            D.31570 = mono_method_signature (method);
            D.31571 = D.31570->generic_param_count;
            count = (int) D.31571;
            count.296 = (unsigned int) count;
            buffer_add_int (buf, count.296);
            i = 0;
            goto <D.27659>;
            <D.27658>:
            {
              struct MonoGenericParam * param;
              struct MonoClass * pklass;

              D.31572 = container->type_params;
              D.31573 = (long unsigned int) i;
              D.31574 = D.31573 * 56;
              param = D.31572 + D.31574;
              D.31378 = method->klass;
              D.31575 = D.31378->image;
              pklass = mono_class_from_generic_parameter (param, D.31575, 1);
              buffer_add_typeid (buf, domain, pklass);
            }
            i = i + 1;
            <D.27659>:
            if (i < count) goto <D.27658>; else goto <D.27660>;
            <D.27660>:
          }
          goto <D.31576>;
          <D.31569>:
          buffer_add_int (buf, 0);
          <D.31576>:
          <D.31567>:
        }
        goto <D.31577>;
        <D.31555>:
        buffer_add_int (buf, 0);
        <D.31577>:
        <D.31547>:
        <D.31549>:
      }
      <D.31519>:
      <D.31521>:
      goto <D.27589>;
      <D.27661>:
      {
        int i;

        header = mono_method_get_header (method);
        if (header == 0B) goto <D.31578>; else goto <D.31579>;
        <D.31578>:
        buffer_add_int (buf, 0);
        protocol_version_set.280 = protocol_version_set;
        if (protocol_version_set.280 != 0) goto <D.31582>; else goto <D.31583>;
        <D.31582>:
        major_version.281 = major_version;
        if (major_version.281 > 2) goto <D.31580>; else goto <D.31584>;
        <D.31584>:
        major_version.281 = major_version;
        if (major_version.281 == 2) goto <D.31585>; else goto <D.31581>;
        <D.31585>:
        minor_version.282 = minor_version;
        if (minor_version.282 > 17) goto <D.31580>; else goto <D.31581>;
        <D.31580>:
        buffer_add_int (buf, 0);
        <D.31581>:
        <D.31583>:
        goto <D.31586>;
        <D.31579>:
        D.31383 = header->code_size;
        buffer_add_int (buf, D.31383);
        i = 0;
        goto <D.27664>;
        <D.27663>:
        D.31587 = header->code;
        D.31588 = (sizetype) i;
        D.31589 = D.31587 + D.31588;
        D.31590 = *D.31589;
        buffer_add_byte (buf, D.31590);
        i = i + 1;
        <D.27664>:
        i.297 = (unsigned int) i;
        D.31383 = header->code_size;
        if (i.297 < D.31383) goto <D.27663>; else goto <D.27665>;
        <D.27665>:
        protocol_version_set.280 = protocol_version_set;
        if (protocol_version_set.280 != 0) goto <D.31593>; else goto <D.31594>;
        <D.31593>:
        major_version.281 = major_version;
        if (major_version.281 > 2) goto <D.31592>; else goto <D.31595>;
        <D.31595>:
        major_version.281 = major_version;
        if (major_version.281 == 2) goto <D.31596>; else goto <D.27669>;
        <D.31596>:
        minor_version.282 = minor_version;
        if (minor_version.282 > 17) goto <D.31592>; else goto <D.27669>;
        <D.31592>:
        D.31597 = header->num_clauses;
        D.31598 = (unsigned int) D.31597;
        buffer_add_int (buf, D.31598);
        i = 0;
        goto <D.27668>;
        <D.27667>:
        {
          struct MonoExceptionClause * clause;

          D.31599 = header->clauses;
          D.31600 = (long unsigned int) i;
          D.31601 = D.31600 * 32;
          clause = D.31599 + D.31601;
          D.31602 = clause->flags;
          buffer_add_int (buf, D.31602);
          D.31603 = clause->try_offset;
          buffer_add_int (buf, D.31603);
          D.31604 = clause->try_len;
          buffer_add_int (buf, D.31604);
          D.31605 = clause->handler_offset;
          buffer_add_int (buf, D.31605);
          D.31606 = clause->handler_len;
          buffer_add_int (buf, D.31606);
          D.31602 = clause->flags;
          if (D.31602 == 0) goto <D.31607>; else goto <D.31608>;
          <D.31607>:
          D.31609 = clause->data.catch_class;
          buffer_add_typeid (buf, domain, D.31609);
          goto <D.31610>;
          <D.31608>:
          D.31602 = clause->flags;
          if (D.31602 == 1) goto <D.31611>; else goto <D.31612>;
          <D.31611>:
          D.31613 = clause->data.filter_offset;
          buffer_add_int (buf, D.31613);
          <D.31612>:
          <D.31610>:
        }
        i = i + 1;
        <D.27668>:
        D.31597 = header->num_clauses;
        D.31614 = (int) D.31597;
        if (D.31614 > i) goto <D.27667>; else goto <D.27669>;
        <D.27669>:
        <D.31594>:
        mono_metadata_free_mh (header);
        <D.31586>:
        goto <D.27589>;
      }
      <D.27670>:
      {
        guint32 token;

        p.298 = p;
        D.31616 = decode_int (p.298, &p, end);
        token = (guint32) D.31616;
        D.31617 = token & 4278190080;
        switch (D.31617) <default: <D.27676>, case 1879048192: <D.27672>>
        <D.27672>:
        {
          struct MonoString * s;
          char * s2;

          D.31378 = method->klass;
          D.31575 = D.31378->image;
          D.31618 = token & 16777215;
          s = mono_ldstr (domain, D.31575, D.31618);
          D.31619 = s == 0B;
          D.31620 = (long int) D.31619;
          D.31621 = __builtin_expect (D.31620, 0);
          if (D.31621 != 0) goto <D.31622>; else goto <D.31623>;
          <D.31622>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 8237, "s");
          <D.31623>:
          s2 = mono_string_to_utf8 (s);
          buffer_add_byte (buf, 0);
          buffer_add_string (buf, s2);
          monoeg_g_free (s2);
          goto <D.27675>;
        }
        <D.27676>:
        {
          void * val;
          struct MonoClass * handle_class;

          try
            {
              D.31524 = BIT_FIELD_REF <*method, 64, 256>;
              D.31624 = D.31524 & 124;
              if (D.31624 == 68) goto <D.31625>; else goto <D.31626>;
              <D.31625>:
              val = mono_method_get_wrapper_data (method, token);
              D.31627 = token + 1;
              handle_class.299 = mono_method_get_wrapper_data (method, D.31627);
              handle_class = handle_class.299;
              handle_class.300 = handle_class;
              if (handle_class.300 == 0B) goto <D.31630>; else goto <D.31631>;
              <D.31630>:
              buffer_add_byte (buf, 4);
              goto <D.27675>;
              <D.31631>:
              goto <D.31632>;
              <D.31626>:
              D.31378 = method->klass;
              D.31575 = D.31378->image;
              val = mono_ldtoken (D.31575, token, &handle_class, 0B);
              D.31633 = val == 0B;
              D.31634 = (long int) D.31633;
              D.31635 = __builtin_expect (D.31634, 0);
              if (D.31635 != 0) goto <D.31636>; else goto <D.31637>;
              <D.31636>:
              monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 8261, "val");
              <D.31637>:
              <D.31632>:
              D.31638 = mono_defaults.typehandle_class;
              handle_class.300 = handle_class;
              if (D.31638 == handle_class.300) goto <D.31639>; else goto <D.31640>;
              <D.31639>:
              buffer_add_byte (buf, 1);
              D.31524 = BIT_FIELD_REF <*method, 64, 256>;
              D.31624 = D.31524 & 124;
              if (D.31624 == 68) goto <D.31641>; else goto <D.31642>;
              <D.31641>:
              buffer_add_typeid (buf, domain, val);
              goto <D.31643>;
              <D.31642>:
              D.31644 = mono_class_from_mono_type (val);
              buffer_add_typeid (buf, domain, D.31644);
              <D.31643>:
              goto <D.31645>;
              <D.31640>:
              D.31646 = mono_defaults.fieldhandle_class;
              handle_class.300 = handle_class;
              if (D.31646 == handle_class.300) goto <D.31647>; else goto <D.31648>;
              <D.31647>:
              buffer_add_byte (buf, 2);
              buffer_add_fieldid (buf, domain, val);
              goto <D.31649>;
              <D.31648>:
              D.31650 = mono_defaults.methodhandle_class;
              handle_class.300 = handle_class;
              if (D.31650 == handle_class.300) goto <D.31651>; else goto <D.31652>;
              <D.31651>:
              buffer_add_byte (buf, 3);
              buffer_add_methodid (buf, domain, val);
              goto <D.31653>;
              <D.31652>:
              D.31654 = mono_defaults.string_class;
              handle_class.300 = handle_class;
              if (D.31654 == handle_class.300) goto <D.31655>; else goto <D.31656>;
              <D.31655>:
              {
                char * s;

                s = mono_string_to_utf8 (val);
                buffer_add_byte (buf, 0);
                buffer_add_string (buf, s);
                monoeg_g_free (s);
              }
              goto <D.31657>;
              <D.31656>:
              monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "debugger-agent.c", 8284);
              <D.31657>:
              <D.31653>:
              <D.31649>:
              <D.31645>:
              goto <D.27675>;
            }
          finally
            {
              handle_class = {CLOBBER};
            }
        }
        <D.27675>:
        goto <D.27589>;
      }
      <D.27680>:
      {
        struct MonoClass * attr_klass;
        struct MonoCustomAttrInfo * cinfo;

        p.298 = p;
        attr_klass = decode_typeid (p.298, &p, end, 0B, &err);
        err.301 = err;
        if (err.301 != 0) goto <D.31659>; else goto <D.31660>;
        <D.31659>:
        err.301 = err;
        D.31482 = (ErrorCode) err.301;
        return D.31482;
        <D.31660>:
        cinfo = mono_custom_attrs_from_method (method);
        D.31378 = method->klass;
        D.31575 = D.31378->image;
        buffer_add_cattrs (buf, domain, D.31575, attr_klass, cinfo);
        goto <D.27589>;
      }
      <D.27683>:
      {
        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.298 = p;
            type_argc = decode_int (p.298, &p, end);
            D.31661 = (long unsigned int) type_argc;
            D.31662 = D.31661 * 8;
            type_argv = monoeg_malloc0 (D.31662);
            i = 0;
            goto <D.27693>;
            <D.27692>:
            p.298 = p;
            klass = decode_typeid (p.298, &p, end, &d, &err);
            err.301 = err;
            if (err.301 != 0) goto <D.31663>; else goto <D.31664>;
            <D.31663>:
            monoeg_g_free (type_argv);
            err.301 = err;
            D.31482 = (ErrorCode) err.301;
            return D.31482;
            <D.31664>:
            d.302 = d;
            if (domain != d.302) goto <D.31666>; else goto <D.31667>;
            <D.31666>:
            monoeg_g_free (type_argv);
            D.31482 = 102;
            return D.31482;
            <D.31667>:
            D.31668 = (long unsigned int) i;
            D.31669 = D.31668 * 8;
            D.31670 = type_argv + D.31669;
            D.31671 = &klass->byval_arg;
            *D.31670 = D.31671;
            i = i + 1;
            <D.27693>:
            if (i < type_argc) goto <D.27692>; else goto <D.27694>;
            <D.27694>:
            ginst = mono_metadata_get_generic_inst (type_argc, type_argv);
            monoeg_g_free (type_argv);
            D.31378 = method->klass;
            D.31673 = D.31378->generic_class;
            if (D.31673 != 0B) goto <D.31674>; else goto <D.31675>;
            <D.31674>:
            D.31378 = method->klass;
            D.31673 = D.31378->generic_class;
            iftmp.303 = D.31673->context.class_inst;
            goto <D.31676>;
            <D.31675>:
            iftmp.303 = 0B;
            <D.31676>:
            tmp_context.class_inst = iftmp.303;
            tmp_context.method_inst = ginst;
            inflated = mono_class_inflate_generic_method (method, &tmp_context);
            D.31677 = mono_verifier_is_method_valid_generic_instantiation (inflated);
            if (D.31677 == 0) goto <D.31678>; else goto <D.31679>;
            <D.31678>:
            D.31482 = 102;
            return D.31482;
            <D.31679>:
            buffer_add_methodid (buf, domain, inflated);
            goto <D.27589>;
          }
        finally
          {
            d = {CLOBBER};
            tmp_context = {CLOBBER};
          }
      }
      <D.27695>:
      D.31482 = 100;
      return D.31482;
      <D.27589>:
      D.31482 = 0;
      return D.31482;
    }
  finally
    {
      err = {CLOBBER};
    }
}


thread_commands (int command, guint8 * p, guint8 * end, struct Buffer * buf)
{
  guint8 * p.304;
  <unnamed type> D.31687;
  ErrorCode D.31690;
  struct MonoThread * thread_obj.305;
  unsigned int name_len.306;
  long int D.31696;
  _Bool D.31697;
  long int D.31698;
  long int D.31699;
  long int len.307;
  unsigned int D.31703;
  int D.31704;
  int suspend_count.308;
  int D.31708;
  struct MonoGHashTable * thread_to_tls.309;
  _Bool D.31713;
  long int D.31714;
  long int D.31715;
  int D.31718;
  unsigned int D.31719;
  struct StackFrame * * D.31720;
  long unsigned int D.31721;
  long unsigned int D.31722;
  struct StackFrame * * D.31723;
  struct StackFrame * D.31724;
  int D.31725;
  unsigned int D.31726;
  struct MonoDomain * D.31727;
  struct MonoMethod * D.31728;
  unsigned int D.31729;
  int D.31730;
  unsigned char D.31731;
  unsigned int D.31732;
  unsigned char D.31733;
  long unsigned int thread.310;
  long unsigned int D.31735;
  int objid;
  int err;
  struct MonoThread * thread_obj;
  struct MonoInternalThread * thread;

  try
    {
      p.304 = p;
      objid = decode_objid (p.304, &p, end);
      D.31687 = get_object (objid, &thread_obj);
      err = (int) D.31687;
      if (err != 0) goto <D.31688>; else goto <D.31689>;
      <D.31688>:
      D.31690 = (ErrorCode) err;
      return D.31690;
      <D.31689>:
      thread_obj.305 = thread_obj;
      thread = thread_obj.305->internal_thread;
      switch (command) <default: <D.27737>, case 1: <D.27722>, case 2: <D.27716>, case 3: <D.27733>, case 4: <D.27734>, case 5: <D.27735>, case 6: <D.27736>>
      <D.27716>:
      {
        guint32 name_len;
        gunichar2 * s;

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

              try
                {
                  name_len.306 = name_len;
                  D.31696 = (long int) name_len.306;
                  name = monoeg_g_utf16_to_utf8 (s, D.31696, 0B, &len, 0B);
                  D.31697 = name == 0B;
                  D.31698 = (long int) D.31697;
                  D.31699 = __builtin_expect (D.31698, 0);
                  if (D.31699 != 0) goto <D.31700>; else goto <D.31701>;
                  <D.31700>:
                  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 8395, "name");
                  <D.31701>:
                  len.307 = len;
                  D.31703 = (unsigned int) len.307;
                  buffer_add_int (buf, D.31703);
                  len.307 = len;
                  D.31704 = (int) len.307;
                  buffer_add_data (buf, name, D.31704);
                  monoeg_g_free (s);
                }
              finally
                {
                  len = {CLOBBER};
                }
            }
            <D.31694>:
            goto <D.27721>;
          }
        finally
          {
            name_len = {CLOBBER};
          }
      }
      <D.27722>:
      {
        struct DebuggerTlsData * tls;
        int i;
        int start_frame;
        int length;

        goto <D.27728>;
        <D.27727>:
        suspend_count.308 = suspend_count;
        if (suspend_count.308 != 0) goto <D.31706>; else goto <D.31707>;
        <D.31706>:
        wait_for_suspend ();
        <D.31707>:
        <D.27728>:
        D.31708 = is_suspended ();
        if (D.31708 == 0) goto <D.27727>; else goto <D.27729>;
        <D.27729>:
        p.304 = p;
        start_frame = decode_int (p.304, &p, end);
        p.304 = p;
        length = decode_int (p.304, &p, end);
        if (start_frame != 0) goto <D.31709>; else goto <D.31711>;
        <D.31711>:
        if (length != -1) goto <D.31709>; else goto <D.31710>;
        <D.31709>:
        D.31690 = 100;
        return D.31690;
        <D.31710>:
        mono_loader_lock ();
        thread_to_tls.309 = thread_to_tls;
        tls = mono_g_hash_table_lookup (thread_to_tls.309, thread);
        mono_loader_unlock ();
        D.31713 = tls == 0B;
        D.31714 = (long int) D.31713;
        D.31715 = __builtin_expect (D.31714, 0);
        if (D.31715 != 0) goto <D.31716>; else goto <D.31717>;
        <D.31716>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 8428, "tls");
        <D.31717>:
        compute_frame_info (thread, tls);
        D.31718 = tls->frame_count;
        D.31719 = (unsigned int) D.31718;
        buffer_add_int (buf, D.31719);
        i = 0;
        goto <D.27731>;
        <D.27730>:
        D.31720 = tls->frames;
        D.31721 = (long unsigned int) i;
        D.31722 = D.31721 * 8;
        D.31723 = D.31720 + D.31722;
        D.31724 = *D.31723;
        D.31725 = D.31724->id;
        D.31726 = (unsigned int) D.31725;
        buffer_add_int (buf, D.31726);
        D.31720 = tls->frames;
        D.31721 = (long unsigned int) i;
        D.31722 = D.31721 * 8;
        D.31723 = D.31720 + D.31722;
        D.31724 = *D.31723;
        D.31727 = D.31724->domain;
        D.31720 = tls->frames;
        D.31721 = (long unsigned int) i;
        D.31722 = D.31721 * 8;
        D.31723 = D.31720 + D.31722;
        D.31724 = *D.31723;
        D.31728 = D.31724->actual_method;
        buffer_add_methodid (buf, D.31727, D.31728);
        D.31720 = tls->frames;
        D.31721 = (long unsigned int) i;
        D.31722 = D.31721 * 8;
        D.31723 = D.31720 + D.31722;
        D.31724 = *D.31723;
        D.31729 = D.31724->il_offset;
        buffer_add_int (buf, D.31729);
        D.31720 = tls->frames;
        D.31721 = (long unsigned int) i;
        D.31722 = D.31721 * 8;
        D.31723 = D.31720 + D.31722;
        D.31724 = *D.31723;
        D.31730 = D.31724->flags;
        D.31731 = (unsigned char) D.31730;
        buffer_add_byte (buf, D.31731);
        i = i + 1;
        <D.27731>:
        D.31718 = tls->frame_count;
        if (D.31718 > i) goto <D.27730>; else goto <D.27732>;
        <D.27732>:
        goto <D.27721>;
      }
      <D.27733>:
      D.31732 = thread->state;
      buffer_add_int (buf, D.31732);
      goto <D.27721>;
      <D.27734>:
      D.31733 = thread->threadpool_thread;
      buffer_add_byte (buf, D.31733);
      goto <D.27721>;
      <D.27735>:
      thread.310 = (long unsigned int) thread;
      buffer_add_long (buf, thread.310);
      goto <D.27721>;
      <D.27736>:
      D.31735 = thread->tid;
      buffer_add_long (buf, D.31735);
      goto <D.27721>;
      <D.27737>:
      D.31690 = 100;
      return D.31690;
      <D.27721>:
      D.31690 = 0;
      return D.31690;
    }
  finally
    {
      thread_obj = {CLOBBER};
    }
}


frame_commands (int command, guint8 * p, guint8 * end, struct Buffer * buf)
{
  guint8 * p.311;
  <unnamed type> D.31741;
  ErrorCode D.31744;
  struct MonoThread * thread_obj.312;
  int D.31746;
  struct MonoGHashTable * thread_to_tls.313;
  _Bool D.31748;
  long int D.31749;
  long int D.31750;
  struct StackFrame * * D.31753;
  long unsigned int D.31754;
  long unsigned int D.31755;
  struct StackFrame * * D.31756;
  struct StackFrame * D.31757;
  int D.31758;
  long int D.31759;
  int D.31761;
  long unsigned int D.31764;
  long unsigned int D.31765;
  struct StackFrame * * D.31766;
  int D.31767;
  struct MonoDebugMethodJitInfo * D.31770;
  struct MonoMethod * D.31773;
  struct MonoDomain * D.31774;
  struct MonoDebugMethodJitInfo * D.31775;
  long unsigned int D.31778;
  long unsigned int D.31779;
  struct MonoMethod * D.31782;
  struct MonoDebugMethodJitInfo * D.31783;
  int log_level.314;
  _Bool D.31787;
  long int D.31788;
  long int D.31789;
  struct FILE * log_file.315;
  struct MonoMethod * D.31793;
  struct MonoSeqPointInfo * D.31794;
  int iftmp.316;
  unsigned int pos.317;
  unsigned int D.31805;
  _Bool D.31806;
  long int D.31807;
  long int D.31808;
  struct MonoDebugVarInfo * D.31811;
  long unsigned int D.31812;
  long unsigned int D.31813;
  struct MonoType * D.31814;
  struct MonoDebugVarInfo * D.31815;
  struct MonoContext * D.31816;
  int iftmp.318;
  unsigned int D.31823;
  _Bool D.31824;
  long int D.31825;
  long int D.31826;
  struct MonoDebugVarInfo * D.31829;
  struct MonoType * D.31830;
  struct MonoDebugVarInfo * D.31831;
  struct MonoClass * D.31832;
  long unsigned int D.31833;
  long unsigned int D.31834;
  long unsigned int D.31837;
  long unsigned int D.31838;
  struct MonoClass * D.31841;
  struct MonoType * D.31842;
  struct MonoClass * D.31844;
  struct MonoType * D.31845;
  struct MonoDebugVarInfo * D.31846;
  struct MonoType * D.31850;
  struct MonoType * D.31852;
  int iftmp.319;
  _Bool D.31860;
  long int D.31861;
  long int D.31862;
  int iftmp.320;
  _Bool D.31871;
  long int D.31872;
  long int D.31873;
  int D.31876;
  struct MonoClass * D.31880;
  int D.31881;
  long unsigned int D.31882;
  <unnamed type> D.31883;
  mgreg_t *[32] * D.31886;
  struct MonoContext * D.31887;
  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.311 = p;
      objid = decode_objid (p.311, &p, end);
      D.31741 = get_object (objid, &thread_obj);
      err = (int) D.31741;
      if (err != 0) goto <D.31742>; else goto <D.31743>;
      <D.31742>:
      D.31744 = (ErrorCode) err;
      return D.31744;
      <D.31743>:
      thread_obj.312 = thread_obj;
      thread = thread_obj.312->internal_thread;
      p.311 = p;
      D.31746 = decode_id (p.311, &p, end);
      id = (gssize) D.31746;
      mono_loader_lock ();
      thread_to_tls.313 = thread_to_tls;
      tls = mono_g_hash_table_lookup (thread_to_tls.313, thread);
      mono_loader_unlock ();
      D.31748 = tls == 0B;
      D.31749 = (long int) D.31748;
      D.31750 = __builtin_expect (D.31749, 0);
      if (D.31750 != 0) goto <D.31751>; else goto <D.31752>;
      <D.31751>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 8495, "tls");
      <D.31752>:
      i = 0;
      goto <D.27761>;
      <D.27760>:
      D.31753 = tls->frames;
      D.31754 = (long unsigned int) i;
      D.31755 = D.31754 * 8;
      D.31756 = D.31753 + D.31755;
      D.31757 = *D.31756;
      D.31758 = D.31757->id;
      D.31759 = (long int) D.31758;
      if (D.31759 == id) goto <D.27759>; else goto <D.31760>;
      <D.31760>:
      i = i + 1;
      <D.27761>:
      D.31761 = tls->frame_count;
      if (D.31761 > i) goto <D.27760>; else goto <D.27759>;
      <D.27759>:
      D.31761 = tls->frame_count;
      if (D.31761 == i) goto <D.31762>; else goto <D.31763>;
      <D.31762>:
      D.31744 = 30;
      return D.31744;
      <D.31763>:
      frame_idx = i;
      D.31753 = tls->frames;
      D.31764 = (long unsigned int) frame_idx;
      D.31765 = D.31764 * 8;
      D.31766 = D.31753 + D.31765;
      frame = *D.31766;
      D.31767 = frame->has_ctx;
      if (D.31767 == 0) goto <D.31768>; else goto <D.31769>;
      <D.31768>:
      D.31744 = 105;
      return D.31744;
      <D.31769>:
      D.31770 = frame->jit;
      if (D.31770 == 0B) goto <D.31771>; else goto <D.31772>;
      <D.31771>:
      D.31773 = frame->api_method;
      D.31774 = frame->domain;
      D.31775 = mono_debug_find_method (D.31773, D.31774);
      frame->jit = D.31775;
      D.31770 = frame->jit;
      if (D.31770 == 0B) goto <D.31776>; else goto <D.31777>;
      <D.31776>:
      D.31773 = frame->api_method;
      D.31778 = BIT_FIELD_REF <*D.31773, 64, 256>;
      D.31779 = D.31778 & 4096;
      if (D.31779 != 0) goto <D.31780>; else goto <D.31781>;
      <D.31780>:
      D.31773 = frame->api_method;
      D.31782 = mono_method_get_declaring_generic_method (D.31773);
      D.31774 = frame->domain;
      D.31783 = mono_debug_find_method (D.31782, D.31774);
      frame->jit = D.31783;
      <D.31781>:
      <D.31777>:
      D.31770 = frame->jit;
      if (D.31770 == 0B) goto <D.31784>; else goto <D.31785>;
      <D.31784>:
      {
        char * s;

        D.31773 = frame->api_method;
        s = mono_method_full_name (D.31773, 1);
        log_level.314 = log_level;
        D.31787 = log_level.314 > 0;
        D.31788 = (long int) D.31787;
        D.31789 = __builtin_expect (D.31788, 0);
        if (D.31789 != 0) goto <D.31790>; else goto <D.31791>;
        <D.31790>:
        log_file.315 = log_file;
        fprintf (log_file.315, "[dbg] No debug information found for \'%s\'.\n", s);
        log_file.315 = log_file;
        fflush (log_file.315);
        <D.31791>:
        monoeg_g_free (s);
        D.31744 = 105;
        return D.31744;
      }
      <D.31785>:
      <D.31772>:
      jit = frame->jit;
      D.31793 = frame->actual_method;
      sig = mono_method_signature (D.31793);
      D.31774 = frame->domain;
      D.31793 = frame->actual_method;
      D.31794 = get_seq_points (D.31774, D.31793);
      if (D.31794 == 0B) goto <D.31795>; else goto <D.31796>;
      <D.31795>:
      D.31744 = 105;
      return D.31744;
      <D.31796>:
      switch (command) <default: <D.27778>, case 1: <D.27763>, case 2: <D.27768>, case 3: <D.27771>>
      <D.27763>:
      p.311 = p;
      len = decode_int (p.311, &p, end);
      D.31793 = frame->actual_method;
      header = mono_method_get_header (D.31793);
      i = 0;
      goto <D.27765>;
      <D.27764>:
      p.311 = p;
      pos = decode_int (p.311, &p, end);
      if (pos < 0) goto <D.31797>; else goto <D.31798>;
      <D.31797>:
      pos = ~pos;
      if (pos < 0) goto <D.31800>; else goto <D.31803>;
      <D.31803>:
      pos.317 = (unsigned int) pos;
      D.31805 = jit->num_params;
      if (pos.317 >= D.31805) goto <D.31800>; else goto <D.31801>;
      <D.31800>:
      iftmp.316 = 1;
      goto <D.31802>;
      <D.31801>:
      iftmp.316 = 0;
      <D.31802>:
      D.31806 = iftmp.316 != 0;
      D.31807 = (long int) D.31806;
      D.31808 = __builtin_expect (D.31807, 0);
      if (D.31808 != 0) goto <D.31809>; else goto <D.31810>;
      <D.31809>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 8545, "pos >= 0 && pos < jit->num_params");
      <D.31810>:
      D.31811 = jit->params;
      D.31812 = (long unsigned int) pos;
      D.31813 = D.31812 * 32;
      var = D.31811 + D.31813;
      D.31814 = sig->params[pos];
      D.31811 = jit->params;
      D.31812 = (long unsigned int) pos;
      D.31813 = D.31812 * 32;
      D.31815 = D.31811 + D.31813;
      D.31816 = &frame->ctx;
      D.31774 = frame->domain;
      add_var (buf, jit, D.31814, D.31815, D.31816, D.31774, 0);
      goto <D.31817>;
      <D.31798>:
      if (pos < 0) goto <D.31819>; else goto <D.31822>;
      <D.31822>:
      pos.317 = (unsigned int) pos;
      D.31823 = jit->num_locals;
      if (pos.317 >= D.31823) goto <D.31819>; else goto <D.31820>;
      <D.31819>:
      iftmp.318 = 1;
      goto <D.31821>;
      <D.31820>:
      iftmp.318 = 0;
      <D.31821>:
      D.31824 = iftmp.318 != 0;
      D.31825 = (long int) D.31824;
      D.31826 = __builtin_expect (D.31825, 0);
      if (D.31826 != 0) goto <D.31827>; else goto <D.31828>;
      <D.31827>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 8551, "pos >= 0 && pos < jit->num_locals");
      <D.31828>:
      D.31829 = jit->locals;
      D.31812 = (long unsigned int) pos;
      D.31813 = D.31812 * 32;
      var = D.31829 + D.31813;
      D.31830 = header->locals[pos];
      D.31829 = jit->locals;
      D.31812 = (long unsigned int) pos;
      D.31813 = D.31812 * 32;
      D.31831 = D.31829 + D.31813;
      D.31816 = &frame->ctx;
      D.31774 = frame->domain;
      add_var (buf, jit, D.31830, D.31831, D.31816, D.31774, 0);
      <D.31817>:
      i = i + 1;
      <D.27765>:
      if (i < len) goto <D.27764>; else goto <D.27766>;
      <D.27766>:
      mono_metadata_free_mh (header);
      goto <D.27767>;
      <D.27768>:
      D.31773 = frame->api_method;
      D.31832 = D.31773->klass;
      D.31833 = BIT_FIELD_REF <*D.31832, 64, 256>;
      D.31834 = D.31833 & 8;
      if (D.31834 != 0) goto <D.31835>; else goto <D.31836>;
      <D.31835>:
      D.31837 = BIT_FIELD_REF <*sig, 64, 64>;
      D.31838 = D.31837 & 18014398509481984;
      if (D.31838 == 0) goto <D.31839>; else goto <D.31840>;
      <D.31839>:
      {
        struct MonoObject * p;

        try
          {
            p = 0B;
            D.31841 = mono_defaults.object_class;
            D.31842 = &D.31841->byval_arg;
            D.31774 = frame->domain;
            buffer_add_value (buf, D.31842, &p, D.31774);
          }
        finally
          {
            p = {CLOBBER};
          }
      }
      goto <D.31843>;
      <D.31840>:
      D.31793 = frame->actual_method;
      D.31844 = D.31793->klass;
      D.31845 = &D.31844->this_arg;
      D.31846 = jit->this_var;
      D.31816 = &frame->ctx;
      D.31774 = frame->domain;
      add_var (buf, jit, D.31845, D.31846, D.31816, D.31774, 1);
      <D.31843>:
      goto <D.31847>;
      <D.31836>:
      D.31837 = BIT_FIELD_REF <*sig, 64, 64>;
      D.31838 = D.31837 & 18014398509481984;
      if (D.31838 == 0) goto <D.31848>; else goto <D.31849>;
      <D.31848>:
      {
        struct MonoObject * p;

        try
          {
            p = 0B;
            D.31793 = frame->actual_method;
            D.31844 = D.31793->klass;
            D.31850 = &D.31844->byval_arg;
            D.31774 = frame->domain;
            buffer_add_value (buf, D.31850, &p, D.31774);
          }
        finally
          {
            p = {CLOBBER};
          }
      }
      goto <D.31851>;
      <D.31849>:
      D.31773 = frame->api_method;
      D.31832 = D.31773->klass;
      D.31852 = &D.31832->byval_arg;
      D.31846 = jit->this_var;
      D.31816 = &frame->ctx;
      D.31774 = frame->domain;
      add_var (buf, jit, D.31852, D.31846, D.31816, D.31774, 1);
      <D.31851>:
      <D.31847>:
      goto <D.27767>;
      <D.27771>:
      {
        guint8 * val_buf;
        struct MonoType * t;
        struct MonoDebugVarInfo * var;

        p.311 = p;
        len = decode_int (p.311, &p, end);
        D.31793 = frame->actual_method;
        header = mono_method_get_header (D.31793);
        i = 0;
        goto <D.27776>;
        <D.27775>:
        p.311 = p;
        pos = decode_int (p.311, &p, end);
        if (pos < 0) goto <D.31853>; else goto <D.31854>;
        <D.31853>:
        pos = ~pos;
        if (pos < 0) goto <D.31856>; else goto <D.31859>;
        <D.31859>:
        pos.317 = (unsigned int) pos;
        D.31805 = jit->num_params;
        if (pos.317 >= D.31805) goto <D.31856>; else goto <D.31857>;
        <D.31856>:
        iftmp.319 = 1;
        goto <D.31858>;
        <D.31857>:
        iftmp.319 = 0;
        <D.31858>:
        D.31860 = iftmp.319 != 0;
        D.31861 = (long int) D.31860;
        D.31862 = __builtin_expect (D.31861, 0);
        if (D.31862 != 0) goto <D.31863>; else goto <D.31864>;
        <D.31863>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 8593, "pos >= 0 && pos < jit->num_params");
        <D.31864>:
        t = sig->params[pos];
        D.31811 = jit->params;
        D.31812 = (long unsigned int) pos;
        D.31813 = D.31812 * 32;
        var = D.31811 + D.31813;
        goto <D.31865>;
        <D.31854>:
        if (pos < 0) goto <D.31867>; else goto <D.31870>;
        <D.31870>:
        pos.317 = (unsigned int) pos;
        D.31823 = jit->num_locals;
        if (pos.317 >= D.31823) goto <D.31867>; else goto <D.31868>;
        <D.31867>:
        iftmp.320 = 1;
        goto <D.31869>;
        <D.31868>:
        iftmp.320 = 0;
        <D.31869>:
        D.31871 = iftmp.320 != 0;
        D.31872 = (long int) D.31871;
        D.31873 = __builtin_expect (D.31872, 0);
        if (D.31873 != 0) goto <D.31874>; else goto <D.31875>;
        <D.31874>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 8598, "pos >= 0 && pos < jit->num_locals");
        <D.31875>:
        t = header->locals[pos];
        D.31829 = jit->locals;
        D.31812 = (long unsigned int) pos;
        D.31813 = D.31812 * 32;
        var = D.31829 + D.31813;
        <D.31865>:
        D.31876 = mono_type_is_reference (t);
        if (D.31876 != 0) goto <D.31877>; else goto <D.31878>;
        <D.31877>:
        val_buf = __builtin_alloca (8);
        goto <D.31879>;
        <D.31878>:
        D.31880 = mono_class_from_mono_type (t);
        D.31881 = mono_class_instance_size (D.31880);
        D.31882 = (long unsigned int) D.31881;
        val_buf = __builtin_alloca (D.31882);
        <D.31879>:
        D.31774 = frame->domain;
        p.311 = p;
        D.31883 = decode_value (t, D.31774, val_buf, p.311, &p, end);
        err = (int) D.31883;
        if (err != 0) goto <D.31884>; else goto <D.31885>;
        <D.31884>:
        D.31744 = (ErrorCode) err;
        return D.31744;
        <D.31885>:
        D.31816 = &frame->ctx;
        D.31774 = frame->domain;
        D.31886 = &frame->reg_locations;
        D.31887 = &tls->restore_ctx;
        set_var (t, var, D.31816, D.31774, val_buf, D.31886, D.31887);
        i = i + 1;
        <D.27776>:
        if (i < len) goto <D.27775>; else goto <D.27777>;
        <D.27777>:
        mono_metadata_free_mh (header);
        goto <D.27767>;
      }
      <D.27778>:
      D.31744 = 100;
      return D.31744;
      <D.27767>:
      D.31744 = 0;
      return D.31744;
    }
  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.31890;
  int D.31891;
  long int reg_val.321;
  long int D.31893;
  unsigned int D.31894;
  int D.31895;
  sizetype D.31896;
  long int D.31897;
  _Bool D.31898;
  long int D.31899;
  long int D.31900;
  _Bool D.31903;
  long int D.31904;
  long int D.31905;
  _Bool D.31908;
  long int D.31909;
  long int D.31910;
  unsigned int D.31913;
  int D.31914;
  long int D.31917;
  unsigned int D.31918;
  int D.31919;
  sizetype D.31920;
  long int D.31924;
  _Bool D.31926;
  long int D.31927;
  long int D.31928;
  unsigned int D.31931;
  int D.31932;
  long int D.31935;
  unsigned int D.31936;
  int D.31937;
  sizetype D.31938;
  long int D.31942;
  _Bool D.31944;
  long int D.31945;
  long int D.31946;
  void * D.31949;
  long int D.31950;
  int D.31951;
  sizetype D.31952;
  guint32 flags;
  int reg;
  guint8 * addr;
  guint8 * gaddr;
  mgreg_t reg_val;

  try
    {
      D.31890 = var->index;
      flags = D.31890 & 4026531840;
      D.31890 = var->index;
      D.31891 = (int) D.31890;
      reg = D.31891 & 268435455;
      switch (flags) <default: <D.26930>, case 0: <D.26918>, case 268435456: <D.26920>, case 805306368: <D.26921>, case 1073741824: <D.26922>, case 1342177280: <D.26924>, case 1610612736: <D.26923>>
      <D.26918>:
      reg_val.321 = mono_arch_context_get_int_reg (ctx, reg);
      reg_val = reg_val.321;
      buffer_add_value_full (buf, t, &reg_val, domain, as_vtype);
      goto <D.26919>;
      <D.26920>:
      D.31893 = mono_arch_context_get_int_reg (ctx, reg);
      addr = (guint8 *) D.31893;
      D.31894 = var->offset;
      D.31895 = (int) D.31894;
      D.31896 = (sizetype) D.31895;
      addr = addr + D.31896;
      buffer_add_value_full (buf, t, addr, domain, as_vtype);
      goto <D.26919>;
      <D.26921>:
      monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "debugger-agent.c", 5939);
      <D.26922>:
      <D.26923>:
      D.31897 = mono_arch_context_get_int_reg (ctx, reg);
      addr = (guint8 *) D.31897;
      D.31894 = var->offset;
      D.31895 = (int) D.31894;
      D.31896 = (sizetype) D.31895;
      addr = addr + D.31896;
      gaddr = MEM[(void * *)addr];
      D.31898 = gaddr == 0B;
      D.31899 = (long int) D.31898;
      D.31900 = __builtin_expect (D.31899, 0);
      if (D.31900 != 0) goto <D.31901>; else goto <D.31902>;
      <D.31901>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 5948, "gaddr");
      <D.31902>:
      buffer_add_value_full (buf, t, gaddr, domain, as_vtype);
      goto <D.26919>;
      <D.26924>:
      {
        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.31903 = info_var == 0B;
        D.31904 = (long int) D.31903;
        D.31905 = __builtin_expect (D.31904, 0);
        if (D.31905 != 0) goto <D.31906>; else goto <D.31907>;
        <D.31906>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 5960, "info_var");
        <D.31907>:
        D.31908 = locals_var == 0B;
        D.31909 = (long int) D.31908;
        D.31910 = __builtin_expect (D.31909, 0);
        if (D.31910 != 0) goto <D.31911>; else goto <D.31912>;
        <D.31911>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 5961, "locals_var");
        <D.31912>:
        D.31913 = info_var->index;
        flags = D.31913 & 4026531840;
        D.31913 = info_var->index;
        D.31914 = (int) D.31913;
        reg = D.31914 & 268435455;
        if (flags == 268435456) goto <D.31915>; else goto <D.31916>;
        <D.31915>:
        D.31917 = mono_arch_context_get_int_reg (ctx, reg);
        addr = (guint8 *) D.31917;
        D.31918 = info_var->offset;
        D.31919 = (int) D.31918;
        D.31920 = (sizetype) D.31919;
        addr = addr + D.31920;
        info = MEM[(void * *)addr];
        goto <D.31921>;
        <D.31916>:
        if (flags == 0) goto <D.31922>; else goto <D.31923>;
        <D.31922>:
        D.31924 = mono_arch_context_get_int_reg (ctx, reg);
        info = (struct MonoGSharedVtMethodRuntimeInfo *) D.31924;
        goto <D.31925>;
        <D.31923>:
        monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "debugger-agent.c", 5972);
        <D.31925>:
        <D.31921>:
        D.31926 = info == 0B;
        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", 5974, "info");
        <D.31930>:
        D.31931 = locals_var->index;
        flags = D.31931 & 4026531840;
        D.31931 = locals_var->index;
        D.31932 = (int) D.31931;
        reg = D.31932 & 268435455;
        if (flags == 268435456) goto <D.31933>; else goto <D.31934>;
        <D.31933>:
        D.31935 = mono_arch_context_get_int_reg (ctx, reg);
        addr = (guint8 *) D.31935;
        D.31936 = locals_var->offset;
        D.31937 = (int) D.31936;
        D.31938 = (sizetype) D.31937;
        addr = addr + D.31938;
        locals = MEM[(void * *)addr];
        goto <D.31939>;
        <D.31934>:
        if (flags == 0) goto <D.31940>; else goto <D.31941>;
        <D.31940>:
        D.31942 = mono_arch_context_get_int_reg (ctx, reg);
        locals = (guint8 *) D.31942;
        goto <D.31943>;
        <D.31941>:
        monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "debugger-agent.c", 5985);
        <D.31943>:
        <D.31939>:
        D.31944 = locals == 0B;
        D.31945 = (long int) D.31944;
        D.31946 = __builtin_expect (D.31945, 0);
        if (D.31946 != 0) goto <D.31947>; else goto <D.31948>;
        <D.31947>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 5987, "locals");
        <D.31948>:
        D.31949 = info->entries[idx];
        D.31950 = (long int) D.31949;
        D.31951 = (int) D.31950;
        D.31952 = (sizetype) D.31951;
        addr = locals + D.31952;
        buffer_add_value_full (buf, t, addr, domain, as_vtype);
        goto <D.26919>;
      }
      <D.26930>:
      monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "debugger-agent.c", 5996);
      <D.26919>:
    }
  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.31953;
  int D.31954;
  int D.31955;
  struct MonoClass * D.31959;
  long int D.31960;
  unsigned int D.31961;
  int D.31962;
  sizetype D.31963;
  long unsigned int D.31964;
  long unsigned int D.31965;
  long unsigned int D.31969;
  long int D.31970;
  _Bool D.31971;
  long int D.31972;
  long int D.31973;
  guint32 flags;
  int reg;
  int size;
  guint8 * addr;
  guint8 * gaddr;

  D.31953 = var->index;
  flags = D.31953 & 4026531840;
  D.31953 = var->index;
  D.31954 = (int) D.31953;
  reg = D.31954 & 268435455;
  D.31955 = mono_type_is_reference (t);
  if (D.31955 != 0) goto <D.31956>; else goto <D.31957>;
  <D.31956>:
  size = 8;
  goto <D.31958>;
  <D.31957>:
  D.31959 = mono_class_from_mono_type (t);
  size = mono_class_value_size (D.31959, 0B);
  <D.31958>:
  switch (flags) <default: <D.26950>, case 0: <D.26945>, case 268435456: <D.26946>, case 805306368: <D.26949>, case 1073741824: <D.26948>>
  <D.26945>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "debugger-agent.c", 6066);
  <D.26946>:
  D.31960 = mono_arch_context_get_int_reg (ctx, reg);
  addr = (guint8 *) D.31960;
  D.31961 = var->offset;
  D.31962 = (int) D.31961;
  D.31963 = (sizetype) D.31962;
  addr = addr + D.31963;
  D.31964 = BIT_FIELD_REF <*t, 64, 64>;
  D.31965 = D.31964 & 1073741824;
  if (D.31965 != 0) goto <D.31966>; else goto <D.31967>;
  <D.31966>:
  addr = MEM[(guint8 * *)addr];
  if (addr == 0B) goto <D.26947>; else goto <D.31968>;
  <D.31968>:
  <D.31967>:
  D.31969 = (long unsigned int) size;
  mono_gc_memmove_atomic (addr, val, D.31969);
  goto <D.26947>;
  <D.26948>:
  D.31970 = mono_arch_context_get_int_reg (ctx, reg);
  addr = (guint8 *) D.31970;
  D.31961 = var->offset;
  D.31962 = (int) D.31961;
  D.31963 = (sizetype) D.31962;
  addr = addr + D.31963;
  gaddr = MEM[(void * *)addr];
  D.31971 = gaddr == 0B;
  D.31972 = (long int) D.31971;
  D.31973 = __builtin_expect (D.31972, 0);
  if (D.31973 != 0) goto <D.31974>; else goto <D.31975>;
  <D.31974>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 6092, "gaddr");
  <D.31975>:
  D.31969 = (long unsigned int) size;
  mono_gc_memmove_atomic (gaddr, val, D.31969);
  goto <D.26947>;
  <D.26949>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "debugger-agent.c", 6097);
  <D.26950>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "debugger-agent.c", 6100);
  <D.26947>:
}


array_commands (int command, guint8 * p, guint8 * end, struct Buffer * buf)
{
  guint8 * p.322;
  <unnamed type> D.31977;
  ErrorCode D.31980;
  struct MonoArray * arr.323;
  struct MonoVTable * D.31982;
  struct MonoClass * D.31983;
  unsigned char D.31984;
  unsigned int D.31985;
  struct MonoArrayBounds * D.31986;
  unsigned int D.31989;
  long unsigned int D.31991;
  long unsigned int D.31992;
  struct MonoArrayBounds * D.31993;
  unsigned int D.31994;
  int D.31995;
  unsigned int D.31996;
  int D.31997;
  int iftmp.324;
  _Bool D.32003;
  long int D.32004;
  long int D.32005;
  unsigned int index.325;
  unsigned int len.326;
  unsigned int D.32010;
  _Bool D.32011;
  long int D.32012;
  long int D.32013;
  double[0:] * D.32016;
  int D.32017;
  sizetype D.32018;
  struct MonoClass * D.32019;
  struct MonoType * D.32020;
  struct MonoDomain * D.32021;
  int D.32022;
  int iftmp.327;
  _Bool D.32028;
  long int D.32029;
  long int D.32030;
  struct MonoArray * arr;
  int objid;
  int err;
  int index;
  int len;
  int i;
  int esize;
  void * elem;

  try
    {
      p.322 = p;
      objid = decode_objid (p.322, &p, end);
      D.31977 = get_object (objid, &arr);
      err = (int) D.31977;
      if (err != 0) goto <D.31978>; else goto <D.31979>;
      <D.31978>:
      D.31980 = (ErrorCode) err;
      return D.31980;
      <D.31979>:
      switch (command) <default: <D.27806>, case 1: <D.27793>, case 2: <D.27798>, case 3: <D.27802>>
      <D.27793>:
      arr.323 = arr;
      D.31982 = arr.323->obj.vtable;
      D.31983 = D.31982->klass;
      D.31984 = D.31983->rank;
      D.31985 = (unsigned int) D.31984;
      buffer_add_int (buf, D.31985);
      arr.323 = arr;
      D.31986 = arr.323->bounds;
      if (D.31986 == 0B) goto <D.31987>; else goto <D.31988>;
      <D.31987>:
      arr.323 = arr;
      D.31989 = arr.323->max_length;
      buffer_add_int (buf, D.31989);
      buffer_add_int (buf, 0);
      goto <D.31990>;
      <D.31988>:
      i = 0;
      goto <D.27795>;
      <D.27794>:
      arr.323 = arr;
      D.31986 = arr.323->bounds;
      D.31991 = (long unsigned int) i;
      D.31992 = D.31991 * 8;
      D.31993 = D.31986 + D.31992;
      D.31994 = D.31993->length;
      buffer_add_int (buf, D.31994);
      arr.323 = arr;
      D.31986 = arr.323->bounds;
      D.31991 = (long unsigned int) i;
      D.31992 = D.31991 * 8;
      D.31993 = D.31986 + D.31992;
      D.31995 = D.31993->lower_bound;
      D.31996 = (unsigned int) D.31995;
      buffer_add_int (buf, D.31996);
      i = i + 1;
      <D.27795>:
      arr.323 = arr;
      D.31982 = arr.323->obj.vtable;
      D.31983 = D.31982->klass;
      D.31984 = D.31983->rank;
      D.31997 = (int) D.31984;
      if (D.31997 > i) goto <D.27794>; else goto <D.27796>;
      <D.27796>:
      <D.31990>:
      goto <D.27797>;
      <D.27798>:
      p.322 = p;
      index = decode_int (p.322, &p, end);
      p.322 = p;
      len = decode_int (p.322, &p, end);
      if (index < 0) goto <D.31999>; else goto <D.32002>;
      <D.32002>:
      if (len < 0) goto <D.31999>; else goto <D.32000>;
      <D.31999>:
      iftmp.324 = 1;
      goto <D.32001>;
      <D.32000>:
      iftmp.324 = 0;
      <D.32001>:
      D.32003 = iftmp.324 != 0;
      D.32004 = (long int) D.32003;
      D.32005 = __builtin_expect (D.32004, 0);
      if (D.32005 != 0) goto <D.32006>; else goto <D.32007>;
      <D.32006>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 8653, "index >= 0 && len >= 0");
      <D.32007>:
      index.325 = (unsigned int) index;
      arr.323 = arr;
      D.31989 = arr.323->max_length;
      len.326 = (unsigned int) len;
      D.32010 = D.31989 - len.326;
      D.32011 = index.325 > D.32010;
      D.32012 = (long int) D.32011;
      D.32013 = __builtin_expect (D.32012, 0);
      if (D.32013 != 0) goto <D.32014>; else goto <D.32015>;
      <D.32014>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 8655, "!(index > arr->max_length - len)");
      <D.32015>:
      arr.323 = arr;
      D.31982 = arr.323->obj.vtable;
      D.31983 = D.31982->klass;
      esize = mono_array_element_size (D.31983);
      i = index;
      goto <D.27800>;
      <D.27799>:
      arr.323 = arr;
      D.32016 = &arr.323->vector;
      D.32017 = i * esize;
      D.32018 = (sizetype) D.32017;
      elem = D.32016 + D.32018;
      arr.323 = arr;
      D.31982 = arr.323->obj.vtable;
      D.31983 = D.31982->klass;
      D.32019 = D.31983->element_class;
      D.32020 = &D.32019->byval_arg;
      arr.323 = arr;
      D.31982 = arr.323->obj.vtable;
      D.32021 = D.31982->domain;
      buffer_add_value (buf, D.32020, elem, D.32021);
      i = i + 1;
      <D.27800>:
      D.32022 = index + len;
      if (D.32022 > i) goto <D.27799>; else goto <D.27801>;
      <D.27801>:
      goto <D.27797>;
      <D.27802>:
      p.322 = p;
      index = decode_int (p.322, &p, end);
      p.322 = p;
      len = decode_int (p.322, &p, end);
      if (index < 0) goto <D.32024>; else goto <D.32027>;
      <D.32027>:
      if (len < 0) goto <D.32024>; else goto <D.32025>;
      <D.32024>:
      iftmp.327 = 1;
      goto <D.32026>;
      <D.32025>:
      iftmp.327 = 0;
      <D.32026>:
      D.32028 = iftmp.327 != 0;
      D.32029 = (long int) D.32028;
      D.32030 = __builtin_expect (D.32029, 0);
      if (D.32030 != 0) goto <D.32031>; else goto <D.32032>;
      <D.32031>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 8667, "index >= 0 && len >= 0");
      <D.32032>:
      index.325 = (unsigned int) index;
      arr.323 = arr;
      D.31989 = arr.323->max_length;
      len.326 = (unsigned int) len;
      D.32010 = D.31989 - len.326;
      D.32011 = index.325 > D.32010;
      D.32012 = (long int) D.32011;
      D.32013 = __builtin_expect (D.32012, 0);
      if (D.32013 != 0) goto <D.32033>; else goto <D.32034>;
      <D.32033>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 8669, "!(index > arr->max_length - len)");
      <D.32034>:
      arr.323 = arr;
      D.31982 = arr.323->obj.vtable;
      D.31983 = D.31982->klass;
      esize = mono_array_element_size (D.31983);
      i = index;
      goto <D.27804>;
      <D.27803>:
      arr.323 = arr;
      D.32016 = &arr.323->vector;
      D.32017 = i * esize;
      D.32018 = (sizetype) D.32017;
      elem = D.32016 + D.32018;
      arr.323 = arr;
      D.31982 = arr.323->obj.vtable;
      D.31983 = D.31982->klass;
      D.32019 = D.31983->element_class;
      D.32020 = &D.32019->byval_arg;
      arr.323 = arr;
      D.31982 = arr.323->obj.vtable;
      D.32021 = D.31982->domain;
      p.322 = p;
      decode_value (D.32020, D.32021, elem, p.322, &p, end);
      i = i + 1;
      <D.27804>:
      D.32022 = index + len;
      if (D.32022 > i) goto <D.27803>; else goto <D.27805>;
      <D.27805>:
      goto <D.27797>;
      <D.27806>:
      D.31980 = 100;
      return D.31980;
      <D.27797>:
      D.31980 = 0;
      return D.31980;
    }
  finally
    {
      arr = {CLOBBER};
    }
}


string_commands (int command, guint8 * p, guint8 * end, struct Buffer * buf)
{
  guint8 * p.328;
  <unnamed type> D.32038;
  ErrorCode D.32041;
  struct MonoString * str.329;
  int D.32043;
  long unsigned int D.32044;
  long int D.32045;
  long int D.32046;
  int D.32047;
  int D.32048;
  mono_unichar2 * D.32051;
  long unsigned int D.32052;
  long unsigned int D.32053;
  long unsigned int D.32054;
  long unsigned int D.32055;
  gunichar2 * D.32056;
  short unsigned int D.32057;
  unsigned int D.32058;
  int objid;
  int err;
  struct MonoString * str;
  char * s;
  int i;
  int index;
  int length;
  gunichar2 * c;

  try
    {
      p.328 = p;
      objid = decode_objid (p.328, &p, end);
      D.32038 = get_object (objid, &str);
      err = (int) D.32038;
      if (err != 0) goto <D.32039>; else goto <D.32040>;
      <D.32039>:
      D.32041 = (ErrorCode) err;
      return D.32041;
      <D.32040>:
      switch (command) <default: <D.27828>, case 1: <D.27821>, case 2: <D.27823>, case 3: <D.27824>>
      <D.27821>:
      str.329 = str;
      s = mono_string_to_utf8 (str.329);
      buffer_add_string (buf, s);
      monoeg_g_free (s);
      goto <D.27822>;
      <D.27823>:
      str.329 = str;
      D.32043 = mono_string_length (str.329);
      D.32044 = (long unsigned int) D.32043;
      buffer_add_long (buf, D.32044);
      goto <D.27822>;
      <D.27824>:
      p.328 = p;
      D.32045 = decode_long (p.328, &p, end);
      index = (int) D.32045;
      p.328 = p;
      D.32046 = decode_long (p.328, &p, end);
      length = (int) D.32046;
      str.329 = str;
      D.32047 = mono_string_length (str.329);
      D.32048 = D.32047 - length;
      if (D.32048 < index) goto <D.32049>; else goto <D.32050>;
      <D.32049>:
      D.32041 = 102;
      return D.32041;
      <D.32050>:
      str.329 = str;
      D.32051 = mono_string_chars (str.329);
      D.32052 = (long unsigned int) index;
      D.32053 = D.32052 * 2;
      c = D.32051 + D.32053;
      i = 0;
      goto <D.27826>;
      <D.27825>:
      D.32054 = (long unsigned int) i;
      D.32055 = D.32054 * 2;
      D.32056 = c + D.32055;
      D.32057 = *D.32056;
      D.32058 = (unsigned int) D.32057;
      buffer_add_short (buf, D.32058);
      i = i + 1;
      <D.27826>:
      if (i < length) goto <D.27825>; else goto <D.27827>;
      <D.27827>:
      goto <D.27822>;
      <D.27828>:
      D.32041 = 100;
      return D.32041;
      <D.27822>:
      D.32041 = 0;
      return D.32041;
    }
  finally
    {
      str = {CLOBBER};
    }
}


buffer_add_short (struct Buffer * buf, guint32 val)
{
  guint8 * D.32061;
  unsigned int D.32062;
  unsigned char D.32063;
  guint8 * D.32064;
  unsigned char D.32065;
  guint8 * D.32066;

  buffer_make_room (buf, 2);
  D.32061 = buf->p;
  D.32062 = val >> 8;
  D.32063 = (unsigned char) D.32062;
  *D.32061 = D.32063;
  D.32061 = buf->p;
  D.32064 = D.32061 + 1;
  D.32065 = (unsigned char) val;
  *D.32064 = D.32065;
  D.32061 = buf->p;
  D.32066 = D.32061 + 2;
  buf->p = D.32066;
}


object_commands (int command, guint8 * p, guint8 * end, struct Buffer * buf)
{
  guint8 * p.330;
  <unnamed type> D.32070;
  int err.331;
  int err.332;
  ErrorCode D.32076;
  <unnamed type> D.32077;
  int err.333;
  struct MonoObject * obj.334;
  struct MonoVTable * D.32082;
  struct MonoDomain * D.32083;
  void * D.32084;
  struct MonoType * D.32085;
  struct MonoClass * D.32086;
  struct MonoClass * D.32089;
  struct MonoType * D.32094;
  short unsigned int D.32095;
  int D.32096;
  int D.32097;
  int D.32100;
  _Bool D.32103;
  long int D.32104;
  long int D.32105;
  struct MonoClass * D.32108;
  int D.32109;
  long unsigned int D.32110;
  int D.32112;
  sizetype D.32113;
  void * D.32114;
  struct MonoClass * D.32117;
  struct MonoType * D.32122;
  short unsigned int D.32123;
  int D.32124;
  int D.32125;
  int D.32128;
  _Bool D.32131;
  long int D.32132;
  long int D.32133;
  struct MonoClass * D.32136;
  int D.32137;
  long unsigned int D.32138;
  <unnamed type> D.32139;
  int err.335;
  int D.32144;
  sizetype D.32145;
  guint8 * D.32146;
  <unnamed type> D.32147;
  int err.336;
  long unsigned int obj.337;
  struct MonoClass * D.32152;
  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.32067>; else goto <D.32068>;
      <D.32067>:
      p.330 = p;
      objid = decode_objid (p.330, &p, end);
      D.32070 = get_object (objid, &obj);
      err.331 = (int) D.32070;
      err = err.331;
      err.332 = err;
      if (err.332 != 0) goto <D.32073>; else goto <D.32074>;
      <D.32073>:
      buffer_add_int (buf, 1);
      goto <D.32075>;
      <D.32074>:
      buffer_add_int (buf, 0);
      <D.32075>:
      D.32076 = 0;
      return D.32076;
      <D.32068>:
      p.330 = p;
      objid = decode_objid (p.330, &p, end);
      D.32077 = get_object (objid, &obj);
      err.333 = (int) D.32077;
      err = err.333;
      err.332 = err;
      if (err.332 != 0) goto <D.32079>; else goto <D.32080>;
      <D.32079>:
      err.332 = err;
      D.32076 = (ErrorCode) err.332;
      return D.32076;
      <D.32080>:
      switch (command) <default: <D.27867>, case 1: <D.27843>, case 2: <D.27845>, case 4: <D.27864>, case 5: <D.27865>, case 6: <D.27855>, case 7: <D.27866>>
      <D.27843>:
      obj.334 = obj;
      D.32082 = obj.334->vtable;
      D.32083 = D.32082->domain;
      obj.334 = obj;
      D.32082 = obj.334->vtable;
      D.32084 = D.32082->type;
      D.32085 = MEM[(struct MonoReflectionType *)D.32084].type;
      D.32086 = mono_class_from_mono_type (D.32085);
      buffer_add_typeid (buf, D.32083, D.32086);
      goto <D.27844>;
      <D.27845>:
      p.330 = p;
      len = decode_int (p.330, &p, end);
      i = 0;
      goto <D.27853>;
      <D.27852>:
      {
        struct MonoClassField * f;

        p.330 = p;
        f = decode_fieldid (p.330, &p, end, 0B, &err);
        err.332 = err;
        if (err.332 != 0) goto <D.32087>; else goto <D.32088>;
        <D.32087>:
        err.332 = err;
        D.32076 = (ErrorCode) err.332;
        return D.32076;
        <D.32088>:
        found = 0;
        obj.334 = obj;
        D.32082 = obj.334->vtable;
        k = D.32082->klass;
        goto <D.27849>;
        <D.27848>:
        D.32089 = f->parent;
        if (D.32089 == k) goto <D.32090>; else goto <D.32091>;
        <D.32090>:
        found = 1;
        goto <D.27847>;
        <D.32091>:
        k = k->parent;
        <D.27849>:
        if (k != 0B) goto <D.27848>; else goto <D.27847>;
        <D.27847>:
        if (found == 0) goto <D.32092>; else goto <D.32093>;
        <D.32092>:
        D.32076 = 25;
        return D.32076;
        <D.32093>:
        D.32094 = f->type;
        D.32095 = D.32094->attrs;
        D.32096 = (int) D.32095;
        D.32097 = D.32096 & 16;
        if (D.32097 != 0) goto <D.32098>; else goto <D.32099>;
        <D.32098>:
        {
          guint8 * val;
          struct MonoVTable * vtable;

          D.32100 = mono_class_field_is_special_static (f);
          if (D.32100 != 0) goto <D.32101>; else goto <D.32102>;
          <D.32101>:
          D.32076 = 25;
          return D.32076;
          <D.32102>:
          D.32094 = f->type;
          D.32095 = D.32094->attrs;
          D.32096 = (int) D.32095;
          D.32097 = D.32096 & 16;
          D.32103 = D.32097 == 0;
          D.32104 = (long int) D.32103;
          D.32105 = __builtin_expect (D.32104, 0);
          if (D.32105 != 0) goto <D.32106>; else goto <D.32107>;
          <D.32106>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 8780, "f->type->attrs & FIELD_ATTRIBUTE_STATIC");
          <D.32107>:
          obj.334 = obj;
          D.32082 = obj.334->vtable;
          D.32083 = D.32082->domain;
          D.32089 = f->parent;
          vtable = mono_class_vtable (D.32083, D.32089);
          D.32094 = f->type;
          D.32108 = mono_class_from_mono_type (D.32094);
          D.32109 = mono_class_instance_size (D.32108);
          D.32110 = (long unsigned int) D.32109;
          val = monoeg_malloc (D.32110);
          mono_field_static_get_value (vtable, f, val);
          D.32094 = f->type;
          obj.334 = obj;
          D.32082 = obj.334->vtable;
          D.32083 = D.32082->domain;
          buffer_add_value (buf, D.32094, val, D.32083);
          monoeg_g_free (val);
        }
        goto <D.32111>;
        <D.32099>:
        D.32094 = f->type;
        obj.334 = obj;
        D.32112 = f->offset;
        D.32113 = (sizetype) D.32112;
        D.32114 = obj.334 + D.32113;
        obj.334 = obj;
        D.32082 = obj.334->vtable;
        D.32083 = D.32082->domain;
        buffer_add_value (buf, D.32094, D.32114, D.32083);
        <D.32111>:
      }
      i = i + 1;
      <D.27853>:
      if (i < len) goto <D.27852>; else goto <D.27854>;
      <D.27854>:
      goto <D.27844>;
      <D.27855>:
      p.330 = p;
      len = decode_int (p.330, &p, end);
      i = 0;
      goto <D.27862>;
      <D.27861>:
      p.330 = p;
      f = decode_fieldid (p.330, &p, end, 0B, &err);
      err.332 = err;
      if (err.332 != 0) goto <D.32115>; else goto <D.32116>;
      <D.32115>:
      err.332 = err;
      D.32076 = (ErrorCode) err.332;
      return D.32076;
      <D.32116>:
      found = 0;
      obj.334 = obj;
      D.32082 = obj.334->vtable;
      k = D.32082->klass;
      goto <D.27858>;
      <D.27857>:
      D.32117 = f->parent;
      if (D.32117 == k) goto <D.32118>; else goto <D.32119>;
      <D.32118>:
      found = 1;
      goto <D.27856>;
      <D.32119>:
      k = k->parent;
      <D.27858>:
      if (k != 0B) goto <D.27857>; else goto <D.27856>;
      <D.27856>:
      if (found == 0) goto <D.32120>; else goto <D.32121>;
      <D.32120>:
      D.32076 = 25;
      return D.32076;
      <D.32121>:
      D.32122 = f->type;
      D.32123 = D.32122->attrs;
      D.32124 = (int) D.32123;
      D.32125 = D.32124 & 16;
      if (D.32125 != 0) goto <D.32126>; else goto <D.32127>;
      <D.32126>:
      {
        guint8 * val;
        struct MonoVTable * vtable;

        D.32128 = mono_class_field_is_special_static (f);
        if (D.32128 != 0) goto <D.32129>; else goto <D.32130>;
        <D.32129>:
        D.32076 = 25;
        return D.32076;
        <D.32130>:
        D.32122 = f->type;
        D.32123 = D.32122->attrs;
        D.32124 = (int) D.32123;
        D.32125 = D.32124 & 16;
        D.32131 = D.32125 == 0;
        D.32132 = (long int) D.32131;
        D.32133 = __builtin_expect (D.32132, 0);
        if (D.32133 != 0) goto <D.32134>; else goto <D.32135>;
        <D.32134>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 8817, "f->type->attrs & FIELD_ATTRIBUTE_STATIC");
        <D.32135>:
        obj.334 = obj;
        D.32082 = obj.334->vtable;
        D.32083 = D.32082->domain;
        D.32117 = f->parent;
        vtable = mono_class_vtable (D.32083, D.32117);
        D.32122 = f->type;
        D.32136 = mono_class_from_mono_type (D.32122);
        D.32137 = mono_class_instance_size (D.32136);
        D.32138 = (long unsigned int) D.32137;
        val = monoeg_malloc (D.32138);
        D.32122 = f->type;
        obj.334 = obj;
        D.32082 = obj.334->vtable;
        D.32083 = D.32082->domain;
        p.330 = p;
        D.32139 = decode_value (D.32122, D.32083, val, p.330, &p, end);
        err.335 = (int) D.32139;
        err = err.335;
        err.332 = err;
        if (err.332 != 0) goto <D.32141>; else goto <D.32142>;
        <D.32141>:
        monoeg_g_free (val);
        err.332 = err;
        D.32076 = (ErrorCode) err.332;
        return D.32076;
        <D.32142>:
        mono_field_static_set_value (vtable, f, val);
        monoeg_g_free (val);
      }
      goto <D.32143>;
      <D.32127>:
      D.32122 = f->type;
      obj.334 = obj;
      D.32082 = obj.334->vtable;
      D.32083 = D.32082->domain;
      obj.334 = obj;
      D.32144 = f->offset;
      D.32145 = (sizetype) D.32144;
      D.32146 = obj.334 + D.32145;
      p.330 = p;
      D.32147 = decode_value (D.32122, D.32083, D.32146, p.330, &p, end);
      err.336 = (int) D.32147;
      err = err.336;
      err.332 = err;
      if (err.332 != 0) goto <D.32149>; else goto <D.32150>;
      <D.32149>:
      err.332 = err;
      D.32076 = (ErrorCode) err.332;
      return D.32076;
      <D.32150>:
      <D.32143>:
      i = i + 1;
      <D.27862>:
      if (i < len) goto <D.27861>; else goto <D.27863>;
      <D.27863>:
      goto <D.27844>;
      <D.27864>:
      obj.334 = obj;
      obj.337 = (long unsigned int) obj.334;
      buffer_add_long (buf, obj.337);
      goto <D.27844>;
      <D.27865>:
      obj.334 = obj;
      D.32082 = obj.334->vtable;
      D.32083 = D.32082->domain;
      buffer_add_domainid (buf, D.32083);
      goto <D.27844>;
      <D.27866>:
      obj.334 = obj;
      D.32082 = obj.334->vtable;
      D.32083 = D.32082->domain;
      obj.334 = obj;
      D.32082 = obj.334->vtable;
      D.32084 = D.32082->type;
      D.32085 = MEM[(struct MonoReflectionType *)D.32084].type;
      D.32152 = mono_class_from_mono_type (D.32085);
      buffer_add_typeid (buf, D.32083, D.32152);
      obj.334 = obj;
      D.32082 = obj.334->vtable;
      D.32083 = D.32082->domain;
      buffer_add_domainid (buf, D.32083);
      goto <D.27844>;
      <D.27867>:
      D.32076 = 100;
      return D.32076;
      <D.27844>:
      D.32076 = 0;
      return D.32076;
    }
  finally
    {
      err = {CLOBBER};
      obj = {CLOBBER};
    }
}


send_reply_packet (int id, int error, struct Buffer * data)
{
  guint8 * D.32155;
  long int D.32156;
  guint8 * D.32157;
  long int D.32158;
  long int D.32159;
  unsigned int D.32160;
  unsigned int D.32161;
  unsigned int len.338;
  unsigned int id.339;
  int D.32164;
  unsigned char D.32165;
  unsigned char D.32166;
  guint8 * D.32167;
  guint8 * D.32168;
  long unsigned int D.32169;
  gboolean D.32170;
  struct Buffer buf;
  int len;
  gboolean res;

  try
    {
      D.32155 = data->p;
      D.32156 = (long int) D.32155;
      D.32157 = data->buf;
      D.32158 = (long int) D.32157;
      D.32159 = D.32156 - D.32158;
      D.32160 = (unsigned int) D.32159;
      D.32161 = D.32160 + 11;
      len = (int) D.32161;
      buffer_init (&buf, len);
      len.338 = (unsigned int) len;
      buffer_add_int (&buf, len.338);
      id.339 = (unsigned int) id;
      buffer_add_int (&buf, id.339);
      buffer_add_byte (&buf, 128);
      D.32164 = error >> 8;
      D.32165 = (unsigned char) D.32164;
      buffer_add_byte (&buf, D.32165);
      D.32166 = (unsigned char) error;
      buffer_add_byte (&buf, D.32166);
      D.32167 = buf.buf;
      D.32168 = D.32167 + 11;
      D.32157 = data->buf;
      D.32155 = data->p;
      D.32156 = (long int) D.32155;
      D.32157 = data->buf;
      D.32158 = (long int) D.32157;
      D.32159 = D.32156 - D.32158;
      D.32169 = (long unsigned int) D.32159;
      memcpy (D.32168, D.32157, D.32169);
      D.32167 = buf.buf;
      res = transport_send (D.32167, len);
      buffer_free (&buf);
      D.32170 = res;
      return D.32170;
    }
  finally
    {
      buf = {CLOBBER};
    }
}


save_thread_context (struct MonoContext * ctx)
{
  unsigned int debugger_tls_id.340;
  _Bool D.32174;
  long int D.32175;
  long int D.32176;
  struct MonoThreadUnwindState * D.32181;
  struct DebuggerTlsData * tls;

  debugger_tls_id.340 = debugger_tls_id;
  tls = pthread_getspecific (debugger_tls_id.340);
  D.32174 = tls == 0B;
  D.32175 = (long int) D.32174;
  D.32176 = __builtin_expect (D.32175, 0);
  if (D.32176 != 0) goto <D.32177>; else goto <D.32178>;
  <D.32177>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 2357, "tls");
  <D.32178>:
  if (ctx != 0B) goto <D.32179>; else goto <D.32180>;
  <D.32179>:
  D.32181 = &tls->context;
  mono_thread_state_init_from_monoctx (D.32181, ctx);
  goto <D.32182>;
  <D.32180>:
  D.32181 = &tls->context;
  mono_thread_state_init_from_current (D.32181);
  <D.32182>:
}


suspend_vm ()
{
  int suspend_count.341;
  int suspend_count.342;
  int log_level.343;
  _Bool D.32186;
  long int D.32187;
  long int D.32188;
  struct FILE * log_file.344;
  long unsigned int D.32192;
  void * D.32193;
  struct MonoGHashTable * thread_to_tls.345;

  mono_loader_lock ();
  pthread_mutex_lock (&suspend_mutex);
  suspend_count.341 = suspend_count;
  suspend_count.342 = suspend_count.341 + 1;
  suspend_count = suspend_count.342;
  log_level.343 = log_level;
  D.32186 = log_level.343 > 0;
  D.32187 = (long int) D.32186;
  D.32188 = __builtin_expect (D.32187, 0);
  if (D.32188 != 0) goto <D.32189>; else goto <D.32190>;
  <D.32189>:
  log_file.344 = log_file;
  D.32192 = GetCurrentThreadId ();
  D.32193 = (void *) D.32192;
  fprintf (log_file.344, "[%p] Suspending vm...\n", D.32193);
  log_file.344 = log_file;
  fflush (log_file.344);
  <D.32190>:
  suspend_count.341 = suspend_count;
  if (suspend_count.341 == 1) goto <D.32194>; else goto <D.32195>;
  <D.32194>:
  start_single_stepping ();
  thread_to_tls.345 = thread_to_tls;
  mono_g_hash_table_foreach (thread_to_tls.345, notify_thread, 0B);
  <D.32195>:
  pthread_mutex_unlock (&suspend_mutex);
  suspend_count.341 = suspend_count;
  if (suspend_count.341 == 1) goto <D.32197>; else goto <D.32198>;
  <D.32197>:
  mono_thread_pool_suspend ();
  <D.32198>:
  mono_loader_unlock ();
}


notify_thread (void * key, void * value, void * user_data)
{
  long unsigned int D.32201;
  int D.32203;
  int log_level.346;
  _Bool D.32205;
  long int D.32206;
  long int D.32207;
  struct FILE * log_file.347;
  long unsigned int D.32211;
  void * D.32212;
  void * tid.348;
  gint32 * D.32214;
  int D.32215;
  long unsigned int D.32218;
  long unsigned int D.32223;
  void * D.32224;
  void * D.32226;
  long unsigned int D.32227;
  char * D.32228;
  long unsigned int D.32229;
  int D.32231;
  long unsigned int D.32236;
  void * D.32237;
  struct MonoInternalThread * thread;
  struct DebuggerTlsData * tls;
  gsize tid;
  int res;

  thread = key;
  tls = value;
  tid = thread->tid;
  D.32201 = GetCurrentThreadId ();
  if (D.32201 == tid) goto <D.32199>; else goto <D.32202>;
  <D.32202>:
  D.32203 = tls->terminated;
  if (D.32203 != 0) goto <D.32199>; else goto <D.32200>;
  <D.32199>:
  return;
  <D.32200>:
  log_level.346 = log_level;
  D.32205 = log_level.346 > 0;
  D.32206 = (long int) D.32205;
  D.32207 = __builtin_expect (D.32206, 0);
  if (D.32207 != 0) goto <D.32208>; else goto <D.32209>;
  <D.32208>:
  log_file.347 = log_file;
  D.32211 = GetCurrentThreadId ();
  D.32212 = (void *) D.32211;
  tid.348 = (void *) tid;
  fprintf (log_file.347, "[%p] Interrupting %p...\n", D.32212, tid.348);
  log_file.347 = log_file;
  fflush (log_file.347);
  <D.32209>:
  D.32214 = &tls->interrupt_count;
  InterlockedIncrement (D.32214);
  D.32215 = mono_thread_info_new_interrupt_enabled ();
  if (D.32215 != 0) goto <D.32216>; else goto <D.32217>;
  <D.32216>:
  {
    struct MonoThreadInfo * info;
    struct MonoJitInfo * ji;

    D.32218 = thread->tid;
    info = mono_thread_info_safe_suspend_sync (D.32218, 0);
    if (info == 0B) goto <D.32219>; else goto <D.32220>;
    <D.32219>:
    log_level.346 = log_level;
    D.32205 = log_level.346 > 0;
    D.32206 = (long int) D.32205;
    D.32207 = __builtin_expect (D.32206, 0);
    if (D.32207 != 0) goto <D.32221>; else goto <D.32222>;
    <D.32221>:
    log_file.347 = log_file;
    D.32223 = GetCurrentThreadId ();
    D.32224 = (void *) D.32223;
    tid.348 = (void *) tid;
    fprintf (log_file.347, "[%p] mono_thread_info_suspend_sync () failed for %p...\n", D.32224, tid.348);
    log_file.347 = log_file;
    fflush (log_file.347);
    <D.32222>:
    tls->terminated = 1;
    goto <D.32225>;
    <D.32220>:
    D.32226 = info->suspend_state.unwind_data[0];
    D.32227 = info->suspend_state.ctx.sc_ir;
    D.32228 = (char *) D.32227;
    ji = mono_jit_info_table_find (D.32226, D.32228);
    thread_interrupt (tls, info, 0B, ji);
    D.32229 = info->node.key;
    mono_thread_info_resume (D.32229);
    <D.32225>:
  }
  goto <D.32230>;
  <D.32217>:
  D.32231 = mono_thread_get_abort_signal ();
  res = mono_thread_kill (thread, D.32231);
  if (res != 0) goto <D.32232>; else goto <D.32233>;
  <D.32232>:
  log_level.346 = log_level;
  D.32205 = log_level.346 > 0;
  D.32206 = (long int) D.32205;
  D.32207 = __builtin_expect (D.32206, 0);
  if (D.32207 != 0) goto <D.32234>; else goto <D.32235>;
  <D.32234>:
  log_file.347 = log_file;
  D.32236 = GetCurrentThreadId ();
  D.32237 = (void *) D.32236;
  tid.348 = (void *) tid;
  fprintf (log_file.347, "[%p] mono_thread_kill () failed for %p: %d...\n", D.32237, tid.348, res);
  log_file.347 = log_file;
  fflush (log_file.347);
  <D.32235>:
  tls->terminated = 1;
  <D.32233>:
  <D.32230>:
}


thread_interrupt (struct DebuggerTlsData * tls, struct MonoThreadInfo * info, void * sigctx, struct MonoJitInfo * ji)
{
  int D.32239;
  gboolean D.32242;
  gint32 * D.32243;
  long unsigned int D.32249;
  int log_level.349;
  _Bool D.32257;
  long int D.32258;
  long int D.32259;
  struct FILE * log_file.350;
  void * tid.351;
  struct MonoMethod * D.32264;
  const char * D.32265;
  signed long D.32266;
  long unsigned int D.32267;
  long unsigned int D.32268;
  struct MonoInternalThread * D.32275;
  struct MonoRuntimeExceptionHandlingCallbacks * D.32283;
  void (*<T28ac>) (gboolean (*MonoInternalStackWalk) (struct MonoStackFrameInfo *, struct MonoContext *, void *), struct MonoThreadUnwindState *, MonoUnwindOptions, void *) D.32284;
  struct MonoThreadUnwindState * D.32285;
  int D.32286;
  struct StackFrameInfo * D.32289;
  struct MonoThreadUnwindState * D.32290;
  _Bool D.32291;
  long int D.32292;
  long int D.32293;
  struct MonoThreadUnwindState * D.32296;
  struct MonoContext * D.32299;
  void * D.32300;
  void * D.32301;
  gboolean res;
  void * ip;
  MonoNativeThreadId tid;

  D.32239 = tls->interrupt_count;
  if (D.32239 == 0) goto <D.32240>; else goto <D.32241>;
  <D.32240>:
  D.32242 = 0;
  return D.32242;
  <D.32241>:
  D.32243 = &tls->interrupt_count;
  InterlockedDecrement (D.32243);
  if (sigctx != 0B) goto <D.32244>; else goto <D.32245>;
  <D.32244>:
  ip = mono_arch_ip_from_context (sigctx);
  goto <D.32246>;
  <D.32245>:
  if (info != 0B) goto <D.32247>; else goto <D.32248>;
  <D.32247>:
  D.32249 = info->suspend_state.ctx.sc_ir;
  ip = (void *) D.32249;
  goto <D.32250>;
  <D.32248>:
  ip = 0B;
  <D.32250>:
  <D.32246>:
  if (info != 0B) goto <D.32251>; else goto <D.32252>;
  <D.32251>:
  tid = info->node.key;
  goto <D.32253>;
  <D.32252>:
  tid = GetCurrentThreadId ();
  <D.32253>:
  if (ji != 0B) goto <D.32254>; else goto <D.32255>;
  <D.32254>:
  log_level.349 = log_level;
  D.32257 = log_level.349 > 0;
  D.32258 = (long int) D.32257;
  D.32259 = __builtin_expect (D.32258, 0);
  if (D.32259 != 0) goto <D.32260>; else goto <D.32261>;
  <D.32260>:
  log_file.350 = log_file;
  tid.351 = (void *) tid;
  D.32264 = jinfo_get_method (ji);
  D.32265 = D.32264->name;
  fprintf (log_file.350, "[%p] Received interrupt while at %s(%p), continuing.\n", tid.351, D.32265, ip);
  log_file.350 = log_file;
  fflush (log_file.350);
  <D.32261>:
  D.32242 = 1;
  return D.32242;
  <D.32255>:
  D.32266 = BIT_FIELD_REF <*tls, 64, 3008>;
  D.32267 = (long unsigned int) D.32266;
  D.32268 = D.32267;
  if (D.32268 == 0) goto <D.32269>; else goto <D.32270>;
  <D.32269>:
  {
    struct MonoContext ctx;
    struct GetLastFrameUserData data;

    try
      {
        if (ip != 0B) goto <D.32271>; else goto <D.32272>;
        <D.32271>:
        log_level.349 = log_level;
        D.32257 = log_level.349 > 0;
        D.32258 = (long int) D.32257;
        D.32259 = __builtin_expect (D.32258, 0);
        if (D.32259 != 0) goto <D.32273>; else goto <D.32274>;
        <D.32273>:
        log_file.350 = log_file;
        tid.351 = (void *) tid;
        fprintf (log_file.350, "[%p] Received interrupt while at %p, treating as suspended.\n", tid.351, ip);
        log_file.350 = log_file;
        fflush (log_file.350);
        <D.32274>:
        <D.32272>:
        D.32275 = tls->thread;
        if (D.32275 == 0B) goto <D.32276>; else goto <D.32277>;
        <D.32276>:
        D.32242 = 1;
        return D.32242;
        <D.32277>:
        data.last_frame_set = 0;
        if (sigctx != 0B) goto <D.32278>; else goto <D.32279>;
        <D.32278>:
        mono_arch_sigctx_to_monoctx (sigctx, &ctx);
        mono_walk_stack_with_ctx (get_last_frame, &ctx, 0, &data);
        goto <D.32280>;
        <D.32279>:
        if (info != 0B) goto <D.32281>; else goto <D.32282>;
        <D.32281>:
        D.32283 = mono_get_eh_callbacks ();
        D.32284 = D.32283->mono_walk_stack_with_state;
        D.32285 = &info->suspend_state;
        D.32284 (get_last_frame, D.32285, 0, &data);
        <D.32282>:
        <D.32280>:
        D.32286 = data.last_frame_set;
        if (D.32286 != 0) goto <D.32287>; else goto <D.32288>;
        <D.32287>:
        D.32289 = &tls->async_last_frame;
        memcpy (D.32289, &data.last_frame, 88);
        D.32290 = &tls->async_state;
        res = mono_thread_state_init_from_monoctx (D.32290, &ctx);
        D.32291 = res == 0;
        D.32292 = (long int) D.32291;
        D.32293 = __builtin_expect (D.32292, 0);
        if (D.32293 != 0) goto <D.32294>; else goto <D.32295>;
        <D.32294>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 2519, "res");
        <D.32295>:
        D.32296 = &tls->context;
        mono_thread_state_init_from_monoctx (D.32296, &ctx);
        D.32291 = res == 0;
        D.32292 = (long int) D.32291;
        D.32293 = __builtin_expect (D.32292, 0);
        if (D.32293 != 0) goto <D.32297>; else goto <D.32298>;
        <D.32297>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 2521, "res");
        <D.32298>:
        D.32299 = &tls->async_state.ctx;
        memcpy (D.32299, &data.ctx, 312);
        D.32300 = data.lmf;
        tls->async_state.unwind_data[1] = D.32300;
        D.32275 = tls->thread;
        D.32301 = D.32275->jit_data;
        tls->async_state.unwind_data[2] = D.32301;
        goto <D.32302>;
        <D.32288>:
        tls->async_state.valid = 0;
        <D.32302>:
        mono_memory_barrier ();
        tls->suspended = 1;
        mono_sem_post (&suspend_sem);
      }
    finally
      {
        ctx = {CLOBBER};
        data = {CLOBBER};
      }
  }
  <D.32270>:
  D.32242 = 1;
  return D.32242;
}


get_last_frame (struct StackFrameInfo * info, struct MonoContext * ctx, void * user_data)
{
  <unnamed type> D.32306;
  gboolean D.32309;
  int D.32310;
  struct StackFrameInfo * D.32313;
  struct MonoContext * D.32314;
  void * D.32315;
  struct GetLastFrameUserData * data;

  data = user_data;
  D.32306 = info->type;
  if (D.32306 == 2) goto <D.32307>; else goto <D.32308>;
  <D.32307>:
  D.32309 = 0;
  return D.32309;
  <D.32308>:
  D.32310 = data->last_frame_set;
  if (D.32310 == 0) goto <D.32311>; else goto <D.32312>;
  <D.32311>:
  D.32313 = &data->last_frame;
  memcpy (D.32313, info, 88);
  data->last_frame_set = 1;
  D.32309 = 0;
  return D.32309;
  <D.32312>:
  D.32314 = &data->ctx;
  memcpy (D.32314, ctx, 312);
  D.32315 = info->lmf;
  data->lmf = D.32315;
  D.32309 = 1;
  return D.32309;
}


mono_memory_barrier ()
{
  __sync_synchronize ();
}


get_objref (struct MonoObject * obj)
{
  struct ObjRef * D.32319;
  struct GHashTable * obj_to_objref.352;
  struct GHashTable * obj_to_objref.353;
  struct MonoGHashTable * suspended_objs.354;
  int D.32325;
  int suspend_count.355;
  struct MonoGHashTable * suspended_objs.356;
  int D.32332;
  long int D.32335;
  const void * D.32336;
  unsigned int D.32339;
  struct MonoObject * D.32340;
  long unsigned int obj.357;
  long unsigned int D.32345;
  const void * D.32346;
  struct MonoObject * D.32349;
  int D.32352;
  unsigned int D.32353;
  struct GHashTable * objrefs.358;
  int D.32355;
  long int D.32356;
  void * D.32357;
  int D.32358;
  void * D.32361;
  void * D.32363;
  struct ObjRef * ref;
  struct GSList * reflist;
  struct GSList * l;
  int hash;

  reflist = 0B;
  hash = 0;
  if (obj == 0B) goto <D.32317>; else goto <D.32318>;
  <D.32317>:
  D.32319 = 0B;
  return D.32319;
  <D.32318>:
  mono_loader_lock ();
  obj_to_objref.352 = obj_to_objref;
  if (obj_to_objref.352 == 0B) goto <D.32321>; else goto <D.32322>;
  <D.32321>:
  obj_to_objref.353 = monoeg_g_hash_table_new (0B, 0B);
  obj_to_objref = obj_to_objref.353;
  suspended_objs.354 = mono_g_hash_table_new_type (0B, 0B, 1);
  suspended_objs = suspended_objs.354;
  D.32325 = mono_gc_is_moving ();
  if (D.32325 == 0) goto <D.32326>; else goto <D.32327>;
  <D.32326>:
  mono_gc_register_root (&suspended_objs, 8, 0B);
  <D.32327>:
  <D.32322>:
  suspend_count.355 = suspend_count;
  if (suspend_count.355 != 0) goto <D.32329>; else goto <D.32330>;
  <D.32329>:
  suspended_objs.356 = suspended_objs;
  mono_g_hash_table_insert (suspended_objs.356, obj, 0B);
  <D.32330>:
  D.32332 = mono_gc_is_moving ();
  if (D.32332 != 0) goto <D.32333>; else goto <D.32334>;
  <D.32333>:
  hash = mono_object_hash (obj);
  obj_to_objref.352 = obj_to_objref;
  D.32335 = (long int) hash;
  D.32336 = (const void *) D.32335;
  reflist = monoeg_g_hash_table_lookup (obj_to_objref.352, D.32336);
  l = reflist;
  goto <D.25610>;
  <D.25609>:
  ref = l->data;
  if (ref != 0B) goto <D.32337>; else goto <D.32338>;
  <D.32337>:
  D.32339 = ref->handle;
  D.32340 = mono_gchandle_get_target (D.32339);
  if (D.32340 == obj) goto <D.32341>; else goto <D.32342>;
  <D.32341>:
  mono_loader_unlock ();
  D.32319 = ref;
  return D.32319;
  <D.32342>:
  <D.32338>:
  l = l->next;
  <D.25610>:
  if (l != 0B) goto <D.25609>; else goto <D.25611>;
  <D.25611>:
  goto <D.32343>;
  <D.32334>:
  obj_to_objref.352 = obj_to_objref;
  obj.357 = (long unsigned int) obj;
  D.32345 = ~obj.357;
  D.32346 = (const void *) D.32345;
  ref = monoeg_g_hash_table_lookup (obj_to_objref.352, D.32346);
  if (ref != 0B) goto <D.32347>; else goto <D.32348>;
  <D.32347>:
  D.32339 = ref->handle;
  D.32349 = mono_gchandle_get_target (D.32339);
  if (D.32349 == obj) goto <D.32350>; else goto <D.32351>;
  <D.32350>:
  mono_loader_unlock ();
  D.32319 = ref;
  return D.32319;
  <D.32351>:
  <D.32348>:
  <D.32343>:
  ref = monoeg_malloc0 (8);
  D.32352 = InterlockedIncrement (&objref_id);
  ref->id = D.32352;
  D.32353 = mono_gchandle_new_weakref (obj, 0);
  ref->handle = D.32353;
  objrefs.358 = objrefs;
  D.32355 = ref->id;
  D.32356 = (long int) D.32355;
  D.32357 = (void *) D.32356;
  monoeg_g_hash_table_insert_replace (objrefs.358, D.32357, ref, 0);
  D.32358 = mono_gc_is_moving ();
  if (D.32358 != 0) goto <D.32359>; else goto <D.32360>;
  <D.32359>:
  reflist = monoeg_g_slist_append (reflist, ref);
  obj_to_objref.352 = obj_to_objref;
  D.32335 = (long int) hash;
  D.32361 = (void *) D.32335;
  monoeg_g_hash_table_insert_replace (obj_to_objref.352, D.32361, reflist, 0);
  goto <D.32362>;
  <D.32360>:
  obj_to_objref.352 = obj_to_objref;
  obj.357 = (long unsigned int) obj;
  D.32345 = ~obj.357;
  D.32363 = (void *) D.32345;
  monoeg_g_hash_table_insert_replace (obj_to_objref.352, D.32363, ref, 0);
  <D.32362>:
  mono_loader_unlock ();
  D.32319 = ref;
  return D.32319;
}


send_packet (int command_set, int command, struct Buffer * data)
{
  guint8 * D.32365;
  long int D.32366;
  guint8 * D.32367;
  long int D.32368;
  long int D.32369;
  unsigned int D.32370;
  unsigned int D.32371;
  unsigned int len.359;
  unsigned int id.360;
  unsigned char D.32374;
  unsigned char D.32375;
  guint8 * D.32376;
  guint8 * D.32377;
  long unsigned int D.32378;
  gboolean D.32379;
  struct Buffer buf;
  int len;
  int id;
  gboolean res;

  try
    {
      id = InterlockedIncrement (&packet_id);
      D.32365 = data->p;
      D.32366 = (long int) D.32365;
      D.32367 = data->buf;
      D.32368 = (long int) D.32367;
      D.32369 = D.32366 - D.32368;
      D.32370 = (unsigned int) D.32369;
      D.32371 = D.32370 + 11;
      len = (int) D.32371;
      buffer_init (&buf, len);
      len.359 = (unsigned int) len;
      buffer_add_int (&buf, len.359);
      id.360 = (unsigned int) id;
      buffer_add_int (&buf, id.360);
      buffer_add_byte (&buf, 0);
      D.32374 = (unsigned char) command_set;
      buffer_add_byte (&buf, D.32374);
      D.32375 = (unsigned char) command;
      buffer_add_byte (&buf, D.32375);
      D.32376 = buf.buf;
      D.32377 = D.32376 + 11;
      D.32367 = data->buf;
      D.32365 = data->p;
      D.32366 = (long int) D.32365;
      D.32367 = data->buf;
      D.32368 = (long int) D.32367;
      D.32369 = D.32366 - D.32368;
      D.32378 = (long unsigned int) D.32369;
      memcpy (D.32377, D.32367, D.32378);
      D.32376 = buf.buf;
      res = transport_send (D.32376, len);
      buffer_free (&buf);
      D.32379 = res;
      return D.32379;
    }
  finally
    {
      buf = {CLOBBER};
    }
}


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

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


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

  switch (event) <default: <D.26157>, case 0: <D.26140>, case 1: <D.26141>, case 2: <D.26142>, case 3: <D.26143>, case 4: <D.26144>, case 5: <D.26145>, case 6: <D.26146>, case 7: <D.26147>, case 8: <D.26148>, case 9: <D.26149>, case 10: <D.26150>, case 11: <D.26151>, case 12: <D.26152>, case 13: <D.26153>, case 14: <D.26154>, case 15: <D.26155>, case 16: <D.26156>>
  <D.26140>:
  D.32383 = "VM_START";
  return D.32383;
  <D.26141>:
  D.32383 = "VM_DEATH";
  return D.32383;
  <D.26142>:
  D.32383 = "THREAD_START";
  return D.32383;
  <D.26143>:
  D.32383 = "THREAD_DEATH";
  return D.32383;
  <D.26144>:
  D.32383 = "APPDOMAIN_CREATE";
  return D.32383;
  <D.26145>:
  D.32383 = "APPDOMAIN_UNLOAD";
  return D.32383;
  <D.26146>:
  D.32383 = "METHOD_ENTRY";
  return D.32383;
  <D.26147>:
  D.32383 = "METHOD_EXIT";
  return D.32383;
  <D.26148>:
  D.32383 = "ASSEMBLY_LOAD";
  return D.32383;
  <D.26149>:
  D.32383 = "ASSEMBLY_UNLOAD";
  return D.32383;
  <D.26150>:
  D.32383 = "BREAKPOINT";
  return D.32383;
  <D.26151>:
  D.32383 = "STEP";
  return D.32383;
  <D.26152>:
  D.32383 = "TYPE_LOAD";
  return D.32383;
  <D.26153>:
  D.32383 = "EXCEPTION";
  return D.32383;
  <D.26154>:
  D.32383 = "KEEPALIVE";
  return D.32383;
  <D.26155>:
  D.32383 = "USER_BREAK";
  return D.32383;
  <D.26156>:
  D.32383 = "USER_LOG";
  return D.32383;
  <D.26157>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "debugger-agent.c", 3535);
  D.32383 = "";
  return D.32383;
}


suspend_current ()
{
  long unsigned int D.32385;
  long unsigned int debugger_thread_id.361;
  _Bool D.32387;
  long int D.32388;
  long int D.32389;
  int D.32392;
  unsigned int debugger_tls_id.362;
  _Bool D.32396;
  long int D.32397;
  long int D.32398;
  int D.32401;
  int log_level.363;
  _Bool D.32405;
  long int D.32406;
  long int D.32407;
  struct FILE * log_file.364;
  long unsigned int D.32411;
  void * D.32412;
  _Bool D.32413;
  long int D.32414;
  long int D.32415;
  int suspend_count.365;
  unsigned int suspend_count.366;
  unsigned int D.32420;
  int threads_suspend_count.367;
  int threads_suspend_count.368;
  long unsigned int D.32425;
  void * D.32426;
  struct InvokeData * D.32427;
  int err;
  struct DebuggerTlsData * tls;

  D.32385 = GetCurrentThreadId ();
  debugger_thread_id.361 = debugger_thread_id;
  D.32387 = D.32385 == debugger_thread_id.361;
  D.32388 = (long int) D.32387;
  D.32389 = __builtin_expect (D.32388, 0);
  if (D.32389 != 0) goto <D.32390>; else goto <D.32391>;
  <D.32390>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 2855, "debugger_thread_id != GetCurrentThreadId ()");
  <D.32391>:
  D.32392 = mono_loader_lock_is_owned_by_self ();
  if (D.32392 != 0) goto <D.32393>; else goto <D.32394>;
  <D.32393>:
  return;
  <D.32394>:
  debugger_tls_id.362 = debugger_tls_id;
  tls = pthread_getspecific (debugger_tls_id.362);
  D.32396 = tls == 0B;
  D.32397 = (long int) D.32396;
  D.32398 = __builtin_expect (D.32397, 0);
  if (D.32398 != 0) goto <D.32399>; else goto <D.32400>;
  <D.32399>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 2866, "tls");
  <D.32400>:
  pthread_mutex_lock (&suspend_mutex);
  tls->suspending = 0;
  tls->really_suspended = 1;
  D.32401 = tls->suspended;
  if (D.32401 == 0) goto <D.32402>; else goto <D.32403>;
  <D.32402>:
  tls->suspended = 1;
  mono_sem_post (&suspend_sem);
  <D.32403>:
  log_level.363 = log_level;
  D.32405 = log_level.363 > 0;
  D.32406 = (long int) D.32405;
  D.32407 = __builtin_expect (D.32406, 0);
  if (D.32407 != 0) goto <D.32408>; else goto <D.32409>;
  <D.32408>:
  log_file.364 = log_file;
  D.32411 = GetCurrentThreadId ();
  D.32412 = (void *) D.32411;
  fprintf (log_file.364, "[%p] Suspended.\n", D.32412);
  log_file.364 = log_file;
  fflush (log_file.364);
  <D.32409>:
  goto <D.25944>;
  <D.25943>:
  err = pthread_cond_wait (&suspend_cond, &suspend_mutex);
  D.32413 = err != 0;
  D.32414 = (long int) D.32413;
  D.32415 = __builtin_expect (D.32414, 0);
  if (D.32415 != 0) goto <D.32416>; else goto <D.32417>;
  <D.32416>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 2893, "err == 0");
  <D.32417>:
  <D.25944>:
  suspend_count.365 = suspend_count;
  suspend_count.366 = (unsigned int) suspend_count.365;
  D.32420 = tls->resume_count;
  if (suspend_count.366 != D.32420) goto <D.25943>; else goto <D.25945>;
  <D.25945>:
  tls->suspended = 0;
  tls->really_suspended = 0;
  threads_suspend_count.367 = threads_suspend_count;
  threads_suspend_count.368 = threads_suspend_count.367 + -1;
  threads_suspend_count = threads_suspend_count.368;
  pthread_mutex_unlock (&suspend_mutex);
  log_level.363 = log_level;
  D.32405 = log_level.363 > 0;
  D.32406 = (long int) D.32405;
  D.32407 = __builtin_expect (D.32406, 0);
  if (D.32407 != 0) goto <D.32423>; else goto <D.32424>;
  <D.32423>:
  log_file.364 = log_file;
  D.32425 = GetCurrentThreadId ();
  D.32426 = (void *) D.32425;
  fprintf (log_file.364, "[%p] Resumed.\n", D.32426);
  log_file.364 = log_file;
  fflush (log_file.364);
  <D.32424>:
  D.32427 = tls->pending_invoke;
  if (D.32427 != 0B) goto <D.32428>; else goto <D.32429>;
  <D.32428>:
  D.32427 = tls->pending_invoke;
  D.32427->has_ctx = 1;
  D.32427 = tls->pending_invoke;
  D.32427->ctx = tls->context.ctx;
  invoke_method ();
  <D.32429>:
  tls->context.valid = 0;
  tls->async_state.valid = 0;
  invalidate_frames (tls);
}


invoke_method ()
{
  unsigned int debugger_tls_id.369;
  _Bool D.32432;
  long int D.32433;
  long int D.32434;
  _Bool D.32437;
  long int D.32438;
  long int D.32439;
  struct InvokeData * D.32442;
  guint8 * p.370;
  guint8 * p.371;
  <unnamed type> D.32448;
  int D.32449;
  int D.32450;
  int D.32453;
  int D.32454;
  unsigned int i.372;
  unsigned int D.32458;
  struct MonoContext * D.32459;
  int D.32460;
  unsigned int D.32465;
  _Bool D.32466;
  long int D.32467;
  long int D.32468;
  unsigned int D.32471;
  int log_level.373;
  _Bool D.32473;
  long int D.32474;
  long int D.32475;
  struct FILE * log_file.374;
  long unsigned int D.32479;
  void * D.32480;
  int D.32481;
  struct MonoInternalThread * D.32484;
  struct InvokeData * D.32485;
  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.369 = debugger_tls_id;
      tls = pthread_getspecific (debugger_tls_id.369);
      D.32432 = tls == 0B;
      D.32433 = (long int) D.32432;
      D.32434 = __builtin_expect (D.32433, 0);
      if (D.32434 != 0) goto <D.32435>; else goto <D.32436>;
      <D.32435>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 6421, "tls");
      <D.32436>:
      mono_loader_lock ();
      invoke = tls->pending_invoke;
      D.32437 = invoke == 0B;
      D.32438 = (long int) D.32437;
      D.32439 = __builtin_expect (D.32438, 0);
      if (D.32439 != 0) goto <D.32440>; else goto <D.32441>;
      <D.32440>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 6431, "invoke");
      <D.32441>:
      tls->pending_invoke = 0B;
      D.32442 = tls->invoke;
      invoke->last_invoke = D.32442;
      tls->invoke = invoke;
      mono_loader_unlock ();
      tls->frames_up_to_date = 0;
      id = invoke->id;
      p.370 = invoke->p;
      p = p.370;
      err = 0;
      mindex = 0;
      goto <D.27065>;
      <D.27064>:
      buffer_init (&buf, 128);
      if (err != 0) goto <D.32444>; else goto <D.32445>;
      <D.32444>:
      goto <D.32446>;
      <D.32445>:
      p.371 = p;
      D.32448 = do_invoke_method (tls, &buf, invoke, p.371, &p);
      err = (int) D.32448;
      <D.32446>:
      D.32449 = invoke->nmethods;
      D.32450 = D.32449 + -1;
      if (D.32450 == mindex) goto <D.32451>; else goto <D.32452>;
      <D.32451>:
      D.32453 = invoke->flags;
      D.32454 = D.32453 & 2;
      if (D.32454 == 0) goto <D.32455>; else goto <D.32456>;
      <D.32455>:
      i = 0;
      goto <D.27062>;
      <D.27061>:
      suspend_vm ();
      i = i + 1;
      <D.27062>:
      i.372 = (unsigned int) i;
      D.32458 = invoke->suspend_count;
      if (i.372 < D.32458) goto <D.27061>; else goto <D.27063>;
      <D.27063>:
      <D.32456>:
      <D.32452>:
      send_reply_packet (id, err, &buf);
      buffer_free (&buf);
      mindex = mindex + 1;
      <D.27065>:
      D.32449 = invoke->nmethods;
      if (D.32449 > mindex) goto <D.27064>; else goto <D.27066>;
      <D.27066>:
      D.32459 = &invoke->ctx;
      memcpy (&restore_ctx, D.32459, 312);
      D.32460 = invoke->has_ctx;
      if (D.32460 != 0) goto <D.32461>; else goto <D.32462>;
      <D.32461>:
      save_thread_context (&restore_ctx);
      <D.32462>:
      D.32453 = invoke->flags;
      D.32454 = D.32453 & 2;
      if (D.32454 != 0) goto <D.32463>; else goto <D.32464>;
      <D.32463>:
      D.32465 = tls->resume_count;
      D.32466 = D.32465 == 0;
      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", 6473, "tls->resume_count");
      <D.32470>:
      D.32465 = tls->resume_count;
      D.32458 = invoke->suspend_count;
      D.32471 = D.32465 - D.32458;
      tls->resume_count = D.32471;
      <D.32464>:
      log_level.373 = log_level;
      D.32473 = log_level.373 > 0;
      D.32474 = (long int) D.32473;
      D.32475 = __builtin_expect (D.32474, 0);
      if (D.32475 != 0) goto <D.32476>; else goto <D.32477>;
      <D.32476>:
      log_file.374 = log_file;
      D.32479 = GetCurrentThreadId ();
      D.32480 = (void *) D.32479;
      D.32465 = tls->resume_count;
      fprintf (log_file.374, "[%p] Invoke finished (%d), resume_count = %d.\n", D.32480, err, D.32465);
      log_file.374 = log_file;
      fflush (log_file.374);
      <D.32477>:
      mono_loader_lock ();
      D.32481 = tls->abort_requested;
      if (D.32481 != 0) goto <D.32482>; else goto <D.32483>;
      <D.32482>:
      D.32484 = tls->thread;
      mono_thread_internal_reset_abort (D.32484);
      <D.32483>:
      D.32442 = tls->invoke;
      D.32485 = D.32442->last_invoke;
      tls->invoke = D.32485;
      tls->abort_requested = 0;
      mono_loader_unlock ();
      p.370 = invoke->p;
      monoeg_g_free (p.370);
      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.32486;
  int log_level.375;
  _Bool D.32490;
  long int D.32491;
  long int D.32492;
  struct FILE * log_file.376;
  long unsigned int D.32496;
  void * D.32497;
  char * D.32498;
  const char * iftmp.377;
  struct MonoObject * this.378;
  struct MonoVTable * D.32503;
  struct MonoClass * D.32504;
  void * * D.32506;
  guint8 * p.379;
  int err.380;
  ErrorCode D.32511;
  struct MonoClass * D.32512;
  long unsigned int D.32513;
  long unsigned int D.32514;
  int D.32517;
  long unsigned int D.32518;
  short unsigned int D.32523;
  int D.32524;
  int D.32525;
  long unsigned int D.32531;
  void * D.32532;
  int D.32533;
  long unsigned int D.32534;
  struct MonoType * D.32535;
  struct MonoDomain * domain.381;
  <unnamed type> D.32537;
  int err.382;
  struct MonoObject * this.383;
  unsigned int D.32547;
  unsigned int D.32548;
  unsigned char D.32550;
  long unsigned int D.32556;
  void * D.32557;
  long unsigned int D.32560;
  void * D.32561;
  char * D.32562;
  const char * iftmp.384;
  struct MonoDomain * D.32569;
  int D.27033;
  int iftmp.385;
  int D.27032;
  const char[6] * D.32581;
  unsigned char D.32582;
  int D.32583;
  unsigned char D.32584;
  int D.32585;
  const unsigned char * D.32590;
  unsigned char D.32591;
  int D.32592;
  const unsigned char * D.32593;
  unsigned char D.32594;
  int D.32595;
  const unsigned char * D.32600;
  unsigned char D.32601;
  int D.32602;
  const unsigned char * D.32603;
  unsigned char D.32604;
  int D.32605;
  const unsigned char * D.32610;
  unsigned char D.32611;
  int D.32612;
  const unsigned char * D.32613;
  unsigned char D.32614;
  int D.32615;
  const char * D.32617;
  unsigned int D.32620;
  struct MonoObject * this.386;
  int D.32627;
  short unsigned int D.32630;
  int D.32631;
  long unsigned int D.32634;
  long unsigned int D.32635;
  struct MonoType * D.32636;
  int D.32637;
  long unsigned int D.32640;
  long unsigned int D.32641;
  guint8 * D.32642;
  <unnamed type> D.32643;
  int err.387;
  void * * D.32646;
  void * D.32647;
  struct MonoVTable * D.32650;
  struct MonoDomain * D.32651;
  guint8 * * D.32655;
  struct MonoClass * D.32656;
  int D.32657;
  long unsigned int D.32658;
  void * D.32659;
  guint8 * D.32660;
  <unnamed type> D.32661;
  int err.388;
  int D.32666;
  int D.32667;
  int D.32671;
  struct MonoLMF * D.32674;
  struct MonoContext * D.32675;
  struct MonoObject * res.389;
  struct MonoObject * res.390;
  long unsigned int D.32683;
  void * D.32684;
  struct MonoObject * res.391;
  const char * iftmp.392;
  struct MonoObject * exc.393;
  struct MonoVTable * D.32690;
  struct MonoClass * D.32691;
  long unsigned int D.32693;
  long int D.32694;
  struct MonoClass * D.32697;
  struct MonoType * D.32698;
  struct MonoType * D.32700;
  unsigned char D.32701;
  int D.27046;
  int iftmp.394;
  int D.27045;
  unsigned char D.32709;
  int D.32710;
  const unsigned char * D.32715;
  unsigned char D.32716;
  int D.32717;
  const unsigned char * D.32722;
  unsigned char D.32723;
  int D.32724;
  const unsigned char * D.32729;
  unsigned char D.32730;
  int D.32731;
  struct MonoClass * D.32735;
  struct MonoType * D.32736;
  int D.32738;
  struct MonoClass * D.32745;
  long unsigned int D.32746;
  long unsigned int D.32747;
  struct MonoClass * D.32750;
  int D.32751;
  int D.32754;
  long unsigned int D.32755;
  _Bool D.32756;
  long int D.32757;
  long int D.32758;
  _Bool D.32762;
  long int D.32763;
  long int D.32764;
  void * D.32767;
  void * D.32770;
  long int D.32771;
  long int D.32772;
  struct MonoLMF * D.32773;
  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.32486 = invoke->method;
      if (D.32486 != 0B) goto <D.32487>; else goto <D.32488>;
      <D.32487>:
      this = 0B;
      log_level.375 = log_level;
      D.32490 = log_level.375 > 0;
      D.32491 = (long int) D.32490;
      D.32492 = __builtin_expect (D.32491, 0);
      if (D.32492 != 0) goto <D.32493>; else goto <D.32494>;
      <D.32493>:
      log_file.376 = log_file;
      D.32496 = GetCurrentThreadId ();
      D.32497 = (void *) D.32496;
      D.32486 = invoke->method;
      D.32498 = mono_method_full_name (D.32486, 1);
      this.378 = this;
      if (this.378 != 0B) goto <D.32501>; else goto <D.32502>;
      <D.32501>:
      this.378 = this;
      D.32503 = this.378->vtable;
      D.32504 = D.32503->klass;
      iftmp.377 = D.32504->name;
      goto <D.32505>;
      <D.32502>:
      iftmp.377 = "<null>";
      <D.32505>:
      fprintf (log_file.376, "[%p] Invoking method \'%s\' on receiver \'%s\'.\n", D.32497, D.32498, iftmp.377);
      log_file.376 = log_file;
      fflush (log_file.376);
      <D.32494>:
      D.32486 = invoke->method;
      D.32506 = invoke->args;
      mono_runtime_invoke (D.32486, 0B, D.32506, &exc);
      monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "debugger-agent.c", 6243);
      <D.32488>:
      p.379 = p;
      m = decode_methodid (p.379, &p, end, &domain, &err);
      err.380 = err;
      if (err.380 != 0) goto <D.32509>; else goto <D.32510>;
      <D.32509>:
      err.380 = err;
      D.32511 = (ErrorCode) err.380;
      return D.32511;
      <D.32510>:
      sig = mono_method_signature (m);
      D.32512 = m->klass;
      D.32513 = BIT_FIELD_REF <*D.32512, 64, 256>;
      D.32514 = D.32513 & 8;
      if (D.32514 != 0) goto <D.32515>; else goto <D.32516>;
      <D.32515>:
      D.32512 = m->klass;
      D.32517 = mono_class_instance_size (D.32512);
      D.32518 = (long unsigned int) D.32517;
      this_buf = __builtin_alloca (D.32518);
      goto <D.32519>;
      <D.32516>:
      this_buf = __builtin_alloca (8);
      <D.32519>:
      D.32512 = m->klass;
      D.32513 = BIT_FIELD_REF <*D.32512, 64, 256>;
      D.32514 = D.32513 & 8;
      if (D.32514 != 0) goto <D.32522>; else goto <D.32520>;
      <D.32522>:
      D.32523 = m->flags;
      D.32524 = (int) D.32523;
      D.32525 = D.32524 & 16;
      if (D.32525 != 0) goto <D.32526>; else goto <D.32520>;
      <D.32526>:
      {
        int type;

        p.379 = p;
        type = decode_byte (p.379, &p, end);
        if (type != 240) goto <D.32527>; else goto <D.32528>;
        <D.32527>:
        log_level.375 = log_level;
        D.32490 = log_level.375 > 0;
        D.32491 = (long int) D.32490;
        D.32492 = __builtin_expect (D.32491, 0);
        if (D.32492 != 0) goto <D.32529>; else goto <D.32530>;
        <D.32529>:
        log_file.376 = log_file;
        D.32531 = GetCurrentThreadId ();
        D.32532 = (void *) D.32531;
        fprintf (log_file.376, "[%p] Error: Static vtype method invoked with this argument.\n", D.32532);
        log_file.376 = log_file;
        fflush (log_file.376);
        <D.32530>:
        D.32511 = 102;
        return D.32511;
        <D.32528>:
        D.32512 = m->klass;
        D.32533 = mono_class_instance_size (D.32512);
        D.32534 = (long unsigned int) D.32533;
        memset (this_buf, 0, D.32534);
      }
      goto <D.32521>;
      <D.32520>:
      D.32512 = m->klass;
      D.32535 = &D.32512->byval_arg;
      domain.381 = domain;
      p.379 = p;
      D.32537 = decode_value (D.32535, domain.381, this_buf, p.379, &p, end);
      err.382 = (int) D.32537;
      err = err.382;
      err.380 = err;
      if (err.380 != 0) goto <D.32539>; else goto <D.32540>;
      <D.32539>:
      err.380 = err;
      D.32511 = (ErrorCode) err.380;
      return D.32511;
      <D.32540>:
      <D.32521>:
      D.32512 = m->klass;
      D.32513 = BIT_FIELD_REF <*D.32512, 64, 256>;
      D.32514 = D.32513 & 8;
      if (D.32514 == 0) goto <D.32541>; else goto <D.32542>;
      <D.32541>:
      this.383 = MEM[(struct MonoObject * *)this_buf];
      this = this.383;
      goto <D.32544>;
      <D.32542>:
      this = 0B;
      <D.32544>:
      D.32512 = m->klass;
      D.32547 = D.32512->flags;
      D.32548 = D.32547 & 32;
      if (D.32548 != 0) goto <D.32545>; else goto <D.32549>;
      <D.32549>:
      D.32512 = m->klass;
      D.32550 = D.32512->byval_arg.type;
      if (D.32550 == 19) goto <D.32545>; else goto <D.32551>;
      <D.32551>:
      D.32512 = m->klass;
      D.32550 = D.32512->byval_arg.type;
      if (D.32550 == 30) goto <D.32545>; else goto <D.32546>;
      <D.32545>:
      this.378 = this;
      if (this.378 == 0B) goto <D.32552>; else goto <D.32553>;
      <D.32552>:
      log_level.375 = log_level;
      D.32490 = log_level.375 > 0;
      D.32491 = (long int) D.32490;
      D.32492 = __builtin_expect (D.32491, 0);
      if (D.32492 != 0) goto <D.32554>; else goto <D.32555>;
      <D.32554>:
      log_file.376 = log_file;
      D.32556 = GetCurrentThreadId ();
      D.32557 = (void *) D.32556;
      fprintf (log_file.376, "[%p] Error: Interface method invoked without this argument.\n", D.32557);
      log_file.376 = log_file;
      fflush (log_file.376);
      <D.32555>:
      D.32511 = 102;
      return D.32511;
      <D.32553>:
      this.378 = this;
      m = mono_object_get_virtual_method (this.378, m);
      <D.32546>:
      log_level.375 = log_level;
      D.32490 = log_level.375 > 0;
      D.32491 = (long int) D.32490;
      D.32492 = __builtin_expect (D.32491, 0);
      if (D.32492 != 0) goto <D.32558>; else goto <D.32559>;
      <D.32558>:
      log_file.376 = log_file;
      D.32560 = GetCurrentThreadId ();
      D.32561 = (void *) D.32560;
      D.32562 = mono_method_full_name (m, 1);
      this.378 = this;
      if (this.378 != 0B) goto <D.32564>; else goto <D.32565>;
      <D.32564>:
      this.378 = this;
      D.32503 = this.378->vtable;
      D.32504 = D.32503->klass;
      iftmp.384 = D.32504->name;
      goto <D.32566>;
      <D.32565>:
      iftmp.384 = "<null>";
      <D.32566>:
      fprintf (log_file.376, "[%p] Invoking method \'%s\' on receiver \'%s\'.\n", D.32561, D.32562, iftmp.384);
      log_file.376 = log_file;
      fflush (log_file.376);
      <D.32559>:
      this.378 = this;
      if (this.378 != 0B) goto <D.32567>; else goto <D.32568>;
      <D.32567>:
      this.378 = this;
      D.32503 = this.378->vtable;
      D.32569 = D.32503->domain;
      domain.381 = domain;
      if (D.32569 != domain.381) goto <D.32570>; else goto <D.32571>;
      <D.32570>:
      monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "debugger-agent.c", 6285);
      <D.32571>:
      <D.32568>:
      D.32512 = m->klass;
      D.32513 = BIT_FIELD_REF <*D.32512, 64, 256>;
      D.32514 = D.32513 & 8;
      if (D.32514 == 0) goto <D.32572>; else goto <D.32573>;
      <D.32572>:
      D.32523 = m->flags;
      D.32524 = (int) D.32523;
      D.32525 = D.32524 & 16;
      if (D.32525 == 0) goto <D.32574>; else goto <D.32575>;
      <D.32574>:
      this.378 = this;
      if (this.378 == 0B) goto <D.32576>; else goto <D.32577>;
      <D.32576>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          __s2 = m->name;
          D.32581 = ".ctor";
          D.32582 = MEM[(const unsigned char *)D.32581];
          D.32583 = (int) D.32582;
          D.32584 = *__s2;
          D.32585 = (int) D.32584;
          __result = D.32583 - D.32585;
          {
            if (__s2_len != 0) goto <D.32586>; else goto <D.32587>;
            <D.32586>:
            if (__result == 0) goto <D.32588>; else goto <D.32589>;
            <D.32588>:
            D.32590 = &MEM[(void *)".ctor" + 1B];
            D.32591 = *D.32590;
            D.32592 = (int) D.32591;
            D.32593 = __s2 + 1;
            D.32594 = *D.32593;
            D.32595 = (int) D.32594;
            __result = D.32592 - D.32595;
            if (__s2_len > 1) goto <D.32596>; else goto <D.32597>;
            <D.32596>:
            if (__result == 0) goto <D.32598>; else goto <D.32599>;
            <D.32598>:
            D.32600 = &MEM[(void *)".ctor" + 2B];
            D.32601 = *D.32600;
            D.32602 = (int) D.32601;
            D.32603 = __s2 + 2;
            D.32604 = *D.32603;
            D.32605 = (int) D.32604;
            __result = D.32602 - D.32605;
            if (__s2_len > 2) goto <D.32606>; else goto <D.32607>;
            <D.32606>:
            if (__result == 0) goto <D.32608>; else goto <D.32609>;
            <D.32608>:
            D.32610 = &MEM[(void *)".ctor" + 3B];
            D.32611 = *D.32610;
            D.32612 = (int) D.32611;
            D.32613 = __s2 + 3;
            D.32614 = *D.32613;
            D.32615 = (int) D.32614;
            __result = D.32612 - D.32615;
            <D.32609>:
            <D.32607>:
            <D.32599>:
            <D.32597>:
            <D.32589>:
            <D.32587>:
          }
          D.27032 = __result;
        }
        iftmp.385 = -D.27032;
        goto <D.32616>;
        <D.32580>:
        D.32617 = m->name;
        iftmp.385 = __builtin_strcmp (D.32617, ".ctor");
        <D.32616>:
        D.27033 = iftmp.385;
      }
      if (D.27033 == 0) goto <D.32618>; else goto <D.32619>;
      <D.32618>:
      D.32512 = m->klass;
      D.32547 = D.32512->flags;
      D.32620 = D.32547 & 128;
      if (D.32620 != 0) goto <D.32621>; else goto <D.32622>;
      <D.32621>:
      D.32511 = 102;
      return D.32511;
      <D.32622>:
      domain.381 = domain;
      D.32512 = m->klass;
      this.386 = mono_object_new (domain.381, D.32512);
      this = this.386;
      goto <D.32624>;
      <D.32619>:
      D.32511 = 102;
      return D.32511;
      <D.32624>:
      <D.32577>:
      <D.32575>:
      <D.32573>:
      this.378 = this;
      if (this.378 != 0B) goto <D.32625>; else goto <D.32626>;
      <D.32625>:
      this.378 = this;
      D.32512 = m->klass;
      D.32535 = &D.32512->byval_arg;
      D.32627 = obj_is_of_type (this.378, D.32535);
      if (D.32627 == 0) goto <D.32628>; else goto <D.32629>;
      <D.32628>:
      D.32511 = 102;
      return D.32511;
      <D.32629>:
      <D.32626>:
      p.379 = p;
      nargs = decode_int (p.379, &p, end);
      D.32630 = sig->param_count;
      D.32631 = (int) D.32630;
      if (D.32631 != nargs) goto <D.32632>; else goto <D.32633>;
      <D.32632>:
      D.32511 = 102;
      return D.32511;
      <D.32633>:
      D.32634 = (long unsigned int) nargs;
      D.32635 = D.32634 * 8;
      arg_buf = __builtin_alloca (D.32635);
      D.32634 = (long unsigned int) nargs;
      D.32635 = D.32634 * 8;
      memset (arg_buf, 0, D.32635);
      D.32634 = (long unsigned int) nargs;
      D.32635 = D.32634 * 8;
      args = __builtin_alloca (D.32635);
      i = 0;
      goto <D.27036>;
      <D.27035>:
      D.32636 = sig->params[i];
      D.32637 = mono_type_is_reference (D.32636);
      if (D.32637 != 0) goto <D.32638>; else goto <D.32639>;
      <D.32638>:
      D.32636 = sig->params[i];
      domain.381 = domain;
      D.32640 = (long unsigned int) i;
      D.32641 = D.32640 * 8;
      D.32642 = args + D.32641;
      p.379 = p;
      D.32643 = decode_value (D.32636, domain.381, D.32642, p.379, &p, end);
      err.387 = (int) D.32643;
      err = err.387;
      err.380 = err;
      if (err.380 != 0) goto <D.27034>; else goto <D.32645>;
      <D.32645>:
      D.32640 = (long unsigned int) i;
      D.32641 = D.32640 * 8;
      D.32646 = args + D.32641;
      D.32647 = *D.32646;
      if (D.32647 != 0B) goto <D.32648>; else goto <D.32649>;
      <D.32648>:
      D.32640 = (long unsigned int) i;
      D.32641 = D.32640 * 8;
      D.32646 = args + D.32641;
      D.32647 = *D.32646;
      D.32650 = MEM[(struct MonoObject *)D.32647].vtable;
      D.32651 = D.32650->domain;
      domain.381 = domain;
      if (D.32651 != domain.381) goto <D.32652>; else goto <D.32653>;
      <D.32652>:
      monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "debugger-agent.c", 6315);
      <D.32653>:
      <D.32649>:
      goto <D.32654>;
      <D.32639>:
      D.32640 = (long unsigned int) i;
      D.32641 = D.32640 * 8;
      D.32655 = arg_buf + D.32641;
      D.32636 = sig->params[i];
      D.32656 = mono_class_from_mono_type (D.32636);
      D.32657 = mono_class_instance_size (D.32656);
      D.32658 = (long unsigned int) D.32657;
      D.32659 = __builtin_alloca (D.32658);
      *D.32655 = D.32659;
      D.32636 = sig->params[i];
      domain.381 = domain;
      D.32640 = (long unsigned int) i;
      D.32641 = D.32640 * 8;
      D.32655 = arg_buf + D.32641;
      D.32660 = *D.32655;
      p.379 = p;
      D.32661 = decode_value (D.32636, domain.381, D.32660, p.379, &p, end);
      err.388 = (int) D.32661;
      err = err.388;
      err.380 = err;
      if (err.380 != 0) goto <D.27034>; else goto <D.32663>;
      <D.32663>:
      D.32640 = (long unsigned int) i;
      D.32641 = D.32640 * 8;
      D.32646 = args + D.32641;
      D.32640 = (long unsigned int) i;
      D.32641 = D.32640 * 8;
      D.32655 = arg_buf + D.32641;
      D.32660 = *D.32655;
      *D.32646 = D.32660;
      <D.32654>:
      i = i + 1;
      <D.27036>:
      if (i < nargs) goto <D.27035>; else goto <D.27034>;
      <D.27034>:
      if (i < nargs) goto <D.32664>; else goto <D.32665>;
      <D.32664>:
      err.380 = err;
      D.32511 = (ErrorCode) err.380;
      return D.32511;
      <D.32665>:
      D.32666 = invoke->flags;
      D.32667 = D.32666 & 1;
      if (D.32667 != 0) goto <D.32668>; else goto <D.32669>;
      <D.32668>:
      tls->disable_breakpoints = 1;
      goto <D.32670>;
      <D.32669>:
      tls->disable_breakpoints = 0;
      <D.32670>:
      D.32671 = invoke->has_ctx;
      if (D.32671 != 0) goto <D.32672>; else goto <D.32673>;
      <D.32672>:
      {
        struct MonoLMF * * lmf_addr;

        lmf_addr = mono_get_lmf_addr ();
        memset (&ext, 0, 664);
        D.32674 = *lmf_addr;
        mono_arch_init_lmf_ext (&ext, D.32674);
        ext.debugger_invoke = 1;
        D.32675 = &invoke->ctx;
        memcpy (&ext.ctx, D.32675, 312);
        mono_set_lmf (&ext);
      }
      <D.32673>:
      mono_stopwatch_start (&watch);
      D.32512 = m->klass;
      D.32513 = BIT_FIELD_REF <*D.32512, 64, 256>;
      D.32514 = D.32513 & 8;
      if (D.32514 != 0) goto <D.32676>; else goto <D.32677>;
      <D.32676>:
      res.389 = mono_runtime_invoke (m, this_buf, args, &exc);
      res = res.389;
      goto <D.32679>;
      <D.32677>:
      this.378 = this;
      res.390 = mono_runtime_invoke (m, this.378, args, &exc);
      res = res.390;
      <D.32679>:
      mono_stopwatch_stop (&watch);
      log_level.375 = log_level;
      D.32490 = log_level.375 > 0;
      D.32491 = (long int) D.32490;
      D.32492 = __builtin_expect (D.32491, 0);
      if (D.32492 != 0) goto <D.32681>; else goto <D.32682>;
      <D.32681>:
      log_file.376 = log_file;
      D.32683 = GetCurrentThreadId ();
      D.32684 = (void *) D.32683;
      res.391 = res;
      exc.393 = exc;
      if (exc.393 != 0B) goto <D.32688>; else goto <D.32689>;
      <D.32688>:
      exc.393 = exc;
      D.32690 = exc.393->vtable;
      D.32691 = D.32690->klass;
      iftmp.392 = D.32691->name;
      goto <D.32692>;
      <D.32689>:
      iftmp.392 = 0B;
      <D.32692>:
      D.32693 = mono_stopwatch_elapsed_ms (&watch);
      D.32694 = (long int) D.32693;
      fprintf (log_file.376, "[%p] Invoke result: %p, exc: %s, time: %ld ms.\n", D.32684, res.391, iftmp.392, D.32694);
      log_file.376 = log_file;
      fflush (log_file.376);
      <D.32682>:
      exc.393 = exc;
      if (exc.393 != 0B) goto <D.32695>; else goto <D.32696>;
      <D.32695>:
      buffer_add_byte (buf, 0);
      D.32697 = mono_defaults.object_class;
      D.32698 = &D.32697->byval_arg;
      domain.381 = domain;
      buffer_add_value (buf, D.32698, &exc, domain.381);
      goto <D.32699>;
      <D.32696>:
      buffer_add_byte (buf, 1);
      D.32700 = sig->ret;
      D.32701 = D.32700->type;
      if (D.32701 == 1) goto <D.32702>; else goto <D.32703>;
      <D.32702>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          __s2 = m->name;
          D.32581 = ".ctor";
          D.32582 = MEM[(const unsigned char *)D.32581];
          D.32583 = (int) D.32582;
          D.32709 = *__s2;
          D.32710 = (int) D.32709;
          __result = D.32583 - D.32710;
          {
            if (__s2_len != 0) goto <D.32711>; else goto <D.32712>;
            <D.32711>:
            if (__result == 0) goto <D.32713>; else goto <D.32714>;
            <D.32713>:
            D.32590 = &MEM[(void *)".ctor" + 1B];
            D.32591 = *D.32590;
            D.32592 = (int) D.32591;
            D.32715 = __s2 + 1;
            D.32716 = *D.32715;
            D.32717 = (int) D.32716;
            __result = D.32592 - D.32717;
            if (__s2_len > 1) goto <D.32718>; else goto <D.32719>;
            <D.32718>:
            if (__result == 0) goto <D.32720>; else goto <D.32721>;
            <D.32720>:
            D.32600 = &MEM[(void *)".ctor" + 2B];
            D.32601 = *D.32600;
            D.32602 = (int) D.32601;
            D.32722 = __s2 + 2;
            D.32723 = *D.32722;
            D.32724 = (int) D.32723;
            __result = D.32602 - D.32724;
            if (__s2_len > 2) goto <D.32725>; else goto <D.32726>;
            <D.32725>:
            if (__result == 0) goto <D.32727>; else goto <D.32728>;
            <D.32727>:
            D.32610 = &MEM[(void *)".ctor" + 3B];
            D.32611 = *D.32610;
            D.32612 = (int) D.32611;
            D.32729 = __s2 + 3;
            D.32730 = *D.32729;
            D.32731 = (int) D.32730;
            __result = D.32612 - D.32731;
            <D.32728>:
            <D.32726>:
            <D.32721>:
            <D.32719>:
            <D.32714>:
            <D.32712>:
          }
          D.27045 = __result;
        }
        iftmp.394 = -D.27045;
        goto <D.32732>;
        <D.32708>:
        D.32617 = m->name;
        iftmp.394 = __builtin_strcmp (D.32617, ".ctor");
        <D.32732>:
        D.27046 = iftmp.394;
      }
      if (D.27046 == 0) goto <D.32733>; else goto <D.32704>;
      <D.32733>:
      D.32512 = m->klass;
      D.32513 = BIT_FIELD_REF <*D.32512, 64, 256>;
      D.32514 = D.32513 & 8;
      if (D.32514 == 0) goto <D.32734>; else goto <D.32704>;
      <D.32734>:
      D.32697 = mono_defaults.object_class;
      D.32698 = &D.32697->byval_arg;
      domain.381 = domain;
      buffer_add_value (buf, D.32698, &this, domain.381);
      goto <D.32705>;
      <D.32704>:
      D.32735 = mono_defaults.void_class;
      D.32736 = &D.32735->byval_arg;
      domain.381 = domain;
      buffer_add_value (buf, D.32736, 0B, domain.381);
      <D.32705>:
      goto <D.32737>;
      <D.32703>:
      D.32700 = sig->ret;
      D.32738 = mono_type_is_reference (D.32700);
      if (D.32738 != 0) goto <D.32739>; else goto <D.32740>;
      <D.32739>:
      D.32700 = sig->ret;
      domain.381 = domain;
      buffer_add_value (buf, D.32700, &res, domain.381);
      goto <D.32741>;
      <D.32740>:
      D.32700 = sig->ret;
      D.32745 = mono_class_from_mono_type (D.32700);
      D.32746 = BIT_FIELD_REF <*D.32745, 64, 256>;
      D.32747 = D.32746 & 8;
      if (D.32747 != 0) goto <D.32742>; else goto <D.32748>;
      <D.32748>:
      D.32700 = sig->ret;
      D.32701 = D.32700->type;
      if (D.32701 == 15) goto <D.32742>; else goto <D.32749>;
      <D.32749>:
      D.32700 = sig->ret;
      D.32701 = D.32700->type;
      if (D.32701 == 27) goto <D.32742>; else goto <D.32743>;
      <D.32742>:
      D.32700 = sig->ret;
      D.32750 = mono_class_from_mono_type (D.32700);
      D.32751 = mono_class_is_nullable (D.32750);
      if (D.32751 != 0) goto <D.32752>; else goto <D.32753>;
      <D.32752>:
      {
        struct MonoClass * k;
        guint8 * nullable_buf;

        D.32700 = sig->ret;
        k = mono_class_from_mono_type (D.32700);
        D.32754 = mono_class_value_size (k, 0B);
        D.32755 = (long unsigned int) D.32754;
        nullable_buf = __builtin_alloca (D.32755);
        D.32756 = nullable_buf == 0B;
        D.32757 = (long int) D.32756;
        D.32758 = __builtin_expect (D.32757, 0);
        if (D.32758 != 0) goto <D.32759>; else goto <D.32760>;
        <D.32759>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 6379, "nullable_buf");
        <D.32760>:
        res.391 = res;
        mono_nullable_init (nullable_buf, res.391, k);
        D.32700 = sig->ret;
        domain.381 = domain;
        buffer_add_value (buf, D.32700, nullable_buf, domain.381);
      }
      goto <D.32761>;
      <D.32753>:
      res.391 = res;
      D.32762 = res.391 == 0B;
      D.32763 = (long int) D.32762;
      D.32764 = __builtin_expect (D.32763, 0);
      if (D.32764 != 0) goto <D.32765>; else goto <D.32766>;
      <D.32765>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 6383, "res");
      <D.32766>:
      D.32700 = sig->ret;
      res.391 = res;
      D.32767 = mono_object_unbox (res.391);
      domain.381 = domain;
      buffer_add_value (buf, D.32700, D.32767, domain.381);
      <D.32761>:
      goto <D.32744>;
      <D.32743>:
      monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "debugger-agent.c", 6387);
      <D.32744>:
      <D.32741>:
      <D.32737>:
      <D.32699>:
      tls->disable_breakpoints = 0;
      D.32671 = invoke->has_ctx;
      if (D.32671 != 0) goto <D.32768>; else goto <D.32769>;
      <D.32768>:
      D.32770 = ext.lmf.previous_lmf;
      D.32771 = (long int) D.32770;
      D.32772 = D.32771 & -4;
      D.32773 = (struct MonoLMF *) D.32772;
      mono_set_lmf (D.32773);
      <D.32769>:
      p.379 = p;
      *endp = p.379;
      D.32511 = 0;
      return D.32511;
    }
  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.32778;
  int D.32783;
  void * D.32785;
  long unsigned int D.32786;

  D.32778 = __builtin_constant_p (__len);
  if (D.32778 != 0) goto <D.32779>; else goto <D.32780>;
  <D.32779>:
  if (__len == 0) goto <D.32781>; else goto <D.32782>;
  <D.32781>:
  D.32783 = __builtin_constant_p (__ch);
  if (D.32783 == 0) goto <D.32776>; else goto <D.32784>;
  <D.32784>:
  if (__ch != 0) goto <D.32776>; else goto <D.32777>;
  <D.32776>:
  __warn_memset_zero_len ();
  D.32785 = __dest;
  return D.32785;
  <D.32777>:
  <D.32782>:
  <D.32780>:
  D.32786 = __builtin_object_size (__dest, 0);
  D.32785 = __builtin___memset_chk (__dest, __ch, __len, D.32786);
  return D.32785;
}


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

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


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

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


mono_stopwatch_elapsed_ms (struct MonoStopwatch * w)
{
  guint64 D.32790;
  long unsigned int D.32791;
  long unsigned int D.32792;

  D.32791 = mono_stopwatch_elapsed (w);
  D.32792 = D.32791 + 500;
  D.32790 = D.32792 / 1000;
  return D.32790;
}


mono_stopwatch_elapsed (struct MonoStopwatch * w)
{
  guint64 D.32794;
  long int D.32795;
  long int D.32796;
  long int D.32797;
  long int D.32798;

  D.32795 = w->stop;
  D.32796 = w->start;
  D.32797 = D.32795 - D.32796;
  D.32798 = D.32797 / 10;
  D.32794 = (guint64) D.32798;
  return D.32794;
}


send_type_load (struct MonoClass * klass)
{
  union mono_mutex_t * D.32800;
  _Bool D.32803;
  long int D.32804;
  long int D.32805;
  struct GHashTable * D.32808;
  void * D.32809;
  _Bool D.32814;
  long int D.32815;
  long int D.32816;
  gboolean type_load;
  struct MonoDomain * domain;
  struct AgentDomainInfo * info;

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

    D.32800 = &domain->lock.mutex;
    ret = pthread_mutex_lock (D.32800);
    if (ret != 0) goto <D.32801>; else goto <D.32802>;
    <D.32801>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.32802>:
    D.32803 = ret != 0;
    D.32804 = (long int) D.32803;
    D.32805 = __builtin_expect (D.32804, 0);
    if (D.32805 != 0) goto <D.32806>; else goto <D.32807>;
    <D.32806>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 3983, "ret == 0");
    <D.32807>:
  }
  info = get_agent_domain_info (domain);
  D.32808 = info->loaded_classes;
  D.32809 = monoeg_g_hash_table_lookup (D.32808, klass);
  if (D.32809 == 0B) goto <D.32810>; else goto <D.32811>;
  <D.32810>:
  type_load = 1;
  D.32808 = info->loaded_classes;
  monoeg_g_hash_table_insert_replace (D.32808, klass, klass, 0);
  <D.32811>:
  {
    int ret;

    D.32800 = &domain->lock.mutex;
    ret = pthread_mutex_unlock (D.32800);
    if (ret != 0) goto <D.32812>; else goto <D.32813>;
    <D.32812>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.32813>:
    D.32814 = ret != 0;
    D.32815 = (long int) D.32814;
    D.32816 = __builtin_expect (D.32815, 0);
    if (D.32816 != 0) goto <D.32817>; else goto <D.32818>;
    <D.32817>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 3992, "ret == 0");
    <D.32818>:
  }
  mono_loader_unlock ();
  if (type_load != 0) goto <D.32819>; else goto <D.32820>;
  <D.32819>:
  emit_type_load (klass, klass, 0B);
  <D.32820>:
}


add_pending_breakpoints (struct MonoMethod * method, struct MonoJitInfo * ji)
{
  struct GPtrArray * breakpoints.395;
  void * * D.32824;
  long unsigned int D.32825;
  long unsigned int D.32826;
  void * * D.32827;
  int D.32828;
  struct GPtrArray * D.32831;
  void * * D.32832;
  long unsigned int D.32833;
  long unsigned int D.32834;
  void * * D.32835;
  struct MonoJitInfo * D.32836;
  unsigned int j.396;
  unsigned int D.32840;
  union mono_mutex_t * D.32843;
  _Bool D.32846;
  long int D.32847;
  long int D.32848;
  void * D.32851;
  struct GHashTable * D.32852;
  long unsigned int D.32855;
  long unsigned int D.32856;
  struct MonoMethod * D.32859;
  _Bool D.32862;
  long int D.32863;
  long int D.32864;
  _Bool D.32869;
  long int D.32870;
  long int D.32871;
  unsigned int i.397;
  unsigned int D.32875;
  int i;
  int j;
  struct MonoSeqPointInfo * seq_points;
  struct MonoDomain * domain;
  struct MonoMethod * jmethod;

  breakpoints.395 = breakpoints;
  if (breakpoints.395 == 0B) goto <D.32822>; else goto <D.32823>;
  <D.32822>:
  return;
  <D.32823>:
  domain = mono_domain_get ();
  mono_loader_lock ();
  i = 0;
  goto <D.26370>;
  <D.26369>:
  {
    struct MonoBreakpoint * bp;
    gboolean found;

    breakpoints.395 = breakpoints;
    D.32824 = breakpoints.395->pdata;
    D.32825 = (long unsigned int) i;
    D.32826 = D.32825 * 8;
    D.32827 = D.32824 + D.32826;
    bp = *D.32827;
    found = 0;
    D.32828 = bp_matches_method (bp, method);
    if (D.32828 == 0) goto <D.32829>; else goto <D.32830>;
    <D.32829>:
    // predicted unlikely by continue predictor.
    goto <D.26362>;
    <D.32830>:
    j = 0;
    goto <D.26365>;
    <D.26364>:
    {
      struct BreakpointInstance * inst;

      D.32831 = bp->children;
      D.32832 = D.32831->pdata;
      D.32833 = (long unsigned int) j;
      D.32834 = D.32833 * 8;
      D.32835 = D.32832 + D.32834;
      inst = *D.32835;
      D.32836 = inst->ji;
      if (D.32836 == ji) goto <D.32837>; else goto <D.32838>;
      <D.32837>:
      found = 1;
      <D.32838>:
    }
    j = j + 1;
    <D.26365>:
    j.396 = (unsigned int) j;
    D.32831 = bp->children;
    D.32840 = D.32831->len;
    if (j.396 < D.32840) goto <D.26364>; else goto <D.26366>;
    <D.26366>:
    if (found == 0) goto <D.32841>; else goto <D.32842>;
    <D.32841>:
    jmethod = jinfo_get_method (ji);
    {
      int ret;

      D.32843 = &domain->lock.mutex;
      ret = pthread_mutex_lock (D.32843);
      if (ret != 0) goto <D.32844>; else goto <D.32845>;
      <D.32844>:
      monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
      <D.32845>:
      D.32846 = ret != 0;
      D.32847 = (long int) D.32846;
      D.32848 = __builtin_expect (D.32847, 0);
      if (D.32848 != 0) goto <D.32849>; else goto <D.32850>;
      <D.32849>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 4271, "ret == 0");
      <D.32850>:
    }
    D.32851 = domain->runtime_info;
    D.32852 = MEM[(struct MonoJitDomainInfo *)D.32851].seq_points;
    seq_points = monoeg_g_hash_table_lookup (D.32852, jmethod);
    if (seq_points == 0B) goto <D.32853>; else goto <D.32854>;
    <D.32853>:
    D.32855 = BIT_FIELD_REF <*jmethod, 64, 256>;
    D.32856 = D.32855 & 4096;
    if (D.32856 != 0) goto <D.32857>; else goto <D.32858>;
    <D.32857>:
    D.32851 = domain->runtime_info;
    D.32852 = MEM[(struct MonoJitDomainInfo *)D.32851].seq_points;
    D.32859 = mono_method_get_declaring_generic_method (jmethod);
    seq_points = monoeg_g_hash_table_lookup (D.32852, D.32859);
    <D.32858>:
    <D.32854>:
    {
      int ret;

      D.32843 = &domain->lock.mutex;
      ret = pthread_mutex_unlock (D.32843);
      if (ret != 0) goto <D.32860>; else goto <D.32861>;
      <D.32860>:
      monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
      <D.32861>:
      D.32862 = ret != 0;
      D.32863 = (long int) D.32862;
      D.32864 = __builtin_expect (D.32863, 0);
      if (D.32864 != 0) goto <D.32865>; else goto <D.32866>;
      <D.32865>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 4275, "ret == 0");
      <D.32866>:
    }
    if (seq_points == 0B) goto <D.32867>; else goto <D.32868>;
    <D.32867>:
    // predicted unlikely by continue predictor.
    goto <D.26362>;
    <D.32868>:
    D.32869 = seq_points == 0B;
    D.32870 = (long int) D.32869;
    D.32871 = __builtin_expect (D.32870, 0);
    if (D.32871 != 0) goto <D.32872>; else goto <D.32873>;
    <D.32872>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 4279, "seq_points");
    <D.32873>:
    insert_breakpoint (seq_points, domain, ji, bp, 0B);
    <D.32842>:
  }
  <D.26362>:
  i = i + 1;
  <D.26370>:
  i.397 = (unsigned int) i;
  breakpoints.395 = breakpoints;
  D.32875 = breakpoints.395->len;
  if (i.397 < D.32875) goto <D.26369>; else goto <D.26371>;
  <D.26371>:
  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.398;
  void * * D.32878;
  long unsigned int D.32879;
  long unsigned int D.32880;
  void * * D.32881;
  int D.32882;
  int D.32885;
  int D.32886;
  unsigned int i.399;
  unsigned int D.32888;
  int i;
  gboolean found;

  mono_loader_lock ();
  found = 1;
  goto <D.26983>;
  <D.26982>:
  found = 0;
  i = 0;
  goto <D.26981>;
  <D.26980>:
  {
    struct EventRequest * req;

    event_requests.398 = event_requests;
    D.32878 = event_requests.398->pdata;
    D.32879 = (long unsigned int) i;
    D.32880 = D.32879 * 8;
    D.32881 = D.32878 + D.32880;
    req = *D.32881;
    D.32882 = event_req_matches_assembly (req, assembly);
    if (D.32882 != 0) goto <D.32883>; else goto <D.32884>;
    <D.32883>:
    D.32885 = req->id;
    D.32886 = req->event_kind;
    clear_event_request (D.32885, D.32886);
    found = 1;
    goto <D.26979>;
    <D.32884>:
  }
  i = i + 1;
  <D.26981>:
  i.399 = (unsigned int) i;
  event_requests.398 = event_requests;
  D.32888 = event_requests.398->len;
  if (i.399 < D.32888) goto <D.26980>; else goto <D.26979>;
  <D.26979>:
  <D.26983>:
  if (found != 0) goto <D.26982>; else goto <D.26984>;
  <D.26984>:
  mono_loader_unlock ();
}


event_req_matches_assembly (struct EventRequest * req, struct MonoAssembly * assembly)
{
  int D.32889;
  gboolean D.32892;
  void * D.32893;
  <unnamed type> D.32894;
  struct MonoClass * D.32897;
  struct MonoImage * D.32900;
  struct MonoAssembly * D.32901;
  struct MonoAssembly * * D.32906;
  long unsigned int D.32909;
  long unsigned int D.32910;
  struct MonoAssembly * * D.32911;
  struct MonoAssembly * D.32912;
  int D.32915;

  D.32889 = req->event_kind;
  if (D.32889 == 10) goto <D.32890>; else goto <D.32891>;
  <D.32890>:
  D.32893 = req->info;
  D.32892 = breakpoint_matches_assembly (D.32893, assembly);
  return D.32892;
  <D.32891>:
  {
    int i;
    int j;

    i = 0;
    goto <D.26971>;
    <D.26970>:
    {
      struct Modifier * m;

      m = &req->modifiers[i];
      D.32894 = m->kind;
      if (D.32894 == 8) goto <D.32895>; else goto <D.32896>;
      <D.32895>:
      D.32897 = m->data.exc_class;
      if (D.32897 != 0B) goto <D.32898>; else goto <D.32899>;
      <D.32898>:
      D.32897 = m->data.exc_class;
      D.32900 = D.32897->image;
      D.32901 = D.32900->assembly;
      if (D.32901 == assembly) goto <D.32902>; else goto <D.32903>;
      <D.32902>:
      D.32892 = 1;
      return D.32892;
      <D.32903>:
      <D.32899>:
      <D.32896>:
      D.32894 = m->kind;
      if (D.32894 == 11) goto <D.32904>; else goto <D.32905>;
      <D.32904>:
      D.32906 = m->data.assemblies;
      if (D.32906 != 0B) goto <D.32907>; else goto <D.32908>;
      <D.32907>:
      j = 0;
      goto <D.26968>;
      <D.26967>:
      D.32906 = m->data.assemblies;
      D.32909 = (long unsigned int) j;
      D.32910 = D.32909 * 8;
      D.32911 = D.32906 + D.32910;
      D.32912 = *D.32911;
      if (D.32912 == assembly) goto <D.32913>; else goto <D.32914>;
      <D.32913>:
      D.32892 = 1;
      return D.32892;
      <D.32914>:
      j = j + 1;
      <D.26968>:
      D.32906 = m->data.assemblies;
      D.32909 = (long unsigned int) j;
      D.32910 = D.32909 * 8;
      D.32911 = D.32906 + D.32910;
      D.32912 = *D.32911;
      if (D.32912 != 0B) goto <D.26967>; else goto <D.26969>;
      <D.26969>:
      <D.32908>:
      <D.32905>:
    }
    i = i + 1;
    <D.26971>:
    D.32915 = req->nmodifiers;
    if (D.32915 > i) goto <D.26970>; else goto <D.26972>;
    <D.26972>:
  }
  D.32892 = 0;
  return D.32892;
}


breakpoint_matches_assembly (struct MonoBreakpoint * bp, struct MonoAssembly * assembly)
{
  gboolean D.32917;
  int iftmp.400;
  struct MonoMethod * D.32921;
  struct MonoClass * D.32923;
  struct MonoImage * D.32924;
  struct MonoAssembly * D.32925;

  D.32921 = bp->method;
  if (D.32921 != 0B) goto <D.32922>; else goto <D.32919>;
  <D.32922>:
  D.32921 = bp->method;
  D.32923 = D.32921->klass;
  D.32924 = D.32923->image;
  D.32925 = D.32924->assembly;
  if (D.32925 == assembly) goto <D.32926>; else goto <D.32919>;
  <D.32926>:
  iftmp.400 = 1;
  goto <D.32920>;
  <D.32919>:
  iftmp.400 = 0;
  <D.32920>:
  D.32917 = iftmp.400;
  return D.32917;
}


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

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


type_comes_from_assembly (void * klass, void * also_klass, void * assembly)
{
  gboolean D.32929;
  struct MonoImage * D.32930;
  struct MonoImage * D.32931;
  _Bool D.32932;

  D.32930 = mono_class_get_image (klass);
  D.32931 = mono_assembly_get_image (assembly);
  D.32932 = D.32930 == D.32931;
  D.32929 = (gboolean) D.32932;
  return D.32929;
}


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

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


thread_end (struct MonoProfiler * prof, uintptr_t tid)
{
  struct MonoGHashTable * tid_to_thread.402;
  const void * tid.403;
  struct MonoGHashTable * tid_to_thread_obj.404;
  struct MonoGHashTable * thread_to_tls.405;
  struct MonoInternalThread * * D.32943;
  int log_level.406;
  _Bool D.32947;
  long int D.32948;
  long int D.32949;
  struct FILE * log_file.407;
  void * tid.408;
  struct MonoInternalThread * thread;
  struct DebuggerTlsData * tls;

  tls = 0B;
  mono_loader_lock ();
  tid_to_thread.402 = tid_to_thread;
  tid.403 = (const void *) tid;
  thread = mono_g_hash_table_lookup (tid_to_thread.402, tid.403);
  if (thread != 0B) goto <D.32937>; else goto <D.32938>;
  <D.32937>:
  tid_to_thread_obj.404 = tid_to_thread_obj;
  tid.403 = (const void *) tid;
  mono_g_hash_table_remove (tid_to_thread_obj.404, tid.403);
  thread_to_tls.405 = thread_to_tls;
  tls = mono_g_hash_table_lookup (thread_to_tls.405, thread);
  if (tls != 0B) goto <D.32941>; else goto <D.32942>;
  <D.32941>:
  tls->terminated = 1;
  D.32943 = &tls->thread;
  mono_gc_deregister_root (D.32943);
  tls->thread = 0B;
  <D.32942>:
  <D.32938>:
  mono_loader_unlock ();
  if (thread != 0B) goto <D.32944>; else goto <D.32945>;
  <D.32944>:
  log_level.406 = log_level;
  D.32947 = log_level.406 > 0;
  D.32948 = (long int) D.32947;
  D.32949 = __builtin_expect (D.32948, 0);
  if (D.32949 != 0) goto <D.32950>; else goto <D.32951>;
  <D.32950>:
  log_file.407 = log_file;
  tid.408 = (void *) tid;
  fprintf (log_file.407, "[%p] Thread terminated, obj=%p, tls=%p.\n", tid.408, thread, tls);
  log_file.407 = log_file;
  fflush (log_file.407);
  <D.32951>:
  process_profiler_event (3, thread);
  <D.32945>:
}


thread_startup (struct MonoProfiler * prof, uintptr_t tid)
{
  long unsigned int debugger_thread_id.409;
  long unsigned int D.32957;
  _Bool D.32958;
  long int D.32959;
  long int D.32960;
  struct MonoGHashTable * tid_to_thread.410;
  const void * tid.411;
  int log_level.412;
  _Bool D.32970;
  long int D.32971;
  long int D.32972;
  struct FILE * log_file.413;
  void * tid.414;
  struct MonoGHashTable * thread_to_tls.415;
  struct MonoGHashTable * tid_to_thread_obj.416;
  unsigned int debugger_tls_id.417;
  _Bool D.32982;
  long int D.32983;
  long int D.32984;
  struct MonoInternalThread * * D.32989;
  void * D.32990;
  struct MonoThread * D.32993;
  struct MonoInternalThread * thread;
  struct MonoInternalThread * old_thread;
  struct DebuggerTlsData * tls;

  thread = mono_thread_internal_current ();
  debugger_thread_id.409 = debugger_thread_id;
  if (tid == debugger_thread_id.409) goto <D.32955>; else goto <D.32956>;
  <D.32955>:
  return;
  <D.32956>:
  D.32957 = thread->tid;
  D.32958 = D.32957 != tid;
  D.32959 = (long int) D.32958;
  D.32960 = __builtin_expect (D.32959, 0);
  if (D.32960 != 0) goto <D.32961>; else goto <D.32962>;
  <D.32961>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 3789, "thread->tid == tid");
  <D.32962>:
  mono_loader_lock ();
  tid_to_thread.410 = tid_to_thread;
  tid.411 = (const void *) tid;
  old_thread = mono_g_hash_table_lookup (tid_to_thread.410, tid.411);
  mono_loader_unlock ();
  if (old_thread != 0B) goto <D.32965>; else goto <D.32966>;
  <D.32965>:
  if (thread == old_thread) goto <D.32967>; else goto <D.32968>;
  <D.32967>:
  log_level.412 = log_level;
  D.32970 = log_level.412 > 0;
  D.32971 = (long int) D.32970;
  D.32972 = __builtin_expect (D.32971, 0);
  if (D.32972 != 0) goto <D.32973>; else goto <D.32974>;
  <D.32973>:
  log_file.413 = log_file;
  tid.414 = (void *) tid;
  tid.414 = (void *) tid;
  fprintf (log_file.413, "[%p] thread_start () called multiple times for %p, ignored.\n", tid.414, tid.414);
  log_file.413 = log_file;
  fflush (log_file.413);
  <D.32974>:
  return;
  <D.32968>:
  log_level.412 = log_level;
  D.32970 = log_level.412 > 0;
  D.32971 = (long int) D.32970;
  D.32972 = __builtin_expect (D.32971, 0);
  if (D.32972 != 0) goto <D.32977>; else goto <D.32978>;
  <D.32977>:
  log_file.413 = log_file;
  tid.414 = (void *) tid;
  tid.414 = (void *) tid;
  fprintf (log_file.413, "[%p] Removing stale data for tid %p.\n", tid.414, tid.414);
  log_file.413 = log_file;
  fflush (log_file.413);
  <D.32978>:
  mono_loader_lock ();
  thread_to_tls.415 = thread_to_tls;
  mono_g_hash_table_remove (thread_to_tls.415, old_thread);
  tid_to_thread.410 = tid_to_thread;
  tid.411 = (const void *) tid;
  mono_g_hash_table_remove (tid_to_thread.410, tid.411);
  tid_to_thread_obj.416 = tid_to_thread_obj;
  tid.411 = (const void *) tid;
  mono_g_hash_table_remove (tid_to_thread_obj.416, tid.411);
  mono_loader_unlock ();
  <D.32966>:
  debugger_tls_id.417 = debugger_tls_id;
  tls = pthread_getspecific (debugger_tls_id.417);
  D.32982 = tls != 0B;
  D.32983 = (long int) D.32982;
  D.32984 = __builtin_expect (D.32983, 0);
  if (D.32984 != 0) goto <D.32985>; else goto <D.32986>;
  <D.32985>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 3817, "!tls");
  <D.32986>:
  tls = monoeg_malloc0 (2184);
  if (0 != 0) goto <D.32987>; else goto <D.32988>;
  <D.32987>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 3820, "sizeof (tls->thread) == sizeof (MonoObject*)");
  <D.32988>:
  D.32989 = &tls->thread;
  D.32990 = mono_gc_make_root_descr_all_refs (1);
  mono_gc_register_root (D.32989, 8, D.32990);
  tls->thread = thread;
  debugger_tls_id.417 = debugger_tls_id;
  mono_native_tls_set_value (debugger_tls_id.417, tls);
  log_level.412 = log_level;
  D.32970 = log_level.412 > 0;
  D.32971 = (long int) D.32970;
  D.32972 = __builtin_expect (D.32971, 0);
  if (D.32972 != 0) goto <D.32991>; else goto <D.32992>;
  <D.32991>:
  log_file.413 = log_file;
  tid.414 = (void *) tid;
  fprintf (log_file.413, "[%p] Thread started, obj=%p, tls=%p.\n", tid.414, thread, tls);
  log_file.413 = log_file;
  fflush (log_file.413);
  <D.32992>:
  mono_loader_lock ();
  thread_to_tls.415 = thread_to_tls;
  mono_g_hash_table_insert (thread_to_tls.415, thread, tls);
  tid_to_thread.410 = tid_to_thread;
  tid.414 = (void *) tid;
  mono_g_hash_table_insert (tid_to_thread.410, tid.414, thread);
  tid_to_thread_obj.416 = tid_to_thread_obj;
  tid.414 = (void *) tid;
  D.32993 = mono_thread_current ();
  mono_g_hash_table_insert (tid_to_thread_obj.416, tid.414, D.32993);
  mono_loader_unlock ();
  process_profiler_event (2, thread);
  suspend_current ();
}


mono_native_tls_set_value (pthread_key_t key, void * value)
{
  int D.32995;
  int D.32996;
  _Bool D.32997;

  D.32996 = pthread_setspecific (key, value);
  D.32997 = D.32996 == 0;
  D.32995 = (int) D.32997;
  return D.32995;
}


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

  clear_breakpoints_for_domain (domain);
  mono_loader_lock ();
  thread_to_tls.418 = thread_to_tls;
  mono_g_hash_table_foreach (thread_to_tls.418, 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.419;
  void * * D.33003;
  long unsigned int D.33004;
  long unsigned int D.33005;
  void * * D.33006;
  struct GPtrArray * D.33007;
  void * * D.33008;
  long unsigned int D.33009;
  long unsigned int D.33010;
  void * * D.33011;
  struct MonoDomain * D.33012;
  unsigned int j.420;
  unsigned int D.33017;
  unsigned int i.421;
  unsigned int D.33019;
  int i;
  int j;

  breakpoints.419 = breakpoints;
  if (breakpoints.419 == 0B) goto <D.33001>; else goto <D.33002>;
  <D.33001>:
  return;
  <D.33002>:
  mono_loader_lock ();
  i = 0;
  goto <D.26433>;
  <D.26432>:
  {
    struct MonoBreakpoint * bp;

    breakpoints.419 = breakpoints;
    D.33003 = breakpoints.419->pdata;
    D.33004 = (long unsigned int) i;
    D.33005 = D.33004 * 8;
    D.33006 = D.33003 + D.33005;
    bp = *D.33006;
    j = 0;
    goto <D.26430>;
    <D.26429>:
    {
      struct BreakpointInstance * inst;

      D.33007 = bp->children;
      D.33008 = D.33007->pdata;
      D.33009 = (long unsigned int) j;
      D.33010 = D.33009 * 8;
      D.33011 = D.33008 + D.33010;
      inst = *D.33011;
      D.33012 = inst->domain;
      if (D.33012 == domain) goto <D.33013>; else goto <D.33014>;
      <D.33013>:
      remove_breakpoint (inst);
      monoeg_g_free (inst);
      D.33007 = bp->children;
      j.420 = (unsigned int) j;
      monoeg_g_ptr_array_remove_index_fast (D.33007, j.420);
      goto <D.33016>;
      <D.33014>:
      j = j + 1;
      <D.33016>:
    }
    <D.26430>:
    j.420 = (unsigned int) j;
    D.33007 = bp->children;
    D.33017 = D.33007->len;
    if (j.420 < D.33017) goto <D.26429>; else goto <D.26431>;
    <D.26431>:
  }
  i = i + 1;
  <D.26433>:
  i.421 = (unsigned int) i;
  breakpoints.419 = breakpoints;
  D.33019 = breakpoints.419->len;
  if (i.421 < D.33019) goto <D.26432>; else goto <D.26434>;
  <D.26434>:
  mono_loader_unlock ();
}


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

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


runtime_initialized (struct MonoProfiler * prof)
{
  struct MonoThread * D.33022;
  int D.33023;

  D.33022 = mono_thread_current ();
  process_profiler_event (0, D.33022);
  D.33023 = agent_config.defer;
  if (D.33023 != 0) goto <D.33024>; else goto <D.33025>;
  <D.33024>:
  start_debugger_thread ();
  <D.33025>:
}


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

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


mono_debugger_agent_cleanup ()
{
  int inited.423;

  inited.423 = inited;
  if (inited.423 == 0) goto <D.33028>; else goto <D.33029>;
  <D.33028>:
  return;
  <D.33029>:
  stop_debugger_thread ();
  breakpoints_cleanup ();
  objrefs_cleanup ();
  ids_cleanup ();
  pthread_mutex_destroy (&debugger_thread_exited_mutex);
}


stop_debugger_thread ()
{
  int inited.424;
  long unsigned int D.33034;
  long unsigned int debugger_thread_id.425;
  int debugger_thread_exited.426;

  inited.424 = inited;
  if (inited.424 == 0) goto <D.33032>; else goto <D.33033>;
  <D.33032>:
  return;
  <D.33033>:
  transport_close1 ();
  D.33034 = GetCurrentThreadId ();
  debugger_thread_id.425 = debugger_thread_id;
  if (D.33034 != debugger_thread_id.425) goto <D.33036>; else goto <D.33037>;
  <D.33036>:
  <D.25486>:
  pthread_mutex_lock (&debugger_thread_exited_mutex);
  debugger_thread_exited.426 = debugger_thread_exited;
  if (debugger_thread_exited.426 == 0) goto <D.33039>; else goto <D.33040>;
  <D.33039>:
  pthread_cond_wait (&debugger_thread_exited_cond, &debugger_thread_exited_mutex);
  <D.33040>:
  pthread_mutex_unlock (&debugger_thread_exited_mutex);
  debugger_thread_exited.426 = debugger_thread_exited;
  if (debugger_thread_exited.426 == 0) goto <D.25486>; else goto <D.25487>;
  <D.25487>:
  <D.33037>:
  transport_close2 ();
}


transport_close1 ()
{
  struct DebuggerTransport * transport.427;
  void (*<T887>) (void) D.33043;

  transport.427 = transport;
  D.33043 = transport.427->close1;
  D.33043 ();
}


breakpoints_cleanup ()
{
  struct GPtrArray * event_requests.428;
  void * * D.33045;
  long unsigned int D.33046;
  long unsigned int D.33047;
  void * * D.33048;
  int D.33049;
  void * D.33052;
  unsigned int i.429;
  unsigned int D.33055;
  struct GPtrArray * breakpoints.430;
  void * * D.33057;
  void * * D.33058;
  void * D.33059;
  unsigned int D.33060;
  struct GHashTable * bp_locs.431;
  int i;

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

    event_requests.428 = event_requests;
    D.33045 = event_requests.428->pdata;
    D.33046 = (long unsigned int) i;
    D.33047 = D.33046 * 8;
    D.33048 = D.33045 + D.33047;
    req = *D.33048;
    D.33049 = req->event_kind;
    if (D.33049 == 10) goto <D.33050>; else goto <D.33051>;
    <D.33050>:
    D.33052 = req->info;
    clear_breakpoint (D.33052);
    event_requests.428 = event_requests;
    i.429 = (unsigned int) i;
    monoeg_g_ptr_array_remove_index_fast (event_requests.428, i.429);
    monoeg_g_free (req);
    goto <D.33054>;
    <D.33051>:
    i = i + 1;
    <D.33054>:
  }
  <D.26417>:
  i.429 = (unsigned int) i;
  event_requests.428 = event_requests;
  D.33055 = event_requests.428->len;
  if (i.429 < D.33055) goto <D.26416>; else goto <D.26418>;
  <D.26418>:
  i = 0;
  goto <D.26420>;
  <D.26419>:
  breakpoints.430 = breakpoints;
  D.33057 = breakpoints.430->pdata;
  D.33046 = (long unsigned int) i;
  D.33047 = D.33046 * 8;
  D.33058 = D.33057 + D.33047;
  D.33059 = *D.33058;
  monoeg_g_free (D.33059);
  i = i + 1;
  <D.26420>:
  i.429 = (unsigned int) i;
  breakpoints.430 = breakpoints;
  D.33060 = breakpoints.430->len;
  if (i.429 < D.33060) goto <D.26419>; else goto <D.26421>;
  <D.26421>:
  breakpoints.430 = breakpoints;
  monoeg_g_ptr_array_free (breakpoints.430, 1);
  bp_locs.431 = bp_locs;
  monoeg_g_hash_table_destroy (bp_locs.431);
  breakpoints = 0B;
  bp_locs = 0B;
  mono_loader_unlock ();
}


objrefs_cleanup ()
{
  struct GHashTable * objrefs.432;

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


ids_cleanup ()
{
  struct GPtrArray * D.33063;
  void * * D.33066;
  long unsigned int D.33067;
  long unsigned int D.33068;
  void * * D.33069;
  void * D.33070;
  unsigned int j.433;
  unsigned int D.33072;
  int i;
  int j;

  i = 0;
  goto <D.25690>;
  <D.25689>:
  D.33063 = ids[i];
  if (D.33063 != 0B) goto <D.33064>; else goto <D.33065>;
  <D.33064>:
  j = 0;
  goto <D.25687>;
  <D.25686>:
  D.33063 = ids[i];
  D.33066 = D.33063->pdata;
  D.33067 = (long unsigned int) j;
  D.33068 = D.33067 * 8;
  D.33069 = D.33066 + D.33068;
  D.33070 = *D.33069;
  monoeg_g_free (D.33070);
  j = j + 1;
  <D.25687>:
  j.433 = (unsigned int) j;
  D.33063 = ids[i];
  D.33072 = D.33063->len;
  if (j.433 < D.33072) goto <D.25686>; else goto <D.25688>;
  <D.25688>:
  D.33063 = ids[i];
  monoeg_g_ptr_array_free (D.33063, 1);
  <D.33065>:
  ids[i] = 0B;
  i = i + 1;
  <D.25690>:
  if (i <= 6) goto <D.25689>; else goto <D.25691>;
  <D.25691>:
}


transport_init ()
{
  int D.25446;
  char * D.33073;
  const char * D.33074;
  int ntransports.434;
  struct _IO_FILE * stderr.435;
  const char * iftmp.436;
  struct DebuggerTransport * transport.437;
  int i;

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

    D.33073 = agent_config.transport;
    D.33074 = transports[i].name;
    D.25446 = __builtin_strcmp (D.33073, D.33074);
  }
  if (D.25446 == 0) goto <D.25447>; else goto <D.33075>;
  <D.33075>:
  i = i + 1;
  <D.25449>:
  ntransports.434 = ntransports;
  if (i < ntransports.434) goto <D.25448>; else goto <D.25447>;
  <D.25447>:
  ntransports.434 = ntransports;
  if (i == ntransports.434) goto <D.33077>; else goto <D.33078>;
  <D.33077>:
  stderr.435 = stderr;
  fprintf (stderr.435, "debugger-agent: The supported values for the \'transport\' option are: ");
  i = 0;
  goto <D.25451>;
  <D.25450>:
  stderr.435 = stderr;
  if (i > 0) goto <D.33081>; else goto <D.33082>;
  <D.33081>:
  iftmp.436 = ", ";
  goto <D.33083>;
  <D.33082>:
  iftmp.436 = "";
  <D.33083>:
  D.33074 = transports[i].name;
  fprintf (stderr.435, "%s\'%s\'", iftmp.436, D.33074);
  i = i + 1;
  <D.25451>:
  ntransports.434 = ntransports;
  if (i < ntransports.434) goto <D.25450>; else goto <D.25452>;
  <D.25452>:
  stderr.435 = stderr;
  fprintf (stderr.435, "\n");
  exit (1);
  <D.33078>:
  transport.437 = &transports[i];
  transport = transport.437;
}


register_socket_transport ()
{
  struct DebuggerTransport trans;

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


socket_transport_recv (void * buf, int len)
{
  sizetype D.33085;
  void * D.33086;
  int D.33087;
  long unsigned int D.33088;
  long int D.33089;
  int D.33092;
  int * D.33098;
  int D.33099;
  unsigned int D.33103;
  int last_keepalive.438;
  int D.33105;
  int D.33113;
  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.25362>:
  again:
  D.33085 = (sizetype) total;
  D.33086 = buf + D.33085;
  D.33087 = len - total;
  D.33088 = (long unsigned int) D.33087;
  D.33089 = recv (fd, D.33086, D.33088, flags);
  res = (int) D.33089;
  if (res > 0) goto <D.33090>; else goto <D.33091>;
  <D.33090>:
  total = total + res;
  <D.33091>:
  D.33092 = agent_config.keepalive;
  if (D.33092 != 0) goto <D.33093>; else goto <D.33094>;
  <D.33093>:
  {
    gboolean need_keepalive;

    need_keepalive = 0;
    if (res == -1) goto <D.33097>; else goto <D.33095>;
    <D.33097>:
    D.33098 = __errno_location ();
    D.33099 = *D.33098;
    if (D.33099 == 11) goto <D.33100>; else goto <D.33095>;
    <D.33100>:
    need_keepalive = 1;
    goto <D.33096>;
    <D.33095>:
    if (res == -1) goto <D.33101>; else goto <D.33102>;
    <D.33101>:
    D.33103 = mono_msec_ticks ();
    msecs = (gint32) D.33103;
    last_keepalive.438 = last_keepalive;
    D.33105 = msecs - last_keepalive.438;
    D.33092 = agent_config.keepalive;
    if (D.33105 >= D.33092) goto <D.33106>; else goto <D.33107>;
    <D.33106>:
    need_keepalive = 1;
    last_keepalive = msecs;
    <D.33107>:
    <D.33102>:
    <D.33096>:
    if (need_keepalive != 0) goto <D.33108>; else goto <D.33109>;
    <D.33108>:
    process_profiler_event (14, 0B);
    goto again;
    <D.33109>:
  }
  <D.33094>:
  if (res > 0) goto <D.33111>; else goto <D.33110>;
  <D.33111>:
  if (total < len) goto <D.25362>; else goto <D.33110>;
  <D.33110>:
  if (res == -1) goto <D.33112>; else goto <D.25363>;
  <D.33112>:
  D.33098 = __errno_location ();
  D.33099 = *D.33098;
  if (D.33099 == 4) goto <D.25362>; else goto <D.25363>;
  <D.25363>:
  D.33113 = total;
  return D.33113;
}


recv (int __fd, void * __buf, size_t __n, int __flags)
{
  long unsigned int D.33115;
  int D.33118;
  ssize_t D.33121;
  long unsigned int D.33122;
  long unsigned int D.33123;
  long unsigned int D.33126;

  D.33115 = __builtin_object_size (__buf, 0);
  if (D.33115 != 18446744073709551615) goto <D.33116>; else goto <D.33117>;
  <D.33116>:
  D.33118 = __builtin_constant_p (__n);
  if (D.33118 == 0) goto <D.33119>; else goto <D.33120>;
  <D.33119>:
  D.33122 = __builtin_object_size (__buf, 0);
  D.33121 = __recv_chk (__fd, __buf, __n, D.33122, __flags);
  return D.33121;
  <D.33120>:
  D.33123 = __builtin_object_size (__buf, 0);
  if (D.33123 < __n) goto <D.33124>; else goto <D.33125>;
  <D.33124>:
  D.33126 = __builtin_object_size (__buf, 0);
  D.33121 = __recv_chk_warn (__fd, __buf, __n, D.33126, __flags);
  return D.33121;
  <D.33125>:
  <D.33117>:
  D.33121 = __recv_alias (__fd, __buf, __n, __flags);
  return D.33121;
}


socket_transport_send (void * data, int len)
{
  int conn_fd.439;
  long unsigned int D.33129;
  long int D.33130;
  int * D.33132;
  int D.33133;
  gboolean D.33136;
  int res;

  <D.25377>:
  conn_fd.439 = conn_fd;
  D.33129 = (long unsigned int) len;
  D.33130 = send (conn_fd.439, data, D.33129, 0);
  res = (int) D.33130;
  if (res == -1) goto <D.33131>; else goto <D.25378>;
  <D.33131>:
  D.33132 = __errno_location ();
  D.33133 = *D.33132;
  if (D.33133 == 4) goto <D.25377>; else goto <D.25378>;
  <D.25378>:
  if (res != len) goto <D.33134>; else goto <D.33135>;
  <D.33134>:
  D.33136 = 0;
  return D.33136;
  <D.33135>:
  D.33136 = 1;
  return D.33136;
}


socket_transport_close2 ()
{
  int conn_fd.440;

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


socket_transport_close1 ()
{
  int conn_fd.441;
  int listen_fd.442;

  conn_fd.441 = conn_fd;
  shutdown (conn_fd.441, 0);
  listen_fd.442 = listen_fd;
  shutdown (listen_fd.442, 2);
  listen_fd.442 = listen_fd;
  close (listen_fd.442);
}


socket_transport_connect (const char * address)
{
  char * D.33141;
  _Bool D.33144;
  long int D.33145;
  long int D.33146;
  char * host.443;
  int port.444;
  struct _IO_FILE * stderr.445;
  const char * D.33157;
  int D.33158;
  _Bool D.33163;
  long int D.33164;
  long int D.33165;
  int * D.33170;
  int D.33171;
  char * D.33172;
  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.33173;
  short unsigned int D.25394;
  int port.446;
  int D.33178;
  int D.33179;
  int D.33180;
  int D.33183;
  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.33186;
  struct sockaddr * D.33187;
  unsigned int D.33188;
  struct addrinfo * result.447;
  int D.33194;
  int log_level.448;
  _Bool D.33198;
  long int D.33199;
  long int D.33200;
  struct FILE * log_file.449;
  int D.33204;
  int D.33207;
  long int D.33208;
  long int D.25408;
  long int iftmp.450;
  int D.33210;
  long int iftmp.451;
  unsigned long __d.452;
  long int D.33219;
  long int D.33220;
  int D.33221;
  long int D.33222;
  long int D.33223;
  int D.33224;
  int conn_fd.453;
  int conn_fd.454;
  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.33236;
  int D.33237;
  int D.33241;
  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.33141 = agent_config.address;
      if (D.33141 != 0B) goto <D.33142>; else goto <D.33143>;
      <D.33142>:
      D.33141 = agent_config.address;
      res = parse_address (D.33141, &host, &port);
      D.33144 = res != 0;
      D.33145 = (long int) D.33144;
      D.33146 = __builtin_expect (D.33145, 0);
      if (D.33146 != 0) goto <D.33147>; else goto <D.33148>;
      <D.33147>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 1177, "res == 0");
      <D.33148>:
      goto <D.33149>;
      <D.33143>:
      host = 0B;
      port = 0;
      <D.33149>:
      conn_fd = -1;
      listen_fd = -1;
      host.443 = host;
      if (host.443 != 0B) goto <D.33151>; else goto <D.33152>;
      <D.33151>:
      port.444 = port;
      sprintf (&port_string, "%d", port.444);
      mono_network_init ();
      memset (&hints, 0, 48);
      hints.ai_family = 0;
      hints.ai_socktype = 1;
      hints.ai_flags = 0;
      hints.ai_protocol = 0;
      host.443 = host;
      s = getaddrinfo (host.443, &port_string, &hints, &result);
      if (s != 0) goto <D.33154>; else goto <D.33155>;
      <D.33154>:
      stderr.445 = stderr;
      host.443 = host;
      port.444 = port;
      D.33157 = gai_strerror (s);
      fprintf (stderr.445, "debugger-agent: Unable to resolve %s:%d: %s\n", host.443, port.444, D.33157);
      exit (1);
      <D.33155>:
      <D.33152>:
      D.33158 = agent_config.server;
      if (D.33158 != 0) goto <D.33159>; else goto <D.33160>;
      <D.33159>:
      host.443 = host;
      if (host.443 == 0B) goto <D.33161>; else goto <D.33162>;
      <D.33161>:
      {
        struct sockaddr_in addr;
        socklen_t addrlen;

        try
          {
            sfd = socket (2, 1, 0);
            D.33163 = sfd == 0;
            D.33164 = (long int) D.33163;
            D.33165 = __builtin_expect (D.33164, 0);
            if (D.33165 != 0) goto <D.33166>; else goto <D.33167>;
            <D.33166>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 1222, "sfd");
            <D.33167>:
            res = listen (sfd, 16);
            if (res == -1) goto <D.33168>; else goto <D.33169>;
            <D.33168>:
            stderr.445 = stderr;
            D.33170 = __errno_location ();
            D.33171 = *D.33170;
            D.33172 = strerror (D.33171);
            fprintf (stderr.445, "debugger-agent: Unable to setup listening socket: %s\n", D.33172);
            exit (1);
            <D.33169>:
            listen_fd = sfd;
            addrlen = 16;
            memset (&addr, 0, 16);
            D.33173.__sockaddr__ = &addr;
            res = getsockname (sfd, D.33173, &addrlen);
            D.33144 = res != 0;
            D.33145 = (long int) D.33144;
            D.33146 = __builtin_expect (D.33145, 0);
            if (D.33146 != 0) goto <D.33174>; else goto <D.33175>;
            <D.33174>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 1235, "res == 0");
            <D.33175>:
            host = "127.0.0.1";
            {
              short unsigned int __bsx;

              __bsx = addr.sin_port;
              D.25394 = __bsx r>> 8;
            }
            port.446 = (int) D.25394;
            port = port.446;
            host.443 = host;
            port.444 = port;
            printf ("%s:%d\n", host.443, port.444);
          }
        finally
          {
            addr = {CLOBBER};
            addrlen = {CLOBBER};
          }
      }
      goto <D.33177>;
      <D.33162>:
      rp = result;
      goto <D.25399>;
      <D.25398>:
      {
        int n;

        try
          {
            n = 1;
            D.33178 = rp->ai_family;
            D.33179 = rp->ai_socktype;
            D.33180 = rp->ai_protocol;
            sfd = socket (D.33178, D.33179, D.33180);
            if (sfd == -1) goto <D.33181>; else goto <D.33182>;
            <D.33181>:
            // predicted unlikely by continue predictor.
            goto <D.25396>;
            <D.33182>:
            D.33183 = setsockopt (sfd, 1, 2, &n, 4);
            if (D.33183 == -1) goto <D.33184>; else goto <D.33185>;
            <D.33184>:
            // predicted unlikely by continue predictor.
            goto <D.25396>;
            <D.33185>:
            D.33187 = rp->ai_addr;
            D.33186.__sockaddr__ = D.33187;
            D.33188 = rp->ai_addrlen;
            res = bind (sfd, D.33186, D.33188);
            if (res == -1) goto <D.33189>; else goto <D.33190>;
            <D.33189>:
            // predicted unlikely by continue predictor.
            goto <D.25396>;
            <D.33190>:
            res = listen (sfd, 16);
            if (res == -1) goto <D.33191>; else goto <D.33192>;
            <D.33191>:
            // predicted unlikely by continue predictor.
            goto <D.25396>;
            <D.33192>:
            listen_fd = sfd;
            goto <D.25397>;
          }
        finally
          {
            n = {CLOBBER};
          }
      }
      <D.25396>:
      rp = rp->ai_next;
      <D.25399>:
      if (rp != 0B) goto <D.25398>; else goto <D.25397>;
      <D.25397>:
      result.447 = result;
      freeaddrinfo (result.447);
      <D.33177>:
      D.33194 = agent_config.defer;
      if (D.33194 != 0) goto <D.33195>; else goto <D.33196>;
      <D.33195>:
      return;
      <D.33196>:
      log_level.448 = log_level;
      D.33198 = log_level.448 > 0;
      D.33199 = (long int) D.33198;
      D.33200 = __builtin_expect (D.33199, 0);
      if (D.33200 != 0) goto <D.33201>; else goto <D.33202>;
      <D.33201>:
      log_file.449 = log_file;
      host.443 = host;
      port.444 = port;
      D.33204 = agent_config.timeout;
      fprintf (log_file.449, "Listening on %s:%d (timeout=%d ms)...\n", host.443, port.444, D.33204);
      log_file.449 = log_file;
      fflush (log_file.449);
      <D.33202>:
      D.33204 = agent_config.timeout;
      if (D.33204 != 0) goto <D.33205>; else goto <D.33206>;
      <D.33205>:
      {
        struct fd_set readfds;
        struct timeval tv;

        try
          {
            tv.tv_sec = 0;
            D.33204 = agent_config.timeout;
            D.33207 = D.33204 * 1000;
            D.33208 = (long int) D.33207;
            tv.tv_usec = D.33208;
            {
              unsigned int __i;
              struct fd_set * __arr;

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

              __d = (long int) sfd;
              D.33210 = __builtin_constant_p (__d);
              if (D.33210 != 0) goto <D.33211>; else goto <D.33212>;
              <D.33211>:
              __d.452 = (unsigned long) __d;
              if (__d.452 <= 1023) goto <D.33215>; else goto <D.33216>;
              <D.33215>:
              iftmp.451 = __d / 64;
              goto <D.33217>;
              <D.33216>:
              iftmp.451 = __fdelt_warn (__d);
              <D.33217>:
              iftmp.450 = iftmp.451;
              goto <D.33218>;
              <D.33212>:
              iftmp.450 = __fdelt_chk (__d);
              <D.33218>:
              D.25408 = iftmp.450;
            }
            D.33219 = D.25408;
            D.33220 = readfds.fds_bits[D.33219];
            D.33221 = sfd % 64;
            D.33222 = 1 << D.33221;
            D.33223 = D.33220 | D.33222;
            readfds.fds_bits[D.33219] = D.33223;
            D.33224 = sfd + 1;
            res = select (D.33224, &readfds, 0B, 0B, &tv);
            if (res == 0) goto <D.33225>; else goto <D.33226>;
            <D.33225>:
            stderr.445 = stderr;
            fprintf (stderr.445, "debugger-agent: Timed out waiting to connect.\n");
            exit (1);
            <D.33226>:
          }
        finally
          {
            readfds = {CLOBBER};
            tv = {CLOBBER};
          }
      }
      <D.33206>:
      conn_fd.453 = socket_transport_accept (sfd);
      conn_fd = conn_fd.453;
      conn_fd.454 = conn_fd;
      if (conn_fd.454 == -1) goto <D.33229>; else goto <D.33230>;
      <D.33229>:
      exit (1);
      <D.33230>:
      log_level.448 = log_level;
      D.33198 = log_level.448 > 0;
      D.33199 = (long int) D.33198;
      D.33200 = __builtin_expect (D.33199, 0);
      if (D.33200 != 0) goto <D.33231>; else goto <D.33232>;
      <D.33231>:
      log_file.449 = log_file;
      conn_fd.454 = conn_fd;
      fprintf (log_file.449, "Accepted connection from client, socket fd=%d.\n", conn_fd.454);
      log_file.449 = log_file;
      fflush (log_file.449);
      <D.33232>:
      goto <D.33233>;
      <D.33160>:
      rp = result;
      goto <D.25412>;
      <D.25411>:
      D.33178 = rp->ai_family;
      D.33179 = rp->ai_socktype;
      D.33180 = rp->ai_protocol;
      sfd = socket (D.33178, D.33179, D.33180);
      if (sfd == -1) goto <D.33234>; else goto <D.33235>;
      <D.33234>:
      // predicted unlikely by continue predictor.
      goto <D.25409>;
      <D.33235>:
      D.33187 = rp->ai_addr;
      D.33236.__sockaddr__ = D.33187;
      D.33188 = rp->ai_addrlen;
      D.33237 = connect (sfd, D.33236, D.33188);
      if (D.33237 != -1) goto <D.25410>; else goto <D.33238>;
      <D.33238>:
      close (sfd);
      <D.25409>:
      rp = rp->ai_next;
      <D.25412>:
      if (rp != 0B) goto <D.25411>; else goto <D.25410>;
      <D.25410>:
      if (rp == 0B) goto <D.33239>; else goto <D.33240>;
      <D.33239>:
      stderr.445 = stderr;
      host.443 = host;
      port.444 = port;
      fprintf (stderr.445, "debugger-agent: Unable to connect to %s:%d\n", host.443, port.444);
      exit (1);
      <D.33240>:
      conn_fd = sfd;
      result.447 = result;
      freeaddrinfo (result.447);
      <D.33233>:
      D.33241 = transport_handshake ();
      if (D.33241 == 0) goto <D.33242>; else goto <D.33243>;
      <D.33242>:
      exit (1);
      <D.33243>:
    }
  finally
    {
      hints = {CLOBBER};
      result = {CLOBBER};
      port_string = {CLOBBER};
      host = {CLOBBER};
      port = {CLOBBER};
    }
}


register_transport (struct DebuggerTransport * trans)
{
  int ntransports.455;
  _Bool D.33250;
  long int D.33251;
  long int D.33252;
  struct DebuggerTransport * D.33255;
  int ntransports.456;

  ntransports.455 = ntransports;
  D.33250 = ntransports.455 > 15;
  D.33251 = (long int) D.33250;
  D.33252 = __builtin_expect (D.33251, 0);
  if (D.33252 != 0) goto <D.33253>; else goto <D.33254>;
  <D.33253>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 1419, "ntransports < MAX_TRANSPORTS");
  <D.33254>:
  ntransports.455 = ntransports;
  D.33255 = &transports[ntransports.455];
  memcpy (D.33255, trans, 48);
  ntransports.455 = ntransports;
  ntransports.456 = ntransports.455 + 1;
  ntransports = ntransports.456;
}


mono_native_tls_alloc (pthread_key_t * key, void * destructor)
{
  int D.33257;
  void (*<Tbf>) (void *) destructor.457;
  int D.33259;
  _Bool D.33260;

  destructor.457 = (void (*<Tbf>) (void *)) destructor;
  D.33259 = pthread_key_create (key, destructor.457);
  D.33260 = D.33259 == 0;
  D.33257 = (int) D.33260;
  return D.33257;
}


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

  i = 0;
  goto <D.25679>;
  <D.25678>:
  D.33262 = monoeg_g_ptr_array_new ();
  ids[i] = D.33262;
  i = i + 1;
  <D.25679>:
  if (i <= 6) goto <D.25678>; else goto <D.25680>;
  <D.25680>:
}


objrefs_init ()
{
  struct GHashTable * objrefs.458;

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


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

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


breakpoints_init ()
{
  struct GPtrArray * breakpoints.459;
  struct GHashTable * bp_locs.460;

  breakpoints.459 = monoeg_g_ptr_array_new ();
  breakpoints = breakpoints.459;
  bp_locs.460 = monoeg_g_hash_table_new (0B, 0B);
  bp_locs = bp_locs.460;
}


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.33267;
  char * D.33270;
  char * D.33273;
  char * D.33274;
  struct _IO_FILE * stderr.461;
  int res;

  D.33267 = InterlockedCompareExchange (&inited, 1, 0);
  if (D.33267 == 1) goto <D.33268>; else goto <D.33269>;
  <D.33268>:
  return;
  <D.33269>:
  D.33270 = agent_config.launch;
  if (D.33270 != 0B) goto <D.33271>; else goto <D.33272>;
  <D.33271>:
  {
    char * argv[16];

    try
      {
        D.33270 = agent_config.launch;
        argv[0] = D.33270;
        D.33273 = agent_config.transport;
        argv[1] = D.33273;
        D.33274 = agent_config.address;
        argv[2] = D.33274;
        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.33275>; else goto <D.33276>;
        <D.33275>:
        stderr.461 = stderr;
        D.33270 = agent_config.launch;
        fprintf (stderr.461, "Failed to execute \'%s\'.\n", D.33270);
        exit (1);
        <D.33276>:
      }
    finally
      {
        argv = {CLOBBER};
      }
  }
  <D.33272>:
  D.33274 = agent_config.address;
  transport_connect (D.33274);
  if (on_startup == 0) goto <D.33278>; else goto <D.33279>;
  <D.33278>:
  vm_start_event_sent = 1;
  start_debugger_thread ();
  <D.33279>:
}


InterlockedCompareExchange (volatile gint32 * dest, gint32 exch, gint32 comp)
{
  gint32 D.33281;
  unsigned int comp.462;
  unsigned int exch.463;
  unsigned int D.33284;

  comp.462 = (unsigned int) comp;
  exch.463 = (unsigned int) exch;
  D.33284 = __sync_val_compare_and_swap_4 (dest, comp.462, exch.463);
  D.33281 = (gint32) D.33284;
  return D.33281;
}


transport_connect (const char * address)
{
  struct DebuggerTransport * transport.464;
  void (*<T3fb3>) (const char *) D.33287;

  transport.464 = transport;
  D.33287 = transport.464->connect;
  D.33287 (address);
}


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


mono_debugger_agent_transport_handshake ()
{
  gboolean D.33288;

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


mono_debugger_agent_free_domain_info (struct MonoDomain * domain)
{
  void * D.33290;
  struct GHashTable * D.33293;
  struct GHashTable * D.33296;
  struct GHashTable * D.33297;
  struct GPtrArray * file_names.465;
  void * * D.33299;
  long unsigned int D.33300;
  long unsigned int D.33301;
  void * * D.33302;
  void * D.33303;
  unsigned int i.466;
  unsigned int D.33305;
  int D.33306;
  struct GHashTable * D.33307;
  char * basename.467;
  struct GSList * l.468;
  int D.33310;
  struct GHashTable * D.33311;
  int D.33312;
  struct GPtrArray * D.33313;
  void * * D.33316;
  long unsigned int D.33317;
  long unsigned int D.33318;
  void * * D.33319;
  struct MonoDomain * D.33320;
  unsigned int j.469;
  unsigned int D.33324;
  struct GHashTable * domains.470;
  struct AgentDomainInfo * info;
  int i;
  int j;
  struct GHashTableIter iter;
  struct GPtrArray * file_names;
  char * basename;
  struct GSList * l;

  try
    {
      D.33290 = domain->runtime_info;
      info = MEM[(struct MonoJitDomainInfo *)D.33290].agent_info;
      if (info != 0B) goto <D.33291>; else goto <D.33292>;
      <D.33291>:
      i = 0;
      goto <D.25703>;
      <D.25702>:
      D.33293 = info->val_to_id[i];
      if (D.33293 != 0B) goto <D.33294>; else goto <D.33295>;
      <D.33294>:
      D.33293 = info->val_to_id[i];
      monoeg_g_hash_table_destroy (D.33293);
      <D.33295>:
      i = i + 1;
      <D.25703>:
      if (i <= 6) goto <D.25702>; else goto <D.25704>;
      <D.25704>:
      D.33296 = info->loaded_classes;
      monoeg_g_hash_table_destroy (D.33296);
      D.33297 = info->source_files;
      monoeg_g_hash_table_iter_init (&iter, D.33297);
      goto <D.25709>;
      <D.25708>:
      i = 0;
      goto <D.25706>;
      <D.25705>:
      file_names.465 = file_names;
      D.33299 = file_names.465->pdata;
      D.33300 = (long unsigned int) i;
      D.33301 = D.33300 * 8;
      D.33302 = D.33299 + D.33301;
      D.33303 = *D.33302;
      monoeg_g_free (D.33303);
      i = i + 1;
      <D.25706>:
      i.466 = (unsigned int) i;
      file_names.465 = file_names;
      D.33305 = file_names.465->len;
      if (i.466 < D.33305) goto <D.25705>; else goto <D.25707>;
      <D.25707>:
      file_names.465 = file_names;
      monoeg_g_ptr_array_free (file_names.465, 1);
      <D.25709>:
      D.33306 = monoeg_g_hash_table_iter_next (&iter, 0B, &file_names);
      if (D.33306 != 0) goto <D.25708>; else goto <D.25710>;
      <D.25710>:
      D.33307 = info->source_file_to_class;
      monoeg_g_hash_table_iter_init (&iter, D.33307);
      goto <D.25712>;
      <D.25711>:
      basename.467 = basename;
      monoeg_g_free (basename.467);
      l.468 = l;
      monoeg_g_slist_free (l.468);
      <D.25712>:
      D.33310 = monoeg_g_hash_table_iter_next (&iter, &basename, &l);
      if (D.33310 != 0) goto <D.25711>; else goto <D.25713>;
      <D.25713>:
      D.33311 = info->source_file_to_class_ignorecase;
      monoeg_g_hash_table_iter_init (&iter, D.33311);
      goto <D.25715>;
      <D.25714>:
      basename.467 = basename;
      monoeg_g_free (basename.467);
      l.468 = l;
      monoeg_g_slist_free (l.468);
      <D.25715>:
      D.33312 = monoeg_g_hash_table_iter_next (&iter, &basename, &l);
      if (D.33312 != 0) goto <D.25714>; else goto <D.25716>;
      <D.25716>:
      monoeg_g_free (info);
      <D.33292>:
      D.33290 = domain->runtime_info;
      MEM[(struct MonoJitDomainInfo *)D.33290].agent_info = 0B;
      i = 0;
      goto <D.25722>;
      <D.25721>:
      D.33313 = ids[i];
      if (D.33313 != 0B) goto <D.33314>; else goto <D.33315>;
      <D.33314>:
      j = 0;
      goto <D.25719>;
      <D.25718>:
      {
        struct Id * id;

        D.33313 = ids[i];
        D.33316 = D.33313->pdata;
        D.33317 = (long unsigned int) j;
        D.33318 = D.33317 * 8;
        D.33319 = D.33316 + D.33318;
        id = *D.33319;
        D.33320 = id->domain;
        if (D.33320 == domain) goto <D.33321>; else goto <D.33322>;
        <D.33321>:
        id->domain = 0B;
        <D.33322>:
      }
      j = j + 1;
      <D.25719>:
      j.469 = (unsigned int) j;
      D.33313 = ids[i];
      D.33324 = D.33313->len;
      if (j.469 < D.33324) goto <D.25718>; else goto <D.25720>;
      <D.25720>:
      <D.33315>:
      i = i + 1;
      <D.25722>:
      if (i <= 6) goto <D.25721>; else goto <D.25723>;
      <D.25723>:
      mono_loader_lock ();
      domains.470 = domains;
      monoeg_g_hash_table_remove (domains.470, 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.471;
  gboolean D.33329;
  unsigned int debugger_tls_id.472;
  int log_level.473;
  _Bool D.33334;
  long int D.33335;
  long int D.33336;
  struct FILE * log_file.474;
  long unsigned int D.33340;
  void * D.33341;
  struct DebuggerTlsData * tls;

  inited.471 = inited;
  if (inited.471 == 0) goto <D.33327>; else goto <D.33328>;
  <D.33327>:
  D.33329 = 0;
  return D.33329;
  <D.33328>:
  debugger_tls_id.472 = debugger_tls_id;
  tls = pthread_getspecific (debugger_tls_id.472);
  if (tls == 0B) goto <D.33331>; else goto <D.33332>;
  <D.33331>:
  log_level.473 = log_level;
  D.33334 = log_level.473 > 0;
  D.33335 = (long int) D.33334;
  D.33336 = __builtin_expect (D.33335, 0);
  if (D.33336 != 0) goto <D.33337>; else goto <D.33338>;
  <D.33337>:
  log_file.474 = log_file;
  D.33340 = GetCurrentThreadId ();
  D.33341 = (void *) D.33340;
  fprintf (log_file.474, "[%p] Received interrupt with no TLS, continuing.\n", D.33341);
  log_file.474 = log_file;
  fflush (log_file.474);
  <D.33338>:
  D.33329 = 0;
  return D.33329;
  <D.33332>:
  D.33329 = thread_interrupt (tls, 0B, sigctx, ji);
  return D.33329;
}


mono_debugger_agent_breakpoint_hit (void * sigctx)
{
  resume_from_signal_handler (sigctx, process_breakpoint);
}


process_breakpoint ()
{
  process_signal_event (process_breakpoint_inner);
}


process_breakpoint_inner (struct DebuggerTlsData * tls)
{
  long unsigned int D.33343;
  struct MonoDomain * D.33344;
  _Bool D.33345;
  long int D.33346;
  long int D.33347;
  long int ip.475;
  void * D.33351;
  long int D.33352;
  long int D.33353;
  long unsigned int D.33356;
  long unsigned int D.33357;
  int D.33359;
  struct MonoDomain * D.33360;
  int native_offset.476;
  _Bool D.33364;
  long int D.33365;
  long int D.33366;
  int log_level.477;
  _Bool D.33370;
  long int D.33371;
  long int D.33372;
  struct FILE * log_file.478;
  long unsigned int D.33376;
  void * D.33377;
  const char * D.33378;
  int iftmp.479;
  struct GPtrArray * breakpoints.480;
  void * * D.33384;
  long unsigned int D.33385;
  long unsigned int D.33386;
  void * * D.33387;
  struct MonoMethod * D.33388;
  struct GPtrArray * D.33391;
  void * * D.33392;
  long unsigned int D.33393;
  long unsigned int D.33394;
  void * * D.33395;
  struct MonoJitInfo * D.33396;
  struct SeqPoint * D.33399;
  struct EventRequest * D.33402;
  int D.33403;
  unsigned int j.481;
  unsigned int D.33408;
  unsigned int i.482;
  unsigned int D.33410;
  unsigned int D.33411;
  unsigned int D.33414;
  int D.33417;
  void * * D.33423;
  void * * D.33424;
  struct MonoInternalThread * D.33425;
  struct MonoInternalThread * D.33426;
  struct MonoSeqPointInfo * info.483;
  unsigned int D.33432;
  int suspend_policy.484;
  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.33343 = ctx->sc_ir;
      ip = (guint8 *) D.33343;
      D.33344 = mono_domain_get ();
      ji = mini_jit_info_table_find (D.33344, ip, 0B);
      D.33345 = ji == 0B;
      D.33346 = (long int) D.33345;
      D.33347 = __builtin_expect (D.33346, 0);
      if (D.33347 != 0) goto <D.33348>; else goto <D.33349>;
      <D.33348>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 4554, "ji");
      <D.33349>:
      method = jinfo_get_method (ji);
      ip.475 = (long int) ip;
      D.33351 = ji->code_start;
      D.33352 = (long int) D.33351;
      D.33353 = ip.475 - D.33352;
      native_offset = (guint32) D.33353;
      mono_arch_skip_breakpoint (ctx, ji);
      D.33356 = BIT_FIELD_REF <*method, 64, 256>;
      D.33357 = D.33356 & 124;
      if (D.33357 != 0) goto <D.33354>; else goto <D.33358>;
      <D.33358>:
      D.33359 = tls->disable_breakpoints;
      if (D.33359 != 0) goto <D.33354>; else goto <D.33355>;
      <D.33354>:
      return;
      <D.33355>:
      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.33360 = mono_domain_get ();
      native_offset.476 = (int) native_offset;
      sp = find_prev_seq_point_for_native_offset (D.33360, method, native_offset.476, &info);
      if (sp == 0B) goto <D.33362>; else goto <D.33363>;
      <D.33362>:
      no_seq_points_found (method);
      <D.33363>:
      D.33364 = sp == 0B;
      D.33365 = (long int) D.33364;
      D.33366 = __builtin_expect (D.33365, 0);
      if (D.33366 != 0) goto <D.33367>; else goto <D.33368>;
      <D.33367>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 4581, "sp");
      <D.33368>:
      log_level.477 = log_level;
      D.33370 = log_level.477 > 0;
      D.33371 = (long int) D.33370;
      D.33372 = __builtin_expect (D.33371, 0);
      if (D.33372 != 0) goto <D.33373>; else goto <D.33374>;
      <D.33373>:
      log_file.478 = log_file;
      D.33376 = GetCurrentThreadId ();
      D.33377 = (void *) D.33376;
      D.33378 = method->name;
      if (sp != 0B) goto <D.33380>; else goto <D.33381>;
      <D.33380>:
      iftmp.479 = sp->il_offset;
      goto <D.33382>;
      <D.33381>:
      iftmp.479 = -1;
      <D.33382>:
      fprintf (log_file.478, "[%p] Breakpoint hit, method=%s, ip=%p, offset=0x%x, sp il offset=0x%x.\n", D.33377, D.33378, ip, native_offset, iftmp.479);
      log_file.478 = log_file;
      fflush (log_file.478);
      <D.33374>:
      bp = 0B;
      i = 0;
      goto <D.26477>;
      <D.26476>:
      breakpoints.480 = breakpoints;
      D.33384 = breakpoints.480->pdata;
      D.33385 = (long unsigned int) i;
      D.33386 = D.33385 * 8;
      D.33387 = D.33384 + D.33386;
      bp = *D.33387;
      D.33388 = bp->method;
      if (D.33388 == 0B) goto <D.33389>; else goto <D.33390>;
      <D.33389>:
      // predicted unlikely by continue predictor.
      goto <D.26472>;
      <D.33390>:
      j = 0;
      goto <D.26474>;
      <D.26473>:
      D.33391 = bp->children;
      D.33392 = D.33391->pdata;
      D.33393 = (long unsigned int) j;
      D.33394 = D.33393 * 8;
      D.33395 = D.33392 + D.33394;
      inst = *D.33395;
      D.33396 = inst->ji;
      if (D.33396 == ji) goto <D.33397>; else goto <D.33398>;
      <D.33397>:
      D.33399 = inst->sp;
      if (D.33399 == sp) goto <D.33400>; else goto <D.33401>;
      <D.33400>:
      D.33402 = bp->req;
      D.33403 = D.33402->event_kind;
      if (D.33403 == 11) goto <D.33404>; else goto <D.33405>;
      <D.33404>:
      D.33402 = bp->req;
      monoeg_g_ptr_array_add (ss_reqs_orig, D.33402);
      goto <D.33406>;
      <D.33405>:
      D.33402 = bp->req;
      monoeg_g_ptr_array_add (bp_reqs, D.33402);
      <D.33406>:
      <D.33401>:
      <D.33398>:
      j = j + 1;
      <D.26474>:
      j.481 = (unsigned int) j;
      D.33391 = bp->children;
      D.33408 = D.33391->len;
      if (j.481 < D.33408) goto <D.26473>; else goto <D.26475>;
      <D.26475>:
      <D.26472>:
      i = i + 1;
      <D.26477>:
      i.482 = (unsigned int) i;
      breakpoints.480 = breakpoints;
      D.33410 = breakpoints.480->len;
      if (i.482 < D.33410) goto <D.26476>; else goto <D.26478>;
      <D.26478>:
      D.33411 = bp_reqs->len;
      if (D.33411 == 0) goto <D.33412>; else goto <D.33413>;
      <D.33412>:
      D.33414 = ss_reqs_orig->len;
      if (D.33414 == 0) goto <D.33415>; else goto <D.33416>;
      <D.33415>:
      D.33417 = sp->il_offset;
      if (D.33417 == -1) goto <D.33418>; else goto <D.33419>;
      <D.33418>:
      kind = 6;
      goto <D.33420>;
      <D.33419>:
      D.33417 = sp->il_offset;
      if (D.33417 == 16777215) goto <D.33421>; else goto <D.33422>;
      <D.33421>:
      kind = 7;
      <D.33422>:
      <D.33420>:
      <D.33416>:
      <D.33413>:
      i = 0;
      goto <D.26484>;
      <D.26483>:
      {
        struct EventRequest * req;
        struct SingleStepReq * ss_req;
        gboolean hit;

        D.33423 = ss_reqs_orig->pdata;
        D.33385 = (long unsigned int) i;
        D.33386 = D.33385 * 8;
        D.33424 = D.33423 + D.33386;
        req = *D.33424;
        ss_req = req->info;
        D.33425 = mono_thread_internal_current ();
        D.33426 = ss_req->thread;
        if (D.33425 != D.33426) goto <D.33427>; else goto <D.33428>;
        <D.33427>:
        // predicted unlikely by continue predictor.
        goto <D.26482>;
        <D.33428>:
        hit = ss_update (ss_req, ji, sp, tls, ctx);
        if (hit != 0) goto <D.33429>; else goto <D.33430>;
        <D.33429>:
        monoeg_g_ptr_array_add (ss_reqs, req);
        <D.33430>:
        info.483 = info;
        ss_start (ss_req, method, sp, info.483, ctx, tls, 0);
      }
      <D.26482>:
      i = i + 1;
      <D.26484>:
      i.482 = (unsigned int) i;
      D.33414 = ss_reqs_orig->len;
      if (i.482 < D.33414) goto <D.26483>; else goto <D.26485>;
      <D.26485>:
      D.33432 = ss_reqs->len;
      if (D.33432 != 0) goto <D.33433>; else goto <D.33434>;
      <D.33433>:
      ss_events = create_event_list (11, ss_reqs, ji, 0B, &suspend_policy);
      <D.33434>:
      D.33411 = bp_reqs->len;
      if (D.33411 != 0) goto <D.33435>; else goto <D.33436>;
      <D.33435>:
      bp_events = create_event_list (10, bp_reqs, ji, 0B, &suspend_policy);
      <D.33436>:
      if (kind != 10) goto <D.33437>; else goto <D.33438>;
      <D.33437>:
      enter_leave_events = create_event_list (kind, 0B, ji, 0B, &suspend_policy);
      <D.33438>:
      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.33439>; else goto <D.33440>;
      <D.33439>:
      suspend_policy.484 = suspend_policy;
      process_event (11, method, 0, ctx, ss_events, suspend_policy.484);
      <D.33440>:
      if (bp_events != 0B) goto <D.33442>; else goto <D.33443>;
      <D.33442>:
      suspend_policy.484 = suspend_policy;
      process_event (kind, method, 0, ctx, bp_events, suspend_policy.484);
      <D.33443>:
      if (enter_leave_events != 0B) goto <D.33444>; else goto <D.33445>;
      <D.33444>:
      suspend_policy.484 = suspend_policy;
      process_event (kind, method, 0, ctx, enter_leave_events, suspend_policy.484);
      <D.33445>:
    }
  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.33449;
  int D.33452;
  int D.33453;
  int log_level.485;
  _Bool D.33457;
  long int D.33458;
  long int D.33459;
  struct FILE * log_file.486;
  long unsigned int D.33463;
  void * D.33464;
  int D.33465;
  gboolean D.33466;
  int D.33471;
  struct MonoThreadUnwindState * D.33474;
  struct MonoInternalThread * D.33475;
  int D.33476;
  int D.33479;
  long unsigned int D.33486;
  void * D.33487;
  <unnamed type> D.33488;
  unsigned int D.33493;
  struct SingleStepReq * ss_req.487;
  struct MonoMethod * D.33498;
  unsigned int D.33500;
  int D.33501;
  unsigned int D.33502;
  long unsigned int D.33507;
  void * D.33508;
  long unsigned int D.33512;
  void * D.33513;
  int D.33516;
  struct MonoDebugMethodInfo * minfo;
  struct MonoDebugSourceLocation * loc;
  gboolean hit;
  struct MonoMethod * method;

  loc = 0B;
  hit = 1;
  D.33449 = req->depth;
  if (D.33449 == 1) goto <D.33450>; else goto <D.33451>;
  <D.33450>:
  D.33452 = sp->flags;
  D.33453 = D.33452 & 1;
  if (D.33453 != 0) goto <D.33454>; else goto <D.33455>;
  <D.33454>:
  log_level.485 = log_level;
  D.33457 = log_level.485 > 0;
  D.33458 = (long int) D.33457;
  D.33459 = __builtin_expect (D.33458, 0);
  if (D.33459 != 0) goto <D.33460>; else goto <D.33461>;
  <D.33460>:
  log_file.486 = log_file;
  D.33463 = GetCurrentThreadId ();
  D.33464 = (void *) D.33463;
  D.33465 = sp->il_offset;
  fprintf (log_file.486, "[%p] Seq point at nonempty stack %x while stepping over, continuing single stepping.\n", D.33464, D.33465);
  log_file.486 = log_file;
  fflush (log_file.486);
  <D.33461>:
  D.33466 = 0;
  return D.33466;
  <D.33455>:
  <D.33451>:
  D.33449 = req->depth;
  if (D.33449 == 1) goto <D.33467>; else goto <D.33468>;
  <D.33467>:
  if (hit != 0) goto <D.33469>; else goto <D.33470>;
  <D.33469>:
  D.33471 = tls->context.valid;
  if (D.33471 == 0) goto <D.33472>; else goto <D.33473>;
  <D.33472>:
  D.33474 = &tls->context;
  mono_thread_state_init_from_monoctx (D.33474, ctx);
  <D.33473>:
  D.33475 = tls->thread;
  compute_frame_info (D.33475, tls);
  D.33476 = req->nframes;
  if (D.33476 != 0) goto <D.33477>; else goto <D.33478>;
  <D.33477>:
  D.33479 = tls->frame_count;
  if (D.33479 != 0) goto <D.33480>; else goto <D.33481>;
  <D.33480>:
  D.33479 = tls->frame_count;
  D.33476 = req->nframes;
  if (D.33479 > D.33476) goto <D.33482>; else goto <D.33483>;
  <D.33482>:
  log_level.485 = log_level;
  D.33457 = log_level.485 > 0;
  D.33458 = (long int) D.33457;
  D.33459 = __builtin_expect (D.33458, 0);
  if (D.33459 != 0) goto <D.33484>; else goto <D.33485>;
  <D.33484>:
  log_file.486 = log_file;
  D.33486 = GetCurrentThreadId ();
  D.33487 = (void *) D.33486;
  fprintf (log_file.486, "[%p] Breakpoint at lower frame while stepping over, continuing single stepping.\n", D.33487);
  log_file.486 = log_file;
  fflush (log_file.486);
  <D.33485>:
  D.33466 = 0;
  return D.33466;
  <D.33483>:
  <D.33481>:
  <D.33478>:
  <D.33470>:
  <D.33468>:
  D.33488 = req->size;
  if (D.33488 != 1) goto <D.33489>; else goto <D.33490>;
  <D.33489>:
  D.33466 = 1;
  return D.33466;
  <D.33490>:
  method = jinfo_get_method (ji);
  minfo = mono_debug_lookup_method (method);
  if (minfo != 0B) goto <D.33491>; else goto <D.33492>;
  <D.33491>:
  D.33465 = sp->il_offset;
  D.33493 = (unsigned int) D.33465;
  loc = mono_debug_symfile_lookup_location (minfo, D.33493);
  <D.33492>:
  if (loc == 0B) goto <D.33494>; else goto <D.33496>;
  <D.33496>:
  ss_req.487 = ss_req;
  D.33498 = ss_req.487->last_method;
  if (D.33498 == method) goto <D.33499>; else goto <D.33495>;
  <D.33499>:
  D.33500 = loc->row;
  ss_req.487 = ss_req;
  D.33501 = ss_req.487->last_line;
  D.33502 = (unsigned int) D.33501;
  if (D.33500 == D.33502) goto <D.33494>; else goto <D.33495>;
  <D.33494>:
  if (loc == 0B) goto <D.33503>; else goto <D.33504>;
  <D.33503>:
  log_level.485 = log_level;
  D.33457 = log_level.485 > 0;
  D.33458 = (long int) D.33457;
  D.33459 = __builtin_expect (D.33458, 0);
  if (D.33459 != 0) goto <D.33505>; else goto <D.33506>;
  <D.33505>:
  log_file.486 = log_file;
  D.33507 = GetCurrentThreadId ();
  D.33508 = (void *) D.33507;
  D.33465 = sp->il_offset;
  fprintf (log_file.486, "[%p] No line number info for il offset %x, continuing single stepping.\n", D.33508, D.33465);
  log_file.486 = log_file;
  fflush (log_file.486);
  <D.33506>:
  goto <D.33509>;
  <D.33504>:
  log_level.485 = log_level;
  D.33457 = log_level.485 > 0;
  D.33458 = (long int) D.33457;
  D.33459 = __builtin_expect (D.33458, 0);
  if (D.33459 != 0) goto <D.33510>; else goto <D.33511>;
  <D.33510>:
  log_file.486 = log_file;
  D.33512 = GetCurrentThreadId ();
  D.33513 = (void *) D.33512;
  D.33500 = loc->row;
  fprintf (log_file.486, "[%p] Same source line (%d), continuing single stepping.\n", D.33513, D.33500);
  log_file.486 = log_file;
  fflush (log_file.486);
  <D.33511>:
  <D.33509>:
  hit = 0;
  <D.33495>:
  if (loc != 0B) goto <D.33514>; else goto <D.33515>;
  <D.33514>:
  ss_req.487 = ss_req;
  ss_req.487->last_method = method;
  ss_req.487 = ss_req;
  D.33500 = loc->row;
  D.33516 = (int) D.33500;
  ss_req.487->last_line = D.33516;
  mono_debug_free_source_location (loc);
  <D.33515>:
  D.33466 = hit;
  return D.33466;
}


process_signal_event (void (*<T462e>) (struct DebuggerTlsData *) func)
{
  unsigned int debugger_tls_id.488;
  struct MonoContext * D.33519;
  struct MonoContext * D.33520;
  struct DebuggerTlsData * tls;
  struct MonoContext orig_restore_ctx;
  struct MonoContext ctx;

  try
    {
      debugger_tls_id.488 = debugger_tls_id;
      tls = pthread_getspecific (debugger_tls_id.488);
      D.33519 = &tls->restore_ctx;
      memcpy (&orig_restore_ctx, D.33519, 312);
      D.33519 = &tls->restore_ctx;
      D.33520 = &tls->handler_ctx;
      memcpy (D.33519, D.33520, 312);
      func (tls);
      D.33519 = &tls->restore_ctx;
      memcpy (&ctx, D.33519, 312);
      D.33519 = &tls->restore_ctx;
      memcpy (D.33519, &orig_restore_ctx, 312);
      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.489;
  struct _IO_FILE * stderr.490;
  long unsigned int D.33525;
  void * D.33526;
  _Bool D.33527;
  long int D.33528;
  long int D.33529;
  struct MonoContext * D.33532;
  long unsigned int func.491;
  struct DebuggerTlsData * tls;
  struct MonoContext ctx;

  try
    {
      debugger_tls_id.489 = debugger_tls_id;
      tls = pthread_getspecific (debugger_tls_id.489);
      if (tls == 0B) goto <D.33522>; else goto <D.33523>;
      <D.33522>:
      stderr.490 = stderr;
      D.33525 = GetCurrentThreadId ();
      D.33526 = (void *) D.33525;
      fprintf (stderr.490, "Thread %p is not attached to the JIT.\n", D.33526);
      <D.33523>:
      D.33527 = tls == 0B;
      D.33528 = (long int) D.33527;
      D.33529 = __builtin_expect (D.33528, 0);
      if (D.33529 != 0) goto <D.33530>; else goto <D.33531>;
      <D.33530>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 4690, "tls");
      <D.33531>:
      mono_arch_sigctx_to_monoctx (sigctx, &ctx);
      D.33532 = &tls->handler_ctx;
      memcpy (D.33532, &ctx, 312);
      func.491 = (long unsigned int) func;
      ctx.sc_ir = func.491;
      mono_arch_monoctx_to_sigctx (&ctx, sigctx);
      mono_ppc_set_func_into_sigctx (sigctx, func);
    }
  finally
    {
      ctx = {CLOBBER};
    }
}


mono_debugger_agent_user_break ()
{
  int D.33534;
  long unsigned int D.33537;
  void * D.33538;
  _Bool D.33539;
  long int D.33540;
  long int D.33541;
  int suspend_policy.492;

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

    try
      {
        ctx.sc_ir = 0;
        mono_walk_stack_with_ctx (user_break_cb, 0B, 0, &ctx);
        D.33537 = ctx.sc_ir;
        D.33538 = (void *) D.33537;
        D.33539 = D.33538 == 0B;
        D.33540 = (long int) D.33539;
        D.33541 = __builtin_expect (D.33540, 0);
        if (D.33541 != 0) goto <D.33542>; else goto <D.33543>;
        <D.33542>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 4747, "MONO_CONTEXT_GET_IP (&ctx) != NULL");
        <D.33543>:
        mono_loader_lock ();
        events = create_event_list (15, 0B, 0B, 0B, &suspend_policy);
        mono_loader_unlock ();
        suspend_policy.492 = suspend_policy;
        process_event (15, 0B, 0, &ctx, events, suspend_policy.492);
      }
    finally
      {
        ctx = {CLOBBER};
        suspend_policy = {CLOBBER};
      }
  }
  goto <D.33545>;
  <D.33536>:
  raise (5);
  <D.33545>:
}


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

  D.33546 = frame->managed;
  if (D.33546 != 0) goto <D.33547>; else goto <D.33548>;
  <D.33547>:
  MEM[(struct MonoContext *)data] = *ctx;
  D.33549 = 1;
  return D.33549;
  <D.33548>:
  D.33549 = 0;
  return D.33549;
}


mono_debugger_agent_single_step_event (void * sigctx)
{
  long unsigned int D.33551;
  long unsigned int debugger_thread_id.493;

  D.33551 = GetCurrentThreadId ();
  debugger_thread_id.493 = debugger_thread_id;
  if (D.33551 == debugger_thread_id.493) goto <D.33553>; else goto <D.33554>;
  <D.33553>:
  {
    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.33554>:
  resume_from_signal_handler (sigctx, process_single_step);
}


process_single_step ()
{
  process_signal_event (process_single_step_inner);
}


process_single_step_inner (struct DebuggerTlsData * tls)
{
  long unsigned int D.33557;
  int suspend_count.494;
  struct SingleStepReq * ss_req.495;
  struct MonoInternalThread * D.33564;
  struct MonoInternalThread * D.33565;
  int log_level.496;
  struct MonoDomain * D.33571;
  _Bool D.33572;
  long int D.33573;
  long int D.33574;
  struct FILE * log_file.497;
  long unsigned int D.33578;
  void * D.33579;
  <unnamed type> D.33580;
  const char * D.33581;
  struct MonoMethod * D.33582;
  char * D.33583;
  void * D.33584;
  long unsigned int D.33585;
  void * D.33586;
  void * D.33587;
  struct MonoDomain * D.33588;
  _Bool D.33589;
  long int D.33590;
  long int D.33591;
  _Bool D.33594;
  long int D.33595;
  long int D.33596;
  long unsigned int D.33599;
  long unsigned int D.33600;
  struct MonoClass * D.33607;
  struct MonoClass * D.33608;
  int D.26545;
  int iftmp.498;
  int D.26544;
  const char[7] * D.33614;
  unsigned char D.33615;
  int D.33616;
  unsigned char D.33617;
  int D.33618;
  const unsigned char * D.33623;
  unsigned char D.33624;
  int D.33625;
  const unsigned char * D.33626;
  unsigned char D.33627;
  int D.33628;
  const unsigned char * D.33633;
  unsigned char D.33634;
  int D.33635;
  const unsigned char * D.33636;
  unsigned char D.33637;
  int D.33638;
  const unsigned char * D.33643;
  unsigned char D.33644;
  int D.33645;
  const unsigned char * D.33646;
  unsigned char D.33647;
  int D.33648;
  const char * D.33650;
  char * D.33652;
  struct MonoDomain * domain.499;
  long int ip.500;
  void * D.33655;
  long int D.33656;
  long int D.33657;
  int D.33658;
  int D.33661;
  struct MonoSeqPointInfo * info.501;
  <unnamed type> D.33665;
  unsigned int D.33666;
  short unsigned int D.33669;
  int D.33670;
  int D.33671;
  int D.26554;
  int iftmp.502;
  int D.26553;
  const char[7] * D.33677;
  unsigned char D.33678;
  int D.33679;
  unsigned char D.33680;
  int D.33681;
  const unsigned char * D.33686;
  unsigned char D.33687;
  int D.33688;
  const unsigned char * D.33689;
  unsigned char D.33690;
  int D.33691;
  const unsigned char * D.33696;
  unsigned char D.33697;
  int D.33698;
  const unsigned char * D.33699;
  unsigned char D.33700;
  int D.33701;
  const unsigned char * D.33706;
  unsigned char D.33707;
  int D.33708;
  const unsigned char * D.33709;
  unsigned char D.33710;
  int D.33711;
  struct EventRequest * D.33715;
  struct MonoMethod * D.33716;
  int suspend_policy.503;
  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.33557 = ctx->sc_ir;
      ip = (guint8 *) D.33557;
      mono_arch_skip_single_step (ctx);
      suspend_count.494 = suspend_count;
      if (suspend_count.494 > 0) goto <D.33559>; else goto <D.33560>;
      <D.33559>:
      process_suspend (tls, ctx);
      return;
      <D.33560>:
      ss_req.495 = ss_req;
      if (ss_req.495 == 0B) goto <D.33562>; else goto <D.33563>;
      <D.33562>:
      return;
      <D.33563>:
      D.33564 = mono_thread_internal_current ();
      ss_req.495 = ss_req;
      D.33565 = ss_req.495->thread;
      if (D.33564 != D.33565) goto <D.33566>; else goto <D.33567>;
      <D.33566>:
      return;
      <D.33567>:
      log_level.496 = log_level;
      if (log_level.496 > 0) goto <D.33569>; else goto <D.33570>;
      <D.33569>:
      D.33571 = mono_domain_get ();
      ji = mini_jit_info_table_find (D.33571, ip, &domain);
      log_level.496 = log_level;
      D.33572 = log_level.496 > 0;
      D.33573 = (long int) D.33572;
      D.33574 = __builtin_expect (D.33573, 0);
      if (D.33574 != 0) goto <D.33575>; else goto <D.33576>;
      <D.33575>:
      log_file.497 = log_file;
      D.33578 = GetCurrentThreadId ();
      D.33579 = (void *) D.33578;
      ss_req.495 = ss_req;
      D.33580 = ss_req.495->depth;
      D.33581 = ss_depth_to_string (D.33580);
      D.33582 = jinfo_get_method (ji);
      D.33583 = mono_method_full_name (D.33582, 1);
      D.33557 = ctx->sc_ir;
      D.33584 = (void *) D.33557;
      D.33585 = ctx->sc_sp;
      D.33586 = (void *) D.33585;
      ss_req.495 = ss_req;
      D.33587 = ss_req.495->last_sp;
      fprintf (log_file.497, "[%p] Single step event (depth=%s) at %s (%p), sp %p, last sp %p\n", D.33579, D.33581, D.33583, D.33584, D.33586, D.33587);
      log_file.497 = log_file;
      fflush (log_file.497);
      <D.33576>:
      <D.33570>:
      D.33588 = mono_domain_get ();
      ji = mini_jit_info_table_find (D.33588, ip, &domain);
      D.33589 = ji == 0B;
      D.33590 = (long int) D.33589;
      D.33591 = __builtin_expect (D.33590, 0);
      if (D.33591 != 0) goto <D.33592>; else goto <D.33593>;
      <D.33592>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 4813, "ji");
      <D.33593>:
      method = jinfo_get_method (ji);
      D.33594 = method == 0B;
      D.33595 = (long int) D.33594;
      D.33596 = __builtin_expect (D.33595, 0);
      if (D.33596 != 0) goto <D.33597>; else goto <D.33598>;
      <D.33597>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 4815, "method");
      <D.33598>:
      D.33599 = BIT_FIELD_REF <*method, 64, 256>;
      D.33600 = D.33599 & 124;
      if (D.33600 != 0) goto <D.33601>; else goto <D.33602>;
      <D.33601>:
      D.33599 = BIT_FIELD_REF <*method, 64, 256>;
      D.33600 = D.33599 & 124;
      if (D.33600 != 68) goto <D.33603>; else goto <D.33604>;
      <D.33603>:
      return;
      <D.33604>:
      <D.33602>:
      D.33607 = method->klass;
      D.33608 = mono_defaults.string_class;
      if (D.33607 == D.33608) goto <D.33609>; else goto <D.33610>;
      <D.33609>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          __s2 = method->name;
          D.33614 = "memset";
          D.33615 = MEM[(const unsigned char *)D.33614];
          D.33616 = (int) D.33615;
          D.33617 = *__s2;
          D.33618 = (int) D.33617;
          __result = D.33616 - D.33618;
          {
            if (__s2_len != 0) goto <D.33619>; else goto <D.33620>;
            <D.33619>:
            if (__result == 0) goto <D.33621>; else goto <D.33622>;
            <D.33621>:
            D.33623 = &MEM[(void *)"memset" + 1B];
            D.33624 = *D.33623;
            D.33625 = (int) D.33624;
            D.33626 = __s2 + 1;
            D.33627 = *D.33626;
            D.33628 = (int) D.33627;
            __result = D.33625 - D.33628;
            if (__s2_len > 1) goto <D.33629>; else goto <D.33630>;
            <D.33629>:
            if (__result == 0) goto <D.33631>; else goto <D.33632>;
            <D.33631>:
            D.33633 = &MEM[(void *)"memset" + 2B];
            D.33634 = *D.33633;
            D.33635 = (int) D.33634;
            D.33636 = __s2 + 2;
            D.33637 = *D.33636;
            D.33638 = (int) D.33637;
            __result = D.33635 - D.33638;
            if (__s2_len > 2) goto <D.33639>; else goto <D.33640>;
            <D.33639>:
            if (__result == 0) goto <D.33641>; else goto <D.33642>;
            <D.33641>:
            D.33643 = &MEM[(void *)"memset" + 3B];
            D.33644 = *D.33643;
            D.33645 = (int) D.33644;
            D.33646 = __s2 + 3;
            D.33647 = *D.33646;
            D.33648 = (int) D.33647;
            __result = D.33645 - D.33648;
            <D.33642>:
            <D.33640>:
            <D.33632>:
            <D.33630>:
            <D.33622>:
            <D.33620>:
          }
          D.26544 = __result;
        }
        iftmp.498 = -D.26544;
        goto <D.33649>;
        <D.33613>:
        D.33650 = method->name;
        iftmp.498 = __builtin_strcmp (D.33650, "memset");
        <D.33649>:
        D.26545 = iftmp.498;
      }
      if (D.26545 == 0) goto <D.33605>; else goto <D.33651>;
      <D.33651>:
      D.33650 = method->name;
      D.33652 = strstr (D.33650, "memcpy");
      if (D.33652 != 0B) goto <D.33605>; else goto <D.33606>;
      <D.33605>:
      return;
      <D.33606>:
      <D.33610>:
      domain.499 = domain;
      ip.500 = (long int) ip;
      D.33655 = ji->code_start;
      D.33656 = (long int) D.33655;
      D.33657 = ip.500 - D.33656;
      D.33658 = (int) D.33657;
      sp = find_next_seq_point_for_native_offset (domain.499, method, D.33658, &info);
      if (sp == 0B) goto <D.33659>; else goto <D.33660>;
      <D.33659>:
      return;
      <D.33660>:
      il_offset = sp->il_offset;
      ss_req.495 = ss_req;
      D.33661 = ss_update (ss_req.495, ji, sp, tls, ctx);
      if (D.33661 == 0) goto <D.33662>; else goto <D.33663>;
      <D.33662>:
      return;
      <D.33663>:
      ss_req.495 = ss_req;
      info.501 = info;
      ss_start (ss_req.495, method, sp, info.501, ctx, tls, 0);
      ss_req.495 = ss_req;
      D.33665 = ss_req.495->filter;
      D.33666 = D.33665 & 1;
      if (D.33666 != 0) goto <D.33667>; else goto <D.33668>;
      <D.33667>:
      D.33669 = method->flags;
      D.33670 = (int) D.33669;
      D.33671 = D.33670 & 2048;
      if (D.33671 != 0) goto <D.33672>; else goto <D.33673>;
      <D.33672>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          __s2 = method->name;
          D.33677 = ".cctor";
          D.33678 = MEM[(const unsigned char *)D.33677];
          D.33679 = (int) D.33678;
          D.33680 = *__s2;
          D.33681 = (int) D.33680;
          __result = D.33679 - D.33681;
          {
            if (__s2_len != 0) goto <D.33682>; else goto <D.33683>;
            <D.33682>:
            if (__result == 0) goto <D.33684>; else goto <D.33685>;
            <D.33684>:
            D.33686 = &MEM[(void *)".cctor" + 1B];
            D.33687 = *D.33686;
            D.33688 = (int) D.33687;
            D.33689 = __s2 + 1;
            D.33690 = *D.33689;
            D.33691 = (int) D.33690;
            __result = D.33688 - D.33691;
            if (__s2_len > 1) goto <D.33692>; else goto <D.33693>;
            <D.33692>:
            if (__result == 0) goto <D.33694>; else goto <D.33695>;
            <D.33694>:
            D.33696 = &MEM[(void *)".cctor" + 2B];
            D.33697 = *D.33696;
            D.33698 = (int) D.33697;
            D.33699 = __s2 + 2;
            D.33700 = *D.33699;
            D.33701 = (int) D.33700;
            __result = D.33698 - D.33701;
            if (__s2_len > 2) goto <D.33702>; else goto <D.33703>;
            <D.33702>:
            if (__result == 0) goto <D.33704>; else goto <D.33705>;
            <D.33704>:
            D.33706 = &MEM[(void *)".cctor" + 3B];
            D.33707 = *D.33706;
            D.33708 = (int) D.33707;
            D.33709 = __s2 + 3;
            D.33710 = *D.33709;
            D.33711 = (int) D.33710;
            __result = D.33708 - D.33711;
            <D.33705>:
            <D.33703>:
            <D.33695>:
            <D.33693>:
            <D.33685>:
            <D.33683>:
          }
          D.26553 = __result;
        }
        iftmp.502 = -D.26553;
        goto <D.33712>;
        <D.33676>:
        D.33650 = method->name;
        iftmp.502 = __builtin_strcmp (D.33650, ".cctor");
        <D.33712>:
        D.26554 = iftmp.502;
      }
      if (D.26554 == 0) goto <D.33713>; else goto <D.33714>;
      <D.33713>:
      return;
      <D.33714>:
      <D.33673>:
      <D.33668>:
      reqs = monoeg_g_ptr_array_new ();
      mono_loader_lock ();
      ss_req.495 = ss_req;
      D.33715 = ss_req.495->req;
      monoeg_g_ptr_array_add (reqs, D.33715);
      events = create_event_list (11, reqs, ji, 0B, &suspend_policy);
      monoeg_g_ptr_array_free (reqs, 1);
      mono_loader_unlock ();
      D.33716 = jinfo_get_method (ji);
      suspend_policy.503 = suspend_policy;
      process_event (11, D.33716, il_offset, ctx, events, suspend_policy.503);
    }
  finally
    {
      suspend_policy = {CLOBBER};
      domain = {CLOBBER};
      info = {CLOBBER};
    }
}


process_suspend (struct DebuggerTlsData * tls, struct MonoContext * ctx)
{
  long unsigned int D.33721;
  int D.33722;
  long unsigned int D.33725;
  long unsigned int debugger_thread_id.504;
  int suspend_count.505;
  unsigned int suspend_count.506;
  unsigned int D.33731;
  int log_level.507;
  _Bool D.33735;
  long int D.33736;
  long int D.33737;
  struct FILE * log_file.508;
  long unsigned int D.33741;
  void * D.33742;
  long unsigned int D.33747;
  void * D.33748;
  struct MonoDomain * D.33749;
  struct MonoClass * D.33752;
  struct MonoClass * D.33753;
  int D.25918;
  int iftmp.509;
  int D.25917;
  const char[7] * D.33759;
  unsigned char D.33760;
  int D.33761;
  unsigned char D.33762;
  int D.33763;
  const unsigned char * D.33768;
  unsigned char D.33769;
  int D.33770;
  const unsigned char * D.33771;
  unsigned char D.33772;
  int D.33773;
  const unsigned char * D.33778;
  unsigned char D.33779;
  int D.33780;
  const unsigned char * D.33781;
  unsigned char D.33782;
  int D.33783;
  const unsigned char * D.33788;
  unsigned char D.33789;
  int D.33790;
  const unsigned char * D.33791;
  unsigned char D.33792;
  int D.33793;
  const char * D.33795;
  char * D.33797;
  guint8 * ip;
  struct MonoJitInfo * ji;
  struct MonoMethod * method;

  D.33721 = ctx->sc_ir;
  ip = (guint8 *) D.33721;
  D.33722 = mono_loader_lock_is_owned_by_self ();
  if (D.33722 != 0) goto <D.33723>; else goto <D.33724>;
  <D.33723>:
  return;
  <D.33724>:
  D.33725 = GetCurrentThreadId ();
  debugger_thread_id.504 = debugger_thread_id;
  if (D.33725 == debugger_thread_id.504) goto <D.33727>; else goto <D.33728>;
  <D.33727>:
  return;
  <D.33728>:
  suspend_count.505 = suspend_count;
  suspend_count.506 = (unsigned int) suspend_count.505;
  D.33731 = tls->resume_count;
  if (suspend_count.506 != D.33731) goto <D.33732>; else goto <D.33733>;
  <D.33732>:
  tls->suspending = 1;
  <D.33733>:
  log_level.507 = log_level;
  D.33735 = log_level.507 > 0;
  D.33736 = (long int) D.33735;
  D.33737 = __builtin_expect (D.33736, 0);
  if (D.33737 != 0) goto <D.33738>; else goto <D.33739>;
  <D.33738>:
  log_file.508 = log_file;
  D.33741 = GetCurrentThreadId ();
  D.33742 = (void *) D.33741;
  fprintf (log_file.508, "[%p] Received single step event for suspending.\n", D.33742);
  log_file.508 = log_file;
  fflush (log_file.508);
  <D.33739>:
  suspend_count.505 = suspend_count;
  suspend_count.506 = (unsigned int) suspend_count.505;
  D.33731 = tls->resume_count;
  if (suspend_count.506 == D.33731) goto <D.33743>; else goto <D.33744>;
  <D.33743>:
  log_level.507 = log_level;
  D.33735 = log_level.507 > 0;
  D.33736 = (long int) D.33735;
  D.33737 = __builtin_expect (D.33736, 0);
  if (D.33737 != 0) goto <D.33745>; else goto <D.33746>;
  <D.33745>:
  log_file.508 = log_file;
  D.33747 = GetCurrentThreadId ();
  D.33748 = (void *) D.33747;
  fprintf (log_file.508, "[%p] Ignored during single threaded invoke.\n", D.33748);
  log_file.508 = log_file;
  fflush (log_file.508);
  <D.33746>:
  return;
  <D.33744>:
  D.33749 = mono_domain_get ();
  ji = mini_jit_info_table_find (D.33749, ip, 0B);
  method = jinfo_get_method (ji);
  D.33752 = method->klass;
  D.33753 = mono_defaults.string_class;
  if (D.33752 == D.33753) goto <D.33754>; else goto <D.33755>;
  <D.33754>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = method->name;
      D.33759 = "memset";
      D.33760 = MEM[(const unsigned char *)D.33759];
      D.33761 = (int) D.33760;
      D.33762 = *__s2;
      D.33763 = (int) D.33762;
      __result = D.33761 - D.33763;
      {
        if (__s2_len != 0) goto <D.33764>; else goto <D.33765>;
        <D.33764>:
        if (__result == 0) goto <D.33766>; else goto <D.33767>;
        <D.33766>:
        D.33768 = &MEM[(void *)"memset" + 1B];
        D.33769 = *D.33768;
        D.33770 = (int) D.33769;
        D.33771 = __s2 + 1;
        D.33772 = *D.33771;
        D.33773 = (int) D.33772;
        __result = D.33770 - D.33773;
        if (__s2_len > 1) goto <D.33774>; else goto <D.33775>;
        <D.33774>:
        if (__result == 0) goto <D.33776>; else goto <D.33777>;
        <D.33776>:
        D.33778 = &MEM[(void *)"memset" + 2B];
        D.33779 = *D.33778;
        D.33780 = (int) D.33779;
        D.33781 = __s2 + 2;
        D.33782 = *D.33781;
        D.33783 = (int) D.33782;
        __result = D.33780 - D.33783;
        if (__s2_len > 2) goto <D.33784>; else goto <D.33785>;
        <D.33784>:
        if (__result == 0) goto <D.33786>; else goto <D.33787>;
        <D.33786>:
        D.33788 = &MEM[(void *)"memset" + 3B];
        D.33789 = *D.33788;
        D.33790 = (int) D.33789;
        D.33791 = __s2 + 3;
        D.33792 = *D.33791;
        D.33793 = (int) D.33792;
        __result = D.33790 - D.33793;
        <D.33787>:
        <D.33785>:
        <D.33777>:
        <D.33775>:
        <D.33767>:
        <D.33765>:
      }
      D.25917 = __result;
    }
    iftmp.509 = -D.25917;
    goto <D.33794>;
    <D.33758>:
    D.33795 = method->name;
    iftmp.509 = __builtin_strcmp (D.33795, "memset");
    <D.33794>:
    D.25918 = iftmp.509;
  }
  if (D.25918 == 0) goto <D.33750>; else goto <D.33796>;
  <D.33796>:
  D.33795 = method->name;
  D.33797 = strstr (D.33795, "memcpy");
  if (D.33797 != 0B) goto <D.33750>; else goto <D.33751>;
  <D.33750>:
  return;
  <D.33751>:
  <D.33755>:
  save_thread_context (ctx);
  suspend_current ();
}


debugger_agent_single_step_from_context (struct MonoContext * ctx)
{
  unsigned int debugger_tls_id.510;
  _Bool D.33800;
  long int D.33801;
  long int D.33802;
  struct MonoContext * D.33805;
  struct DebuggerTlsData * tls;
  struct MonoContext orig_restore_ctx;

  try
    {
      debugger_tls_id.510 = debugger_tls_id;
      tls = pthread_getspecific (debugger_tls_id.510);
      D.33800 = tls == 0B;
      D.33801 = (long int) D.33800;
      D.33802 = __builtin_expect (D.33801, 0);
      if (D.33802 != 0) goto <D.33803>; else goto <D.33804>;
      <D.33803>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 4909, "tls");
      <D.33804>:
      D.33805 = &tls->restore_ctx;
      memcpy (&orig_restore_ctx, D.33805, 312);
      D.33805 = &tls->restore_ctx;
      memcpy (D.33805, ctx, 312);
      process_single_step_inner (tls);
      D.33805 = &tls->restore_ctx;
      memcpy (ctx, D.33805, 312);
      D.33805 = &tls->restore_ctx;
      memcpy (D.33805, &orig_restore_ctx, 312);
    }
  finally
    {
      orig_restore_ctx = {CLOBBER};
    }
}


debugger_agent_breakpoint_from_context (struct MonoContext * ctx)
{
  unsigned int debugger_tls_id.511;
  _Bool D.33807;
  long int D.33808;
  long int D.33809;
  struct MonoContext * D.33812;
  struct DebuggerTlsData * tls;
  struct MonoContext orig_restore_ctx;

  try
    {
      debugger_tls_id.511 = debugger_tls_id;
      tls = pthread_getspecific (debugger_tls_id.511);
      D.33807 = tls == 0B;
      D.33808 = (long int) D.33807;
      D.33809 = __builtin_expect (D.33808, 0);
      if (D.33809 != 0) goto <D.33810>; else goto <D.33811>;
      <D.33810>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 4928, "tls");
      <D.33811>:
      D.33812 = &tls->restore_ctx;
      memcpy (&orig_restore_ctx, D.33812, 312);
      D.33812 = &tls->restore_ctx;
      memcpy (D.33812, ctx, 312);
      process_breakpoint_inner (tls);
      D.33812 = &tls->restore_ctx;
      memcpy (ctx, D.33812, 312);
      D.33812 = &tls->restore_ctx;
      memcpy (D.33812, &orig_restore_ctx, 312);
    }
  finally
    {
      orig_restore_ctx = {CLOBBER};
    }
}


mono_debugger_agent_debug_log (int level, struct MonoString * category, struct MonoString * message)
{
  int D.33813;
  char * iftmp.512;
  char * iftmp.513;
  int suspend_policy.514;
  char * D.33825;
  char * D.33826;
  int suspend_policy;
  struct GSList * events;
  struct EventInfo ei;

  try
    {
      D.33813 = agent_config.enabled;
      if (D.33813 == 0) goto <D.33814>; else goto <D.33815>;
      <D.33814>:
      return;
      <D.33815>:
      mono_loader_lock ();
      events = create_event_list (16, 0B, 0B, 0B, &suspend_policy);
      mono_loader_unlock ();
      ei.level = level;
      if (category != 0B) goto <D.33817>; else goto <D.33818>;
      <D.33817>:
      iftmp.512 = mono_string_to_utf8 (category);
      goto <D.33819>;
      <D.33818>:
      iftmp.512 = 0B;
      <D.33819>:
      ei.category = iftmp.512;
      if (message != 0B) goto <D.33821>; else goto <D.33822>;
      <D.33821>:
      iftmp.513 = mono_string_to_utf8 (message);
      goto <D.33823>;
      <D.33822>:
      iftmp.513 = 0B;
      <D.33823>:
      ei.message = iftmp.513;
      suspend_policy.514 = suspend_policy;
      process_event (16, &ei, 0, 0B, events, suspend_policy.514);
      D.33825 = ei.category;
      monoeg_g_free (D.33825);
      D.33826 = ei.message;
      monoeg_g_free (D.33826);
    }
  finally
    {
      suspend_policy = {CLOBBER};
      ei = {CLOBBER};
    }
}


mono_debugger_agent_debug_log_is_enabled ()
{
  gboolean D.33830;

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


mono_debugger_agent_handle_exception (struct MonoException * exc, struct MonoContext * throw_ctx, struct MonoContext * catch_ctx)
{
  struct MonoGHashTable * thread_to_tls.515;
  int D.33837;
  int D.33842;
  int D.33847;
  int inited.516;
  struct GSList * D.33854;
  struct MonoVTable * D.33859;
  struct MonoClass * D.33860;
  struct MonoType * D.33861;
  int D.26682;
  int iftmp.517;
  int D.26681;
  const char[1] * D.33867;
  unsigned char D.33868;
  int D.33869;
  unsigned char D.33870;
  int D.33871;
  const unsigned char * D.33876;
  unsigned char D.33877;
  int D.33878;
  const unsigned char * D.33879;
  unsigned char D.33880;
  int D.33881;
  const unsigned char * D.33886;
  unsigned char D.33887;
  int D.33888;
  const unsigned char * D.33889;
  unsigned char D.33890;
  int D.33891;
  const unsigned char * D.33896;
  unsigned char D.33897;
  int D.33898;
  const unsigned char * D.33899;
  unsigned char D.33900;
  int D.33901;
  unsigned char D.33903;
  int D.26691;
  struct MonoDomain * D.33909;
  long unsigned int D.33910;
  char * D.33911;
  struct MonoDomain * D.33914;
  long unsigned int D.33915;
  char * D.33916;
  _Bool D.33918;
  int D.33919;
  struct GPtrArray * event_requests.518;
  void * * D.33921;
  long unsigned int D.33922;
  long unsigned int D.33923;
  void * * D.33924;
  int D.33925;
  <unnamed type> D.33928;
  long unsigned int D.33935;
  long unsigned int D.33936;
  struct MonoAssembly * * D.33937;
  struct MonoAssembly * D.33938;
  struct MonoMethod * D.33939;
  struct MonoClass * D.33940;
  struct MonoImage * D.33941;
  struct MonoAssembly * D.33942;
  int D.33947;
  unsigned int i.519;
  unsigned int D.33949;
  int D.33952;
  struct MonoThreadUnwindState * D.33957;
  struct MonoDomain * D.33958;
  int suspend_policy.520;
  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.515 = thread_to_tls;
      if (thread_to_tls.515 != 0B) goto <D.33833>; else goto <D.33834>;
      <D.33833>:
      {
        struct MonoInternalThread * thread;

        thread = mono_thread_internal_current ();
        mono_loader_lock ();
        thread_to_tls.515 = thread_to_tls;
        tls = mono_g_hash_table_lookup (thread_to_tls.515, thread);
        mono_loader_unlock ();
        if (tls != 0B) goto <D.33835>; else goto <D.33836>;
        <D.33835>:
        D.33837 = tls->abort_requested;
        if (D.33837 != 0) goto <D.33838>; else goto <D.33839>;
        <D.33838>:
        return;
        <D.33839>:
        <D.33836>:
        if (tls != 0B) goto <D.33840>; else goto <D.33841>;
        <D.33840>:
        D.33842 = tls->disable_breakpoints;
        if (D.33842 != 0) goto <D.33843>; else goto <D.33844>;
        <D.33843>:
        return;
        <D.33844>:
        <D.33841>:
      }
      <D.33834>:
      memset (&ei, 0, 352);
      if (catch_ctx == 0B) goto <D.33845>; else goto <D.33846>;
      <D.33845>:
      D.33847 = agent_config.onuncaught;
      if (D.33847 != 0) goto <D.33848>; else goto <D.33849>;
      <D.33848>:
      inited.516 = inited;
      if (inited.516 == 0) goto <D.33851>; else goto <D.33852>;
      <D.33851>:
      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.33852>:
      <D.33849>:
      goto <D.33853>;
      <D.33846>:
      D.33854 = agent_config.onthrow;
      if (D.33854 != 0B) goto <D.33855>; else goto <D.33856>;
      <D.33855>:
      inited.516 = inited;
      if (inited.516 == 0) goto <D.33857>; else goto <D.33858>;
      <D.33857>:
      {
        struct GSList * l;
        gboolean found;

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

          ex_type = l->data;
          D.33859 = exc->object.vtable;
          D.33860 = D.33859->klass;
          D.33861 = &D.33860->byval_arg;
          f = mono_type_full_name (D.33861);
          {
            size_t __s1_len;
            size_t __s2_len;

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

              __s2 = ex_type;
              D.33867 = "";
              D.33868 = MEM[(const unsigned char *)D.33867];
              D.33869 = (int) D.33868;
              D.33870 = *__s2;
              D.33871 = (int) D.33870;
              __result = D.33869 - D.33871;
              {
                if (__s2_len != 0) goto <D.33872>; else goto <D.33873>;
                <D.33872>:
                if (__result == 0) goto <D.33874>; else goto <D.33875>;
                <D.33874>:
                D.33876 = &MEM[(void *)"" + 1B];
                D.33877 = *D.33876;
                D.33878 = (int) D.33877;
                D.33879 = __s2 + 1;
                D.33880 = *D.33879;
                D.33881 = (int) D.33880;
                __result = D.33878 - D.33881;
                if (__s2_len > 1) goto <D.33882>; else goto <D.33883>;
                <D.33882>:
                if (__result == 0) goto <D.33884>; else goto <D.33885>;
                <D.33884>:
                D.33886 = &MEM[(void *)"" + 2B];
                D.33887 = *D.33886;
                D.33888 = (int) D.33887;
                D.33889 = __s2 + 2;
                D.33890 = *D.33889;
                D.33891 = (int) D.33890;
                __result = D.33888 - D.33891;
                if (__s2_len > 2) goto <D.33892>; else goto <D.33893>;
                <D.33892>:
                if (__result == 0) goto <D.33894>; else goto <D.33895>;
                <D.33894>:
                D.33896 = &MEM[(void *)"" + 3B];
                D.33897 = *D.33896;
                D.33898 = (int) D.33897;
                D.33899 = __s2 + 3;
                D.33900 = *D.33899;
                D.33901 = (int) D.33900;
                __result = D.33898 - D.33901;
                <D.33895>:
                <D.33893>:
                <D.33885>:
                <D.33883>:
                <D.33875>:
                <D.33873>:
              }
              D.26681 = __result;
            }
            iftmp.517 = -D.26681;
            goto <D.33902>;
            <D.33866>:
            D.33903 = MEM[(const unsigned char * {ref-all})ex_type];
            iftmp.517 = (int) D.33903;
            <D.33902>:
            D.26682 = iftmp.517;
          }
          if (D.26682 == 0) goto <D.33862>; else goto <D.33904>;
          <D.33904>:
          {
            size_t __s1_len;
            size_t __s2_len;

            D.26691 = __builtin_strcmp (ex_type, f);
          }
          if (D.26691 == 0) goto <D.33862>; else goto <D.33863>;
          <D.33862>:
          found = 1;
          <D.33863>:
          monoeg_g_free (f);
        }
        l = l->next;
        <D.26693>:
        if (l != 0B) goto <D.26692>; else goto <D.26694>;
        <D.26694>:
        if (found != 0) goto <D.33905>; else goto <D.33906>;
        <D.33905>:
        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.33906>:
      }
      <D.33858>:
      <D.33856>:
      <D.33853>:
      inited.516 = inited;
      if (inited.516 == 0) goto <D.33907>; else goto <D.33908>;
      <D.33907>:
      return;
      <D.33908>:
      D.33909 = mono_domain_get ();
      D.33910 = throw_ctx->sc_ir;
      D.33911 = (char *) D.33910;
      ji = mini_jit_info_table_find (D.33909, D.33911, 0B);
      if (catch_ctx != 0B) goto <D.33912>; else goto <D.33913>;
      <D.33912>:
      D.33914 = mono_domain_get ();
      D.33915 = catch_ctx->sc_ir;
      D.33916 = (char *) D.33915;
      catch_ji = mini_jit_info_table_find (D.33914, D.33916, 0B);
      goto <D.33917>;
      <D.33913>:
      catch_ji = 0B;
      <D.33917>:
      ei.exc = exc;
      D.33918 = catch_ctx != 0B;
      D.33919 = (int) D.33918;
      ei.caught = D.33919;
      mono_loader_lock ();
      i = 0;
      goto <D.26708>;
      <D.26707>:
      {
        struct EventRequest * req;

        event_requests.518 = event_requests;
        D.33921 = event_requests.518->pdata;
        D.33922 = (long unsigned int) i;
        D.33923 = D.33922 * 8;
        D.33924 = D.33921 + D.33923;
        req = *D.33924;
        D.33925 = req->event_kind;
        if (D.33925 != 13) goto <D.33926>; else goto <D.33927>;
        <D.33926>:
        // predicted unlikely by continue predictor.
        goto <D.26696>;
        <D.33927>:
        j = 0;
        goto <D.26705>;
        <D.26704>:
        {
          struct Modifier * mod;

          mod = &req->modifiers[j];
          D.33928 = mod->kind;
          if (D.33928 == 11) goto <D.33929>; else goto <D.33930>;
          <D.33929>:
          if (catch_ji != 0B) goto <D.33931>; else goto <D.33932>;
          <D.33931>:
          {
            int k;
            gboolean found;
            struct MonoAssembly * * assemblies;

            found = 0;
            assemblies = mod->data.assemblies;
            if (assemblies != 0B) goto <D.33933>; else goto <D.33934>;
            <D.33933>:
            k = 0;
            goto <D.26702>;
            <D.26701>:
            D.33935 = (long unsigned int) k;
            D.33936 = D.33935 * 8;
            D.33937 = assemblies + D.33936;
            D.33938 = *D.33937;
            D.33939 = jinfo_get_method (catch_ji);
            D.33940 = D.33939->klass;
            D.33941 = D.33940->image;
            D.33942 = D.33941->assembly;
            if (D.33938 == D.33942) goto <D.33943>; else goto <D.33944>;
            <D.33943>:
            found = 1;
            <D.33944>:
            k = k + 1;
            <D.26702>:
            D.33935 = (long unsigned int) k;
            D.33936 = D.33935 * 8;
            D.33937 = assemblies + D.33936;
            D.33938 = *D.33937;
            if (D.33938 != 0B) goto <D.26701>; else goto <D.26703>;
            <D.26703>:
            <D.33934>:
            if (found == 0) goto <D.33945>; else goto <D.33946>;
            <D.33945>:
            ei.caught = 0;
            <D.33946>:
          }
          <D.33932>:
          <D.33930>:
        }
        j = j + 1;
        <D.26705>:
        D.33947 = req->nmodifiers;
        if (D.33947 > j) goto <D.26704>; else goto <D.26706>;
        <D.26706>:
      }
      <D.26696>:
      i = i + 1;
      <D.26708>:
      i.519 = (unsigned int) i;
      event_requests.518 = event_requests;
      D.33949 = event_requests.518->len;
      if (i.519 < D.33949) goto <D.26707>; else goto <D.26709>;
      <D.26709>:
      events = create_event_list (13, 0B, ji, &ei, &suspend_policy);
      mono_loader_unlock ();
      if (tls != 0B) goto <D.33950>; else goto <D.33951>;
      <D.33950>:
      D.33952 = ei.caught;
      if (D.33952 != 0) goto <D.33953>; else goto <D.33954>;
      <D.33953>:
      if (catch_ctx != 0B) goto <D.33955>; else goto <D.33956>;
      <D.33955>:
      D.33957 = &tls->catch_state;
      memset (D.33957, 0, 344);
      tls->catch_state.ctx = *catch_ctx;
      D.33958 = mono_domain_get ();
      tls->catch_state.unwind_data[0] = D.33958;
      tls->catch_state.valid = 1;
      <D.33956>:
      <D.33954>:
      <D.33951>:
      suspend_policy.520 = suspend_policy;
      process_event (13, &ei, 0, throw_ctx, events, suspend_policy.520);
      if (tls != 0B) goto <D.33960>; else goto <D.33961>;
      <D.33960>:
      tls->catch_state.valid = 0;
      <D.33961>:
    }
  finally
    {
      suspend_policy = {CLOBBER};
      ei = {CLOBBER};
    }
}


mono_debugger_agent_begin_exception_filter (struct MonoException * exc, struct MonoContext * ctx, struct MonoContext * orig_ctx)
{
  int inited.521;
  unsigned int debugger_tls_id.522;
  struct MonoThreadUnwindState * D.33971;
  int D.33972;
  _Bool D.33973;
  long int D.33974;
  long int D.33975;
  struct DebuggerTlsData * tls;

  inited.521 = inited;
  if (inited.521 == 0) goto <D.33966>; else goto <D.33967>;
  <D.33966>:
  return;
  <D.33967>:
  debugger_tls_id.522 = debugger_tls_id;
  tls = pthread_getspecific (debugger_tls_id.522);
  if (tls == 0B) goto <D.33969>; else goto <D.33970>;
  <D.33969>:
  return;
  <D.33970>:
  D.33971 = &tls->filter_state;
  D.33972 = mono_thread_state_init_from_monoctx (D.33971, orig_ctx);
  D.33973 = D.33972 == 0;
  D.33974 = (long int) D.33973;
  D.33975 = __builtin_expect (D.33974, 0);
  if (D.33975 != 0) goto <D.33976>; else goto <D.33977>;
  <D.33976>:
  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.33977>:
}


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

  inited.523 = inited;
  if (inited.523 == 0) goto <D.33980>; else goto <D.33981>;
  <D.33980>:
  return;
  <D.33981>:
  debugger_tls_id.524 = debugger_tls_id;
  tls = pthread_getspecific (debugger_tls_id.524);
  if (tls == 0B) goto <D.33983>; else goto <D.33984>;
  <D.33983>:
  return;
  <D.33984>:
  tls->filter_state.valid = 0;
}