mono_debugger_agent_parse_options (char * options)
{
  int D.27888;
  const gchar * D.27891;
  gchar * D.27892;
  int D.27894;
  const gchar * D.27897;
  gchar * D.27898;
  int D.27900;
  const char * D.27903;
  int D.27904;
  int D.27906;
  gchar * D.27909;
  int D.27911;
  char * D.27914;
  int D.27915;
  int D.27917;
  char * D.27920;
  int D.27921;
  int D.27923;
  char * D.27926;
  int D.27927;
  int D.27929;
  gchar * D.27932;
  struct GSList * D.27933;
  struct GSList * D.27934;
  int D.27936;
  gchar * D.27939;
  struct GSList * D.27940;
  int D.27942;
  int D.27945;
  const char * D.27948;
  int D.27949;
  int D.27951;
  const gchar * D.27954;
  gchar * D.27955;
  int D.27957;
  const char * D.27960;
  int D.27961;
  _Bool D.27962;
  int D.27963;
  int D.27965;
  int D.27968;
  int D.27970;
  int D.27973;
  char * D.27976;
  int D.27977;
  int D.27980;
  char * D.27983;
  unsigned int D.27986;
  unsigned int D.27987;
  unsigned int D.27988;
  gchar * D.27989;
  char * D.27990;
  struct _IO_FILE * stderr.0;
  int D.25260;
  int iftmp.1;
  int D.25259;
  const char[10] * D.28001;
  unsigned char D.28002;
  int D.28003;
  unsigned char D.28004;
  int D.28005;
  _Bool D.28006;
  _Bool D.28007;
  _Bool D.28008;
  const unsigned char * D.28011;
  unsigned char D.28012;
  int D.28013;
  const unsigned char * D.28014;
  unsigned char D.28015;
  int D.28016;
  _Bool D.28017;
  _Bool D.28018;
  const unsigned char * D.28021;
  unsigned char D.28022;
  int D.28023;
  const unsigned char * D.28024;
  unsigned char D.28025;
  int D.28026;
  _Bool D.28027;
  _Bool D.28028;
  const unsigned char * D.28031;
  unsigned char D.28032;
  int D.28033;
  const unsigned char * D.28034;
  unsigned char D.28035;
  int D.28036;
  int D.28042;
  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.27886>; else goto <D.27887>;
      <D.27886>:
      options = monoeg_g_strdup_printf ("%s,%s", options, extra);
      <D.27887>:
      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.25250>;
      <D.25249>:
      {
        char * arg;

        arg = *ptr;
        D.27888 = strncmp (arg, "transport=", 10);
        if (D.27888 == 0) goto <D.27889>; else goto <D.27890>;
        <D.27889>:
        D.27891 = arg + 10;
        D.27892 = monoeg_strdup (D.27891);
        agent_config.transport = D.27892;
        goto <D.27893>;
        <D.27890>:
        D.27894 = strncmp (arg, "address=", 8);
        if (D.27894 == 0) goto <D.27895>; else goto <D.27896>;
        <D.27895>:
        D.27897 = arg + 8;
        D.27898 = monoeg_strdup (D.27897);
        agent_config.address = D.27898;
        goto <D.27899>;
        <D.27896>:
        D.27900 = strncmp (arg, "loglevel=", 9);
        if (D.27900 == 0) goto <D.27901>; else goto <D.27902>;
        <D.27901>:
        D.27903 = arg + 9;
        D.27904 = atoi (D.27903);
        agent_config.log_level = D.27904;
        goto <D.27905>;
        <D.27902>:
        D.27906 = strncmp (arg, "logfile=", 8);
        if (D.27906 == 0) goto <D.27907>; else goto <D.27908>;
        <D.27907>:
        D.27897 = arg + 8;
        D.27909 = monoeg_strdup (D.27897);
        agent_config.log_file = D.27909;
        goto <D.27910>;
        <D.27908>:
        D.27911 = strncmp (arg, "suspend=", 8);
        if (D.27911 == 0) goto <D.27912>; else goto <D.27913>;
        <D.27912>:
        D.27914 = arg + 8;
        D.27915 = parse_flag ("suspend", D.27914);
        agent_config.suspend = D.27915;
        goto <D.27916>;
        <D.27913>:
        D.27917 = strncmp (arg, "server=", 7);
        if (D.27917 == 0) goto <D.27918>; else goto <D.27919>;
        <D.27918>:
        D.27920 = arg + 7;
        D.27921 = parse_flag ("server", D.27920);
        agent_config.server = D.27921;
        goto <D.27922>;
        <D.27919>:
        D.27923 = strncmp (arg, "onuncaught=", 11);
        if (D.27923 == 0) goto <D.27924>; else goto <D.27925>;
        <D.27924>:
        D.27926 = arg + 11;
        D.27927 = parse_flag ("onuncaught", D.27926);
        agent_config.onuncaught = D.27927;
        goto <D.27928>;
        <D.27925>:
        D.27929 = strncmp (arg, "onthrow=", 8);
        if (D.27929 == 0) goto <D.27930>; else goto <D.27931>;
        <D.27930>:
        D.27897 = arg + 8;
        D.27932 = monoeg_strdup (D.27897);
        D.27933 = agent_config.onthrow;
        D.27934 = monoeg_g_slist_append (D.27933, D.27932);
        agent_config.onthrow = D.27934;
        goto <D.27935>;
        <D.27931>:
        D.27936 = strncmp (arg, "onthrow", 7);
        if (D.27936 == 0) goto <D.27937>; else goto <D.27938>;
        <D.27937>:
        D.27939 = monoeg_strdup ("");
        D.27933 = agent_config.onthrow;
        D.27940 = monoeg_g_slist_append (D.27933, D.27939);
        agent_config.onthrow = D.27940;
        goto <D.27941>;
        <D.27938>:
        D.27942 = strncmp (arg, "help", 4);
        if (D.27942 == 0) goto <D.27943>; else goto <D.27944>;
        <D.27943>:
        print_usage ();
        exit (0);
        <D.27944>:
        D.27945 = strncmp (arg, "timeout=", 8);
        if (D.27945 == 0) goto <D.27946>; else goto <D.27947>;
        <D.27946>:
        D.27948 = arg + 8;
        D.27949 = atoi (D.27948);
        agent_config.timeout = D.27949;
        goto <D.27950>;
        <D.27947>:
        D.27951 = strncmp (arg, "launch=", 7);
        if (D.27951 == 0) goto <D.27952>; else goto <D.27953>;
        <D.27952>:
        D.27954 = arg + 7;
        D.27955 = monoeg_strdup (D.27954);
        agent_config.launch = D.27955;
        goto <D.27956>;
        <D.27953>:
        D.27957 = strncmp (arg, "embedding=", 10);
        if (D.27957 == 0) goto <D.27958>; else goto <D.27959>;
        <D.27958>:
        D.27960 = arg + 10;
        D.27961 = atoi (D.27960);
        D.27962 = D.27961 == 1;
        D.27963 = (int) D.27962;
        agent_config.embedding = D.27963;
        goto <D.27964>;
        <D.27959>:
        D.27965 = strncmp (arg, "keepalive=", 10);
        if (D.27965 == 0) goto <D.27966>; else goto <D.27967>;
        <D.27966>:
        D.27960 = arg + 10;
        D.27968 = atoi (D.27960);
        agent_config.keepalive = D.27968;
        goto <D.27969>;
        <D.27967>:
        D.27970 = strncmp (arg, "setpgid=", 8);
        if (D.27970 == 0) goto <D.27971>; else goto <D.27972>;
        <D.27971>:
        D.27914 = arg + 8;
        D.27973 = parse_flag ("setpgid", D.27914);
        agent_config.setpgid = D.27973;
        goto <D.27974>;
        <D.27972>:
        print_usage ();
        exit (1);
        <D.27974>:
        <D.27969>:
        <D.27964>:
        <D.27956>:
        <D.27950>:
        <D.27941>:
        <D.27935>:
        <D.27928>:
        <D.27922>:
        <D.27916>:
        <D.27910>:
        <D.27905>:
        <D.27899>:
        <D.27893>:
      }
      ptr = ptr + 8;
      <D.25250>:
      if (ptr != 0B) goto <D.27975>; else goto <D.25251>;
      <D.27975>:
      D.27976 = *ptr;
      if (D.27976 != 0B) goto <D.25249>; else goto <D.25251>;
      <D.25251>:
      D.27977 = agent_config.server;
      if (D.27977 != 0) goto <D.27978>; else goto <D.27979>;
      <D.27978>:
      D.27980 = agent_config.suspend;
      if (D.27980 == 0) goto <D.27981>; else goto <D.27982>;
      <D.27981>:
      agent_config.defer = 1;
      D.27983 = agent_config.address;
      if (D.27983 == 0B) goto <D.27984>; else goto <D.27985>;
      <D.27984>:
      D.27986 = GetCurrentProcessId ();
      D.27987 = D.27986 % 1000;
      D.27988 = D.27987 + 56000;
      D.27989 = monoeg_g_strdup_printf ("0.0.0.0:%u", D.27988);
      agent_config.address = D.27989;
      <D.27985>:
      <D.27982>:
      <D.27979>:
      D.27990 = agent_config.transport;
      if (D.27990 == 0B) goto <D.27991>; else goto <D.27992>;
      <D.27991>:
      stderr.0 = stderr;
      fprintf (stderr.0, "debugger-agent: The \'transport\' option is mandatory.\n");
      exit (1);
      <D.27992>:
      D.27983 = agent_config.address;
      if (D.27983 == 0B) goto <D.27994>; else goto <D.27995>;
      <D.27994>:
      D.27977 = agent_config.server;
      if (D.27977 == 0) goto <D.27996>; else goto <D.27997>;
      <D.27996>:
      stderr.0 = stderr;
      fprintf (stderr.0, "debugger-agent: The \'address\' option is mandatory.\n");
      exit (1);
      <D.27997>:
      <D.27995>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          __s2 = agent_config.transport;
          D.28001 = "dt_socket";
          D.28002 = MEM[(const unsigned char *)D.28001];
          D.28003 = (int) D.28002;
          D.28004 = *__s2;
          D.28005 = (int) D.28004;
          __result = D.28003 - D.28005;
          {
            D.28006 = __s2_len != 0;
            D.28007 = __result == 0;
            D.28008 = D.28006 & D.28007;
            if (D.28008 != 0) goto <D.28009>; else goto <D.28010>;
            <D.28009>:
            D.28011 = &MEM[(void *)"dt_socket" + 1B];
            D.28012 = *D.28011;
            D.28013 = (int) D.28012;
            D.28014 = __s2 + 1;
            D.28015 = *D.28014;
            D.28016 = (int) D.28015;
            __result = D.28013 - D.28016;
            D.28017 = __s2_len > 1;
            D.28007 = __result == 0;
            D.28018 = D.28017 & D.28007;
            if (D.28018 != 0) goto <D.28019>; else goto <D.28020>;
            <D.28019>:
            D.28021 = &MEM[(void *)"dt_socket" + 2B];
            D.28022 = *D.28021;
            D.28023 = (int) D.28022;
            D.28024 = __s2 + 2;
            D.28025 = *D.28024;
            D.28026 = (int) D.28025;
            __result = D.28023 - D.28026;
            D.28027 = __s2_len > 2;
            D.28007 = __result == 0;
            D.28028 = D.28027 & D.28007;
            if (D.28028 != 0) goto <D.28029>; else goto <D.28030>;
            <D.28029>:
            D.28031 = &MEM[(void *)"dt_socket" + 3B];
            D.28032 = *D.28031;
            D.28033 = (int) D.28032;
            D.28034 = __s2 + 3;
            D.28035 = *D.28034;
            D.28036 = (int) D.28035;
            __result = D.28033 - D.28036;
            <D.28030>:
            <D.28020>:
            <D.28010>:
          }
          D.25259 = __result;
        }
        iftmp.1 = -D.25259;
        goto <D.28037>;
        <D.28000>:
        D.27990 = agent_config.transport;
        iftmp.1 = __builtin_strcmp (D.27990, "dt_socket");
        <D.28037>:
        D.25260 = iftmp.1;
      }
      if (D.25260 == 0) goto <D.28038>; else goto <D.28039>;
      <D.28038>:
      D.27983 = agent_config.address;
      if (D.27983 != 0B) goto <D.28040>; else goto <D.28041>;
      <D.28040>:
      D.27983 = agent_config.address;
      D.28042 = parse_address (D.27983, &host, &port);
      if (D.28042 != 0) goto <D.28043>; else goto <D.28044>;
      <D.28043>:
      stderr.0 = stderr;
      fprintf (stderr.0, "debugger-agent: The format of the \'address\' options is \'<host>:<port>\'\n");
      exit (1);
      <D.28044>:
      <D.28041>:
      <D.28039>:
    }
  finally
    {
      host = {CLOBBER};
      port = {CLOBBER};
    }
}


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

  if (str != 0B) goto <D.28045>; else goto <D.28046>;
  <D.28045>:
  D.28047 = __strdup (str);
  return D.28047;
  <D.28046>:
  D.28047 = 0B;
  return D.28047;
}


atoi (const char * __nptr)
{
  int D.28049;
  long int D.28050;

  D.28050 = strtol (__nptr, 0B, 10);
  D.28049 = (int) D.28050;
  return D.28049;
}


parse_flag (const char * option, char * flag)
{
  int D.25095;
  int iftmp.2;
  int D.25094;
  const char[2] * D.28055;
  unsigned char D.28056;
  int D.28057;
  unsigned char D.28058;
  int D.28059;
  _Bool D.28060;
  _Bool D.28061;
  _Bool D.28062;
  const unsigned char * D.28065;
  unsigned char D.28066;
  int D.28067;
  const unsigned char * D.28068;
  unsigned char D.28069;
  int D.28070;
  _Bool D.28071;
  _Bool D.28072;
  const unsigned char * D.28075;
  unsigned char D.28076;
  int D.28077;
  const unsigned char * D.28078;
  unsigned char D.28079;
  int D.28080;
  _Bool D.28081;
  _Bool D.28082;
  const unsigned char * D.28085;
  unsigned char D.28086;
  int D.28087;
  const unsigned char * D.28088;
  unsigned char D.28089;
  int D.28090;
  gboolean D.28094;
  int D.25104;
  int iftmp.3;
  int D.25103;
  const char[2] * D.28098;
  unsigned char D.28099;
  int D.28100;
  unsigned char D.28101;
  int D.28102;
  _Bool D.28103;
  _Bool D.28104;
  _Bool D.28105;
  const unsigned char * D.28108;
  unsigned char D.28109;
  int D.28110;
  const unsigned char * D.28111;
  unsigned char D.28112;
  int D.28113;
  _Bool D.28114;
  _Bool D.28115;
  const unsigned char * D.28118;
  unsigned char D.28119;
  int D.28120;
  const unsigned char * D.28121;
  unsigned char D.28122;
  int D.28123;
  _Bool D.28124;
  _Bool D.28125;
  const unsigned char * D.28128;
  unsigned char D.28129;
  int D.28130;
  const unsigned char * D.28131;
  unsigned char D.28132;
  int D.28133;
  struct _IO_FILE * stderr.4;

  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = flag;
      D.28055 = "y";
      D.28056 = MEM[(const unsigned char *)D.28055];
      D.28057 = (int) D.28056;
      D.28058 = *__s2;
      D.28059 = (int) D.28058;
      __result = D.28057 - D.28059;
      {
        D.28060 = __s2_len != 0;
        D.28061 = __result == 0;
        D.28062 = D.28060 & D.28061;
        if (D.28062 != 0) goto <D.28063>; else goto <D.28064>;
        <D.28063>:
        D.28065 = &MEM[(void *)"y" + 1B];
        D.28066 = *D.28065;
        D.28067 = (int) D.28066;
        D.28068 = __s2 + 1;
        D.28069 = *D.28068;
        D.28070 = (int) D.28069;
        __result = D.28067 - D.28070;
        D.28071 = __s2_len > 1;
        D.28061 = __result == 0;
        D.28072 = D.28071 & D.28061;
        if (D.28072 != 0) goto <D.28073>; else goto <D.28074>;
        <D.28073>:
        D.28075 = &MEM[(void *)"y" + 2B];
        D.28076 = *D.28075;
        D.28077 = (int) D.28076;
        D.28078 = __s2 + 2;
        D.28079 = *D.28078;
        D.28080 = (int) D.28079;
        __result = D.28077 - D.28080;
        D.28081 = __s2_len > 2;
        D.28061 = __result == 0;
        D.28082 = D.28081 & D.28061;
        if (D.28082 != 0) goto <D.28083>; else goto <D.28084>;
        <D.28083>:
        D.28085 = &MEM[(void *)"y" + 3B];
        D.28086 = *D.28085;
        D.28087 = (int) D.28086;
        D.28088 = __s2 + 3;
        D.28089 = *D.28088;
        D.28090 = (int) D.28089;
        __result = D.28087 - D.28090;
        <D.28084>:
        <D.28074>:
        <D.28064>:
      }
      D.25094 = __result;
    }
    iftmp.2 = -D.25094;
    goto <D.28091>;
    <D.28054>:
    iftmp.2 = __builtin_strcmp (flag, "y");
    <D.28091>:
    D.25095 = iftmp.2;
  }
  if (D.25095 == 0) goto <D.28092>; else goto <D.28093>;
  <D.28092>:
  D.28094 = 1;
  return D.28094;
  <D.28093>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = flag;
      D.28098 = "n";
      D.28099 = MEM[(const unsigned char *)D.28098];
      D.28100 = (int) D.28099;
      D.28101 = *__s2;
      D.28102 = (int) D.28101;
      __result = D.28100 - D.28102;
      {
        D.28103 = __s2_len != 0;
        D.28104 = __result == 0;
        D.28105 = D.28103 & D.28104;
        if (D.28105 != 0) goto <D.28106>; else goto <D.28107>;
        <D.28106>:
        D.28108 = &MEM[(void *)"n" + 1B];
        D.28109 = *D.28108;
        D.28110 = (int) D.28109;
        D.28111 = __s2 + 1;
        D.28112 = *D.28111;
        D.28113 = (int) D.28112;
        __result = D.28110 - D.28113;
        D.28114 = __s2_len > 1;
        D.28104 = __result == 0;
        D.28115 = D.28114 & D.28104;
        if (D.28115 != 0) goto <D.28116>; else goto <D.28117>;
        <D.28116>:
        D.28118 = &MEM[(void *)"n" + 2B];
        D.28119 = *D.28118;
        D.28120 = (int) D.28119;
        D.28121 = __s2 + 2;
        D.28122 = *D.28121;
        D.28123 = (int) D.28122;
        __result = D.28120 - D.28123;
        D.28124 = __s2_len > 2;
        D.28104 = __result == 0;
        D.28125 = D.28124 & D.28104;
        if (D.28125 != 0) goto <D.28126>; else goto <D.28127>;
        <D.28126>:
        D.28128 = &MEM[(void *)"n" + 3B];
        D.28129 = *D.28128;
        D.28130 = (int) D.28129;
        D.28131 = __s2 + 3;
        D.28132 = *D.28131;
        D.28133 = (int) D.28132;
        __result = D.28130 - D.28133;
        <D.28127>:
        <D.28117>:
        <D.28107>:
      }
      D.25103 = __result;
    }
    iftmp.3 = -D.25103;
    goto <D.28134>;
    <D.28097>:
    iftmp.3 = __builtin_strcmp (flag, "n");
    <D.28134>:
    D.25104 = iftmp.3;
  }
  if (D.25104 == 0) goto <D.28135>; else goto <D.28136>;
  <D.28135>:
  D.28094 = 0;
  return D.28094;
  <D.28136>:
  stderr.4 = stderr;
  fprintf (stderr.4, "debugger-agent: The valid values for the \'%s\' option are \'y\' and \'n\'.\n", option);
  exit (1);
  D.28094 = 0;
  return D.28094;
}


print_usage ()
{
  struct _IO_FILE * stderr.5;

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


parse_address (char * address, char * * host, int * port)
{
  _Bool D.28140;
  _Bool D.28141;
  _Bool D.28142;
  int D.28145;
  long int pos.6;
  long int address.7;
  long int D.28148;
  long int D.28149;
  long unsigned int D.28150;
  void * D.28151;
  long unsigned int D.28152;
  char * D.28153;
  sizetype D.28154;
  char * D.28155;
  const char * D.28156;
  int D.28157;
  char * pos;

  pos = __builtin_strchr (address, 58);
  D.28140 = pos == 0B;
  D.28141 = pos == address;
  D.28142 = D.28140 | D.28141;
  if (D.28142 != 0) goto <D.28143>; else goto <D.28144>;
  <D.28143>:
  D.28145 = 1;
  return D.28145;
  <D.28144>:
  pos.6 = (long int) pos;
  address.7 = (long int) address;
  D.28148 = pos.6 - address.7;
  D.28149 = D.28148 + 1;
  D.28150 = (long unsigned int) D.28149;
  D.28151 = monoeg_malloc (D.28150);
  *host = D.28151;
  pos.6 = (long int) pos;
  address.7 = (long int) address;
  D.28148 = pos.6 - address.7;
  D.28152 = (long unsigned int) D.28148;
  D.28153 = *host;
  strncpy (D.28153, address, D.28152);
  D.28153 = *host;
  pos.6 = (long int) pos;
  address.7 = (long int) address;
  D.28148 = pos.6 - address.7;
  D.28154 = (sizetype) D.28148;
  D.28155 = D.28153 + D.28154;
  *D.28155 = 0;
  D.28156 = pos + 1;
  D.28157 = atoi (D.28156);
  *port = D.28157;
  D.28145 = 0;
  return D.28145;
}


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

  D.28160 = __builtin_object_size (__dest, 1);
  D.28159 = __builtin___strncpy_chk (__dest, __src, __len, D.28160);
  return D.28159;
}


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

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


mono_debugger_agent_init ()
{
  int D.28164;
  struct GPtrArray * event_requests.8;
  struct MonoGHashTable * thread_to_tls.9;
  int D.28169;
  struct MonoGHashTable * tid_to_thread.10;
  int D.28173;
  struct MonoGHashTable * tid_to_thread_obj.11;
  int D.28177;
  struct GPtrArray * pending_assembly_loads.12;
  struct GHashTable * domains.13;
  int log_level.14;
  int embedding.15;
  char * D.28184;
  struct FILE * log_file.16;
  struct FILE * log_file.17;
  int * D.28191;
  int D.28192;
  char * D.28193;
  struct _IO_FILE * stderr.18;
  struct _IO_FILE * stdout.19;
  struct MonoDebugOptions * D.28197;
  struct MonoDebugOptions * D.28198;
  struct MonoDebugOptions * D.28199;
  int D.28200;
  int D.28203;
  struct GSList * D.28206;

  D.28164 = agent_config.enabled;
  if (D.28164 == 0) goto <D.28165>; else goto <D.28166>;
  <D.28165>:
  return;
  <D.28166>:
  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.28169 = mono_gc_is_moving ();
  if (D.28169 == 0) goto <D.28170>; else goto <D.28171>;
  <D.28170>:
  mono_gc_register_root (&thread_to_tls, 8, 0B);
  <D.28171>:
  tid_to_thread.10 = mono_g_hash_table_new_type (0B, 0B, 2);
  tid_to_thread = tid_to_thread.10;
  D.28173 = mono_gc_is_moving ();
  if (D.28173 == 0) goto <D.28174>; else goto <D.28175>;
  <D.28174>:
  mono_gc_register_root (&tid_to_thread, 8, 0B);
  <D.28175>:
  tid_to_thread_obj.11 = mono_g_hash_table_new_type (0B, 0B, 2);
  tid_to_thread_obj = tid_to_thread_obj.11;
  D.28177 = mono_gc_is_moving ();
  if (D.28177 == 0) goto <D.28178>; else goto <D.28179>;
  <D.28178>:
  mono_gc_register_root (&tid_to_thread_obj, 8, 0B);
  <D.28179>:
  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.28184 = agent_config.log_file;
  if (D.28184 != 0B) goto <D.28185>; else goto <D.28186>;
  <D.28185>:
  D.28184 = agent_config.log_file;
  log_file.16 = fopen (D.28184, "w+");
  log_file = log_file.16;
  log_file.17 = log_file;
  if (log_file.17 == 0B) goto <D.28189>; else goto <D.28190>;
  <D.28189>:
  D.28191 = __errno_location ();
  D.28192 = *D.28191;
  D.28193 = strerror (D.28192);
  D.28184 = agent_config.log_file;
  stderr.18 = stderr;
  fprintf (stderr.18, "Unable to create log file \'%s\': %s.\n", D.28184, D.28193);
  exit (1);
  <D.28190>:
  goto <D.28195>;
  <D.28186>:
  stdout.19 = stdout;
  log_file = stdout.19;
  <D.28195>:
  ids_init ();
  objrefs_init ();
  breakpoints_init ();
  suspend_init ();
  D.28197 = mini_get_debug_options ();
  D.28197->gen_seq_points = 1;
  D.28198 = mini_get_debug_options ();
  D.28198->mdb_optimizations = 1;
  D.28199 = mini_get_debug_options ();
  D.28199->load_aot_jit_info_eagerly = 1;
  D.28200 = agent_config.setpgid;
  if (D.28200 != 0) goto <D.28201>; else goto <D.28202>;
  <D.28201>:
  setpgid (0, 0);
  <D.28202>:
  D.28203 = agent_config.onuncaught;
  if (D.28203 == 0) goto <D.28204>; else goto <D.28205>;
  <D.28204>:
  D.28206 = agent_config.onthrow;
  if (D.28206 == 0B) goto <D.28207>; else goto <D.28208>;
  <D.28207>:
  finish_agent_init (1);
  <D.28208>:
  <D.28205>:
}


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.28218;
  struct MonoInternalThread * D.28219;
  struct GPtrArray * event_requests.23;
  void * * D.28221;
  long unsigned int D.28222;
  long unsigned int D.28223;
  void * * D.28224;
  int D.28225;
  void * D.28228;
  unsigned int i.24;
  unsigned int D.28230;
  int i;
  void * stackptr;

  stackptr = __builtin_frame_address (1);
  embedding.20 = embedding;
  if (embedding.20 == 0) goto <D.28210>; else goto <D.28213>;
  <D.28213>:
  ss_req.21 = ss_req;
  if (ss_req.21 == 0B) goto <D.28210>; else goto <D.28215>;
  <D.28215>:
  ss_invoke_addr.22 = ss_invoke_addr;
  if (stackptr != ss_invoke_addr.22) goto <D.28210>; else goto <D.28217>;
  <D.28217>:
  ss_req.21 = ss_req;
  D.28218 = ss_req.21->thread;
  D.28219 = mono_thread_internal_current ();
  if (D.28218 != D.28219) goto <D.28210>; else goto <D.28211>;
  <D.28210>:
  return;
  <D.28211>:
  mono_loader_lock ();
  ss_invoke_addr = 0B;
  i = 0;
  goto <D.26189>;
  <D.26188>:
  {
    struct EventRequest * req;

    event_requests.23 = event_requests;
    D.28221 = event_requests.23->pdata;
    D.28222 = (long unsigned int) i;
    D.28223 = D.28222 * 8;
    D.28224 = D.28221 + D.28223;
    req = *D.28224;
    D.28225 = req->event_kind;
    if (D.28225 == 11) goto <D.28226>; else goto <D.28227>;
    <D.28226>:
    D.28228 = req->info;
    ss_destroy (D.28228);
    i.24 = (unsigned int) i;
    event_requests.23 = event_requests;
    monoeg_g_ptr_array_remove_index_fast (event_requests.23, i.24);
    monoeg_g_free (req);
    goto <D.26187>;
    <D.28227>:
  }
  i = i + 1;
  <D.26189>:
  i.24 = (unsigned int) i;
  event_requests.23 = event_requests;
  D.28230 = event_requests.23->len;
  if (i.24 < D.28230) goto <D.26188>; else goto <D.26187>;
  <D.26187>:
  mono_loader_unlock ();
}


ss_destroy (struct SingleStepReq * req)
{
  struct SingleStepReq * ss_req.25;
  _Bool D.28233;
  long int D.28234;
  long int D.28235;

  ss_req.25 = ss_req;
  D.28233 = ss_req.25 != req;
  D.28234 = (long int) D.28233;
  D.28235 = __builtin_expect (D.28234, 0);
  if (D.28235 != 0) goto <D.28236>; else goto <D.28237>;
  <D.28236>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 5255, "ss_req == req");
  <D.28237>:
  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.28238;
  void * D.28241;
  int D.28242;

  D.28238 = ss_req->bps;
  if (D.28238 != 0B) goto <D.28239>; else goto <D.28240>;
  <D.28239>:
  {
    struct GSList * l;

    l = ss_req->bps;
    goto <D.26506>;
    <D.26505>:
    D.28241 = l->data;
    clear_breakpoint (D.28241);
    l = l->next;
    <D.26506>:
    if (l != 0B) goto <D.26505>; else goto <D.26507>;
    <D.26507>:
    D.28238 = ss_req->bps;
    monoeg_g_slist_free (D.28238);
    ss_req->bps = 0B;
  }
  <D.28240>:
  D.28242 = ss_req->global;
  if (D.28242 != 0) goto <D.28243>; else goto <D.28244>;
  <D.28243>:
  stop_single_stepping ();
  ss_req->global = 0;
  <D.28244>:
}


clear_breakpoint (struct MonoBreakpoint * bp)
{
  struct GPtrArray * D.28245;
  void * * D.28246;
  long unsigned int D.28247;
  long unsigned int D.28248;
  void * * D.28249;
  unsigned int i.26;
  unsigned int D.28251;
  struct GPtrArray * breakpoints.27;
  int i;

  i = 0;
  goto <D.26329>;
  <D.26328>:
  {
    struct BreakpointInstance * inst;

    D.28245 = bp->children;
    D.28246 = D.28245->pdata;
    D.28247 = (long unsigned int) i;
    D.28248 = D.28247 * 8;
    D.28249 = D.28246 + D.28248;
    inst = *D.28249;
    remove_breakpoint (inst);
    monoeg_g_free (inst);
  }
  i = i + 1;
  <D.26329>:
  i.26 = (unsigned int) i;
  D.28245 = bp->children;
  D.28251 = D.28245->len;
  if (i.26 < D.28251) goto <D.26328>; else goto <D.26330>;
  <D.26330>:
  mono_loader_lock ();
  breakpoints.27 = breakpoints;
  monoeg_g_ptr_array_remove (breakpoints.27, bp);
  mono_loader_unlock ();
  D.28245 = bp->children;
  monoeg_g_ptr_array_free (D.28245, 1);
  monoeg_g_free (bp);
}


remove_breakpoint (struct BreakpointInstance * inst)
{
  struct GHashTable * bp_locs.28;
  void * D.28254;
  long int D.28255;
  int D.28256;
  long int D.28257;
  void * D.28258;
  _Bool D.28259;
  long int D.28260;
  long int D.28261;
  long int D.28266;
  int count;
  struct MonoJitInfo * ji;
  guint8 * ip;

  ji = inst->ji;
  ip = inst->ip;
  mono_loader_lock ();
  bp_locs.28 = bp_locs;
  D.28254 = monoeg_g_hash_table_lookup (bp_locs.28, ip);
  D.28255 = (long int) D.28254;
  count = (int) D.28255;
  D.28256 = count + -1;
  D.28257 = (long int) D.28256;
  D.28258 = (void *) D.28257;
  bp_locs.28 = bp_locs;
  monoeg_g_hash_table_insert_replace (bp_locs.28, ip, D.28258, 0);
  mono_loader_unlock ();
  D.28259 = count <= 0;
  D.28260 = (long int) D.28259;
  D.28261 = __builtin_expect (D.28260, 0);
  if (D.28261 != 0) goto <D.28262>; else goto <D.28263>;
  <D.28262>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 4193, "count > 0");
  <D.28263>:
  if (count == 1) goto <D.28264>; else goto <D.28265>;
  <D.28264>:
  D.28266 = inst->native_offset;
  if (D.28266 != -1) goto <D.28267>; else goto <D.28268>;
  <D.28267>:
  mono_arch_clear_breakpoint (ji, ip);
  <D.28268>:
  <D.28265>:
}


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

  val = InterlockedDecrement (&ss_count);
  if (val == 0) goto <D.28269>; else goto <D.28270>;
  <D.28269>:
  mono_arch_stop_single_stepping ();
  <D.28270>:
  ss_req.29 = ss_req;
  if (ss_req.29 != 0B) goto <D.28272>; else goto <D.28273>;
  <D.28272>:
  ss_invoke_addr = 0B;
  <D.28273>:
}


InterlockedDecrement (volatile gint32 * val)
{
  gint32 D.28274;
  unsigned int D.28275;

  D.28275 = __sync_sub_and_fetch_4 (val, 1);
  D.28274 = (gint32) D.28275;
  return D.28274;
}


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.28278>; else goto <D.28279>;
  <D.28278>:
  tls->invoke_addr = stackptr;
  <D.28279>:
  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.28281;
  void * * D.28284;
  struct MonoClass * D.28286;

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

    assembly = 0B;
    mono_loader_lock ();
    pending_assembly_loads.31 = pending_assembly_loads;
    D.28281 = pending_assembly_loads.31->len;
    if (D.28281 != 0) goto <D.28282>; else goto <D.28283>;
    <D.28282>:
    pending_assembly_loads.31 = pending_assembly_loads;
    D.28284 = pending_assembly_loads.31->pdata;
    assembly = *D.28284;
    pending_assembly_loads.31 = pending_assembly_loads;
    monoeg_g_ptr_array_remove_index (pending_assembly_loads.31, 0);
    <D.28283>:
    mono_loader_unlock ();
    if (assembly != 0B) goto <D.28285>; else goto <D.26212>;
    <D.28285>:
    process_profiler_event (8, assembly);
  }
  goto <D.26213>;
  <D.26212>:
  D.28286 = method->klass;
  send_type_load (D.28286);
  if (result == 0) goto <D.28287>; else goto <D.28288>;
  <D.28287>:
  add_pending_breakpoints (method, jinfo);
  <D.28288>:
}


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.28289>; else goto <D.28290>;
      <D.28289>:
      ei.klass = arg;
      ei_arg = &ei;
      <D.28290>:
      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.28296;
  void * * D.28297;
  long unsigned int D.28298;
  long unsigned int D.28299;
  void * * D.28300;
  int D.28301;
  unsigned int D.28302;
  <unnamed type> D.28305;
  int D.28308;
  int D.28313;
  struct MonoInternalThread * D.28319;
  struct MonoInternalThread * D.28320;
  struct MonoClass * D.28328;
  int D.28331;
  struct MonoObject * D.28334;
  struct MonoVTable * D.28335;
  struct MonoClass * D.28336;
  int D.28337;
  int D.28346;
  int D.28349;
  int D.28354;
  long unsigned int D.28363;
  long unsigned int D.28364;
  struct MonoAssembly * * D.28365;
  struct MonoAssembly * D.28366;
  struct MonoMethod * D.28367;
  struct MonoClass * D.28368;
  struct MonoImage * D.28369;
  struct MonoAssembly * D.28370;
  struct MonoClass * D.28379;
  struct GPtrArray * source_file_list.33;
  void * * D.28384;
  long unsigned int D.28385;
  long unsigned int D.28386;
  void * * D.28387;
  char * D.28388;
  struct GHashTable * D.28389;
  void * D.28390;
  void * D.28394;
  unsigned int i.34;
  unsigned int D.28398;
  struct MonoType * D.28406;
  struct GHashTable * D.28407;
  void * D.28408;
  <unnamed type> D.28413;
  unsigned int D.28414;
  struct MonoMethod * D.28419;
  short unsigned int D.28420;
  int D.28421;
  int D.28422;
  int D.26046;
  int iftmp.35;
  int D.26045;
  struct MonoMethod * D.28428;
  const char[7] * D.28429;
  unsigned char D.28430;
  int D.28431;
  unsigned char D.28432;
  int D.28433;
  _Bool D.28434;
  _Bool D.28435;
  _Bool D.28436;
  const unsigned char * D.28439;
  unsigned char D.28440;
  int D.28441;
  const unsigned char * D.28442;
  unsigned char D.28443;
  int D.28444;
  _Bool D.28445;
  _Bool D.28446;
  const unsigned char * D.28449;
  unsigned char D.28450;
  int D.28451;
  const unsigned char * D.28452;
  unsigned char D.28453;
  int D.28454;
  _Bool D.28455;
  _Bool D.28456;
  const unsigned char * D.28459;
  unsigned char D.28460;
  int D.28461;
  const unsigned char * D.28462;
  unsigned char D.28463;
  int D.28464;
  struct MonoMethod * D.28466;
  const char * D.28467;
  unsigned int D.28470;
  struct MonoClass * klass.36;
  struct MonoImage * D.28478;
  struct MonoClass * klass.37;
  _Bool D.28480;
  long int D.28481;
  long int D.28482;
  unsigned char D.28485;
  unsigned char D.28486;
  struct MonoMethod * D.28489;
  int D.28492;
  unsigned char D.28495;
  unsigned int D.28498;
  struct MonoClass * klass.38;
  struct MonoClass * klass.39;
  _Bool D.28507;
  long int D.28508;
  long int D.28509;
  unsigned char D.28512;
  unsigned char D.28513;
  struct MonoMethod * D.28516;
  int D.28519;
  struct MonoMethod * D.28522;
  struct MonoClass * D.28523;
  int D.28526;
  unsigned char D.28529;
  int D.28532;
  int D.28535;
  int D.28536;
  int D.28537;
  int D.28538;
  long int D.28539;
  void * D.28540;
  unsigned int i.40;
  unsigned int D.28542;
  int i;
  int j;
  struct GSList * events;

  events = 0B;
  *suspend_policy = 0;
  if (reqs == 0B) goto <D.28292>; else goto <D.28293>;
  <D.28292>:
  reqs = event_requests;
  <D.28293>:
  if (reqs == 0B) goto <D.28294>; else goto <D.28295>;
  <D.28294>:
  D.28296 = 0B;
  return D.28296;
  <D.28295>:
  i = 0;
  goto <D.26055>;
  <D.26054>:
  {
    struct EventRequest * req;

    D.28297 = reqs->pdata;
    D.28298 = (long unsigned int) i;
    D.28299 = D.28298 * 8;
    D.28300 = D.28297 + D.28299;
    req = *D.28300;
    D.28301 = req->event_kind;
    D.28302 = (unsigned int) D.28301;
    if (D.28302 == event) goto <D.28303>; else goto <D.28304>;
    <D.28303>:
    {
      gboolean filtered;

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

        mod = &req->modifiers[j];
        D.28305 = mod->kind;
        if (D.28305 == 1) goto <D.28306>; else goto <D.28307>;
        <D.28306>:
        filtered = 1;
        D.28308 = mod->data.count;
        if (D.28308 > 0) goto <D.28309>; else goto <D.28310>;
        <D.28309>:
        D.28308 = mod->data.count;
        if (D.28308 > 0) goto <D.28311>; else goto <D.28312>;
        <D.28311>:
        D.28308 = mod->data.count;
        D.28313 = D.28308 + -1;
        mod->data.count = D.28313;
        D.28308 = mod->data.count;
        if (D.28308 == 0) goto <D.28314>; else goto <D.28315>;
        <D.28314>:
        filtered = 0;
        <D.28315>:
        <D.28312>:
        <D.28310>:
        goto <D.28316>;
        <D.28307>:
        D.28305 = mod->kind;
        if (D.28305 == 3) goto <D.28317>; else goto <D.28318>;
        <D.28317>:
        D.28319 = mod->data.thread;
        D.28320 = mono_thread_internal_current ();
        if (D.28319 != D.28320) goto <D.28321>; else goto <D.28322>;
        <D.28321>:
        filtered = 1;
        <D.28322>:
        goto <D.28323>;
        <D.28318>:
        D.28305 = mod->kind;
        if (D.28305 == 8) goto <D.28326>; else goto <D.28324>;
        <D.28326>:
        if (ei != 0B) goto <D.28327>; else goto <D.28324>;
        <D.28327>:
        D.28328 = mod->data.exc_class;
        if (D.28328 != 0B) goto <D.28329>; else goto <D.28330>;
        <D.28329>:
        D.28331 = mod->subclasses;
        if (D.28331 != 0) goto <D.28332>; else goto <D.28333>;
        <D.28332>:
        D.28334 = ei->exc;
        D.28335 = D.28334->vtable;
        D.28336 = D.28335->klass;
        D.28328 = mod->data.exc_class;
        D.28337 = mono_class_is_assignable_from (D.28328, D.28336);
        if (D.28337 == 0) goto <D.28338>; else goto <D.28339>;
        <D.28338>:
        filtered = 1;
        <D.28339>:
        <D.28333>:
        <D.28330>:
        D.28328 = mod->data.exc_class;
        if (D.28328 != 0B) goto <D.28340>; else goto <D.28341>;
        <D.28340>:
        D.28331 = mod->subclasses;
        if (D.28331 == 0) goto <D.28342>; else goto <D.28343>;
        <D.28342>:
        D.28328 = mod->data.exc_class;
        D.28334 = ei->exc;
        D.28335 = D.28334->vtable;
        D.28336 = D.28335->klass;
        if (D.28328 != D.28336) goto <D.28344>; else goto <D.28345>;
        <D.28344>:
        filtered = 1;
        <D.28345>:
        <D.28343>:
        <D.28341>:
        D.28346 = ei->caught;
        if (D.28346 != 0) goto <D.28347>; else goto <D.28348>;
        <D.28347>:
        D.28349 = mod->caught;
        if (D.28349 == 0) goto <D.28350>; else goto <D.28351>;
        <D.28350>:
        filtered = 1;
        <D.28351>:
        <D.28348>:
        D.28346 = ei->caught;
        if (D.28346 == 0) goto <D.28352>; else goto <D.28353>;
        <D.28352>:
        D.28354 = mod->uncaught;
        if (D.28354 == 0) goto <D.28355>; else goto <D.28356>;
        <D.28355>:
        filtered = 1;
        <D.28356>:
        <D.28353>:
        goto <D.28325>;
        <D.28324>:
        D.28305 = mod->kind;
        if (D.28305 == 11) goto <D.28359>; else goto <D.28357>;
        <D.28359>:
        if (ji != 0B) goto <D.28360>; else goto <D.28357>;
        <D.28360>:
        {
          int k;
          gboolean found;
          struct MonoAssembly * * assemblies;

          found = 0;
          assemblies = mod->data.assemblies;
          if (assemblies != 0B) goto <D.28361>; else goto <D.28362>;
          <D.28361>:
          k = 0;
          goto <D.26018>;
          <D.26017>:
          D.28363 = (long unsigned int) k;
          D.28364 = D.28363 * 8;
          D.28365 = assemblies + D.28364;
          D.28366 = *D.28365;
          D.28367 = jinfo_get_method (ji);
          D.28368 = D.28367->klass;
          D.28369 = D.28368->image;
          D.28370 = D.28369->assembly;
          if (D.28366 == D.28370) goto <D.28371>; else goto <D.28372>;
          <D.28371>:
          found = 1;
          <D.28372>:
          k = k + 1;
          <D.26018>:
          D.28363 = (long unsigned int) k;
          D.28364 = D.28363 * 8;
          D.28365 = assemblies + D.28364;
          D.28366 = *D.28365;
          if (D.28366 != 0B) goto <D.26017>; else goto <D.26019>;
          <D.26019>:
          <D.28362>:
          if (found == 0) goto <D.28373>; else goto <D.28374>;
          <D.28373>:
          filtered = 1;
          <D.28374>:
        }
        goto <D.28358>;
        <D.28357>:
        D.28305 = mod->kind;
        if (D.28305 == 12) goto <D.28377>; else goto <D.28375>;
        <D.28377>:
        if (ei != 0B) goto <D.28378>; else goto <D.28375>;
        <D.28378>:
        D.28379 = ei->klass;
        if (D.28379 != 0B) goto <D.28380>; else goto <D.28375>;
        <D.28380>:
        {
          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.26035>;
              <D.26034>:
              {
                struct MonoDebugMethodInfo * minfo;

                minfo = mono_debug_lookup_method (method);
                if (minfo != 0B) goto <D.28381>; else goto <D.28382>;
                <D.28381>:
                mono_debug_symfile_get_line_numbers_full (minfo, &source_file, &source_file_list, 0B, 0B, 0B, 0B, 0B);
                i = 0;
                goto <D.26032>;
                <D.26031>:
                source_file_list.33 = source_file_list;
                D.28384 = source_file_list.33->pdata;
                D.28385 = (long unsigned int) i;
                D.28386 = D.28385 * 8;
                D.28387 = D.28384 + D.28386;
                sinfo = *D.28387;
                D.28388 = sinfo->source_file;
                s = strdup_tolower (D.28388);
                D.28389 = mod->data.source_files;
                D.28390 = monoeg_g_hash_table_lookup (D.28389, s);
                if (D.28390 != 0B) goto <D.28391>; else goto <D.28392>;
                <D.28391>:
                found = 1;
                goto <D.28393>;
                <D.28392>:
                {
                  char * s2;
                  char * s3;

                  D.28388 = sinfo->source_file;
                  s2 = monoeg_g_path_get_basename (D.28388);
                  s3 = strdup_tolower (s2);
                  D.28389 = mod->data.source_files;
                  D.28394 = monoeg_g_hash_table_lookup (D.28389, s3);
                  if (D.28394 != 0B) goto <D.28395>; else goto <D.28396>;
                  <D.28395>:
                  found = 1;
                  <D.28396>:
                  monoeg_g_free (s2);
                  monoeg_g_free (s3);
                }
                <D.28393>:
                monoeg_g_free (s);
                i = i + 1;
                <D.26032>:
                i.34 = (unsigned int) i;
                source_file_list.33 = source_file_list;
                D.28398 = source_file_list.33->len;
                if (i.34 < D.28398) goto <D.26031>; else goto <D.26033>;
                <D.26033>:
                source_file_list.33 = source_file_list;
                monoeg_g_ptr_array_free (source_file_list.33, 1);
                <D.28382>:
              }
              <D.26035>:
              D.28379 = ei->klass;
              method = mono_class_get_methods (D.28379, &iter);
              if (method != 0B) goto <D.26034>; else goto <D.26036>;
              <D.26036>:
              if (found == 0) goto <D.28399>; else goto <D.28400>;
              <D.28399>:
              filtered = 1;
              <D.28400>:
            }
          finally
            {
              iter = {CLOBBER};
              source_file = {CLOBBER};
              source_file_list = {CLOBBER};
            }
        }
        goto <D.28376>;
        <D.28375>:
        D.28305 = mod->kind;
        if (D.28305 == 13) goto <D.28403>; else goto <D.28401>;
        <D.28403>:
        if (ei != 0B) goto <D.28404>; else goto <D.28401>;
        <D.28404>:
        D.28379 = ei->klass;
        if (D.28379 != 0B) goto <D.28405>; else goto <D.28401>;
        <D.28405>:
        {
          char * s;

          D.28379 = ei->klass;
          D.28406 = &D.28379->byval_arg;
          s = mono_type_full_name (D.28406);
          D.28407 = mod->data.type_names;
          D.28408 = monoeg_g_hash_table_lookup (D.28407, s);
          if (D.28408 == 0B) goto <D.28409>; else goto <D.28410>;
          <D.28409>:
          filtered = 1;
          <D.28410>:
          monoeg_g_free (s);
        }
        goto <D.28402>;
        <D.28401>:
        D.28305 = mod->kind;
        if (D.28305 == 10) goto <D.28411>; else goto <D.28412>;
        <D.28411>:
        D.28413 = mod->data.filter;
        D.28414 = D.28413 & 1;
        if (D.28414 != 0) goto <D.28415>; else goto <D.28416>;
        <D.28415>:
        if (ji != 0B) goto <D.28417>; else goto <D.28418>;
        <D.28417>:
        D.28419 = jinfo_get_method (ji);
        D.28420 = D.28419->flags;
        D.28421 = (int) D.28420;
        D.28422 = D.28421 & 2048;
        if (D.28422 != 0) goto <D.28423>; else goto <D.28424>;
        <D.28423>:
        {
          size_t __s1_len;
          size_t __s2_len;

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

            D.28428 = jinfo_get_method (ji);
            __s2 = D.28428->name;
            D.28429 = ".cctor";
            D.28430 = MEM[(const unsigned char *)D.28429];
            D.28431 = (int) D.28430;
            D.28432 = *__s2;
            D.28433 = (int) D.28432;
            __result = D.28431 - D.28433;
            {
              D.28434 = __s2_len != 0;
              D.28435 = __result == 0;
              D.28436 = D.28434 & D.28435;
              if (D.28436 != 0) goto <D.28437>; else goto <D.28438>;
              <D.28437>:
              D.28439 = &MEM[(void *)".cctor" + 1B];
              D.28440 = *D.28439;
              D.28441 = (int) D.28440;
              D.28442 = __s2 + 1;
              D.28443 = *D.28442;
              D.28444 = (int) D.28443;
              __result = D.28441 - D.28444;
              D.28445 = __s2_len > 1;
              D.28435 = __result == 0;
              D.28446 = D.28445 & D.28435;
              if (D.28446 != 0) goto <D.28447>; else goto <D.28448>;
              <D.28447>:
              D.28449 = &MEM[(void *)".cctor" + 2B];
              D.28450 = *D.28449;
              D.28451 = (int) D.28450;
              D.28452 = __s2 + 2;
              D.28453 = *D.28452;
              D.28454 = (int) D.28453;
              __result = D.28451 - D.28454;
              D.28455 = __s2_len > 2;
              D.28435 = __result == 0;
              D.28456 = D.28455 & D.28435;
              if (D.28456 != 0) goto <D.28457>; else goto <D.28458>;
              <D.28457>:
              D.28459 = &MEM[(void *)".cctor" + 3B];
              D.28460 = *D.28459;
              D.28461 = (int) D.28460;
              D.28462 = __s2 + 3;
              D.28463 = *D.28462;
              D.28464 = (int) D.28463;
              __result = D.28461 - D.28464;
              <D.28458>:
              <D.28448>:
              <D.28438>:
            }
            D.26045 = __result;
          }
          iftmp.35 = -D.26045;
          goto <D.28465>;
          <D.28427>:
          D.28466 = jinfo_get_method (ji);
          D.28467 = D.28466->name;
          iftmp.35 = __builtin_strcmp (D.28467, ".cctor");
          <D.28465>:
          D.26046 = iftmp.35;
        }
        if (D.26046 == 0) goto <D.28468>; else goto <D.28469>;
        <D.28468>:
        filtered = 1;
        <D.28469>:
        <D.28424>:
        <D.28418>:
        <D.28416>:
        D.28413 = mod->data.filter;
        D.28470 = D.28413 & 2;
        if (D.28470 != 0) goto <D.28471>; else goto <D.28472>;
        <D.28471>:
        if (ji != 0B) goto <D.28473>; else goto <D.28474>;
        <D.28473>:
        {
          struct MonoCustomAttrInfo * ainfo;
          static struct MonoClass * klass;

          klass.36 = klass;
          if (klass.36 == 0B) goto <D.28476>; else goto <D.28477>;
          <D.28476>:
          D.28478 = mono_defaults.corlib;
          klass.37 = mono_class_from_name (D.28478, "System.Diagnostics", "DebuggerHiddenAttribute");
          klass = klass.37;
          klass.36 = klass;
          D.28480 = klass.36 == 0B;
          D.28481 = (long int) D.28480;
          D.28482 = __builtin_expect (D.28481, 0);
          if (D.28482 != 0) goto <D.28483>; else goto <D.28484>;
          <D.28483>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 3454, "klass");
          <D.28484>:
          <D.28477>:
          D.28485 = BIT_FIELD_REF <*ji, 8, 272>;
          D.28486 = D.28485 & 64;
          if (D.28486 == 0) goto <D.28487>; else goto <D.28488>;
          <D.28487>:
          D.28489 = jinfo_get_method (ji);
          ainfo = mono_custom_attrs_from_method (D.28489);
          if (ainfo != 0B) goto <D.28490>; else goto <D.28491>;
          <D.28490>:
          klass.36 = klass;
          D.28492 = mono_custom_attrs_has_attr (ainfo, klass.36);
          if (D.28492 != 0) goto <D.28493>; else goto <D.28494>;
          <D.28493>:
          ji->dbg_hidden = -1;
          <D.28494>:
          mono_custom_attrs_free (ainfo);
          <D.28491>:
          ji->dbg_hidden_inited = -1;
          <D.28488>:
          D.28485 = BIT_FIELD_REF <*ji, 8, 272>;
          D.28495 = D.28485 & 128;
          if (D.28495 != 0) goto <D.28496>; else goto <D.28497>;
          <D.28496>:
          filtered = 1;
          <D.28497>:
        }
        <D.28474>:
        <D.28472>:
        D.28413 = mod->data.filter;
        D.28498 = D.28413 & 4;
        if (D.28498 != 0) goto <D.28499>; else goto <D.28500>;
        <D.28499>:
        if (ji != 0B) goto <D.28501>; else goto <D.28502>;
        <D.28501>:
        {
          struct MonoCustomAttrInfo * ainfo;
          static struct MonoClass * klass;

          klass.38 = klass;
          if (klass.38 == 0B) goto <D.28504>; else goto <D.28505>;
          <D.28504>:
          D.28478 = mono_defaults.corlib;
          klass.39 = mono_class_from_name (D.28478, "System.Diagnostics", "DebuggerStepThroughAttribute");
          klass = klass.39;
          klass.38 = klass;
          D.28507 = klass.38 == 0B;
          D.28508 = (long int) D.28507;
          D.28509 = __builtin_expect (D.28508, 0);
          if (D.28509 != 0) goto <D.28510>; else goto <D.28511>;
          <D.28510>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 3474, "klass");
          <D.28511>:
          <D.28505>:
          D.28512 = BIT_FIELD_REF <*ji, 8, 280>;
          D.28513 = D.28512 & 2;
          if (D.28513 == 0) goto <D.28514>; else goto <D.28515>;
          <D.28514>:
          D.28516 = jinfo_get_method (ji);
          ainfo = mono_custom_attrs_from_method (D.28516);
          if (ainfo != 0B) goto <D.28517>; else goto <D.28518>;
          <D.28517>:
          klass.38 = klass;
          D.28519 = mono_custom_attrs_has_attr (ainfo, klass.38);
          if (D.28519 != 0) goto <D.28520>; else goto <D.28521>;
          <D.28520>:
          ji->dbg_step_through = -1;
          <D.28521>:
          mono_custom_attrs_free (ainfo);
          <D.28518>:
          D.28522 = jinfo_get_method (ji);
          D.28523 = D.28522->klass;
          ainfo = mono_custom_attrs_from_class (D.28523);
          if (ainfo != 0B) goto <D.28524>; else goto <D.28525>;
          <D.28524>:
          klass.38 = klass;
          D.28526 = mono_custom_attrs_has_attr (ainfo, klass.38);
          if (D.28526 != 0) goto <D.28527>; else goto <D.28528>;
          <D.28527>:
          ji->dbg_step_through = -1;
          <D.28528>:
          mono_custom_attrs_free (ainfo);
          <D.28525>:
          ji->dbg_step_through_inited = -1;
          <D.28515>:
          D.28512 = BIT_FIELD_REF <*ji, 8, 280>;
          D.28529 = D.28512 & 4;
          if (D.28529 != 0) goto <D.28530>; else goto <D.28531>;
          <D.28530>:
          filtered = 1;
          <D.28531>:
        }
        <D.28502>:
        <D.28500>:
        <D.28412>:
        <D.28402>:
        <D.28376>:
        <D.28358>:
        <D.28325>:
        <D.28323>:
        <D.28316>:
      }
      j = j + 1;
      <D.26052>:
      D.28532 = req->nmodifiers;
      if (D.28532 > j) goto <D.26051>; else goto <D.26053>;
      <D.26053>:
      if (filtered == 0) goto <D.28533>; else goto <D.28534>;
      <D.28533>:
      D.28535 = req->suspend_policy;
      D.28536 = *suspend_policy;
      D.28537 = MAX_EXPR <D.28535, D.28536>;
      *suspend_policy = D.28537;
      D.28538 = req->id;
      D.28539 = (long int) D.28538;
      D.28540 = (void *) D.28539;
      events = monoeg_g_slist_append (events, D.28540);
      <D.28534>:
    }
    <D.28304>:
  }
  i = i + 1;
  <D.26055>:
  i.40 = (unsigned int) i;
  D.28542 = reqs->len;
  if (i.40 < D.28542) goto <D.26054>; else goto <D.26056>;
  <D.26056>:
  if (event == 0) goto <D.28543>; else goto <D.28544>;
  <D.28543>:
  events = monoeg_g_slist_append (events, 0B);
  <D.28544>:
  if (event == 1) goto <D.28545>; else goto <D.28546>;
  <D.28545>:
  events = monoeg_g_slist_append (events, 0B);
  <D.28546>:
  D.28296 = events;
  return D.28296;
}


strdup_tolower (char * s)
{
  int D.25997;
  char D.28550;
  int D.28551;
  int D.28552;
  const int iftmp.41;
  unsigned int __c.42;
  unsigned int D.28557;
  const __int32_t * * D.28560;
  const __int32_t * D.28561;
  long unsigned int D.28562;
  long unsigned int D.28563;
  const __int32_t * D.28564;
  long unsigned int D.28568;
  long unsigned int D.28569;
  const __int32_t * D.28570;
  char D.28571;
  char * D.28572;
  char * s2;
  char * p;

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

    {
      if (0 != 0) goto <D.28548>; else goto <D.28549>;
      <D.28548>:
      D.28550 = *p;
      D.28551 = (int) D.28550;
      D.28552 = __builtin_constant_p (D.28551);
      if (D.28552 != 0) goto <D.28553>; else goto <D.28554>;
      <D.28553>:
      {
        int __c;

        D.28550 = *p;
        __c = (int) D.28550;
        __c.42 = (unsigned int) __c;
        D.28557 = __c.42 + 128;
        if (D.28557 <= 383) goto <D.28558>; else goto <D.28559>;
        <D.28558>:
        D.28560 = __ctype_tolower_loc ();
        D.28561 = *D.28560;
        D.28562 = (long unsigned int) __c;
        D.28563 = D.28562 * 4;
        D.28564 = D.28561 + D.28563;
        iftmp.41 = *D.28564;
        goto <D.28565>;
        <D.28559>:
        iftmp.41 = __c;
        <D.28565>:
        __res = iftmp.41;
      }
      goto <D.28566>;
      <D.28554>:
      D.28550 = *p;
      D.28551 = (int) D.28550;
      __res = tolower (D.28551);
      <D.28566>:
      goto <D.28567>;
      <D.28549>:
      D.28560 = __ctype_tolower_loc ();
      D.28561 = *D.28560;
      D.28550 = *p;
      D.28568 = (long unsigned int) D.28550;
      D.28569 = D.28568 * 4;
      D.28570 = D.28561 + D.28569;
      __res = *D.28570;
      <D.28567>:
    }
    D.25997 = __res;
  }
  D.28571 = (char) D.25997;
  *p = D.28571;
  p = p + 1;
  <D.25999>:
  D.28550 = *p;
  if (D.28550 != 0) goto <D.25998>; else goto <D.26000>;
  <D.26000>:
  D.28572 = s2;
  return D.28572;
}


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

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


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.28580;
  long int D.28581;
  long int D.28582;
  const char * D.28585;
  struct FILE * log_file.45;
  int vm_start_event_sent.46;
  const char * D.28594;
  int vm_death_event_sent.47;
  const char * D.28600;
  int D.28601;
  const char * D.28608;
  int disconnected.48;
  const char * D.28614;
  int D.28620;
  long unsigned int D.28623;
  long unsigned int debugger_thread_id.49;
  long unsigned int D.28629;
  unsigned int D.28634;
  unsigned char D.28635;
  int D.28636;
  unsigned int nevents.50;
  unsigned char D.28638;
  int D.28639;
  void * D.28640;
  long int D.28641;
  unsigned int D.28642;
  int ecount.51;
  int ecount.52;
  _Bool D.28647;
  _Bool D.28648;
  _Bool D.28649;
  long unsigned int D.28652;
  struct MonoDomain * D.28653;
  int protocol_version_set.53;
  int major_version.54;
  int minor_version.55;
  int D.28663;
  unsigned int D.28664;
  struct MonoObject * D.28665;
  int D.28666;
  unsigned int D.28667;
  const char * iftmp.56;
  char * D.28669;
  const char * iftmp.57;
  char * D.28674;
  int iftmp.58;
  int D.28681;
  int D.28689;
  const char * D.28700;
  _Bool D.28703;
  long int D.28704;
  long int D.28705;
  const char * D.28708;
  long unsigned int D.28709;
  void * D.28710;
  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.28577>; else goto <D.28578>;
      <D.28577>:
      log_level.44 = log_level;
      D.28580 = log_level.44 > 1;
      D.28581 = (long int) D.28580;
      D.28582 = __builtin_expect (D.28581, 0);
      if (D.28582 != 0) goto <D.28583>; else goto <D.28584>;
      <D.28583>:
      D.28585 = event_to_string (event);
      log_file.45 = log_file;
      fprintf (log_file.45, "Debugger agent not initialized yet: dropping %s\n", D.28585);
      log_file.45 = log_file;
      fflush (log_file.45);
      <D.28584>:
      return;
      <D.28578>:
      vm_start_event_sent.46 = vm_start_event_sent;
      if (vm_start_event_sent.46 == 0) goto <D.28588>; else goto <D.28589>;
      <D.28588>:
      if (event != 0) goto <D.28590>; else goto <D.28591>;
      <D.28590>:
      log_level.44 = log_level;
      D.28580 = log_level.44 > 1;
      D.28581 = (long int) D.28580;
      D.28582 = __builtin_expect (D.28581, 0);
      if (D.28582 != 0) goto <D.28592>; else goto <D.28593>;
      <D.28592>:
      D.28594 = event_to_string (event);
      log_file.45 = log_file;
      fprintf (log_file.45, "VM start event not sent yet: dropping %s\n", D.28594);
      log_file.45 = log_file;
      fflush (log_file.45);
      <D.28593>:
      return;
      <D.28591>:
      <D.28589>:
      vm_death_event_sent.47 = vm_death_event_sent;
      if (vm_death_event_sent.47 != 0) goto <D.28596>; else goto <D.28597>;
      <D.28596>:
      log_level.44 = log_level;
      D.28580 = log_level.44 > 1;
      D.28581 = (long int) D.28580;
      D.28582 = __builtin_expect (D.28581, 0);
      if (D.28582 != 0) goto <D.28598>; else goto <D.28599>;
      <D.28598>:
      D.28600 = event_to_string (event);
      log_file.45 = log_file;
      fprintf (log_file.45, "VM death event has been sent: dropping %s\n", D.28600);
      log_file.45 = log_file;
      fflush (log_file.45);
      <D.28599>:
      return;
      <D.28597>:
      D.28601 = mono_runtime_is_shutting_down ();
      if (D.28601 != 0) goto <D.28602>; else goto <D.28603>;
      <D.28602>:
      if (event != 1) goto <D.28604>; else goto <D.28605>;
      <D.28604>:
      log_level.44 = log_level;
      D.28580 = log_level.44 > 1;
      D.28581 = (long int) D.28580;
      D.28582 = __builtin_expect (D.28581, 0);
      if (D.28582 != 0) goto <D.28606>; else goto <D.28607>;
      <D.28606>:
      D.28608 = event_to_string (event);
      log_file.45 = log_file;
      fprintf (log_file.45, "Mono runtime is shutting down: dropping %s\n", D.28608);
      log_file.45 = log_file;
      fflush (log_file.45);
      <D.28607>:
      return;
      <D.28605>:
      <D.28603>:
      disconnected.48 = disconnected;
      if (disconnected.48 != 0) goto <D.28610>; else goto <D.28611>;
      <D.28610>:
      log_level.44 = log_level;
      D.28580 = log_level.44 > 1;
      D.28581 = (long int) D.28580;
      D.28582 = __builtin_expect (D.28581, 0);
      if (D.28582 != 0) goto <D.28612>; else goto <D.28613>;
      <D.28612>:
      D.28614 = event_to_string (event);
      log_file.45 = log_file;
      fprintf (log_file.45, "Debugger client is not connected: dropping %s\n", D.28614);
      log_file.45 = log_file;
      fflush (log_file.45);
      <D.28613>:
      return;
      <D.28611>:
      if (event == 14) goto <D.28615>; else goto <D.28616>;
      <D.28615>:
      suspend_policy = 0;
      goto <D.28617>;
      <D.28616>:
      if (events == 0B) goto <D.28618>; else goto <D.28619>;
      <D.28618>:
      return;
      <D.28619>:
      D.28620 = agent_config.defer;
      if (D.28620 != 0) goto <D.28621>; else goto <D.28622>;
      <D.28621>:
      D.28623 = GetCurrentThreadId ();
      debugger_thread_id.49 = debugger_thread_id;
      if (D.28623 == debugger_thread_id.49) goto <D.28625>; else goto <D.28626>;
      <D.28625>:
      suspend_policy = 0;
      thread = mono_thread_get_main ();
      goto <D.28627>;
      <D.28626>:
      thread = mono_thread_current ();
      <D.28627>:
      goto <D.28628>;
      <D.28622>:
      D.28629 = GetCurrentThreadId ();
      debugger_thread_id.49 = debugger_thread_id;
      if (D.28629 == debugger_thread_id.49) goto <D.28630>; else goto <D.28631>;
      <D.28630>:
      if (event != 1) goto <D.28632>; else goto <D.28633>;
      <D.28632>:
      return;
      <D.28633>:
      <D.28631>:
      <D.28628>:
      <D.28617>:
      D.28634 = monoeg_g_slist_length (events);
      nevents = (int) D.28634;
      buffer_init (&buf, 128);
      D.28635 = (unsigned char) suspend_policy;
      D.28636 = (int) D.28635;
      buffer_add_byte (&buf, D.28636);
      nevents.50 = (unsigned int) nevents;
      buffer_add_int (&buf, nevents.50);
      l = events;
      goto <D.26116>;
      <D.26115>:
      D.28638 = (unsigned char) event;
      D.28639 = (int) D.28638;
      buffer_add_byte (&buf, D.28639);
      D.28640 = l->data;
      D.28641 = (long int) D.28640;
      D.28642 = (unsigned int) D.28641;
      buffer_add_int (&buf, D.28642);
      ecount.51 = ecount;
      ecount.52 = ecount.51 + 1;
      ecount = ecount.52;
      if (thread == 0B) goto <D.28645>; else goto <D.28646>;
      <D.28645>:
      thread = mono_thread_current ();
      <D.28646>:
      D.28647 = event == 0;
      D.28648 = arg != 0B;
      D.28649 = D.28647 & D.28648;
      if (D.28649 != 0) goto <D.28650>; else goto <D.28651>;
      <D.28650>:
      thread = arg;
      <D.28651>:
      buffer_add_objid (&buf, thread);
      switch (event) <default: <D.26114>, case 0: <D.26106>, case 1: <D.26107>, case 2: <D.26094>, case 3: <D.26095>, case 4: <D.26097>, case 5: <D.26098>, case 6: <D.26099>, case 7: <D.26100>, case 8: <D.26101>, case 9: <D.26102>, case 10: <D.26104>, case 11: <D.26105>, case 12: <D.26103>, case 13: <D.26108>, case 14: <D.26113>, case 15: <D.26110>, case 16: <D.26111>>
      <D.26094>:
      <D.26095>:
      goto <D.26096>;
      <D.26097>:
      <D.26098>:
      buffer_add_domainid (&buf, arg);
      goto <D.26096>;
      <D.26099>:
      <D.26100>:
      buffer_add_methodid (&buf, domain, arg);
      goto <D.26096>;
      <D.26101>:
      <D.26102>:
      buffer_add_assemblyid (&buf, domain, arg);
      goto <D.26096>;
      <D.26103>:
      buffer_add_typeid (&buf, domain, arg);
      goto <D.26096>;
      <D.26104>:
      <D.26105>:
      buffer_add_methodid (&buf, domain, arg);
      D.28652 = (long unsigned int) il_offset;
      buffer_add_long (&buf, D.28652);
      goto <D.26096>;
      <D.26106>:
      D.28653 = mono_get_root_domain ();
      buffer_add_domainid (&buf, D.28653);
      goto <D.26096>;
      <D.26107>:
      protocol_version_set.53 = protocol_version_set;
      if (protocol_version_set.53 != 0) goto <D.28657>; else goto <D.28658>;
      <D.28657>:
      major_version.54 = major_version;
      if (major_version.54 > 2) goto <D.28654>; else goto <D.28660>;
      <D.28660>:
      major_version.54 = major_version;
      if (major_version.54 == 2) goto <D.28661>; else goto <D.28655>;
      <D.28661>:
      minor_version.55 = minor_version;
      if (minor_version.55 > 26) goto <D.28654>; else goto <D.28655>;
      <D.28654>:
      D.28663 = mono_environment_exitcode_get ();
      D.28664 = (unsigned int) D.28663;
      buffer_add_int (&buf, D.28664);
      <D.28655>:
      <D.28658>:
      goto <D.26096>;
      <D.26108>:
      {
        struct EventInfo * ei;

        ei = arg;
        D.28665 = ei->exc;
        buffer_add_objid (&buf, D.28665);
        keepalive_obj = ei->exc;
        goto <D.26096>;
      }
      <D.26110>:
      goto <D.26096>;
      <D.26111>:
      {
        struct EventInfo * ei;

        ei = arg;
        D.28666 = ei->level;
        D.28667 = (unsigned int) D.28666;
        buffer_add_int (&buf, D.28667);
        D.28669 = ei->category;
        if (D.28669 != 0B) goto <D.28670>; else goto <D.28671>;
        <D.28670>:
        iftmp.56 = ei->category;
        goto <D.28672>;
        <D.28671>:
        iftmp.56 = "";
        <D.28672>:
        buffer_add_string (&buf, iftmp.56);
        D.28674 = ei->message;
        if (D.28674 != 0B) goto <D.28675>; else goto <D.28676>;
        <D.28675>:
        iftmp.57 = ei->message;
        goto <D.28677>;
        <D.28676>:
        iftmp.57 = "";
        <D.28677>:
        buffer_add_string (&buf, iftmp.57);
        goto <D.26096>;
      }
      <D.26113>:
      suspend_policy = 0;
      goto <D.26096>;
      <D.26114>:
      monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "debugger-agent.c", 3680);
      <D.26096>:
      l = l->next;
      <D.26116>:
      if (l != 0B) goto <D.26115>; else goto <D.26117>;
      <D.26117>:
      if (event == 0) goto <D.28678>; else goto <D.28679>;
      <D.28678>:
      D.28681 = agent_config.suspend;
      if (D.28681 != 0) goto <D.28682>; else goto <D.28683>;
      <D.28682>:
      iftmp.58 = 2;
      goto <D.28684>;
      <D.28683>:
      iftmp.58 = 0;
      <D.28684>:
      suspend_policy = iftmp.58;
      D.28620 = agent_config.defer;
      if (D.28620 == 0) goto <D.28685>; else goto <D.28686>;
      <D.28685>:
      start_debugger_thread ();
      <D.28686>:
      <D.28679>:
      if (event == 1) goto <D.28687>; else goto <D.28688>;
      <D.28687>:
      vm_death_event_sent = 1;
      suspend_policy = 0;
      <D.28688>:
      D.28689 = mono_runtime_is_shutting_down ();
      if (D.28689 != 0) goto <D.28690>; else goto <D.28691>;
      <D.28690>:
      suspend_policy = 0;
      <D.28691>:
      if (suspend_policy != 0) goto <D.28692>; else goto <D.28693>;
      <D.28692>:
      save_thread_context (ctx);
      suspend_vm ();
      if (keepalive_obj != 0B) goto <D.28694>; else goto <D.28695>;
      <D.28694>:
      get_objref (keepalive_obj);
      <D.28695>:
      <D.28693>:
      send_success = send_packet (64, 100, &buf);
      buffer_free (&buf);
      monoeg_g_slist_free (events);
      events = 0B;
      if (send_success == 0) goto <D.28696>; else goto <D.28697>;
      <D.28696>:
      log_level.44 = log_level;
      D.28580 = log_level.44 > 1;
      D.28581 = (long int) D.28580;
      D.28582 = __builtin_expect (D.28581, 0);
      if (D.28582 != 0) goto <D.28698>; else goto <D.28699>;
      <D.28698>:
      D.28700 = event_to_string (event);
      log_file.45 = log_file;
      fprintf (log_file.45, "Sending command %s failed.\n", D.28700);
      log_file.45 = log_file;
      fflush (log_file.45);
      <D.28699>:
      return;
      <D.28697>:
      if (event == 0) goto <D.28701>; else goto <D.28702>;
      <D.28701>:
      vm_start_event_sent = 1;
      <D.28702>:
      log_level.44 = log_level;
      D.28703 = log_level.44 > 0;
      D.28704 = (long int) D.28703;
      D.28705 = __builtin_expect (D.28704, 0);
      if (D.28705 != 0) goto <D.28706>; else goto <D.28707>;
      <D.28706>:
      ecount.51 = ecount;
      D.28708 = event_to_string (event);
      D.28709 = GetCurrentThreadId ();
      D.28710 = (void *) D.28709;
      log_file.45 = log_file;
      fprintf (log_file.45, "[%p] Sent %d events %s(%d), suspend=%d.\n", D.28710, nevents, D.28708, ecount.51, suspend_policy);
      log_file.45 = log_file;
      fflush (log_file.45);
      <D.28707>:
      switch (suspend_policy) <default: <D.26122>, case 0: <D.26118>, case 1: <D.26121>, case 2: <D.26120>>
      <D.26118>:
      goto <D.26119>;
      <D.26120>:
      suspend_current ();
      goto <D.26119>;
      <D.26121>:
      monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "debugger-agent.c", 3737);
      <D.26122>:
      monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "debugger-agent.c", 3740);
      <D.26119>:
    }
  finally
    {
      buf = {CLOBBER};
    }
}


buffer_init (struct Buffer * buf, int size)
{
  long unsigned int D.28716;
  void * D.28717;
  guint8 * D.28718;
  sizetype D.28719;
  guint8 * D.28720;

  D.28716 = (long unsigned int) size;
  D.28717 = monoeg_malloc (D.28716);
  buf->buf = D.28717;
  D.28718 = buf->buf;
  buf->p = D.28718;
  D.28718 = buf->buf;
  D.28719 = (sizetype) size;
  D.28720 = D.28718 + D.28719;
  buf->end = D.28720;
}


buffer_add_byte (struct Buffer * buf, guint8 val)
{
  guint8 * D.28721;
  guint8 * D.28722;

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


buffer_make_room (struct Buffer * buf, int size)
{
  guint8 * D.28723;
  long int D.28724;
  guint8 * D.28725;
  long int D.28726;
  long int D.28727;
  long int D.28728;
  guint8 * D.28731;
  long int D.28732;
  long int D.28733;
  unsigned int D.28734;
  unsigned int size.59;
  unsigned int D.28736;
  unsigned int D.28737;
  long unsigned int D.28738;
  long int D.28739;
  sizetype D.28740;
  guint8 * D.28741;
  sizetype D.28742;
  guint8 * D.28743;

  D.28723 = buf->end;
  D.28724 = (long int) D.28723;
  D.28725 = buf->p;
  D.28726 = (long int) D.28725;
  D.28727 = D.28724 - D.28726;
  D.28728 = (long int) size;
  if (D.28727 < D.28728) goto <D.28729>; else goto <D.28730>;
  <D.28729>:
  {
    int new_size;
    guint8 * p;

    D.28723 = buf->end;
    D.28724 = (long int) D.28723;
    D.28731 = buf->buf;
    D.28732 = (long int) D.28731;
    D.28733 = D.28724 - D.28732;
    D.28734 = (unsigned int) D.28733;
    size.59 = (unsigned int) size;
    D.28736 = D.28734 + size.59;
    D.28737 = D.28736 + 32;
    new_size = (int) D.28737;
    D.28738 = (long unsigned int) new_size;
    D.28731 = buf->buf;
    p = monoeg_realloc (D.28731, D.28738);
    D.28725 = buf->p;
    D.28726 = (long int) D.28725;
    D.28731 = buf->buf;
    D.28732 = (long int) D.28731;
    D.28739 = D.28726 - D.28732;
    size = (int) D.28739;
    buf->buf = p;
    D.28740 = (sizetype) size;
    D.28741 = p + D.28740;
    buf->p = D.28741;
    D.28731 = buf->buf;
    D.28742 = (sizetype) new_size;
    D.28743 = D.28731 + D.28742;
    buf->end = D.28743;
  }
  <D.28730>:
}


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

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


get_id (struct MonoDomain * domain, IdType type, void * val)
{
  int D.28747;
  union mono_mutex_t * D.28748;
  _Bool D.28751;
  long int D.28752;
  long int D.28753;
  struct GHashTable * D.28756;
  struct GHashTable * D.28759;
  _Bool D.28764;
  long int D.28765;
  long int D.28766;
  struct GPtrArray * D.28769;
  unsigned int D.28770;
  unsigned int D.28771;
  int D.28772;
  _Bool D.28775;
  long int D.28776;
  long int D.28777;
  struct Id * id;
  struct AgentDomainInfo * info;

  if (val == 0B) goto <D.28745>; else goto <D.28746>;
  <D.28745>:
  D.28747 = 0;
  return D.28747;
  <D.28746>:
  mono_loader_lock ();
  {
    int ret;

    D.28748 = &domain->lock.mutex;
    ret = pthread_mutex_lock (D.28748);
    if (ret != 0) goto <D.28749>; else goto <D.28750>;
    <D.28749>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.28750>:
    D.28751 = ret != 0;
    D.28752 = (long int) D.28751;
    D.28753 = __builtin_expect (D.28752, 0);
    if (D.28753 != 0) goto <D.28754>; else goto <D.28755>;
    <D.28754>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 2149, "ret == 0");
    <D.28755>:
  }
  info = get_agent_domain_info (domain);
  D.28756 = info->val_to_id[type];
  if (D.28756 == 0B) goto <D.28757>; else goto <D.28758>;
  <D.28757>:
  D.28759 = monoeg_g_hash_table_new (mono_aligned_addr_hash, 0B);
  info->val_to_id[type] = D.28759;
  <D.28758>:
  D.28756 = info->val_to_id[type];
  id = monoeg_g_hash_table_lookup (D.28756, val);
  if (id != 0B) goto <D.28760>; else goto <D.28761>;
  <D.28760>:
  {
    int ret;

    D.28748 = &domain->lock.mutex;
    ret = pthread_mutex_unlock (D.28748);
    if (ret != 0) goto <D.28762>; else goto <D.28763>;
    <D.28762>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.28763>:
    D.28764 = ret != 0;
    D.28765 = (long int) D.28764;
    D.28766 = __builtin_expect (D.28765, 0);
    if (D.28766 != 0) goto <D.28767>; else goto <D.28768>;
    <D.28767>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 2158, "ret == 0");
    <D.28768>:
  }
  mono_loader_unlock ();
  D.28747 = id->id;
  return D.28747;
  <D.28761>:
  id = monoeg_malloc0 (24);
  D.28769 = ids[type];
  D.28770 = D.28769->len;
  D.28771 = D.28770 + 1;
  D.28772 = (int) D.28771;
  id->id = D.28772;
  id->domain = domain;
  id->data.val = val;
  D.28756 = info->val_to_id[type];
  monoeg_g_hash_table_insert_replace (D.28756, val, id, 0);
  {
    int ret;

    D.28748 = &domain->lock.mutex;
    ret = pthread_mutex_unlock (D.28748);
    if (ret != 0) goto <D.28773>; else goto <D.28774>;
    <D.28773>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.28774>:
    D.28775 = ret != 0;
    D.28776 = (long int) D.28775;
    D.28777 = __builtin_expect (D.28776, 0);
    if (D.28777 != 0) goto <D.28778>; else goto <D.28779>;
    <D.28778>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 2171, "ret == 0");
    <D.28779>:
  }
  D.28769 = ids[type];
  monoeg_g_ptr_array_add (D.28769, id);
  mono_loader_unlock ();
  D.28747 = id->id;
  return D.28747;
}


get_agent_domain_info (struct MonoDomain * domain)
{
  union mono_mutex_t * D.28781;
  _Bool D.28784;
  long int D.28785;
  long int D.28786;
  void * D.28789;
  void * D.28792;
  struct GHashTable * D.28793;
  struct GHashTable * D.28794;
  struct GHashTable * D.28795;
  struct GHashTable * D.28796;
  _Bool D.28799;
  long int D.28800;
  long int D.28801;
  struct AgentDomainInfo * D.28804;
  struct AgentDomainInfo * info;

  info = 0B;
  {
    int ret;

    D.28781 = &domain->lock.mutex;
    ret = pthread_mutex_lock (D.28781);
    if (ret != 0) goto <D.28782>; else goto <D.28783>;
    <D.28782>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.28783>:
    D.28784 = ret != 0;
    D.28785 = (long int) D.28784;
    D.28786 = __builtin_expect (D.28785, 0);
    if (D.28786 != 0) goto <D.28787>; else goto <D.28788>;
    <D.28787>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 2122, "ret == 0");
    <D.28788>:
  }
  D.28789 = domain->runtime_info;
  info = MEM[(struct MonoJitDomainInfo *)D.28789].agent_info;
  if (info == 0B) goto <D.28790>; else goto <D.28791>;
  <D.28790>:
  D.28789 = domain->runtime_info;
  D.28792 = monoeg_malloc0 (88);
  MEM[(struct MonoJitDomainInfo *)D.28789].agent_info = D.28792;
  info = MEM[(struct MonoJitDomainInfo *)D.28789].agent_info;
  D.28793 = monoeg_g_hash_table_new (mono_aligned_addr_hash, 0B);
  info->loaded_classes = D.28793;
  D.28794 = monoeg_g_hash_table_new (mono_aligned_addr_hash, 0B);
  info->source_files = D.28794;
  D.28795 = monoeg_g_hash_table_new (monoeg_g_str_hash, monoeg_g_str_equal);
  info->source_file_to_class = D.28795;
  D.28796 = monoeg_g_hash_table_new (monoeg_g_str_hash, monoeg_g_str_equal);
  info->source_file_to_class_ignorecase = D.28796;
  <D.28791>:
  {
    int ret;

    D.28781 = &domain->lock.mutex;
    ret = pthread_mutex_unlock (D.28781);
    if (ret != 0) goto <D.28797>; else goto <D.28798>;
    <D.28797>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.28798>:
    D.28799 = ret != 0;
    D.28800 = (long int) D.28799;
    D.28801 = __builtin_expect (D.28800, 0);
    if (D.28801 != 0) goto <D.28802>; else goto <D.28803>;
    <D.28802>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 2133, "ret == 0");
    <D.28803>:
  }
  D.28804 = info;
  return D.28804;
}


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.28808;
  long int D.28809;
  long int D.28810;
  struct MonoType * D.28815;
  long unsigned int D.28816;
  long unsigned int debugger_thread_id.62;
  struct FILE * log_file.63;
  long unsigned int D.28826;
  void * D.28827;

  buffer_add_ptr_id (buf, domain, 2, klass);
  log_level.61 = log_level;
  D.28808 = log_level.61 > 1;
  D.28809 = (long int) D.28808;
  D.28810 = __builtin_expect (D.28809, 0);
  if (D.28810 != 0) goto <D.28811>; else goto <D.28812>;
  <D.28811>:
  if (klass != 0B) goto <D.28813>; else goto <D.28814>;
  <D.28813>:
  {
    char * s;

    D.28815 = &klass->byval_arg;
    s = mono_type_full_name (D.28815);
    D.28816 = GetCurrentThreadId ();
    debugger_thread_id.62 = debugger_thread_id;
    if (D.28816 == debugger_thread_id.62) goto <D.28818>; else goto <D.28819>;
    <D.28818>:
    log_level.61 = log_level;
    D.28808 = log_level.61 > 1;
    D.28809 = (long int) D.28808;
    D.28810 = __builtin_expect (D.28809, 0);
    if (D.28810 != 0) goto <D.28820>; else goto <D.28821>;
    <D.28820>:
    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.28821>:
    goto <D.28823>;
    <D.28819>:
    log_level.61 = log_level;
    D.28808 = log_level.61 > 1;
    D.28809 = (long int) D.28808;
    D.28810 = __builtin_expect (D.28809, 0);
    if (D.28810 != 0) goto <D.28824>; else goto <D.28825>;
    <D.28824>:
    D.28826 = GetCurrentThreadId ();
    D.28827 = (void *) D.28826;
    log_file.63 = log_file;
    fprintf (log_file.63, "[%p]   send class [%s]\n", D.28827, s);
    log_file.63 = log_file;
    fflush (log_file.63);
    <D.28825>:
    <D.28823>:
    monoeg_g_free (s);
  }
  <D.28814>:
  <D.28812>:
}


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

  buffer_add_ptr_id (buf, domain, 3, method);
  log_level.64 = log_level;
  D.28829 = log_level.64 > 1;
  D.28830 = (long int) D.28829;
  D.28831 = __builtin_expect (D.28830, 0);
  if (D.28831 != 0) goto <D.28832>; else goto <D.28833>;
  <D.28832>:
  if (method != 0B) goto <D.28834>; else goto <D.28835>;
  <D.28834>:
  {
    char * s;

    s = mono_method_full_name (method, 1);
    log_level.64 = log_level;
    D.28829 = log_level.64 > 1;
    D.28830 = (long int) D.28829;
    D.28831 = __builtin_expect (D.28830, 0);
    if (D.28831 != 0) goto <D.28836>; else goto <D.28837>;
    <D.28836>:
    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.28837>:
    monoeg_g_free (s);
  }
  <D.28835>:
  <D.28833>:
}


buffer_add_long (struct Buffer * buf, guint64 l)
{
  long unsigned int D.28839;
  unsigned int D.28840;
  unsigned int D.28841;

  D.28839 = l >> 32;
  D.28840 = (unsigned int) D.28839;
  buffer_add_int (buf, D.28840);
  D.28841 = (unsigned int) l;
  buffer_add_int (buf, D.28841);
}


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

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


get_objid (struct MonoObject * obj)
{
  int D.28843;
  struct ObjRef * D.28844;

  D.28844 = get_objref (obj);
  D.28843 = D.28844->id;
  return D.28843;
}


buffer_add_int (struct Buffer * buf, guint32 val)
{
  guint8 * D.28846;
  unsigned int D.28847;
  unsigned char D.28848;
  guint8 * D.28849;
  unsigned int D.28850;
  unsigned char D.28851;
  guint8 * D.28852;
  unsigned int D.28853;
  unsigned char D.28854;
  guint8 * D.28855;
  unsigned char D.28856;
  guint8 * D.28857;

  buffer_make_room (buf, 4);
  D.28846 = buf->p;
  D.28847 = val >> 24;
  D.28848 = (unsigned char) D.28847;
  *D.28846 = D.28848;
  D.28846 = buf->p;
  D.28849 = D.28846 + 1;
  D.28850 = val >> 16;
  D.28851 = (unsigned char) D.28850;
  *D.28849 = D.28851;
  D.28846 = buf->p;
  D.28852 = D.28846 + 2;
  D.28853 = val >> 8;
  D.28854 = (unsigned char) D.28853;
  *D.28852 = D.28854;
  D.28846 = buf->p;
  D.28855 = D.28846 + 3;
  D.28856 = (unsigned char) val;
  *D.28855 = D.28856;
  D.28846 = buf->p;
  D.28857 = D.28846 + 4;
  buf->p = D.28857;
}


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

  if (str == 0B) goto <D.28858>; else goto <D.28859>;
  <D.28858>:
  buffer_add_int (buf, 0);
  goto <D.28860>;
  <D.28859>:
  D.28861 = strlen (str);
  len = (int) D.28861;
  len.66 = (unsigned int) len;
  buffer_add_int (buf, len.66);
  buffer_add_data (buf, str, len);
  <D.28860>:
}


buffer_add_data (struct Buffer * buf, guint8 * data, int len)
{
  long unsigned int D.28863;
  guint8 * D.28864;
  sizetype D.28865;
  guint8 * D.28866;

  buffer_make_room (buf, len);
  D.28863 = (long unsigned int) len;
  D.28864 = buf->p;
  memcpy (D.28864, data, D.28863);
  D.28864 = buf->p;
  D.28865 = (sizetype) len;
  D.28866 = D.28864 + D.28865;
  buf->p = D.28866;
}


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

  D.28868 = __builtin_object_size (__dest, 0);
  D.28867 = __builtin___memcpy_chk (__dest, __src, __len, D.28868);
  return D.28867;
}


start_debugger_thread ()
{
  void * debugger_thread_handle.67;
  void * debugger_thread_handle.68;
  _Bool D.28872;
  long int D.28873;
  long int D.28874;

  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.28872 = debugger_thread_handle.68 == 0B;
  D.28873 = (long int) D.28872;
  D.28874 = __builtin_expect (D.28873, 0);
  if (D.28874 != 0) goto <D.28875>; else goto <D.28876>;
  <D.28875>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 1580, "debugger_thread_handle");
  <D.28876>:
}


debugger_thread (void * arg)
{
  int log_level.69;
  _Bool D.28878;
  long int D.28879;
  long int D.28880;
  long unsigned int D.28883;
  void * D.28884;
  struct FILE * log_file.70;
  long unsigned int debugger_thread_id.71;
  struct MonoDomain * D.28887;
  struct MonoInternalThread * D.28888;
  long unsigned int D.28889;
  long unsigned int D.28890;
  int D.28891;
  int D.28894;
  struct MonoThread * D.28900;
  guint8 * p.72;
  _Bool D.28906;
  long int D.28907;
  long int D.28908;
  <unnamed type> command_set.73;
  const char * D.28918;
  int D.28919;
  long unsigned int D.28920;
  sizetype D.28927;
  sizetype D.28928;
  _Bool D.28929;
  _Bool D.28930;
  _Bool D.28931;
  int err.74;
  unsigned int command.75;
  unsigned int D.28940;
  _Bool D.28944;
  _Bool D.28945;
  _Bool D.28946;
  int vm_death_event_sent.76;
  int D.28954;
  _Bool D.28957;
  long int D.28958;
  long int D.28959;
  guint32 D.28962;
  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.28878 = log_level.69 > 0;
      D.28879 = (long int) D.28878;
      D.28880 = __builtin_expect (D.28879, 0);
      if (D.28880 != 0) goto <D.28881>; else goto <D.28882>;
      <D.28881>:
      D.28883 = GetCurrentThreadId ();
      D.28884 = (void *) D.28883;
      log_file.70 = log_file;
      fprintf (log_file.70, "[dbg] Agent thread started, pid=%p\n", D.28884);
      log_file.70 = log_file;
      fflush (log_file.70);
      <D.28882>:
      debugger_thread_id.71 = GetCurrentThreadId ();
      debugger_thread_id = debugger_thread_id.71;
      D.28887 = mono_get_root_domain ();
      mono_jit_thread_attach (D.28887);
      D.28888 = mono_thread_internal_current ();
      D.28889 = D.28888->flags;
      D.28890 = D.28889 | 1;
      D.28888->flags = D.28890;
      mono_set_is_debugger_attached (1);
      D.28891 = agent_config.defer;
      if (D.28891 != 0) goto <D.28892>; else goto <D.28893>;
      <D.28892>:
      D.28894 = wait_for_attach ();
      if (D.28894 == 0) goto <D.28895>; else goto <D.28896>;
      <D.28895>:
      log_level.69 = log_level;
      D.28878 = log_level.69 > 0;
      D.28879 = (long int) D.28878;
      D.28880 = __builtin_expect (D.28879, 0);
      if (D.28880 != 0) goto <D.28897>; else goto <D.28898>;
      <D.28897>:
      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.28898>:
      attach_failed = 1;
      goto <D.28899>;
      <D.28896>:
      D.28900 = mono_thread_get_main ();
      process_profiler_event (0, D.28900);
      <D.28899>:
      <D.28893>:
      goto <D.27884>;
      <D.27883>:
      res = transport_recv (&header, 11);
      if (res != 11) goto <D.28901>; else goto <D.28902>;
      <D.28901>:
      log_level.69 = log_level;
      D.28878 = log_level.69 > 0;
      D.28879 = (long int) D.28878;
      D.28880 = __builtin_expect (D.28879, 0);
      if (D.28880 != 0) goto <D.28903>; else goto <D.28904>;
      <D.28903>:
      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.28904>:
      goto <D.27866>;
      <D.28902>:
      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.28906 = flags != 0;
      D.28907 = (long int) D.28906;
      D.28908 = __builtin_expect (D.28907, 0);
      if (D.28908 != 0) goto <D.28909>; else goto <D.28910>;
      <D.28909>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 9156, "flags == 0");
      <D.28910>:
      log_level.69 = log_level;
      if (log_level.69 != 0) goto <D.28911>; else goto <D.28912>;
      <D.28911>:
      {
        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.28914>; else goto <D.28915>;
            <D.28914>:
            sprintf (&cmd_num, "%d", command);
            cmd_str = &cmd_num;
            <D.28915>:
            log_level.69 = log_level;
            D.28878 = log_level.69 > 0;
            D.28879 = (long int) D.28878;
            D.28880 = __builtin_expect (D.28879, 0);
            if (D.28880 != 0) goto <D.28916>; else goto <D.28917>;
            <D.28916>:
            command_set.73 = (<unnamed type>) command_set;
            D.28918 = command_set_to_string (command_set.73);
            log_file.70 = log_file;
            fprintf (log_file.70, "[dbg] Command %s(%s) [%d].\n", D.28918, cmd_str, id);
            log_file.70 = log_file;
            fflush (log_file.70);
            <D.28917>:
          }
        finally
          {
            cmd_num = {CLOBBER};
          }
      }
      <D.28912>:
      D.28919 = len + -11;
      D.28920 = (long unsigned int) D.28919;
      data = monoeg_malloc (D.28920);
      if (len > 11) goto <D.28921>; else goto <D.28922>;
      <D.28921>:
      D.28919 = len + -11;
      res = transport_recv (data, D.28919);
      D.28919 = len + -11;
      if (D.28919 != res) goto <D.28923>; else goto <D.28924>;
      <D.28923>:
      log_level.69 = log_level;
      D.28878 = log_level.69 > 0;
      D.28879 = (long int) D.28878;
      D.28880 = __builtin_expect (D.28879, 0);
      if (D.28880 != 0) goto <D.28925>; else goto <D.28926>;
      <D.28925>:
      D.28919 = len + -11;
      log_file.70 = log_file;
      fprintf (log_file.70, "[dbg] transport_recv () returned %d, expected %d.\n", res, D.28919);
      log_file.70 = log_file;
      fflush (log_file.70);
      <D.28926>:
      goto <D.27866>;
      <D.28924>:
      <D.28922>:
      p = data;
      D.28927 = (sizetype) len;
      D.28928 = D.28927 + 18446744073709551605;
      end = data + D.28928;
      buffer_init (&buf, 128);
      err = 0;
      no_reply = 0;
      switch (command_set) <default: <D.27882>, case 1: <D.27869>, case 9: <D.27881>, case 10: <D.27880>, case 11: <D.27877>, case 13: <D.27879>, case 15: <D.27871>, case 16: <D.27878>, case 20: <D.27872>, case 21: <D.27873>, case 22: <D.27876>, case 23: <D.27875>, case 24: <D.27874>>
      <D.27869>:
      p.72 = p;
      err = vm_commands (command, id, p.72, end, &buf);
      D.28929 = err == 0;
      D.28930 = command == 7;
      D.28931 = D.28929 & D.28930;
      if (D.28931 != 0) goto <D.28932>; else goto <D.28933>;
      <D.28932>:
      no_reply = 1;
      <D.28933>:
      goto <D.27870>;
      <D.27871>:
      p.72 = p;
      err = event_commands (command, p.72, end, &buf);
      goto <D.27870>;
      <D.27872>:
      p.72 = p;
      err = domain_commands (command, p.72, end, &buf);
      goto <D.27870>;
      <D.27873>:
      p.72 = p;
      err = assembly_commands (command, p.72, end, &buf);
      goto <D.27870>;
      <D.27874>:
      p.72 = p;
      err = module_commands (command, p.72, end, &buf);
      goto <D.27870>;
      <D.27875>:
      p.72 = p;
      err = type_commands (command, p.72, end, &buf);
      goto <D.27870>;
      <D.27876>:
      p.72 = p;
      err = method_commands (command, p.72, end, &buf);
      goto <D.27870>;
      <D.27877>:
      p.72 = p;
      err = thread_commands (command, p.72, end, &buf);
      goto <D.27870>;
      <D.27878>:
      p.72 = p;
      err = frame_commands (command, p.72, end, &buf);
      goto <D.27870>;
      <D.27879>:
      p.72 = p;
      err = array_commands (command, p.72, end, &buf);
      goto <D.27870>;
      <D.27880>:
      p.72 = p;
      err = string_commands (command, p.72, end, &buf);
      goto <D.27870>;
      <D.27881>:
      p.72 = p;
      err = object_commands (command, p.72, end, &buf);
      goto <D.27870>;
      <D.27882>:
      err = 100;
      <D.27870>:
      if (no_reply == 0) goto <D.28934>; else goto <D.28935>;
      <D.28934>:
      err.74 = (int) err;
      send_reply_packet (id, err.74, &buf);
      <D.28935>:
      monoeg_g_free (data);
      buffer_free (&buf);
      if (command_set == 1) goto <D.28937>; else goto <D.28938>;
      <D.28937>:
      command.75 = (unsigned int) command;
      D.28940 = command.75 + 4294967291;
      if (D.28940 <= 1) goto <D.27866>; else goto <D.28941>;
      <D.28941>:
      <D.28938>:
      <D.27884>:
      if (attach_failed == 0) goto <D.27883>; else goto <D.27866>;
      <D.27866>:
      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.28878 = log_level.69 > 0;
      D.28879 = (long int) D.28878;
      D.28880 = __builtin_expect (D.28879, 0);
      if (D.28880 != 0) goto <D.28942>; else goto <D.28943>;
      <D.28942>:
      log_file.70 = log_file;
      fprintf (log_file.70, "[dbg] Debugger thread exited.\n");
      log_file.70 = log_file;
      fflush (log_file.70);
      <D.28943>:
      D.28944 = attach_failed == 0;
      D.28945 = command_set == 1;
      D.28946 = D.28944 & D.28945;
      if (D.28946 != 0) goto <D.28947>; else goto <D.28948>;
      <D.28947>:
      if (command == 6) goto <D.28949>; else goto <D.28950>;
      <D.28949>:
      vm_death_event_sent.76 = vm_death_event_sent;
      if (vm_death_event_sent.76 == 0) goto <D.28952>; else goto <D.28953>;
      <D.28952>:
      D.28954 = mono_runtime_is_shutting_down ();
      if (D.28954 == 0) goto <D.28955>; else goto <D.28956>;
      <D.28955>:
      log_level.69 = log_level;
      D.28957 = log_level.69 > 1;
      D.28958 = (long int) D.28957;
      D.28959 = __builtin_expect (D.28958, 0);
      if (D.28959 != 0) goto <D.28960>; else goto <D.28961>;
      <D.28960>:
      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.28961>:
      start_debugger_thread ();
      <D.28956>:
      <D.28953>:
      <D.28950>:
      <D.28948>:
      D.28962 = 0;
      return D.28962;
    }
  finally
    {
      header = {CLOBBER};
      p = {CLOBBER};
      buf = {CLOBBER};
    }
}


wait_for_attach ()
{
  int listen_fd.77;
  int log_level.78;
  _Bool D.28969;
  long int D.28970;
  long int D.28971;
  struct FILE * log_file.79;
  gboolean D.28975;
  int conn_fd.80;
  int conn_fd.81;
  int D.28984;
  _Bool D.28985;
  int disconnected.82;
  int disconnected.83;

  listen_fd.77 = listen_fd;
  if (listen_fd.77 == -1) goto <D.28966>; else goto <D.28967>;
  <D.28966>:
  log_level.78 = log_level;
  D.28969 = log_level.78 > 0;
  D.28970 = (long int) D.28969;
  D.28971 = __builtin_expect (D.28970, 0);
  if (D.28971 != 0) goto <D.28972>; else goto <D.28973>;
  <D.28972>:
  log_file.79 = log_file;
  fprintf (log_file.79, "[dbg] Invalid listening socket\n");
  log_file.79 = log_file;
  fflush (log_file.79);
  <D.28973>:
  D.28975 = 0;
  return D.28975;
  <D.28967>:
  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.28969 = log_level.78 > 0;
  D.28970 = (long int) D.28969;
  D.28971 = __builtin_expect (D.28970, 0);
  if (D.28971 != 0) goto <D.28977>; else goto <D.28978>;
  <D.28977>:
  conn_fd.81 = conn_fd;
  log_file.79 = log_file;
  fprintf (log_file.79, "Accepted connection on %d\n", conn_fd.81);
  log_file.79 = log_file;
  fflush (log_file.79);
  <D.28978>:
  conn_fd.81 = conn_fd;
  if (conn_fd.81 == -1) goto <D.28980>; else goto <D.28981>;
  <D.28980>:
  log_level.78 = log_level;
  D.28969 = log_level.78 > 0;
  D.28970 = (long int) D.28969;
  D.28971 = __builtin_expect (D.28970, 0);
  if (D.28971 != 0) goto <D.28982>; else goto <D.28983>;
  <D.28982>:
  log_file.79 = log_file;
  fprintf (log_file.79, "[dbg] Bad client connection\n");
  log_file.79 = log_file;
  fflush (log_file.79);
  <D.28983>:
  D.28975 = 0;
  return D.28975;
  <D.28981>:
  D.28984 = transport_handshake ();
  D.28985 = D.28984 == 0;
  disconnected.82 = (int) D.28985;
  disconnected = disconnected.82;
  disconnected.83 = disconnected;
  if (disconnected.83 != 0) goto <D.28988>; else goto <D.28989>;
  <D.28988>:
  log_level.78 = log_level;
  D.28969 = log_level.78 > 0;
  D.28970 = (long int) D.28969;
  D.28971 = __builtin_expect (D.28970, 0);
  if (D.28971 != 0) goto <D.28990>; else goto <D.28991>;
  <D.28990>:
  log_file.79 = log_file;
  fprintf (log_file.79, "Transport handshake failed!\n");
  log_file.79 = log_file;
  fflush (log_file.79);
  <D.28991>:
  D.28975 = 0;
  return D.28975;
  <D.28989>:
  D.28975 = 1;
  return D.28975;
}


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.28993;
  int conn_fd.84;
  int conn_fd.85;
  struct _IO_FILE * stderr.86;
  int log_level.87;
  _Bool D.29001;
  long int D.29002;
  long int D.29003;
  struct FILE * log_file.88;
  int D.29007;

  D.28993.__sockaddr__ = 0B;
  conn_fd.84 = accept (socket_fd, D.28993, 0B);
  conn_fd = conn_fd.84;
  conn_fd.85 = conn_fd;
  if (conn_fd.85 == -1) goto <D.28996>; else goto <D.28997>;
  <D.28996>:
  stderr.86 = stderr;
  fprintf (stderr.86, "debugger-agent: Unable to listen on %d\n", socket_fd);
  goto <D.28999>;
  <D.28997>:
  log_level.87 = log_level;
  D.29001 = log_level.87 > 0;
  D.29002 = (long int) D.29001;
  D.29003 = __builtin_expect (D.29002, 0);
  if (D.29003 != 0) goto <D.29004>; else goto <D.29005>;
  <D.29004>:
  conn_fd.85 = conn_fd;
  log_file.88 = log_file;
  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.29005>:
  <D.28999>:
  D.29007 = conn_fd;
  return D.29007;
}


transport_handshake ()
{
  long unsigned int D.29009;
  int D.29010;
  int * D.29012;
  int D.29013;
  _Bool D.29014;
  long int D.29015;
  long int D.29016;
  long unsigned int D.29019;
  int D.29020;
  long unsigned int D.29023;
  long unsigned int D.29024;
  char[128] * handshake_msg.89;
  char D.29027;
  _Bool D.29028;
  long unsigned int D.29029;
  int D.29030;
  struct _IO_FILE * stderr.90;
  gboolean D.29032;
  int conn_fd.91;
  _Bool D.29036;
  long int D.29037;
  long int D.29038;
  char handshake_msg[128];
  guint8 buf[128];
  int res;

  try
    {
      disconnected = 1;
      sprintf (&handshake_msg, "DWP-Handshake");
      <D.25399>:
      D.29009 = strlen (&handshake_msg);
      D.29010 = (int) D.29009;
      res = transport_send (&handshake_msg, D.29010);
      if (res == -1) goto <D.29011>; else goto <D.25400>;
      <D.29011>:
      D.29012 = __errno_location ();
      D.29013 = *D.29012;
      if (D.29013 == 4) goto <D.25399>; else goto <D.25400>;
      <D.25400>:
      D.29014 = res == -1;
      D.29015 = (long int) D.29014;
      D.29016 = __builtin_expect (D.29015, 0);
      if (D.29016 != 0) goto <D.29017>; else goto <D.29018>;
      <D.29017>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 1498, "res != -1");
      <D.29018>:
      D.29019 = strlen (&handshake_msg);
      D.29020 = (int) D.29019;
      res = transport_recv (&buf, D.29020);
      D.29023 = (long unsigned int) res;
      D.29024 = strlen (&handshake_msg);
      if (D.29023 != D.29024) goto <D.29021>; else goto <D.29025>;
      <D.29025>:
      handshake_msg.89 = &handshake_msg;
      D.29027 = MEM[(const char *)handshake_msg.89];
      D.29028 = D.29027 != 0;
      D.29029 = (long unsigned int) D.29028;
      D.29030 = memcmp (&buf, &handshake_msg, D.29029);
      if (D.29030 != 0) goto <D.29021>; else goto <D.29022>;
      <D.29021>:
      stderr.90 = stderr;
      fprintf (stderr.90, "debugger-agent: DWP handshake failed.\n");
      D.29032 = 0;
      return D.29032;
      <D.29022>:
      major_version = 2;
      minor_version = 27;
      protocol_version_set = 0;
      conn_fd.91 = conn_fd;
      if (conn_fd.91 != 0) goto <D.29034>; else goto <D.29035>;
      <D.29034>:
      {
        int flag;
        int result;

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


transport_send (void * buf, int len)
{
  int D.29043;
  struct DebuggerTransport * transport.92;
  gboolean (*<T3f5e>) (void *, int) D.29045;

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


set_keepalive ()
{
  int D.29049;
  int conn_fd.93;
  int D.29052;
  long int D.29053;
  int D.29054;
  int D.29055;
  long int D.29056;
  _Bool D.29057;
  long int D.29058;
  long int D.29059;
  struct timeval tv;
  int result;

  try
    {
      D.29049 = agent_config.keepalive;
      if (D.29049 == 0) goto <D.29047>; else goto <D.29050>;
      <D.29050>:
      conn_fd.93 = conn_fd;
      if (conn_fd.93 == 0) goto <D.29047>; else goto <D.29048>;
      <D.29047>:
      return;
      <D.29048>:
      D.29049 = agent_config.keepalive;
      D.29052 = D.29049 / 1000;
      D.29053 = (long int) D.29052;
      tv.tv_sec = D.29053;
      D.29049 = agent_config.keepalive;
      D.29054 = D.29049 % 1000;
      D.29055 = D.29054 * 1000;
      D.29056 = (long int) D.29055;
      tv.tv_usec = D.29056;
      conn_fd.93 = conn_fd;
      result = setsockopt (conn_fd.93, 1, 20, &tv, 16);
      D.29057 = result < 0;
      D.29058 = (long int) D.29057;
      D.29059 = __builtin_expect (D.29058, 0);
      if (D.29059 != 0) goto <D.29060>; else goto <D.29061>;
      <D.29060>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 1126, "result >= 0");
      <D.29061>:
    }
  finally
    {
      tv = {CLOBBER};
    }
}


decode_int (guint8 * buf, guint8 * * endbuf, guint8 * limit)
{
  guint8 * D.29065;
  guint8 * D.29066;
  _Bool D.29067;
  long int D.29068;
  long int D.29069;
  int D.29072;
  unsigned char D.29073;
  int D.29074;
  int D.29075;
  guint8 * D.29076;
  unsigned char D.29077;
  int D.29078;
  int D.29079;
  int D.29080;
  guint8 * D.29081;
  unsigned char D.29082;
  int D.29083;
  int D.29084;
  int D.29085;
  guint8 * D.29086;
  unsigned char D.29087;
  int D.29088;

  D.29065 = buf + 4;
  *endbuf = D.29065;
  D.29066 = *endbuf;
  D.29067 = D.29066 > limit;
  D.29068 = (long int) D.29067;
  D.29069 = __builtin_expect (D.29068, 0);
  if (D.29069 != 0) goto <D.29070>; else goto <D.29071>;
  <D.29070>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 1599, "*endbuf <= limit");
  <D.29071>:
  D.29073 = *buf;
  D.29074 = (int) D.29073;
  D.29075 = D.29074 << 24;
  D.29076 = buf + 1;
  D.29077 = *D.29076;
  D.29078 = (int) D.29077;
  D.29079 = D.29078 << 16;
  D.29080 = D.29075 | D.29079;
  D.29081 = buf + 2;
  D.29082 = *D.29081;
  D.29083 = (int) D.29082;
  D.29084 = D.29083 << 8;
  D.29085 = D.29080 | D.29084;
  D.29086 = buf + 3;
  D.29087 = *D.29086;
  D.29088 = (int) D.29087;
  D.29072 = D.29085 | D.29088;
  return D.29072;
}


decode_byte (guint8 * buf, guint8 * * endbuf, guint8 * limit)
{
  guint8 * D.29090;
  guint8 * D.29091;
  _Bool D.29092;
  long int D.29093;
  long int D.29094;
  int D.29097;
  unsigned char D.29098;

  D.29090 = buf + 1;
  *endbuf = D.29090;
  D.29091 = *endbuf;
  D.29092 = D.29091 > limit;
  D.29093 = (long int) D.29092;
  D.29094 = __builtin_expect (D.29093, 0);
  if (D.29094 != 0) goto <D.29095>; else goto <D.29096>;
  <D.29095>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 1591, "*endbuf <= limit");
  <D.29096>:
  D.29098 = *buf;
  D.29097 = (int) D.29098;
  return D.29097;
}


cmd_to_string (CommandSet set, int command)
{
  const char * D.29100;
  _Bool D.29101;
  _Bool D.29102;
  _Bool D.29103;
  long unsigned int D.29106;
  long unsigned int D.29107;
  sizetype D.29108;
  const char * * D.29109;
  const char * * cmds;
  int cmds_len;

  cmds_len = 0;
  switch (set) <default: <D.27845>, case 1: <D.27831>, case 9: <D.27833>, case 10: <D.27834>, case 11: <D.27835>, case 13: <D.27836>, case 15: <D.27837>, case 16: <D.27838>, case 20: <D.27839>, case 21: <D.27840>, case 22: <D.27841>, case 23: <D.27842>, case 24: <D.27843>, case 64: <D.27844>>
  <D.27831>:
  cmds = &vm_cmds_str;
  cmds_len = 12;
  goto <D.27832>;
  <D.27833>:
  cmds = &object_cmds_str;
  cmds_len = 7;
  goto <D.27832>;
  <D.27834>:
  cmds = &string_cmds_str;
  cmds_len = 3;
  goto <D.27832>;
  <D.27835>:
  cmds = &thread_cmds_str;
  cmds_len = 6;
  goto <D.27832>;
  <D.27836>:
  cmds = &array_cmds_str;
  cmds_len = 3;
  goto <D.27832>;
  <D.27837>:
  cmds = &event_cmds_str;
  cmds_len = 3;
  goto <D.27832>;
  <D.27838>:
  cmds = &stack_frame_cmds_str;
  cmds_len = 3;
  goto <D.27832>;
  <D.27839>:
  cmds = &appdomain_cmds_str;
  cmds_len = 7;
  goto <D.27832>;
  <D.27840>:
  cmds = &assembly_cmds_str;
  cmds_len = 6;
  goto <D.27832>;
  <D.27841>:
  cmds = &method_cmds_str;
  cmds_len = 10;
  goto <D.27832>;
  <D.27842>:
  cmds = &type_cmds_str;
  cmds_len = 18;
  goto <D.27832>;
  <D.27843>:
  cmds = &module_cmds_str;
  cmds_len = 1;
  goto <D.27832>;
  <D.27844>:
  cmds = &event_cmds_str;
  cmds_len = 3;
  goto <D.27832>;
  <D.27845>:
  D.29100 = 0B;
  return D.29100;
  <D.27832>:
  D.29101 = command > 0;
  D.29102 = command <= cmds_len;
  D.29103 = D.29101 & D.29102;
  if (D.29103 != 0) goto <D.29104>; else goto <D.29105>;
  <D.29104>:
  D.29106 = (long unsigned int) command;
  D.29107 = D.29106 * 8;
  D.29108 = D.29107 + 18446744073709551608;
  D.29109 = cmds + D.29108;
  D.29100 = *D.29109;
  return D.29100;
  <D.29105>:
  D.29100 = 0B;
  return D.29100;
}


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

  D.29112 = __builtin_object_size (__s, 1);
  D.29111 = __builtin___sprintf_chk (__s, 1, D.29112, __fmt, __builtin_va_arg_pack ());
  return D.29111;
}


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

  switch (command_set) <default: <D.27812>, case 1: <D.27799>, case 9: <D.27800>, case 10: <D.27801>, case 11: <D.27802>, case 13: <D.27803>, case 15: <D.27804>, case 16: <D.27805>, case 20: <D.27806>, case 21: <D.27807>, case 22: <D.27808>, case 23: <D.27809>, case 24: <D.27810>, case 64: <D.27811>>
  <D.27799>:
  D.29114 = "VM";
  return D.29114;
  <D.27800>:
  D.29114 = "OBJECT_REF";
  return D.29114;
  <D.27801>:
  D.29114 = "STRING_REF";
  return D.29114;
  <D.27802>:
  D.29114 = "THREAD";
  return D.29114;
  <D.27803>:
  D.29114 = "ARRAY_REF";
  return D.29114;
  <D.27804>:
  D.29114 = "EVENT_REQUEST";
  return D.29114;
  <D.27805>:
  D.29114 = "STACK_FRAME";
  return D.29114;
  <D.27806>:
  D.29114 = "APPDOMAIN";
  return D.29114;
  <D.27807>:
  D.29114 = "ASSEMBLY";
  return D.29114;
  <D.27808>:
  D.29114 = "METHOD";
  return D.29114;
  <D.27809>:
  D.29114 = "TYPE";
  return D.29114;
  <D.27810>:
  D.29114 = "MODULE";
  return D.29114;
  <D.27811>:
  D.29114 = "EVENT";
  return D.29114;
  <D.27812>:
  D.29114 = "";
  return D.29114;
}


transport_recv (void * buf, int len)
{
  int D.29116;
  struct DebuggerTransport * transport.94;
  int (*<T3f5f>) (void *, int) D.29118;

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


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.29124;
  long int D.29125;
  long int D.29126;
  int minor_version.99;
  int major_version.100;
  struct FILE * log_file.101;
  struct MonoGHashTable * tid_to_thread_obj.102;
  unsigned int D.29133;
  int suspend_count.103;
  ErrorCode D.29137;
  struct GPtrArray * event_requests.104;
  void * * D.29139;
  int D.29140;
  int D.29141;
  unsigned int D.29142;
  int D.29143;
  int D.29144;
  struct MonoImage * D.29145;
  struct MonoGHashTable * tid_to_thread.105;
  _Bool D.29149;
  _Bool D.29150;
  _Bool D.29151;
  struct MonoGHashTable * thread_to_tls.106;
  void * D.29155;
  void * D.29156;
  void * D.29157;
  struct InvokeData * D.29158;
  int D.29160;
  <unnamed type> D.29168;
  int D.29176;
  struct MonoThread * thread.107;
  struct _MonoInternalThread * D.29180;
  _Bool D.29181;
  long int D.29182;
  long int D.29183;
  int D.29186;
  struct InvokeData * D.29189;
  void * D.29192;
  long int end.108;
  long int p.109;
  long int D.29195;
  long unsigned int D.29196;
  void * D.29197;
  long unsigned int D.29198;
  guint8 * D.29199;
  sizetype D.29200;
  guint8 * D.29201;
  unsigned int suspend_count.110;
  int D.29203;
  <unnamed type> D.29207;
  struct MonoThread * thread.111;
  struct _MonoInternalThread * D.29211;
  _Bool D.29212;
  long int D.29213;
  long int D.29214;
  int D.29217;
  struct InvokeData * D.29222;
  int D.29224;
  struct GHashTable * domains.112;
  struct MonoDomain * domain.113;
  void * D.29227;
  struct GHashTable * D.29228;
  struct MonoClass * klass.114;
  struct GHashTable * D.29230;
  void * D.29231;
  void * * D.29234;
  long unsigned int D.29235;
  long unsigned int D.29236;
  void * * D.29237;
  struct GHashTable * D.29238;
  gchar * D.29241;
  struct GHashTable * D.29243;
  gchar * D.29246;
  unsigned int i.115;
  unsigned int D.29249;
  int D.29250;
  void * klass.116;
  int D.29255;
  unsigned int D.29256;
  void * * D.29257;
  void * * D.29258;
  void * D.29259;
  void * * D.29260;
  void * * D.29261;
  void * D.29262;
  int D.29263;
  struct MonoDomain * domain.117;
  union mono_mutex_t * D.29267;
  _Bool D.29270;
  long int D.29271;
  long int D.29272;
  struct MonoImage * D.29275;
  struct MonoClass * D.29280;
  _Bool D.29283;
  long int D.29284;
  long int D.29285;
  int D.29288;
  unsigned int D.29289;
  void * * D.29290;
  long unsigned int D.29291;
  long unsigned int D.29292;
  void * * D.29293;
  void * D.29294;
  void * * D.29295;
  void * * D.29296;
  void * D.29297;
  unsigned int i.118;

  switch (command) <default: <D.27151>, case 1: <D.27039>, case 2: <D.27044>, case 3: <D.27045>, case 4: <D.27046>, case 5: <D.27055>, case 6: <D.27047>, case 7: <D.27072>, case 8: <D.27043>, case 9: <D.27085>, case 10: <D.27091>, case 11: <D.27093>, case 12: <D.27127>, case 13: <D.27073>>
  <D.27039>:
  {
    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.27042>;
  }
  <D.27043>:
  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.29124 = log_level.98 > 0;
  D.29125 = (long int) D.29124;
  D.29126 = __builtin_expect (D.29125, 0);
  if (D.29126 != 0) goto <D.29127>; else goto <D.29128>;
  <D.29127>:
  minor_version.99 = minor_version;
  major_version.100 = major_version;
  log_file.101 = log_file;
  fprintf (log_file.101, "[dbg] Protocol version %d.%d, client protocol version %d.%d.\n", 2, 27, major_version.100, minor_version.99);
  log_file.101 = log_file;
  fflush (log_file.101);
  <D.29128>:
  goto <D.27042>;
  <D.27044>:
  mono_loader_lock ();
  tid_to_thread_obj.102 = tid_to_thread_obj;
  D.29133 = mono_g_hash_table_size (tid_to_thread_obj.102);
  buffer_add_int (buf, D.29133);
  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.27042>;
  <D.27045>:
  suspend_vm ();
  wait_for_suspend ();
  goto <D.27042>;
  <D.27046>:
  suspend_count.103 = suspend_count;
  if (suspend_count.103 == 0) goto <D.29135>; else goto <D.29136>;
  <D.29135>:
  D.29137 = 101;
  return D.29137;
  <D.29136>:
  resume_vm ();
  clear_suspended_objs ();
  goto <D.27042>;
  <D.27047>:
  mono_loader_lock ();
  goto <D.27050>;
  <D.27049>:
  {
    struct EventRequest * req;

    event_requests.104 = event_requests;
    D.29139 = event_requests.104->pdata;
    req = *D.29139;
    D.29140 = req->event_kind;
    D.29141 = req->id;
    clear_event_request (D.29141, D.29140);
  }
  <D.27050>:
  event_requests.104 = event_requests;
  D.29142 = event_requests.104->len;
  if (D.29142 != 0) goto <D.27049>; else goto <D.27051>;
  <D.27051>:
  mono_loader_unlock ();
  goto <D.27053>;
  <D.27052>:
  resume_vm ();
  <D.27053>:
  suspend_count.103 = suspend_count;
  if (suspend_count.103 > 0) goto <D.27052>; else goto <D.27054>;
  <D.27054>:
  disconnected = 1;
  vm_start_event_sent = 0;
  goto <D.27042>;
  <D.27055>:
  {
    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.27064>;
    <D.27063>:
    {
      struct EventRequest * req;

      event_requests.104 = event_requests;
      D.29139 = event_requests.104->pdata;
      req = *D.29139;
      D.29143 = req->event_kind;
      D.29144 = req->id;
      clear_event_request (D.29144, D.29143);
    }
    <D.27064>:
    event_requests.104 = event_requests;
    D.29142 = event_requests.104->len;
    if (D.29142 != 0) goto <D.27063>; else goto <D.27065>;
    <D.27065>:
    mono_loader_unlock ();
    suspend_vm ();
    wait_for_suspend ();
    D.29145 = mono_defaults.corlib;
    env_class = mono_class_from_name (D.29145, "System", "Environment");
    if (env_class != 0B) goto <D.29146>; else goto <D.29147>;
    <D.29146>:
    exit_method = mono_class_get_method_from_name (env_class, "Exit", 1);
    <D.29147>:
    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 ();
    D.29149 = thread != 0B;
    D.29150 = exit_method != 0B;
    D.29151 = D.29149 & D.29150;
    if (D.29151 != 0) goto <D.29152>; else goto <D.29153>;
    <D.29152>:
    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.29155 = monoeg_malloc (4);
    *args = D.29155;
    D.29156 = *args;
    MEM[(int *)D.29156] = exit_code;
    D.29157 = monoeg_malloc0 (200);
    tls->pending_invoke = D.29157;
    D.29158 = tls->pending_invoke;
    D.29158->method = exit_method;
    D.29158 = tls->pending_invoke;
    D.29158->args = args;
    D.29158 = tls->pending_invoke;
    D.29158->nmethods = 1;
    goto <D.27067>;
    <D.27066>:
    resume_vm ();
    <D.27067>:
    suspend_count.103 = suspend_count;
    if (suspend_count.103 > 0) goto <D.27066>; else goto <D.27068>;
    <D.27068>:
    goto <D.29159>;
    <D.29153>:
    goto <D.27070>;
    <D.27069>:
    resume_vm ();
    <D.27070>:
    suspend_count.103 = suspend_count;
    if (suspend_count.103 > 0) goto <D.27069>; else goto <D.27071>;
    <D.27071>:
    D.29160 = mono_runtime_try_shutdown ();
    if (D.29160 == 0) goto <D.27042>; else goto <D.29161>;
    <D.29161>:
    mono_environment_exitcode_set (exit_code);
    log_level.98 = log_level;
    D.29124 = log_level.98 > 0;
    D.29125 = (long int) D.29124;
    D.29126 = __builtin_expect (D.29125, 0);
    if (D.29126 != 0) goto <D.29162>; else goto <D.29163>;
    <D.29162>:
    log_file.101 = log_file;
    fprintf (log_file.101, "Suspending all threads...\n");
    log_file.101 = log_file;
    fflush (log_file.101);
    <D.29163>:
    mono_thread_suspend_all_other_threads ();
    log_level.98 = log_level;
    D.29124 = log_level.98 > 0;
    D.29125 = (long int) D.29124;
    D.29126 = __builtin_expect (D.29125, 0);
    if (D.29126 != 0) goto <D.29164>; else goto <D.29165>;
    <D.29164>:
    log_file.101 = log_file;
    fprintf (log_file.101, "Shutting down the runtime...\n");
    log_file.101 = log_file;
    fflush (log_file.101);
    <D.29165>:
    mono_runtime_quit ();
    transport_close2 ();
    log_level.98 = log_level;
    D.29124 = log_level.98 > 0;
    D.29125 = (long int) D.29124;
    D.29126 = __builtin_expect (D.29125, 0);
    if (D.29126 != 0) goto <D.29166>; else goto <D.29167>;
    <D.29166>:
    log_file.101 = log_file;
    fprintf (log_file.101, "Exiting...\n");
    log_file.101 = log_file;
    fflush (log_file.101);
    <D.29167>:
    exit (exit_code);
    <D.29159>:
    goto <D.27042>;
  }
  <D.27072>:
  <D.27073>:
  {
    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.29168 = get_object (objid, &thread);
        err = (int) D.29168;
        if (err != 0) goto <D.29169>; else goto <D.29170>;
        <D.29169>:
        D.29137 = (ErrorCode) err;
        return D.29137;
        <D.29170>:
        p.95 = p;
        flags = decode_int (p.95, &p, end);
        if (command == 13) goto <D.29171>; else goto <D.29172>;
        <D.29171>:
        p.95 = p;
        nmethods = decode_int (p.95, &p, end);
        goto <D.29173>;
        <D.29172>:
        nmethods = 1;
        <D.29173>:
        suspend_count.103 = suspend_count;
        if (suspend_count.103 != 0) goto <D.29174>; else goto <D.29175>;
        <D.29174>:
        wait_for_suspend ();
        <D.29175>:
        D.29176 = is_suspended ();
        if (D.29176 == 0) goto <D.29177>; else goto <D.29178>;
        <D.29177>:
        D.29137 = 101;
        return D.29137;
        <D.29178>:
        mono_loader_lock ();
        thread.107 = thread;
        D.29180 = thread.107->internal_thread;
        thread_to_tls.106 = thread_to_tls;
        tls = mono_g_hash_table_lookup (thread_to_tls.106, D.29180);
        mono_loader_unlock ();
        D.29181 = tls == 0B;
        D.29182 = (long int) D.29181;
        D.29183 = __builtin_expect (D.29182, 0);
        if (D.29183 != 0) goto <D.29184>; else goto <D.29185>;
        <D.29184>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 6722, "tls");
        <D.29185>:
        D.29186 = tls->really_suspended;
        if (D.29186 == 0) goto <D.29187>; else goto <D.29188>;
        <D.29187>:
        D.29137 = 101;
        return D.29137;
        <D.29188>:
        D.29189 = tls->pending_invoke;
        if (D.29189 != 0B) goto <D.29190>; else goto <D.29191>;
        <D.29190>:
        D.29137 = 101;
        return D.29137;
        <D.29191>:
        D.29192 = monoeg_malloc0 (200);
        tls->pending_invoke = D.29192;
        D.29189 = tls->pending_invoke;
        D.29189->id = id;
        D.29189 = tls->pending_invoke;
        D.29189->flags = flags;
        D.29189 = tls->pending_invoke;
        end.108 = (long int) end;
        p.95 = p;
        p.109 = (long int) p.95;
        D.29195 = end.108 - p.109;
        D.29196 = (long unsigned int) D.29195;
        D.29197 = monoeg_malloc (D.29196);
        D.29189->p = D.29197;
        end.108 = (long int) end;
        p.95 = p;
        p.109 = (long int) p.95;
        D.29195 = end.108 - p.109;
        D.29198 = (long unsigned int) D.29195;
        p.95 = p;
        D.29189 = tls->pending_invoke;
        D.29199 = D.29189->p;
        memcpy (D.29199, p.95, D.29198);
        D.29189 = tls->pending_invoke;
        D.29189 = tls->pending_invoke;
        D.29199 = D.29189->p;
        end.108 = (long int) end;
        p.95 = p;
        p.109 = (long int) p.95;
        D.29195 = end.108 - p.109;
        D.29200 = (sizetype) D.29195;
        D.29201 = D.29199 + D.29200;
        D.29189->endp = D.29201;
        D.29189 = tls->pending_invoke;
        suspend_count.103 = suspend_count;
        suspend_count.110 = (unsigned int) suspend_count.103;
        D.29189->suspend_count = suspend_count.110;
        D.29189 = tls->pending_invoke;
        D.29189->nmethods = nmethods;
        D.29203 = flags & 2;
        if (D.29203 != 0) goto <D.29204>; else goto <D.29205>;
        <D.29204>:
        thread.107 = thread;
        D.29180 = thread.107->internal_thread;
        resume_thread (D.29180);
        goto <D.29206>;
        <D.29205>:
        count = suspend_count;
        i = 0;
        goto <D.27083>;
        <D.27082>:
        resume_vm ();
        i = i + 1;
        <D.27083>:
        if (i < count) goto <D.27082>; else goto <D.27084>;
        <D.27084>:
        <D.29206>:
        goto <D.27042>;
      }
    finally
      {
        thread = {CLOBBER};
      }
  }
  <D.27085>:
  {
    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.29207 = get_object (objid, &thread);
        err = (int) D.29207;
        if (err != 0) goto <D.29208>; else goto <D.29209>;
        <D.29208>:
        D.29137 = (ErrorCode) err;
        return D.29137;
        <D.29209>:
        p.95 = p;
        invoke_id = decode_int (p.95, &p, end);
        mono_loader_lock ();
        thread.111 = thread;
        D.29211 = thread.111->internal_thread;
        thread_to_tls.106 = thread_to_tls;
        tls = mono_g_hash_table_lookup (thread_to_tls.106, D.29211);
        D.29212 = tls == 0B;
        D.29213 = (long int) D.29212;
        D.29214 = __builtin_expect (D.29213, 0);
        if (D.29214 != 0) goto <D.29215>; else goto <D.29216>;
        <D.29215>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 6767, "tls");
        <D.29216>:
        D.29217 = tls->abort_requested;
        if (D.29217 != 0) goto <D.29218>; else goto <D.29219>;
        <D.29218>:
        mono_loader_unlock ();
        goto <D.27042>;
        <D.29219>:
        D.29222 = tls->invoke;
        if (D.29222 == 0B) goto <D.29220>; else goto <D.29223>;
        <D.29223>:
        D.29222 = tls->invoke;
        D.29224 = D.29222->id;
        if (D.29224 != invoke_id) goto <D.29220>; else goto <D.29221>;
        <D.29220>:
        mono_loader_unlock ();
        D.29137 = 104;
        return D.29137;
        <D.29221>:
        tls->abort_requested = 1;
        thread.111 = thread;
        D.29211 = thread.111->internal_thread;
        ves_icall_System_Threading_Thread_Abort (D.29211, 0B);
        mono_loader_unlock ();
        goto <D.27042>;
      }
    finally
      {
        thread = {CLOBBER};
      }
  }
  <D.27091>:
  {
    int timeout;

    p.95 = p;
    timeout = decode_int (p.95, &p, end);
    agent_config.keepalive = timeout;
    set_keepalive ();
    goto <D.27042>;
  }
  <D.27093>:
  {
    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.27122>;
        <D.27121>:
        {
          struct AgentDomainInfo * info;

          domain.113 = domain;
          D.29227 = domain.113->runtime_info;
          info = MEM[(struct MonoJitDomainInfo *)D.29227].agent_info;
          D.29228 = info->loaded_classes;
          monoeg_g_hash_table_iter_init (&kiter, D.29228);
          goto <D.27115>;
          <D.27114>:
          klass.114 = klass;
          D.29230 = info->source_files;
          D.29231 = monoeg_g_hash_table_lookup (D.29230, klass.114);
          if (D.29231 == 0B) goto <D.29232>; else goto <D.29233>;
          <D.29232>:
          klass.114 = klass;
          files = get_source_files_for_type (klass.114);
          klass.114 = klass;
          D.29230 = info->source_files;
          monoeg_g_hash_table_insert_replace (D.29230, klass.114, files, 0);
          i = 0;
          goto <D.27112>;
          <D.27111>:
          {
            char * s;
            char * s2;
            char * s3;

            D.29234 = files->pdata;
            D.29235 = (long unsigned int) i;
            D.29236 = D.29235 * 8;
            D.29237 = D.29234 + D.29236;
            s = *D.29237;
            s2 = monoeg_g_path_get_basename (s);
            D.29238 = info->source_file_to_class;
            class_list = monoeg_g_hash_table_lookup (D.29238, s2);
            if (class_list == 0B) goto <D.29239>; else goto <D.29240>;
            <D.29239>:
            klass.114 = klass;
            class_list = monoeg_g_slist_prepend (class_list, klass.114);
            D.29241 = monoeg_strdup (s2);
            D.29238 = info->source_file_to_class;
            monoeg_g_hash_table_insert_replace (D.29238, D.29241, class_list, 0);
            goto <D.29242>;
            <D.29240>:
            klass.114 = klass;
            class_list = monoeg_g_slist_prepend (class_list, klass.114);
            D.29238 = info->source_file_to_class;
            monoeg_g_hash_table_insert_replace (D.29238, s2, class_list, 0);
            <D.29242>:
            s3 = strdup_tolower (s2);
            D.29243 = info->source_file_to_class_ignorecase;
            class_list = monoeg_g_hash_table_lookup (D.29243, s3);
            if (class_list == 0B) goto <D.29244>; else goto <D.29245>;
            <D.29244>:
            klass.114 = klass;
            class_list = monoeg_g_slist_prepend (class_list, klass.114);
            D.29246 = monoeg_strdup (s3);
            D.29243 = info->source_file_to_class_ignorecase;
            monoeg_g_hash_table_insert_replace (D.29243, D.29246, class_list, 0);
            goto <D.29247>;
            <D.29245>:
            klass.114 = klass;
            class_list = monoeg_g_slist_prepend (class_list, klass.114);
            D.29243 = info->source_file_to_class_ignorecase;
            monoeg_g_hash_table_insert_replace (D.29243, s3, class_list, 0);
            <D.29247>:
            monoeg_g_free (s2);
            monoeg_g_free (s3);
          }
          i = i + 1;
          <D.27112>:
          i.115 = (unsigned int) i;
          D.29249 = files->len;
          if (i.115 < D.29249) goto <D.27111>; else goto <D.27113>;
          <D.27113>:
          <D.29233>:
          <D.27115>:
          D.29250 = monoeg_g_hash_table_iter_next (&kiter, 0B, &klass);
          if (D.29250 != 0) goto <D.27114>; else goto <D.27116>;
          <D.27116>:
          if (ignore_case != 0) goto <D.29251>; else goto <D.29252>;
          <D.29251>:
          {
            char * s;

            s = strdup_tolower (basename);
            D.29243 = info->source_file_to_class_ignorecase;
            class_list = monoeg_g_hash_table_lookup (D.29243, s);
            monoeg_g_free (s);
          }
          goto <D.29253>;
          <D.29252>:
          D.29238 = info->source_file_to_class;
          class_list = monoeg_g_hash_table_lookup (D.29238, basename);
          <D.29253>:
          l = class_list;
          goto <D.27119>;
          <D.27118>:
          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.27119>:
          if (l != 0B) goto <D.27118>; else goto <D.27120>;
          <D.27120>:
        }
        <D.27122>:
        D.29255 = monoeg_g_hash_table_iter_next (&iter, 0B, &domain);
        if (D.29255 != 0) goto <D.27121>; else goto <D.27123>;
        <D.27123>:
        mono_loader_unlock ();
        monoeg_g_free (fname);
        monoeg_g_free (basename);
        D.29256 = res_classes->len;
        buffer_add_int (buf, D.29256);
        i = 0;
        goto <D.27125>;
        <D.27124>:
        D.29257 = res_classes->pdata;
        D.29235 = (long unsigned int) i;
        D.29236 = D.29235 * 8;
        D.29258 = D.29257 + D.29236;
        D.29259 = *D.29258;
        D.29260 = res_domains->pdata;
        D.29235 = (long unsigned int) i;
        D.29236 = D.29235 * 8;
        D.29261 = D.29260 + D.29236;
        D.29262 = *D.29261;
        buffer_add_typeid (buf, D.29262, D.29259);
        i = i + 1;
        <D.27125>:
        i.115 = (unsigned int) i;
        D.29256 = res_classes->len;
        if (i.115 < D.29256) goto <D.27124>; else goto <D.27126>;
        <D.27126>:
        monoeg_g_ptr_array_free (res_classes, 1);
        monoeg_g_ptr_array_free (res_domains, 1);
        goto <D.27042>;
      }
    finally
      {
        iter = {CLOBBER};
        kiter = {CLOBBER};
        domain = {CLOBBER};
        klass = {CLOBBER};
      }
  }
  <D.27127>:
  {
    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.29263 = mono_reflection_parse_type (name, &info);
        if (D.29263 == 0) goto <D.29264>; else goto <D.29265>;
        <D.29264>:
        monoeg_g_free (name);
        mono_reflection_free_type_info (&info);
        D.29137 = 102;
        return D.29137;
        <D.29265>:
        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.27146>;
        <D.27145>:
        {
          struct MonoAssembly * ass;
          gboolean type_resolve;
          struct MonoType * t;
          struct GSList * tmp;

          try
            {
              {
                int ret;

                domain.117 = domain;
                D.29267 = &domain.117->assemblies_lock.mutex;
                ret = pthread_mutex_lock (D.29267);
                if (ret != 0) goto <D.29268>; else goto <D.29269>;
                <D.29268>:
                monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
                <D.29269>:
                D.29270 = ret != 0;
                D.29271 = (long int) D.29270;
                D.29272 = __builtin_expect (D.29271, 0);
                if (D.29272 != 0) goto <D.29273>; else goto <D.29274>;
                <D.29273>:
                monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 6927, "ret == 0");
                <D.29274>:
              }
              domain.117 = domain;
              tmp = domain.117->domain_assemblies;
              goto <D.27142>;
              <D.27141>:
              ass = tmp->data;
              D.29275 = ass->image;
              if (D.29275 != 0B) goto <D.29276>; else goto <D.29277>;
              <D.29276>:
              type_resolve = 1;
              D.29275 = ass->image;
              t = mono_reflection_get_type (D.29275, &info, ignore_case, &type_resolve);
              if (t != 0B) goto <D.29278>; else goto <D.29279>;
              <D.29278>:
              D.29280 = mono_type_get_class (t);
              monoeg_g_ptr_array_add (res_classes, D.29280);
              domain.117 = domain;
              monoeg_g_ptr_array_add (res_domains, domain.117);
              <D.29279>:
              <D.29277>:
              tmp = tmp->next;
              <D.27142>:
              if (tmp != 0B) goto <D.27141>; else goto <D.27143>;
              <D.27143>:
              {
                int ret;

                domain.117 = domain;
                D.29267 = &domain.117->assemblies_lock.mutex;
                ret = pthread_mutex_unlock (D.29267);
                if (ret != 0) goto <D.29281>; else goto <D.29282>;
                <D.29281>:
                monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
                <D.29282>:
                D.29283 = ret != 0;
                D.29284 = (long int) D.29283;
                D.29285 = __builtin_expect (D.29284, 0);
                if (D.29285 != 0) goto <D.29286>; else goto <D.29287>;
                <D.29286>:
                monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 6940, "ret == 0");
                <D.29287>:
              }
            }
          finally
            {
              type_resolve = {CLOBBER};
            }
        }
        <D.27146>:
        D.29288 = monoeg_g_hash_table_iter_next (&iter, 0B, &domain);
        if (D.29288 != 0) goto <D.27145>; else goto <D.27147>;
        <D.27147>:
        mono_loader_unlock ();
        monoeg_g_free (name);
        mono_reflection_free_type_info (&info);
        D.29289 = res_classes->len;
        buffer_add_int (buf, D.29289);
        i = 0;
        goto <D.27149>;
        <D.27148>:
        D.29290 = res_classes->pdata;
        D.29291 = (long unsigned int) i;
        D.29292 = D.29291 * 8;
        D.29293 = D.29290 + D.29292;
        D.29294 = *D.29293;
        D.29295 = res_domains->pdata;
        D.29291 = (long unsigned int) i;
        D.29292 = D.29291 * 8;
        D.29296 = D.29295 + D.29292;
        D.29297 = *D.29296;
        buffer_add_typeid (buf, D.29297, D.29294);
        i = i + 1;
        <D.27149>:
        i.118 = (unsigned int) i;
        D.29289 = res_classes->len;
        if (i.118 < D.29289) goto <D.27148>; else goto <D.27150>;
        <D.27150>:
        monoeg_g_ptr_array_free (res_classes, 1);
        monoeg_g_ptr_array_free (res_domains, 1);
        goto <D.27042>;
      }
    finally
      {
        iter = {CLOBBER};
        domain = {CLOBBER};
        info = {CLOBBER};
      }
  }
  <D.27151>:
  D.29137 = 100;
  return D.29137;
  <D.27042>:
  D.29137 = 0;
  return D.29137;
}


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


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

  D.29316 = 1;
  return D.29316;
}


clear_event_request (int req_id, int etype)
{
  struct GPtrArray * event_requests.121;
  void * * D.29319;
  long unsigned int D.29320;
  long unsigned int D.29321;
  void * * D.29322;
  int D.29323;
  int D.29326;
  void * D.29331;
  unsigned int i.122;
  unsigned int D.29339;
  int i;

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

    event_requests.121 = event_requests;
    D.29319 = event_requests.121->pdata;
    D.29320 = (long unsigned int) i;
    D.29321 = D.29320 * 8;
    D.29322 = D.29319 + D.29321;
    req = *D.29322;
    D.29323 = req->id;
    if (D.29323 == req_id) goto <D.29324>; else goto <D.29325>;
    <D.29324>:
    D.29326 = req->event_kind;
    if (D.29326 == etype) goto <D.29327>; else goto <D.29328>;
    <D.29327>:
    D.29326 = req->event_kind;
    if (D.29326 == 10) goto <D.29329>; else goto <D.29330>;
    <D.29329>:
    D.29331 = req->info;
    clear_breakpoint (D.29331);
    <D.29330>:
    D.29326 = req->event_kind;
    if (D.29326 == 11) goto <D.29332>; else goto <D.29333>;
    <D.29332>:
    D.29331 = req->info;
    ss_destroy (D.29331);
    <D.29333>:
    D.29326 = req->event_kind;
    if (D.29326 == 6) goto <D.29334>; else goto <D.29335>;
    <D.29334>:
    D.29331 = req->info;
    clear_breakpoint (D.29331);
    <D.29335>:
    D.29326 = req->event_kind;
    if (D.29326 == 7) goto <D.29336>; else goto <D.29337>;
    <D.29336>:
    D.29331 = req->info;
    clear_breakpoint (D.29331);
    <D.29337>:
    i.122 = (unsigned int) i;
    event_requests.121 = event_requests;
    monoeg_g_ptr_array_remove_index_fast (event_requests.121, i.122);
    monoeg_g_free (req);
    goto <D.26885>;
    <D.29328>:
    <D.29325>:
  }
  i = i + 1;
  <D.26887>:
  i.122 = (unsigned int) i;
  event_requests.121 = event_requests;
  D.29339 = event_requests.121->len;
  if (i.122 < D.29339) goto <D.26886>; else goto <D.26885>;
  <D.26885>:
  mono_loader_unlock ();
}


transport_close2 ()
{
  struct DebuggerTransport * transport.123;
  void (*<T86e>) (void) D.29341;

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


wait_for_suspend ()
{
  struct MonoGHashTable * thread_to_tls.124;
  unsigned int D.29343;
  int log_level.125;
  _Bool D.29346;
  long int D.29347;
  long int D.29348;
  struct FILE * log_file.126;
  _Bool D.29352;
  long int D.29353;
  long int D.29354;
  int nthreads;
  int nwait;
  int err;
  gboolean waited;

  waited = 0;
  mono_loader_lock ();
  thread_to_tls.124 = thread_to_tls;
  D.29343 = mono_g_hash_table_size (thread_to_tls.124);
  nthreads = (int) D.29343;
  mono_loader_unlock ();
  <D.25884>:
  nwait = count_threads_to_wait_for ();
  if (nwait != 0) goto <D.29344>; else goto <D.25883>;
  <D.29344>:
  log_level.125 = log_level;
  D.29346 = log_level.125 > 0;
  D.29347 = (long int) D.29346;
  D.29348 = __builtin_expect (D.29347, 0);
  if (D.29348 != 0) goto <D.29349>; else goto <D.29350>;
  <D.29349>:
  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.29350>:
  err = mono_sem_wait (&suspend_sem, 0);
  D.29352 = err != 0;
  D.29353 = (long int) D.29352;
  D.29354 = __builtin_expect (D.29353, 0);
  if (D.29354 != 0) goto <D.29355>; else goto <D.29356>;
  <D.29355>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 2962, "err == 0");
  <D.29356>:
  waited = 1;
  goto <D.25884>;
  <D.25883>:
  if (waited != 0) goto <D.29357>; else goto <D.29358>;
  <D.29357>:
  log_level.125 = log_level;
  D.29346 = log_level.125 > 0;
  D.29347 = (long int) D.29346;
  D.29348 = __builtin_expect (D.29347, 0);
  if (D.29348 != 0) goto <D.29359>; else goto <D.29360>;
  <D.29359>:
  log_file.126 = log_file;
  fprintf (log_file.126, "%d threads suspended.\n", nthreads);
  log_file.126 = log_file;
  fflush (log_file.126);
  <D.29360>:
  <D.29358>:
}


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


count_thread (void * key, void * value, void * user_data)
{
  int D.29365;
  int D.29368;
  int D.29371;
  int D.29372;
  struct DebuggerTlsData * tls;

  tls = value;
  D.29365 = tls->suspended;
  if (D.29365 == 0) goto <D.29366>; else goto <D.29367>;
  <D.29366>:
  D.29368 = tls->terminated;
  if (D.29368 == 0) goto <D.29369>; else goto <D.29370>;
  <D.29369>:
  D.29371 = MEM[(int *)user_data];
  D.29372 = D.29371 + 1;
  MEM[(int *)user_data] = D.29372;
  <D.29370>:
  <D.29367>:
}


is_suspended ()
{
  gboolean D.29373;
  int D.29374;
  _Bool D.29375;

  D.29374 = count_threads_to_wait_for ();
  D.29375 = D.29374 == 0;
  D.29373 = (gboolean) D.29375;
  return D.29373;
}


resume_thread (struct MonoInternalThread * thread)
{
  long unsigned int D.29377;
  long unsigned int debugger_thread_id.128;
  _Bool D.29379;
  long int D.29380;
  long int D.29381;
  struct MonoGHashTable * thread_to_tls.129;
  _Bool D.29385;
  long int D.29386;
  long int D.29387;
  int suspend_count.130;
  _Bool D.29391;
  long int D.29392;
  long int D.29393;
  int log_level.131;
  _Bool D.29397;
  long int D.29398;
  long int D.29399;
  long unsigned int D.29402;
  void * D.29403;
  struct FILE * log_file.132;
  unsigned int D.29405;
  unsigned int suspend_count.133;
  unsigned int D.29407;
  _Bool D.29408;
  long int D.29409;
  long int D.29410;
  int err;
  struct DebuggerTlsData * tls;

  D.29377 = GetCurrentThreadId ();
  debugger_thread_id.128 = debugger_thread_id;
  D.29379 = D.29377 != debugger_thread_id.128;
  D.29380 = (long int) D.29379;
  D.29381 = __builtin_expect (D.29380, 0);
  if (D.29381 != 0) goto <D.29382>; else goto <D.29383>;
  <D.29382>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 2796, "debugger_thread_id == GetCurrentThreadId ()");
  <D.29383>:
  mono_loader_lock ();
  thread_to_tls.129 = thread_to_tls;
  tls = mono_g_hash_table_lookup (thread_to_tls.129, thread);
  D.29385 = tls == 0B;
  D.29386 = (long int) D.29385;
  D.29387 = __builtin_expect (D.29386, 0);
  if (D.29387 != 0) goto <D.29388>; else goto <D.29389>;
  <D.29388>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 2801, "tls");
  <D.29389>:
  pthread_mutex_lock (&suspend_mutex);
  suspend_count.130 = suspend_count;
  D.29391 = suspend_count.130 <= 0;
  D.29392 = (long int) D.29391;
  D.29393 = __builtin_expect (D.29392, 0);
  if (D.29393 != 0) goto <D.29394>; else goto <D.29395>;
  <D.29394>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 2805, "suspend_count > 0");
  <D.29395>:
  log_level.131 = log_level;
  D.29397 = log_level.131 > 0;
  D.29398 = (long int) D.29397;
  D.29399 = __builtin_expect (D.29398, 0);
  if (D.29399 != 0) goto <D.29400>; else goto <D.29401>;
  <D.29400>:
  D.29402 = thread->tid;
  D.29403 = (void *) D.29402;
  log_file.132 = log_file;
  fprintf (log_file.132, "[%p] Resuming thread...\n", D.29403);
  log_file.132 = log_file;
  fflush (log_file.132);
  <D.29401>:
  D.29405 = tls->resume_count;
  suspend_count.130 = suspend_count;
  suspend_count.133 = (unsigned int) suspend_count.130;
  D.29407 = D.29405 + suspend_count.133;
  tls->resume_count = D.29407;
  err = pthread_cond_broadcast (&suspend_cond);
  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", 2816, "err == 0");
  <D.29412>:
  pthread_mutex_unlock (&suspend_mutex);
  mono_loader_unlock ();
}


resume_vm ()
{
  long unsigned int D.29413;
  long unsigned int debugger_thread_id.134;
  _Bool D.29415;
  long int D.29416;
  long int D.29417;
  int suspend_count.135;
  _Bool D.29421;
  long int D.29422;
  long int D.29423;
  int suspend_count.136;
  int log_level.137;
  _Bool D.29428;
  long int D.29429;
  long int D.29430;
  long unsigned int D.29433;
  void * D.29434;
  struct FILE * log_file.138;
  struct MonoGHashTable * thread_to_tls.139;
  _Bool D.29439;
  long int D.29440;
  long int D.29441;
  int err;

  D.29413 = GetCurrentThreadId ();
  debugger_thread_id.134 = debugger_thread_id;
  D.29415 = D.29413 != debugger_thread_id.134;
  D.29416 = (long int) D.29415;
  D.29417 = __builtin_expect (D.29416, 0);
  if (D.29417 != 0) goto <D.29418>; else goto <D.29419>;
  <D.29418>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 2755, "debugger_thread_id == GetCurrentThreadId ()");
  <D.29419>:
  mono_loader_lock ();
  pthread_mutex_lock (&suspend_mutex);
  suspend_count.135 = suspend_count;
  D.29421 = suspend_count.135 <= 0;
  D.29422 = (long int) D.29421;
  D.29423 = __builtin_expect (D.29422, 0);
  if (D.29423 != 0) goto <D.29424>; else goto <D.29425>;
  <D.29424>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 2761, "suspend_count > 0");
  <D.29425>:
  suspend_count.135 = suspend_count;
  suspend_count.136 = suspend_count.135 + -1;
  suspend_count = suspend_count.136;
  log_level.137 = log_level;
  D.29428 = log_level.137 > 0;
  D.29429 = (long int) D.29428;
  D.29430 = __builtin_expect (D.29429, 0);
  if (D.29430 != 0) goto <D.29431>; else goto <D.29432>;
  <D.29431>:
  suspend_count.135 = suspend_count;
  D.29433 = GetCurrentThreadId ();
  D.29434 = (void *) D.29433;
  log_file.138 = log_file;
  fprintf (log_file.138, "[%p] Resuming vm, suspend count=%d...\n", D.29434, suspend_count.135);
  log_file.138 = log_file;
  fflush (log_file.138);
  <D.29432>:
  suspend_count.135 = suspend_count;
  if (suspend_count.135 == 0) goto <D.29436>; else goto <D.29437>;
  <D.29436>:
  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.29437>:
  err = pthread_cond_broadcast (&suspend_cond);
  D.29439 = err != 0;
  D.29440 = (long int) D.29439;
  D.29441 = __builtin_expect (D.29440, 0);
  if (D.29441 != 0) goto <D.29442>; else goto <D.29443>;
  <D.29442>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 2774, "err == 0");
  <D.29443>:
  pthread_mutex_unlock (&suspend_mutex);
  suspend_count.135 = suspend_count;
  if (suspend_count.135 == 0) goto <D.29444>; else goto <D.29445>;
  <D.29444>:
  mono_thread_pool_resume ();
  <D.29445>:
  mono_loader_unlock ();
}


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

  tls = value;
  D.29446 = tls->really_suspended;
  if (D.29446 == 0) goto <D.29447>; else goto <D.29448>;
  <D.29447>:
  D.29449 = tls->suspended;
  if (D.29449 != 0) goto <D.29450>; else goto <D.29451>;
  <D.29450>:
  tls->suspended = 0;
  tls->context.valid = 0;
  tls->async_state.valid = 0;
  invalidate_frames (tls);
  <D.29451>:
  <D.29448>:
}


invalidate_frames (struct DebuggerTlsData * tls)
{
  unsigned int debugger_tls_id.140;
  _Bool D.29455;
  long int D.29456;
  long int D.29457;
  struct StackFrame * * D.29460;
  long unsigned int D.29461;
  long unsigned int D.29462;
  struct StackFrame * * D.29463;
  struct StackFrame * D.29464;
  struct MonoDebugMethodJitInfo * D.29465;
  int D.29468;
  int i;

  if (tls == 0B) goto <D.29452>; else goto <D.29453>;
  <D.29452>:
  debugger_tls_id.140 = debugger_tls_id;
  tls = pthread_getspecific (debugger_tls_id.140);
  <D.29453>:
  D.29455 = tls == 0B;
  D.29456 = (long int) D.29455;
  D.29457 = __builtin_expect (D.29456, 0);
  if (D.29457 != 0) goto <D.29458>; else goto <D.29459>;
  <D.29458>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 2831, "tls");
  <D.29459>:
  i = 0;
  goto <D.25856>;
  <D.25855>:
  D.29460 = tls->frames;
  D.29461 = (long unsigned int) i;
  D.29462 = D.29461 * 8;
  D.29463 = D.29460 + D.29462;
  D.29464 = *D.29463;
  D.29465 = D.29464->jit;
  if (D.29465 != 0B) goto <D.29466>; else goto <D.29467>;
  <D.29466>:
  D.29460 = tls->frames;
  D.29461 = (long unsigned int) i;
  D.29462 = D.29461 * 8;
  D.29463 = D.29460 + D.29462;
  D.29464 = *D.29463;
  D.29465 = D.29464->jit;
  mono_debug_free_method_jit_info (D.29465);
  <D.29467>:
  D.29460 = tls->frames;
  D.29461 = (long unsigned int) i;
  D.29462 = D.29461 * 8;
  D.29463 = D.29460 + D.29462;
  D.29464 = *D.29463;
  monoeg_g_free (D.29464);
  i = i + 1;
  <D.25856>:
  D.29468 = tls->frame_count;
  if (D.29468 > i) goto <D.25855>; else goto <D.25857>;
  <D.25857>:
  D.29460 = tls->frames;
  monoeg_g_free (D.29460);
  tls->frame_count = 0;
  tls->frames = 0B;
}


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

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


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

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


get_object (int objid, struct MonoObject * * obj)
{
  <unnamed type> D.29473;
  ErrorCode D.29476;
  struct MonoObject * D.29477;
  int err;

  D.29473 = get_object_allow_null (objid, obj);
  err = (int) D.29473;
  if (err != 0) goto <D.29474>; else goto <D.29475>;
  <D.29474>:
  D.29476 = (ErrorCode) err;
  return D.29476;
  <D.29475>:
  D.29477 = *obj;
  if (D.29477 == 0B) goto <D.29478>; else goto <D.29479>;
  <D.29478>:
  D.29476 = 20;
  return D.29476;
  <D.29479>:
  D.29476 = 0;
  return D.29476;
}


get_object_allow_null (int objid, struct MonoObject * * obj)
{
  ErrorCode D.29483;
  struct GHashTable * objrefs.141;
  long int D.29487;
  const void * D.29488;
  unsigned int D.29491;
  struct MonoObject * D.29492;
  struct MonoObject * D.29493;
  struct ObjRef * ref;

  if (objid == 0) goto <D.29481>; else goto <D.29482>;
  <D.29481>:
  *obj = 0B;
  D.29483 = 0;
  return D.29483;
  <D.29482>:
  objrefs.141 = objrefs;
  if (objrefs.141 == 0B) goto <D.29485>; else goto <D.29486>;
  <D.29485>:
  D.29483 = 20;
  return D.29483;
  <D.29486>:
  mono_loader_lock ();
  D.29487 = (long int) objid;
  D.29488 = (const void *) D.29487;
  objrefs.141 = objrefs;
  ref = monoeg_g_hash_table_lookup (objrefs.141, D.29488);
  if (ref != 0B) goto <D.29489>; else goto <D.29490>;
  <D.29489>:
  D.29491 = ref->handle;
  D.29492 = mono_gchandle_get_target (D.29491);
  *obj = D.29492;
  mono_loader_unlock ();
  D.29493 = *obj;
  if (D.29493 == 0B) goto <D.29494>; else goto <D.29495>;
  <D.29494>:
  D.29483 = 20;
  return D.29483;
  <D.29495>:
  D.29483 = 0;
  return D.29483;
  <D.29490>:
  mono_loader_unlock ();
  D.29483 = 20;
  return D.29483;
}


get_source_files_for_type (struct MonoClass * klass)
{
  struct GPtrArray * source_file_list.142;
  void * * D.29500;
  long unsigned int D.29501;
  long unsigned int D.29502;
  void * * D.29503;
  int D.27022;
  char * D.29504;
  void * * D.29505;
  long unsigned int D.29506;
  long unsigned int D.29507;
  void * * D.29508;
  void * D.29509;
  unsigned int i.143;
  unsigned int D.29512;
  gchar * D.29515;
  unsigned int j.144;
  unsigned int D.29517;
  struct GPtrArray * D.29518;
  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.27030>;
      <D.27029>:
      {
        struct MonoDebugMethodInfo * minfo;
        struct GPtrArray * source_file_list;

        try
          {
            minfo = mono_debug_lookup_method (method);
            if (minfo != 0B) goto <D.29497>; else goto <D.29498>;
            <D.29497>:
            mono_debug_symfile_get_line_numbers_full (minfo, 0B, &source_file_list, 0B, 0B, 0B, 0B, 0B);
            j = 0;
            goto <D.27027>;
            <D.27026>:
            source_file_list.142 = source_file_list;
            D.29500 = source_file_list.142->pdata;
            D.29501 = (long unsigned int) j;
            D.29502 = D.29501 * 8;
            D.29503 = D.29500 + D.29502;
            sinfo = *D.29503;
            i = 0;
            goto <D.27025>;
            <D.27024>:
            {
              size_t __s1_len;
              size_t __s2_len;

              D.29504 = sinfo->source_file;
              D.29505 = files->pdata;
              D.29506 = (long unsigned int) i;
              D.29507 = D.29506 * 8;
              D.29508 = D.29505 + D.29507;
              D.29509 = *D.29508;
              D.27022 = __builtin_strcmp (D.29509, D.29504);
            }
            if (D.27022 == 0) goto <D.27023>; else goto <D.29510>;
            <D.29510>:
            i = i + 1;
            <D.27025>:
            i.143 = (unsigned int) i;
            D.29512 = files->len;
            if (i.143 < D.29512) goto <D.27024>; else goto <D.27023>;
            <D.27023>:
            i.143 = (unsigned int) i;
            D.29512 = files->len;
            if (i.143 == D.29512) goto <D.29513>; else goto <D.29514>;
            <D.29513>:
            D.29504 = sinfo->source_file;
            D.29515 = monoeg_strdup (D.29504);
            monoeg_g_ptr_array_add (files, D.29515);
            <D.29514>:
            j = j + 1;
            <D.27027>:
            j.144 = (unsigned int) j;
            source_file_list.142 = source_file_list;
            D.29517 = source_file_list.142->len;
            if (j.144 < D.29517) goto <D.27026>; else goto <D.27028>;
            <D.27028>:
            source_file_list.142 = source_file_list;
            monoeg_g_ptr_array_free (source_file_list.142, 1);
            <D.29498>:
          }
        finally
          {
            source_file_list = {CLOBBER};
          }
      }
      <D.27030>:
      method = mono_class_get_methods (klass, &iter);
      if (method != 0B) goto <D.27029>; else goto <D.27031>;
      <D.27031>:
      D.29518 = files;
      return D.29518;
    }
  finally
    {
      iter = {CLOBBER};
    }
}


decode_string (guint8 * buf, guint8 * * endbuf, guint8 * limit)
{
  guint8 * buf.145;
  char * D.29524;
  int D.29525;
  long unsigned int D.29526;
  _Bool D.29527;
  long int D.29528;
  long int D.29529;
  long unsigned int D.29532;
  sizetype D.29533;
  char * D.29534;
  guint8 * buf.146;
  int len;
  char * s;

  buf.145 = buf;
  len = decode_int (buf.145, &buf, limit);
  if (len < 0) goto <D.29522>; else goto <D.29523>;
  <D.29522>:
  buf.145 = buf;
  *endbuf = buf.145;
  D.29524 = 0B;
  return D.29524;
  <D.29523>:
  D.29525 = len + 1;
  D.29526 = (long unsigned int) D.29525;
  s = monoeg_malloc (D.29526);
  D.29527 = s == 0B;
  D.29528 = (long int) D.29527;
  D.29529 = __builtin_expect (D.29528, 0);
  if (D.29529 != 0) goto <D.29530>; else goto <D.29531>;
  <D.29530>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 1633, "s");
  <D.29531>:
  D.29532 = (long unsigned int) len;
  buf.145 = buf;
  memcpy (s, buf.145, D.29532);
  D.29533 = (sizetype) len;
  D.29534 = s + D.29533;
  *D.29534 = 0;
  buf.145 = buf;
  D.29533 = (sizetype) len;
  buf.146 = buf.145 + D.29533;
  buf = buf.146;
  buf.145 = buf;
  *endbuf = buf.145;
  D.29524 = s;
  return D.29524;
}


event_commands (int command, guint8 * p, guint8 * end, struct Buffer * buf)
{
  guint8 * p.147;
  long unsigned int D.29538;
  long unsigned int D.29539;
  long unsigned int D.29540;
  int D.29541;
  <unnamed type> mod.148;
  int D.29545;
  int err.149;
  ErrorCode D.29552;
  int protocol_version_set.150;
  int major_version.151;
  int minor_version.152;
  <unnamed type> filter.153;
  <unnamed type> D.29571;
  unsigned int D.29572;
  unsigned int D.29575;
  struct MonoInternalThread * * D.29579;
  <unnamed type> D.29580;
  int err.154;
  int D.29589;
  int D.29590;
  int D.29597;
  int log_level.155;
  _Bool D.29599;
  long int D.29600;
  long int D.29601;
  const char * iftmp.156;
  int D.29605;
  const char * iftmp.157;
  int D.29610;
  const char * iftmp.158;
  int D.29615;
  const char * iftmp.159;
  struct FILE * log_file.160;
  struct MonoClass * D.29626;
  int D.29627;
  long unsigned int D.29633;
  long unsigned int D.29634;
  void * D.29635;
  struct MonoAssembly * * D.29636;
  long unsigned int D.29637;
  long unsigned int D.29638;
  struct MonoAssembly * * D.29639;
  struct MonoAssembly * D.29640;
  struct GHashTable * D.29646;
  struct GHashTable * D.29649;
  struct GHashTable * D.29653;
  struct GHashTable * D.29656;
  int D.29658;
  _Bool D.29661;
  long int D.29662;
  long int D.29663;
  struct MonoBreakpoint * D.29666;
  int D.29667;
  const char * D.29672;
  _Bool D.29676;
  long int D.29677;
  long int D.29678;
  <unnamed type> D.29681;
  int err.161;
  <unnamed type> depth.162;
  <unnamed type> size.163;
  struct MonoThread * step_thread.164;
  struct _MonoInternalThread * D.29688;
  <unnamed type> D.29689;
  int err.165;
  struct MonoBreakpoint * D.29696;
  struct MonoBreakpoint * D.29700;
  int D.29708;
  struct GPtrArray * event_requests.166;
  int D.29712;
  struct GHashTable * domains.167;
  struct MonoGHashTable * tid_to_thread.168;
  int D.29717;
  unsigned int D.29718;
  void * * D.29719;
  long unsigned int D.29720;
  long unsigned int D.29721;
  void * * D.29722;
  int D.29723;
  void * D.29726;
  unsigned int i.169;
  unsigned int D.29729;
  int err;
  struct MonoError error;

  try
    {
      switch (command) <default: <D.27215>, case 1: <D.27160>, case 2: <D.27206>, case 3: <D.27209>>
      <D.27160>:
      {
        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.29538 = (long unsigned int) nmodifiers;
            D.29539 = D.29538 * 32;
            D.29540 = D.29539 + 24;
            req = monoeg_malloc0 (D.29540);
            D.29541 = InterlockedIncrement (&event_request_id);
            req->id = D.29541;
            req->event_kind = event_kind;
            req->suspend_policy = suspend_policy;
            req->nmodifiers = nmodifiers;
            method = 0B;
            i = 0;
            goto <D.27197>;
            <D.27196>:
            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.29543>; else goto <D.29544>;
            <D.29543>:
            p.147 = p;
            D.29545 = decode_int (p.147, &p, end);
            req->modifiers[i].data.count = D.29545;
            goto <D.29546>;
            <D.29544>:
            if (mod == 7) goto <D.29547>; else goto <D.29548>;
            <D.29547>:
            p.147 = p;
            method = decode_methodid (p.147, &p, end, &domain, &err);
            err.149 = err;
            if (err.149 != 0) goto <D.29550>; else goto <D.29551>;
            <D.29550>:
            err.149 = err;
            D.29552 = (ErrorCode) err.149;
            return D.29552;
            <D.29551>:
            p.147 = p;
            location = decode_long (p.147, &p, end);
            goto <D.29553>;
            <D.29548>:
            if (mod == 10) goto <D.29554>; else goto <D.29555>;
            <D.29554>:
            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.29559>; else goto <D.29560>;
            <D.29559>:
            major_version.151 = major_version;
            if (major_version.151 > 2) goto <D.29556>; else goto <D.29562>;
            <D.29562>:
            major_version.151 = major_version;
            if (major_version.151 == 2) goto <D.29563>; else goto <D.29557>;
            <D.29563>:
            minor_version.152 = minor_version;
            if (minor_version.152 > 15) goto <D.29556>; else goto <D.29557>;
            <D.29556>:
            p.147 = p;
            filter = decode_int (p.147, &p, end);
            <D.29557>:
            <D.29560>:
            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.29566>; else goto <D.29568>;
            <D.29568>:
            major_version.151 = major_version;
            if (major_version.151 <= 2) goto <D.29569>; else goto <D.29567>;
            <D.29569>:
            major_version.151 = major_version;
            if (major_version.151 != 2) goto <D.29566>; else goto <D.29570>;
            <D.29570>:
            minor_version.152 = minor_version;
            if (minor_version.152 <= 25) goto <D.29566>; else goto <D.29567>;
            <D.29566>:
            D.29571 = req->modifiers[i].data.filter;
            D.29572 = D.29571 & 2;
            if (D.29572 != 0) goto <D.29573>; else goto <D.29574>;
            <D.29573>:
            D.29571 = req->modifiers[i].data.filter;
            D.29575 = D.29571 | 4;
            req->modifiers[i].data.filter = D.29575;
            <D.29574>:
            <D.29567>:
            goto <D.29576>;
            <D.29555>:
            if (mod == 3) goto <D.29577>; else goto <D.29578>;
            <D.29577>:
            {
              int id;

              p.147 = p;
              id = decode_id (p.147, &p, end);
              D.29579 = &req->modifiers[i].data.thread;
              D.29580 = get_object (id, D.29579);
              err.154 = (int) D.29580;
              err = err.154;
              err.149 = err;
              if (err.149 != 0) goto <D.29582>; else goto <D.29583>;
              <D.29582>:
              monoeg_g_free (req);
              err.149 = err;
              D.29552 = (ErrorCode) err.149;
              return D.29552;
              <D.29583>:
            }
            goto <D.29584>;
            <D.29578>:
            if (mod == 8) goto <D.29585>; else goto <D.29586>;
            <D.29585>:
            {
              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.29587>; else goto <D.29588>;
              <D.29587>:
              err.149 = err;
              D.29552 = (ErrorCode) err.149;
              return D.29552;
              <D.29588>:
              p.147 = p;
              D.29589 = decode_byte (p.147, &p, end);
              req->modifiers[i].caught = D.29589;
              p.147 = p;
              D.29590 = decode_byte (p.147, &p, end);
              req->modifiers[i].uncaught = D.29590;
              protocol_version_set.150 = protocol_version_set;
              if (protocol_version_set.150 != 0) goto <D.29594>; else goto <D.29591>;
              <D.29594>:
              major_version.151 = major_version;
              if (major_version.151 > 2) goto <D.29592>; else goto <D.29595>;
              <D.29595>:
              major_version.151 = major_version;
              if (major_version.151 == 2) goto <D.29596>; else goto <D.29591>;
              <D.29596>:
              minor_version.152 = minor_version;
              if (minor_version.152 > 24) goto <D.29592>; else goto <D.29591>;
              <D.29592>:
              p.147 = p;
              D.29597 = decode_byte (p.147, &p, end);
              req->modifiers[i].subclasses = D.29597;
              goto <D.29593>;
              <D.29591>:
              req->modifiers[i].subclasses = 1;
              <D.29593>:
              log_level.155 = log_level;
              D.29599 = log_level.155 > 0;
              D.29600 = (long int) D.29599;
              D.29601 = __builtin_expect (D.29600, 0);
              if (D.29601 != 0) goto <D.29602>; else goto <D.29603>;
              <D.29602>:
              D.29605 = req->modifiers[i].subclasses;
              if (D.29605 != 0) goto <D.29606>; else goto <D.29607>;
              <D.29606>:
              iftmp.156 = ", include-subclasses";
              goto <D.29608>;
              <D.29607>:
              iftmp.156 = "";
              <D.29608>:
              D.29610 = req->modifiers[i].uncaught;
              if (D.29610 != 0) goto <D.29611>; else goto <D.29612>;
              <D.29611>:
              iftmp.157 = ", uncaught";
              goto <D.29613>;
              <D.29612>:
              iftmp.157 = "";
              <D.29613>:
              D.29615 = req->modifiers[i].caught;
              if (D.29615 != 0) goto <D.29616>; else goto <D.29617>;
              <D.29616>:
              iftmp.158 = ", caught";
              goto <D.29618>;
              <D.29617>:
              iftmp.158 = "";
              <D.29618>:
              if (exc_class != 0B) goto <D.29620>; else goto <D.29621>;
              <D.29620>:
              iftmp.159 = exc_class->name;
              goto <D.29622>;
              <D.29621>:
              iftmp.159 = "all";
              <D.29622>:
              log_file.160 = log_file;
              fprintf (log_file.160, "[dbg] \tEXCEPTION_ONLY filter (%s%s%s%s).\n", iftmp.159, iftmp.158, iftmp.157, iftmp.156);
              log_file.160 = log_file;
              fflush (log_file.160);
              <D.29603>:
              if (exc_class != 0B) goto <D.29624>; else goto <D.29625>;
              <D.29624>:
              req->modifiers[i].data.exc_class = exc_class;
              D.29626 = mono_defaults.exception_class;
              D.29627 = mono_class_is_assignable_from (D.29626, exc_class);
              if (D.29627 == 0) goto <D.29628>; else goto <D.29629>;
              <D.29628>:
              monoeg_g_free (req);
              D.29552 = 102;
              return D.29552;
              <D.29629>:
              <D.29625>:
            }
            goto <D.29630>;
            <D.29586>:
            if (mod == 11) goto <D.29631>; else goto <D.29632>;
            <D.29631>:
            {
              int n;
              int j;

              p.147 = p;
              n = decode_int (p.147, &p, end);
              D.29633 = (long unsigned int) n;
              D.29634 = D.29633 * 8;
              D.29635 = monoeg_malloc0 (D.29634);
              req->modifiers[i].data.assemblies = D.29635;
              j = 0;
              goto <D.27181>;
              <D.27180>:
              D.29636 = req->modifiers[i].data.assemblies;
              D.29637 = (long unsigned int) j;
              D.29638 = D.29637 * 8;
              D.29639 = D.29636 + D.29638;
              p.147 = p;
              D.29640 = decode_assemblyid (p.147, &p, end, &domain, &err);
              *D.29639 = D.29640;
              err.149 = err;
              if (err.149 != 0) goto <D.29641>; else goto <D.29642>;
              <D.29641>:
              D.29636 = req->modifiers[i].data.assemblies;
              monoeg_g_free (D.29636);
              err.149 = err;
              D.29552 = (ErrorCode) err.149;
              return D.29552;
              <D.29642>:
              j = j + 1;
              <D.27181>:
              if (j < n) goto <D.27180>; else goto <D.27182>;
              <D.27182>:
            }
            goto <D.29643>;
            <D.29632>:
            if (mod == 12) goto <D.29644>; else goto <D.29645>;
            <D.29644>:
            {
              int n;
              int j;

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

                p.147 = p;
                s = decode_string (p.147, &p, end);
                if (s != 0B) goto <D.29647>; else goto <D.29648>;
                <D.29647>:
                s2 = strdup_tolower (s);
                D.29649 = modifier->data.source_files;
                monoeg_g_hash_table_insert_replace (D.29649, s2, s2, 0);
                monoeg_g_free (s);
                <D.29648>:
              }
              j = j + 1;
              <D.27188>:
              if (j < n) goto <D.27187>; else goto <D.27189>;
              <D.27189>:
            }
            goto <D.29650>;
            <D.29645>:
            if (mod == 13) goto <D.29651>; else goto <D.29652>;
            <D.29651>:
            {
              int n;
              int j;

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

                p.147 = p;
                s = decode_string (p.147, &p, end);
                if (s != 0B) goto <D.29654>; else goto <D.29655>;
                <D.29654>:
                D.29656 = modifier->data.type_names;
                monoeg_g_hash_table_insert_replace (D.29656, s, s, 0);
                <D.29655>:
              }
              j = j + 1;
              <D.27194>:
              if (j < n) goto <D.27193>; else goto <D.27195>;
              <D.27195>:
            }
            goto <D.29657>;
            <D.29652>:
            monoeg_g_free (req);
            D.29552 = 100;
            return D.29552;
            <D.29657>:
            <D.29650>:
            <D.29643>:
            <D.29630>:
            <D.29584>:
            <D.29576>:
            <D.29553>:
            <D.29546>:
            i = i + 1;
            <D.27197>:
            if (i < nmodifiers) goto <D.27196>; else goto <D.27198>;
            <D.27198>:
            D.29658 = req->event_kind;
            if (D.29658 == 10) goto <D.29659>; else goto <D.29660>;
            <D.29659>:
            D.29661 = method == 0B;
            D.29662 = (long int) D.29661;
            D.29663 = __builtin_expect (D.29662, 0);
            if (D.29663 != 0) goto <D.29664>; else goto <D.29665>;
            <D.29664>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 7086, "method");
            <D.29665>:
            D.29666 = set_breakpoint (method, location, req, &error);
            req->info = D.29666;
            D.29667 = mono_error_ok (&error);
            if (D.29667 == 0) goto <D.29668>; else goto <D.29669>;
            <D.29668>:
            monoeg_g_free (req);
            log_level.155 = log_level;
            D.29599 = log_level.155 > 0;
            D.29600 = (long int) D.29599;
            D.29601 = __builtin_expect (D.29600, 0);
            if (D.29601 != 0) goto <D.29670>; else goto <D.29671>;
            <D.29670>:
            D.29672 = mono_error_get_message (&error);
            log_file.160 = log_file;
            fprintf (log_file.160, "[dbg] Failed to set breakpoint: %s\n", D.29672);
            log_file.160 = log_file;
            fflush (log_file.160);
            <D.29671>:
            mono_error_cleanup (&error);
            D.29552 = 106;
            return D.29552;
            <D.29669>:
            goto <D.29673>;
            <D.29660>:
            D.29658 = req->event_kind;
            if (D.29658 == 11) goto <D.29674>; else goto <D.29675>;
            <D.29674>:
            D.29676 = step_thread_id == 0;
            D.29677 = (long int) D.29676;
            D.29678 = __builtin_expect (D.29677, 0);
            if (D.29678 != 0) goto <D.29679>; else goto <D.29680>;
            <D.29679>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 7096, "step_thread_id");
            <D.29680>:
            D.29681 = get_object (step_thread_id, &step_thread);
            err.161 = (int) D.29681;
            err = err.161;
            err.149 = err;
            if (err.149 != 0) goto <D.29683>; else goto <D.29684>;
            <D.29683>:
            monoeg_g_free (req);
            err.149 = err;
            D.29552 = (ErrorCode) err.149;
            return D.29552;
            <D.29684>:
            depth.162 = (<unnamed type>) depth;
            size.163 = (<unnamed type>) size;
            step_thread.164 = step_thread;
            D.29688 = step_thread.164->internal_thread;
            D.29689 = ss_create (D.29688, size.163, depth.162, req);
            err.165 = (int) D.29689;
            err = err.165;
            err.149 = err;
            if (err.149 != 0) goto <D.29691>; else goto <D.29692>;
            <D.29691>:
            monoeg_g_free (req);
            err.149 = err;
            D.29552 = (ErrorCode) err.149;
            return D.29552;
            <D.29692>:
            goto <D.29693>;
            <D.29675>:
            D.29658 = req->event_kind;
            if (D.29658 == 6) goto <D.29694>; else goto <D.29695>;
            <D.29694>:
            D.29696 = set_breakpoint (0B, -1, req, 0B);
            req->info = D.29696;
            goto <D.29697>;
            <D.29695>:
            D.29658 = req->event_kind;
            if (D.29658 == 7) goto <D.29698>; else goto <D.29699>;
            <D.29698>:
            D.29700 = set_breakpoint (0B, 16777215, req, 0B);
            req->info = D.29700;
            goto <D.29701>;
            <D.29699>:
            D.29658 = req->event_kind;
            if (D.29658 == 13) goto <D.29702>; else goto <D.29703>;
            <D.29702>:
            goto <D.29704>;
            <D.29703>:
            D.29658 = req->event_kind;
            if (D.29658 == 12) goto <D.29705>; else goto <D.29706>;
            <D.29705>:
            goto <D.29707>;
            <D.29706>:
            D.29708 = req->nmodifiers;
            if (D.29708 != 0) goto <D.29709>; else goto <D.29710>;
            <D.29709>:
            monoeg_g_free (req);
            D.29552 = 100;
            return D.29552;
            <D.29710>:
            <D.29707>:
            <D.29704>:
            <D.29701>:
            <D.29697>:
            <D.29693>:
            <D.29673>:
            mono_loader_lock ();
            event_requests.166 = event_requests;
            monoeg_g_ptr_array_add (event_requests.166, req);
            D.29712 = agent_config.defer;
            if (D.29712 != 0) goto <D.29713>; else goto <D.29714>;
            <D.29713>:
            D.29658 = req->event_kind;
            switch (D.29658) <default: <D.27204>, case 2: <D.27202>, case 4: <D.27199>, case 8: <D.27201>, case 12: <D.27203>>
            <D.27199>:
            domains.167 = domains;
            monoeg_g_hash_table_foreach (domains.167, emit_appdomain_load, 0B);
            goto <D.27200>;
            <D.27201>:
            mono_assembly_foreach (emit_assembly_load, 0B);
            goto <D.27200>;
            <D.27202>:
            tid_to_thread.168 = tid_to_thread;
            mono_g_hash_table_foreach (tid_to_thread.168, emit_thread_start, 0B);
            goto <D.27200>;
            <D.27203>:
            mono_domain_foreach (send_types_for_domain, 0B);
            goto <D.27200>;
            <D.27204>:
            goto <D.27200>;
            <D.27200>:
            <D.29714>:
            mono_loader_unlock ();
            D.29717 = req->id;
            D.29718 = (unsigned int) D.29717;
            buffer_add_int (buf, D.29718);
            goto <D.27205>;
          }
        finally
          {
            step_thread = {CLOBBER};
            domain = {CLOBBER};
          }
      }
      <D.27206>:
      {
        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.27205>;
      }
      <D.27209>:
      {
        int i;

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

          event_requests.166 = event_requests;
          D.29719 = event_requests.166->pdata;
          D.29720 = (long unsigned int) i;
          D.29721 = D.29720 * 8;
          D.29722 = D.29719 + D.29721;
          req = *D.29722;
          D.29723 = req->event_kind;
          if (D.29723 == 10) goto <D.29724>; else goto <D.29725>;
          <D.29724>:
          D.29726 = req->info;
          clear_breakpoint (D.29726);
          i.169 = (unsigned int) i;
          event_requests.166 = event_requests;
          monoeg_g_ptr_array_remove_index_fast (event_requests.166, i.169);
          monoeg_g_free (req);
          goto <D.29728>;
          <D.29725>:
          i = i + 1;
          <D.29728>:
        }
        <D.27213>:
        i.169 = (unsigned int) i;
        event_requests.166 = event_requests;
        D.29729 = event_requests.166->len;
        if (i.169 < D.29729) goto <D.27212>; else goto <D.27214>;
        <D.27214>:
        mono_loader_unlock ();
        goto <D.27205>;
      }
      <D.27215>:
      D.29552 = 100;
      return D.29552;
      <D.27205>:
      D.29552 = 0;
      return D.29552;
    }
  finally
    {
      err = {CLOBBER};
      error = {CLOBBER};
    }
}


send_types_for_domain (struct MonoDomain * domain, void * user_data)
{
  union mono_mutex_t * D.29735;
  _Bool D.29738;
  long int D.29739;
  long int D.29740;
  _Bool D.29743;
  long int D.29744;
  long int D.29745;
  struct GHashTable * D.29748;
  _Bool D.29751;
  long int D.29752;
  long int D.29753;
  struct AgentDomainInfo * info;

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

    D.29735 = &domain->lock.mutex;
    ret = pthread_mutex_lock (D.29735);
    if (ret != 0) goto <D.29736>; else goto <D.29737>;
    <D.29736>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.29737>:
    D.29738 = ret != 0;
    D.29739 = (long int) D.29738;
    D.29740 = __builtin_expect (D.29739, 0);
    if (D.29740 != 0) goto <D.29741>; else goto <D.29742>;
    <D.29741>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 4009, "ret == 0");
    <D.29742>:
  }
  info = get_agent_domain_info (domain);
  D.29743 = info == 0B;
  D.29744 = (long int) D.29743;
  D.29745 = __builtin_expect (D.29744, 0);
  if (D.29745 != 0) goto <D.29746>; else goto <D.29747>;
  <D.29746>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 4011, "info");
  <D.29747>:
  D.29748 = info->loaded_classes;
  monoeg_g_hash_table_foreach (D.29748, emit_type_load, 0B);
  {
    int ret;

    D.29735 = &domain->lock.mutex;
    ret = pthread_mutex_unlock (D.29735);
    if (ret != 0) goto <D.29749>; else goto <D.29750>;
    <D.29749>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.29750>:
    D.29751 = ret != 0;
    D.29752 = (long int) D.29751;
    D.29753 = __builtin_expect (D.29752, 0);
    if (D.29753 != 0) goto <D.29754>; else goto <D.29755>;
    <D.29754>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 4013, "ret == 0");
    <D.29755>:
  }
  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.29757;
  long unsigned int D.29758;
  long unsigned int debugger_thread_id.171;

  key.170 = (long int) key;
  D.29757 = (int) key.170;
  D.29758 = (long unsigned int) D.29757;
  debugger_thread_id.171 = debugger_thread_id;
  if (D.29758 != debugger_thread_id.171) goto <D.29760>; else goto <D.29761>;
  <D.29760>:
  process_profiler_event (2, value);
  <D.29761>:
}


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.29762;
  struct GHashTable * D.29763;

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


InterlockedIncrement (volatile gint32 * val)
{
  gint32 D.29764;
  unsigned int D.29765;

  D.29765 = __sync_add_and_fetch_4 (val, 1);
  D.29764 = (gint32) D.29765;
  return D.29764;
}


decode_methodid (guint8 * buf, guint8 * * endbuf, guint8 * limit, struct MonoDomain * * domain, int * err)
{
  int log_level.172;
  _Bool D.29768;
  long int D.29769;
  long int D.29770;
  struct FILE * log_file.173;
  struct MonoMethod * D.29778;
  struct MonoMethod * m;

  m = decode_ptr_id (buf, endbuf, limit, 3, domain, err);
  log_level.172 = log_level;
  D.29768 = log_level.172 > 1;
  D.29769 = (long int) D.29768;
  D.29770 = __builtin_expect (D.29769, 0);
  if (D.29770 != 0) goto <D.29771>; else goto <D.29772>;
  <D.29771>:
  if (m != 0B) goto <D.29773>; else goto <D.29774>;
  <D.29773>:
  {
    char * s;

    s = mono_method_full_name (m, 1);
    log_level.172 = log_level;
    D.29768 = log_level.172 > 1;
    D.29769 = (long int) D.29768;
    D.29770 = __builtin_expect (D.29769, 0);
    if (D.29770 != 0) goto <D.29775>; else goto <D.29776>;
    <D.29775>:
    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.29776>:
    monoeg_g_free (s);
  }
  <D.29774>:
  <D.29772>:
  D.29778 = m;
  return D.29778;
}


decode_ptr_id (guint8 * buf, guint8 * * endbuf, guint8 * limit, IdType type, struct MonoDomain * * domain, int * err)
{
  void * D.29784;
  int iftmp.174;
  unsigned int id.175;
  struct GPtrArray * D.29791;
  unsigned int D.29792;
  _Bool D.29793;
  long int D.29794;
  long int D.29795;
  void * * D.29798;
  long unsigned int D.29799;
  long unsigned int D.29800;
  sizetype D.29801;
  void * * D.29802;
  struct MonoDomain * D.29803;
  struct Id * res;
  int id;

  id = decode_id (buf, endbuf, limit);
  *err = 0;
  if (domain != 0B) goto <D.29780>; else goto <D.29781>;
  <D.29780>:
  *domain = 0B;
  <D.29781>:
  if (id == 0) goto <D.29782>; else goto <D.29783>;
  <D.29782>:
  D.29784 = 0B;
  return D.29784;
  <D.29783>:
  mono_loader_lock ();
  if (id <= 0) goto <D.29786>; else goto <D.29789>;
  <D.29789>:
  id.175 = (unsigned int) id;
  D.29791 = ids[type];
  D.29792 = D.29791->len;
  if (id.175 > D.29792) goto <D.29786>; else goto <D.29787>;
  <D.29786>:
  iftmp.174 = 1;
  goto <D.29788>;
  <D.29787>:
  iftmp.174 = 0;
  <D.29788>:
  D.29793 = iftmp.174 != 0;
  D.29794 = (long int) D.29793;
  D.29795 = __builtin_expect (D.29794, 0);
  if (D.29795 != 0) goto <D.29796>; else goto <D.29797>;
  <D.29796>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 2196, "id > 0 && id <= ids [type]->len");
  <D.29797>:
  D.29791 = ids[type];
  D.29798 = D.29791->pdata;
  D.29799 = (long unsigned int) id;
  D.29800 = D.29799 * 8;
  D.29801 = D.29800 + 18446744073709551608;
  D.29802 = D.29798 + D.29801;
  res = *D.29802;
  mono_loader_unlock ();
  D.29803 = res->domain;
  if (D.29803 == 0B) goto <D.29804>; else goto <D.29805>;
  <D.29804>:
  *err = 103;
  D.29784 = 0B;
  return D.29784;
  <D.29805>:
  if (domain != 0B) goto <D.29806>; else goto <D.29807>;
  <D.29806>:
  D.29803 = res->domain;
  *domain = D.29803;
  <D.29807>:
  D.29784 = res->data.val;
  return D.29784;
}


decode_long (guint8 * buf, guint8 * * endbuf, guint8 * limit)
{
  guint8 * buf.176;
  int D.29810;
  int D.29811;
  gint64 D.29812;
  long unsigned int D.29813;
  long unsigned int D.29814;
  long unsigned int D.29815;
  long unsigned int D.29816;
  guint32 high;
  guint32 low;

  buf.176 = buf;
  D.29810 = decode_int (buf.176, &buf, limit);
  high = (guint32) D.29810;
  buf.176 = buf;
  D.29811 = decode_int (buf.176, &buf, limit);
  low = (guint32) D.29811;
  buf.176 = buf;
  *endbuf = buf.176;
  D.29813 = (long unsigned int) high;
  D.29814 = D.29813 << 32;
  D.29815 = (long unsigned int) low;
  D.29816 = D.29814 | D.29815;
  D.29812 = (gint64) D.29816;
  return D.29812;
}


decode_typeid (guint8 * buf, guint8 * * endbuf, guint8 * limit, struct MonoDomain * * domain, int * err)
{
  int log_level.177;
  _Bool D.29819;
  long int D.29820;
  long int D.29821;
  struct MonoType * D.29826;
  struct FILE * log_file.178;
  struct MonoClass * D.29830;
  struct MonoClass * klass;

  klass = decode_ptr_id (buf, endbuf, limit, 2, domain, err);
  log_level.177 = log_level;
  D.29819 = log_level.177 > 1;
  D.29820 = (long int) D.29819;
  D.29821 = __builtin_expect (D.29820, 0);
  if (D.29821 != 0) goto <D.29822>; else goto <D.29823>;
  <D.29822>:
  if (klass != 0B) goto <D.29824>; else goto <D.29825>;
  <D.29824>:
  {
    char * s;

    D.29826 = &klass->byval_arg;
    s = mono_type_full_name (D.29826);
    log_level.177 = log_level;
    D.29819 = log_level.177 > 1;
    D.29820 = (long int) D.29819;
    D.29821 = __builtin_expect (D.29820, 0);
    if (D.29821 != 0) goto <D.29827>; else goto <D.29828>;
    <D.29827>:
    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.29828>:
    monoeg_g_free (s);
  }
  <D.29825>:
  <D.29823>:
  D.29830 = klass;
  return D.29830;
}


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

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


ss_create (struct MonoInternalThread * thread, StepSize size, StepDepth depth, struct EventRequest * req)
{
  int suspend_count.179;
  ErrorCode D.29837;
  struct SingleStepReq * ss_req.180;
  int log_level.181;
  _Bool D.29842;
  long int D.29843;
  long int D.29844;
  struct FILE * log_file.182;
  _Bool D.29848;
  long int D.29849;
  long int D.29850;
  const char * D.29853;
  void * ss_req.183;
  struct MonoGHashTable * thread_to_tls.184;
  _Bool D.29856;
  long int D.29857;
  long int D.29858;
  int D.29861;
  _Bool D.29862;
  long int D.29863;
  long int D.29864;
  long int D.29867;
  void * D.29868;
  void * D.29869;
  int D.29870;
  struct MonoContext * D.29873;
  void * D.29874;
  void * D.29875;
  _Bool D.29876;
  long int D.29877;
  long int D.29878;
  <unnamed type> D.29881;
  _Bool D.29882;
  long int D.29883;
  long int D.29884;
  int D.29887;
  struct MonoMethod * D.29888;
  struct MonoDomain * D.29889;
  _Bool D.29892;
  long int D.29893;
  long int D.29894;
  <unnamed type> D.29899;
  int D.29902;
  struct StackFrame * * D.29905;
  struct MonoMethod * D.29906;
  unsigned int D.29909;
  unsigned int D.29914;
  int D.29915;
  unsigned int D.29922;
  unsigned int D.29925;
  int D.29926;
  struct MonoMethod * D.29927;
  struct MonoDomain * D.29928;
  struct MonoContext * D.29933;
  struct MonoSeqPointInfo * info.185;
  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.29835>; else goto <D.29836>;
      <D.29835>:
      D.29837 = 101;
      return D.29837;
      <D.29836>:
      wait_for_suspend ();
      ss_req.180 = ss_req;
      if (ss_req.180 != 0B) goto <D.29839>; else goto <D.29840>;
      <D.29839>:
      log_level.181 = log_level;
      D.29842 = log_level.181 >= 0;
      D.29843 = (long int) D.29842;
      D.29844 = __builtin_expect (D.29843, 0);
      if (D.29844 != 0) goto <D.29845>; else goto <D.29846>;
      <D.29845>:
      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.29846>:
      D.29837 = 100;
      return D.29837;
      <D.29840>:
      log_level.181 = log_level;
      D.29848 = log_level.181 > 0;
      D.29849 = (long int) D.29848;
      D.29850 = __builtin_expect (D.29849, 0);
      if (D.29850 != 0) goto <D.29851>; else goto <D.29852>;
      <D.29851>:
      D.29853 = ss_depth_to_string (depth);
      log_file.182 = log_file;
      fprintf (log_file.182, "[dbg] Starting single step of thread %p (depth=%s).\n", thread, D.29853);
      log_file.182 = log_file;
      fflush (log_file.182);
      <D.29852>:
      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.29856 = tls == 0B;
      D.29857 = (long int) D.29856;
      D.29858 = __builtin_expect (D.29857, 0);
      if (D.29858 != 0) goto <D.29859>; else goto <D.29860>;
      <D.29859>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 5168, "tls");
      <D.29860>:
      D.29861 = tls->context.valid;
      D.29862 = D.29861 == 0;
      D.29863 = (long int) D.29862;
      D.29864 = __builtin_expect (D.29863, 0);
      if (D.29864 != 0) goto <D.29865>; else goto <D.29866>;
      <D.29865>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 5169, "tls->context.valid");
      <D.29866>:
      ss_req.180 = ss_req;
      ss_req.180 = ss_req;
      D.29867 = tls->context.ctx.rsp;
      D.29868 = (void *) D.29867;
      ss_req.180->last_sp = D.29868;
      D.29869 = ss_req.180->last_sp;
      ss_req.180->start_sp = D.29869;
      D.29870 = tls->catch_state.valid;
      if (D.29870 != 0) goto <D.29871>; else goto <D.29872>;
      <D.29871>:
      {
        gboolean res;
        struct StackFrameInfo frame;
        struct MonoContext new_ctx;
        struct MonoLMF * lmf;

        try
          {
            lmf = 0B;
            D.29873 = &tls->catch_state.ctx;
            D.29874 = thread->jit_data;
            D.29875 = tls->catch_state.unwind_data[0];
            res = mono_find_jit_info_ext (D.29875, D.29874, 0B, D.29873, &new_ctx, 0B, &lmf, 0B, &frame);
            D.29876 = res == 0;
            D.29877 = (long int) D.29876;
            D.29878 = __builtin_expect (D.29877, 0);
            if (D.29878 != 0) goto <D.29879>; else goto <D.29880>;
            <D.29879>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 5184, "res");
            <D.29880>:
            D.29881 = frame.type;
            D.29882 = D.29881 != 0;
            D.29883 = (long int) D.29882;
            D.29884 = __builtin_expect (D.29883, 0);
            if (D.29884 != 0) goto <D.29885>; else goto <D.29886>;
            <D.29885>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 5185, "frame.type == FRAME_TYPE_MANAGED");
            <D.29886>:
            D.29887 = frame.native_offset;
            D.29888 = frame.method;
            D.29889 = frame.domain;
            sp = find_next_seq_point_for_native_offset (D.29889, D.29888, D.29887, &info);
            if (sp == 0B) goto <D.29890>; else goto <D.29891>;
            <D.29890>:
            D.29888 = frame.method;
            no_seq_points_found (D.29888);
            <D.29891>:
            D.29892 = sp == 0B;
            D.29893 = (long int) D.29892;
            D.29894 = __builtin_expect (D.29893, 0);
            if (D.29894 != 0) goto <D.29895>; else goto <D.29896>;
            <D.29895>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 5194, "sp");
            <D.29896>:
            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.29872>:
      if (step_to_catch == 0) goto <D.29897>; else goto <D.29898>;
      <D.29897>:
      ss_req.180 = ss_req;
      D.29899 = ss_req.180->size;
      if (D.29899 == 1) goto <D.29900>; else goto <D.29901>;
      <D.29900>:
      {
        struct StackFrame * frame;

        compute_frame_info (thread, tls);
        D.29902 = tls->frame_count;
        if (D.29902 != 0) goto <D.29903>; else goto <D.29904>;
        <D.29903>:
        D.29905 = tls->frames;
        frame = *D.29905;
        ss_req.180 = ss_req;
        D.29906 = frame->method;
        ss_req.180->last_method = D.29906;
        ss_req.180 = ss_req;
        ss_req.180->last_line = -1;
        D.29906 = frame->method;
        minfo = mono_debug_lookup_method (D.29906);
        if (minfo != 0B) goto <D.29907>; else goto <D.29908>;
        <D.29907>:
        D.29909 = frame->il_offset;
        if (D.29909 != 4294967295) goto <D.29910>; else goto <D.29911>;
        <D.29910>:
        {
          struct MonoDebugSourceLocation * loc;

          D.29909 = frame->il_offset;
          loc = mono_debug_symfile_lookup_location (minfo, D.29909);
          if (loc != 0B) goto <D.29912>; else goto <D.29913>;
          <D.29912>:
          ss_req.180 = ss_req;
          D.29914 = loc->row;
          D.29915 = (int) D.29914;
          ss_req.180->last_line = D.29915;
          monoeg_g_free (loc);
          <D.29913>:
        }
        <D.29911>:
        <D.29908>:
        <D.29904>:
      }
      <D.29901>:
      <D.29898>:
      if (step_to_catch == 0) goto <D.29916>; else goto <D.29917>;
      <D.29916>:
      {
        struct StackFrame * frame;

        compute_frame_info (thread, tls);
        D.29902 = tls->frame_count;
        if (D.29902 != 0) goto <D.29918>; else goto <D.29919>;
        <D.29918>:
        D.29905 = tls->frames;
        frame = *D.29905;
        if (method == 0B) goto <D.29920>; else goto <D.29921>;
        <D.29920>:
        D.29922 = frame->il_offset;
        if (D.29922 != 4294967295) goto <D.29923>; else goto <D.29924>;
        <D.29923>:
        D.29925 = frame->native_offset;
        D.29926 = (int) D.29925;
        D.29927 = frame->method;
        D.29928 = frame->domain;
        sp = find_prev_seq_point_for_native_offset (D.29928, D.29927, D.29926, &info);
        if (sp == 0B) goto <D.29929>; else goto <D.29930>;
        <D.29929>:
        D.29927 = frame->method;
        no_seq_points_found (D.29927);
        <D.29930>:
        D.29892 = sp == 0B;
        D.29893 = (long int) D.29892;
        D.29894 = __builtin_expect (D.29893, 0);
        if (D.29894 != 0) goto <D.29931>; else goto <D.29932>;
        <D.29931>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 5240, "sp");
        <D.29932>:
        method = frame->method;
        <D.29924>:
        <D.29921>:
        <D.29919>:
      }
      <D.29917>:
      D.29933 = &tls->context.ctx;
      info.185 = info;
      ss_req.180 = ss_req;
      ss_start (ss_req.180, method, sp, info.185, D.29933, tls, step_to_catch);
      D.29837 = 0;
      return D.29837;
    }
  finally
    {
      info = {CLOBBER};
    }
}


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

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


find_next_seq_point_for_native_offset (struct MonoDomain * domain, struct MonoMethod * method, gint32 native_offset, struct MonoSeqPointInfo * * info)
{
  struct SeqPoint * D.29943;
  _Bool D.29944;
  long int D.29945;
  long int D.29946;
  int D.29951;
  int D.29954;
  struct MonoSeqPointInfo * seq_points;
  int i;

  seq_points = get_seq_points (domain, method);
  if (seq_points == 0B) goto <D.29939>; else goto <D.29940>;
  <D.29939>:
  if (info != 0B) goto <D.29941>; else goto <D.29942>;
  <D.29941>:
  *info = 0B;
  <D.29942>:
  D.29943 = 0B;
  return D.29943;
  <D.29940>:
  D.29944 = seq_points == 0B;
  D.29945 = (long int) D.29944;
  D.29946 = __builtin_expect (D.29945, 0);
  if (D.29946 != 0) goto <D.29947>; else goto <D.29948>;
  <D.29947>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 3028, "seq_points");
  <D.29948>:
  if (info != 0B) goto <D.29949>; else goto <D.29950>;
  <D.29949>:
  *info = seq_points;
  <D.29950>:
  i = 0;
  goto <D.25907>;
  <D.25906>:
  D.29951 = seq_points->seq_points[i].native_offset;
  if (D.29951 >= native_offset) goto <D.29952>; else goto <D.29953>;
  <D.29952>:
  D.29943 = &seq_points->seq_points[i];
  return D.29943;
  <D.29953>:
  i = i + 1;
  <D.25907>:
  D.29954 = seq_points->len;
  if (D.29954 > i) goto <D.25906>; else goto <D.25908>;
  <D.25908>:
  D.29943 = 0B;
  return D.29943;
}


get_seq_points (struct MonoDomain * domain, struct MonoMethod * method)
{
  union mono_mutex_t * D.29956;
  _Bool D.29959;
  long int D.29960;
  long int D.29961;
  void * D.29964;
  struct GHashTable * D.29965;
  unsigned char D.29968;
  unsigned char D.29969;
  struct MonoMethod * D.29972;
  struct MonoMethod * D.29975;
  _Bool D.29978;
  long int D.29979;
  long int D.29980;
  struct MonoSeqPointInfo * D.29983;
  struct MonoSeqPointInfo * seq_points;

  {
    int ret;

    D.29956 = &domain->lock.mutex;
    ret = pthread_mutex_lock (D.29956);
    if (ret != 0) goto <D.29957>; else goto <D.29958>;
    <D.29957>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.29958>:
    D.29959 = ret != 0;
    D.29960 = (long int) D.29959;
    D.29961 = __builtin_expect (D.29960, 0);
    if (D.29961 != 0) goto <D.29962>; else goto <D.29963>;
    <D.29962>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 2989, "ret == 0");
    <D.29963>:
  }
  D.29964 = domain->runtime_info;
  D.29965 = MEM[(struct MonoJitDomainInfo *)D.29964].seq_points;
  seq_points = monoeg_g_hash_table_lookup (D.29965, method);
  if (seq_points == 0B) goto <D.29966>; else goto <D.29967>;
  <D.29966>:
  D.29968 = BIT_FIELD_REF <*method, 8, 264>;
  D.29969 = D.29968 & 16;
  if (D.29969 != 0) goto <D.29970>; else goto <D.29971>;
  <D.29970>:
  D.29972 = mono_method_get_declaring_generic_method (method);
  D.29964 = domain->runtime_info;
  D.29965 = MEM[(struct MonoJitDomainInfo *)D.29964].seq_points;
  seq_points = monoeg_g_hash_table_lookup (D.29965, D.29972);
  if (seq_points == 0B) goto <D.29973>; else goto <D.29974>;
  <D.29973>:
  D.29975 = mini_get_shared_method (method);
  D.29964 = domain->runtime_info;
  D.29965 = MEM[(struct MonoJitDomainInfo *)D.29964].seq_points;
  seq_points = monoeg_g_hash_table_lookup (D.29965, D.29975);
  <D.29974>:
  <D.29971>:
  <D.29967>:
  {
    int ret;

    D.29956 = &domain->lock.mutex;
    ret = pthread_mutex_unlock (D.29956);
    if (ret != 0) goto <D.29976>; else goto <D.29977>;
    <D.29976>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.29977>:
    D.29978 = ret != 0;
    D.29979 = (long int) D.29978;
    D.29980 = __builtin_expect (D.29979, 0);
    if (D.29980 != 0) goto <D.29981>; else goto <D.29982>;
    <D.29981>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 2997, "ret == 0");
    <D.29982>:
  }
  D.29983 = seq_points;
  return D.29983;
}


compute_frame_info (struct MonoInternalThread * thread, struct DebuggerTlsData * tls)
{
  struct StackFrame * * D.29985;
  int D.29988;
  int log_level.186;
  _Bool D.29992;
  long int D.29993;
  long int D.29994;
  long unsigned int D.29997;
  long int D.29998;
  struct FILE * log_file.187;
  int D.30000;
  int D.30005;
  int D.30007;
  struct StackFrameInfo * D.30009;
  struct MonoThreadUnwindState * D.30010;
  int D.30011;
  int D.30014;
  struct MonoThreadUnwindState * D.30017;
  struct MonoThreadUnwindState * D.30018;
  struct GSList * D.30023;
  unsigned int D.30024;
  long unsigned int D.30025;
  long unsigned int D.30026;
  long unsigned int D.30027;
  long unsigned int D.30028;
  struct StackFrame * * D.30029;
  struct StackFrame * D.30030;
  long int D.30031;
  void * D.30032;
  long int D.30033;
  void * D.30034;
  int D.30037;
  int D.30038;
  int D.30041;
  int findex.188;
  long unsigned int D.30043;
  long unsigned int D.30044;
  struct StackFrame * * D.30045;
  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.29985 = tls->frames;
      if (D.29985 != 0B) goto <D.29986>; else goto <D.29987>;
      <D.29986>:
      D.29988 = tls->frames_up_to_date;
      if (D.29988 != 0) goto <D.29989>; else goto <D.29990>;
      <D.29989>:
      return;
      <D.29990>:
      <D.29987>:
      log_level.186 = log_level;
      D.29992 = log_level.186 > 0;
      D.29993 = (long int) D.29992;
      D.29994 = __builtin_expect (D.29993, 0);
      if (D.29994 != 0) goto <D.29995>; else goto <D.29996>;
      <D.29995>:
      D.29997 = thread->tid;
      D.29998 = (long int) D.29997;
      log_file.187 = log_file;
      fprintf (log_file.187, "Frames for %p(tid=%lx):\n", thread, D.29998);
      log_file.187 = log_file;
      fflush (log_file.187);
      <D.29996>:
      user_data.tls = tls;
      user_data.frames = 0B;
      D.30000 = tls->terminated;
      if (D.30000 != 0) goto <D.30001>; else goto <D.30002>;
      <D.30001>:
      tls->frame_count = 0;
      return;
      <D.30002>:
      D.30005 = tls->really_suspended;
      if (D.30005 == 0) goto <D.30006>; else goto <D.30003>;
      <D.30006>:
      D.30007 = tls->async_state.valid;
      if (D.30007 != 0) goto <D.30008>; else goto <D.30003>;
      <D.30008>:
      D.30009 = &tls->async_last_frame;
      process_frame (D.30009, 0B, &user_data);
      D.30010 = &tls->async_state;
      mono_walk_stack_with_state (process_frame, D.30010, opts, &user_data);
      goto <D.30004>;
      <D.30003>:
      D.30011 = tls->filter_state.valid;
      if (D.30011 != 0) goto <D.30012>; else goto <D.30013>;
      <D.30012>:
      D.30014 = tls->context.valid;
      if (D.30014 != 0) goto <D.30015>; else goto <D.30016>;
      <D.30015>:
      D.30017 = &tls->context;
      mono_walk_stack_with_state (process_filter_frame, D.30017, opts, &user_data);
      <D.30016>:
      D.30018 = &tls->filter_state;
      mono_walk_stack_with_state (process_frame, D.30018, opts, &user_data);
      goto <D.30019>;
      <D.30013>:
      D.30014 = tls->context.valid;
      if (D.30014 != 0) goto <D.30020>; else goto <D.30021>;
      <D.30020>:
      D.30017 = &tls->context;
      mono_walk_stack_with_state (process_frame, D.30017, opts, &user_data);
      goto <D.30022>;
      <D.30021>:
      tls->frame_count = 0;
      return;
      <D.30022>:
      <D.30019>:
      <D.30004>:
      D.30023 = user_data.frames;
      D.30024 = monoeg_g_slist_length (D.30023);
      new_frame_count = (int) D.30024;
      D.30025 = (long unsigned int) new_frame_count;
      D.30026 = D.30025 * 8;
      new_frames = monoeg_malloc0 (D.30026);
      findex = 0;
      tmp = user_data.frames;
      goto <D.25969>;
      <D.25968>:
      f = tmp->data;
      i = 0;
      goto <D.25967>;
      <D.25966>:
      D.29985 = tls->frames;
      D.30027 = (long unsigned int) i;
      D.30028 = D.30027 * 8;
      D.30029 = D.29985 + D.30028;
      D.30030 = *D.30029;
      D.30031 = D.30030->ctx.rsp;
      D.30032 = (void *) D.30031;
      D.30033 = f->ctx.rsp;
      D.30034 = (void *) D.30033;
      if (D.30032 == D.30034) goto <D.30035>; else goto <D.30036>;
      <D.30035>:
      D.29985 = tls->frames;
      D.30027 = (long unsigned int) i;
      D.30028 = D.30027 * 8;
      D.30029 = D.29985 + D.30028;
      D.30030 = *D.30029;
      D.30037 = D.30030->id;
      f->id = D.30037;
      goto <D.25965>;
      <D.30036>:
      i = i + 1;
      <D.25967>:
      D.30038 = tls->frame_count;
      if (D.30038 > i) goto <D.25966>; else goto <D.25965>;
      <D.25965>:
      D.30038 = tls->frame_count;
      if (D.30038 <= i) goto <D.30039>; else goto <D.30040>;
      <D.30039>:
      D.30041 = InterlockedIncrement (&frame_id);
      f->id = D.30041;
      <D.30040>:
      findex.188 = findex;
      findex = findex.188 + 1;
      D.30043 = (long unsigned int) findex.188;
      D.30044 = D.30043 * 8;
      D.30045 = new_frames + D.30044;
      *D.30045 = f;
      tmp = tmp->next;
      <D.25969>:
      if (tmp != 0B) goto <D.25968>; else goto <D.25970>;
      <D.25970>:
      D.30023 = user_data.frames;
      monoeg_g_slist_free (D.30023);
      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 int D.30049;
  void * D.30050;
  struct DebuggerTlsData * D.30051;
  long int D.30052;
  void * D.30053;
  gboolean D.30056;
  struct ComputeFramesUserData * ud;

  ud = user_data;
  D.30049 = ctx->rsp;
  D.30050 = (void *) D.30049;
  D.30051 = ud->tls;
  D.30052 = D.30051->filter_state.ctx.rsp;
  D.30053 = (void *) D.30052;
  if (D.30050 >= D.30053) goto <D.30054>; else goto <D.30055>;
  <D.30054>:
  D.30056 = 1;
  return D.30056;
  <D.30055>:
  D.30056 = process_frame (info, ctx, user_data);
  return D.30056;
}


process_frame (struct StackFrameInfo * info, struct MonoContext * ctx, void * user_data)
{
  <unnamed type> D.30058;
  struct GSList * D.30063;
  struct GSList * D.30066;
  void * D.30067;
  int D.30068;
  int D.30069;
  gboolean D.30070;
  struct MonoJitInfo * D.30071;
  unsigned char D.30080;
  unsigned char D.30081;
  _Bool D.30082;
  _Bool D.30083;
  _Bool D.30084;
  unsigned char D.30086;
  int D.30087;
  int D.30092;
  struct MonoDomain * D.30093;
  int D.30096;
  unsigned int D.30099;
  int D.30100;
  int log_level.189;
  _Bool D.30102;
  long int D.30103;
  long int D.30104;
  int D.30107;
  char * D.30108;
  struct FILE * log_file.190;
  int protocol_version_set.191;
  int major_version.192;
  int minor_version.193;
  unsigned int D.30122;
  unsigned int D.30123;
  mgreg_t * * D.30124;
  mgreg_t *[16] * D.30127;
  struct GSList * D.30130;
  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.30058 = info->type;
  if (D.30058 != 0) goto <D.30059>; else goto <D.30060>;
  <D.30059>:
  D.30058 = info->type;
  if (D.30058 == 1) goto <D.30061>; else goto <D.30062>;
  <D.30061>:
  D.30063 = ud->frames;
  if (D.30063 != 0B) goto <D.30064>; else goto <D.30065>;
  <D.30064>:
  D.30063 = ud->frames;
  D.30066 = monoeg_g_slist_last (D.30063);
  D.30067 = D.30066->data;
  D.30068 = MEM[(struct StackFrame *)D.30067].flags;
  D.30069 = D.30068 | 1;
  MEM[(struct StackFrame *)D.30067].flags = D.30069;
  <D.30065>:
  <D.30062>:
  D.30070 = 0;
  return D.30070;
  <D.30060>:
  D.30071 = info->ji;
  if (D.30071 != 0B) goto <D.30072>; else goto <D.30073>;
  <D.30072>:
  D.30071 = info->ji;
  method = jinfo_get_method (D.30071);
  goto <D.30074>;
  <D.30073>:
  method = info->method;
  <D.30074>:
  actual_method = info->actual_method;
  api_method = method;
  if (method == 0B) goto <D.30075>; else goto <D.30076>;
  <D.30075>:
  D.30070 = 0;
  return D.30070;
  <D.30076>:
  if (method == 0B) goto <D.30077>; else goto <D.30079>;
  <D.30079>:
  D.30080 = BIT_FIELD_REF <*method, 8, 256>;
  D.30081 = D.30080 & 124;
  D.30082 = D.30081 != 0;
  D.30083 = D.30081 != 68;
  D.30084 = D.30082 & D.30083;
  if (D.30084 != 0) goto <D.30085>; else goto <D.30078>;
  <D.30085>:
  D.30080 = BIT_FIELD_REF <*method, 8, 256>;
  D.30086 = D.30080 & 124;
  if (D.30086 != 24) goto <D.30077>; else goto <D.30078>;
  <D.30077>:
  D.30070 = 0;
  return D.30070;
  <D.30078>:
  D.30087 = info->il_offset;
  if (D.30087 == -1) goto <D.30088>; else goto <D.30089>;
  <D.30088>:
  D.30063 = ud->frames;
  if (D.30063 == 0B) goto <D.30090>; else goto <D.30091>;
  <D.30090>:
  D.30092 = info->native_offset;
  D.30093 = info->domain;
  sp = find_prev_seq_point_for_native_offset (D.30093, method, D.30092, 0B);
  if (sp != 0B) goto <D.30094>; else goto <D.30095>;
  <D.30094>:
  D.30096 = sp->il_offset;
  info->il_offset = D.30096;
  <D.30095>:
  <D.30091>:
  D.30087 = info->il_offset;
  if (D.30087 == -1) goto <D.30097>; else goto <D.30098>;
  <D.30097>:
  D.30092 = info->native_offset;
  D.30099 = (unsigned int) D.30092;
  D.30093 = info->domain;
  D.30100 = mono_debug_il_offset_from_address (method, D.30093, D.30099);
  info->il_offset = D.30100;
  <D.30098>:
  <D.30089>:
  log_level.189 = log_level;
  D.30102 = log_level.189 > 0;
  D.30103 = (long int) D.30102;
  D.30104 = __builtin_expect (D.30103, 0);
  if (D.30104 != 0) goto <D.30105>; else goto <D.30106>;
  <D.30105>:
  D.30107 = info->managed;
  D.30092 = info->native_offset;
  D.30087 = info->il_offset;
  D.30108 = mono_method_full_name (method, 1);
  log_file.190 = log_file;
  fprintf (log_file.190, "\tFrame: %s:%x(%x) %d\n", D.30108, D.30087, D.30092, D.30107);
  log_file.190 = log_file;
  fflush (log_file.190);
  <D.30106>:
  D.30080 = BIT_FIELD_REF <*method, 8, 256>;
  D.30086 = D.30080 & 124;
  if (D.30086 == 24) goto <D.30110>; else goto <D.30111>;
  <D.30110>:
  protocol_version_set.191 = protocol_version_set;
  if (protocol_version_set.191 == 0) goto <D.30112>; else goto <D.30115>;
  <D.30115>:
  major_version.192 = major_version;
  if (major_version.192 <= 2) goto <D.30117>; else goto <D.30113>;
  <D.30117>:
  major_version.192 = major_version;
  if (major_version.192 != 2) goto <D.30112>; else goto <D.30118>;
  <D.30118>:
  minor_version.193 = minor_version;
  if (minor_version.193 <= 16) goto <D.30112>; else goto <D.30113>;
  <D.30112>:
  D.30070 = 0;
  return D.30070;
  <D.30113>:
  api_method = mono_marshal_method_from_wrapper (method);
  if (api_method == 0B) goto <D.30120>; else goto <D.30121>;
  <D.30120>:
  D.30070 = 0;
  return D.30070;
  <D.30121>:
  actual_method = api_method;
  flags = flags | 2;
  <D.30111>:
  frame = monoeg_malloc0 (344);
  frame->method = method;
  frame->actual_method = actual_method;
  frame->api_method = api_method;
  D.30087 = info->il_offset;
  D.30122 = (unsigned int) D.30087;
  frame->il_offset = D.30122;
  D.30092 = info->native_offset;
  D.30123 = (unsigned int) D.30092;
  frame->native_offset = D.30123;
  frame->flags = flags;
  D.30071 = info->ji;
  frame->ji = D.30071;
  D.30124 = info->reg_locations;
  if (D.30124 != 0B) goto <D.30125>; else goto <D.30126>;
  <D.30125>:
  D.30124 = info->reg_locations;
  D.30127 = &frame->reg_locations;
  memcpy (D.30127, D.30124, 128);
  <D.30126>:
  if (ctx != 0B) goto <D.30128>; else goto <D.30129>;
  <D.30128>:
  frame->ctx = *ctx;
  frame->has_ctx = 1;
  <D.30129>:
  D.30093 = info->domain;
  frame->domain = D.30093;
  D.30063 = ud->frames;
  D.30130 = monoeg_g_slist_append (D.30063, frame);
  ud->frames = D.30130;
  D.30070 = 0;
  return D.30070;
}


find_prev_seq_point_for_native_offset (struct MonoDomain * domain, struct MonoMethod * method, gint32 native_offset, struct MonoSeqPointInfo * * info)
{
  struct SeqPoint * D.30136;
  int D.30137;
  int D.30138;
  struct MonoSeqPointInfo * seq_points;
  int i;

  seq_points = get_seq_points (domain, method);
  if (info != 0B) goto <D.30132>; else goto <D.30133>;
  <D.30132>:
  *info = seq_points;
  <D.30133>:
  if (seq_points == 0B) goto <D.30134>; else goto <D.30135>;
  <D.30134>:
  D.30136 = 0B;
  return D.30136;
  <D.30135>:
  D.30137 = seq_points->len;
  i = D.30137 + -1;
  goto <D.25918>;
  <D.25917>:
  D.30138 = seq_points->seq_points[i].native_offset;
  if (D.30138 <= native_offset) goto <D.30139>; else goto <D.30140>;
  <D.30139>:
  D.30136 = &seq_points->seq_points[i];
  return D.30136;
  <D.30140>:
  i = i + -1;
  <D.25918>:
  if (i >= 0) goto <D.25917>; else goto <D.25919>;
  <D.25919>:
  D.30136 = 0B;
  return D.30136;
}


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

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


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

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


ss_start (struct SingleStepReq * ss_req, struct MonoMethod * method, struct SeqPoint * sp, struct MonoSeqPointInfo * info, struct MonoContext * ctx, struct DebuggerTlsData * tls, gboolean step_to_catch)
{
  struct EventRequest * D.30147;
  int D.30148;
  long int D.30149;
  struct GSList * D.30150;
  struct GSList * D.30151;
  int D.30156;
  <unnamed type> D.30158;
  int D.30162;
  struct MonoThreadUnwindState * D.30165;
  struct MonoInternalThread * D.30166;
  struct StackFrame * * D.30169;
  long unsigned int D.30170;
  long unsigned int D.30171;
  struct StackFrame * * D.30172;
  unsigned int D.30173;
  int D.30174;
  struct MonoMethod * D.30175;
  struct MonoDomain * D.30176;
  int D.30180;
  unsigned int D.30186;
  int D.30187;
  struct MonoMethod * D.30188;
  struct MonoDomain * D.30189;
  struct MonoSeqPointInfo * info.194;
  int * D.30198;
  long unsigned int D.30199;
  long unsigned int D.30200;
  int * D.30201;
  int D.30202;
  int D.30203;
  long int D.30204;
  struct GSList * D.30205;
  int D.30208;
  long unsigned int D.30211;
  struct StackFrame * * D.30212;
  struct MonoJitInfo * D.30213;
  void * D.30216;
  long int D.30217;
  void * D.30218;
  long int D.30219;
  long int D.30220;
  int D.30221;
  struct MonoMethod * D.30222;
  struct MonoDomain * D.30223;
  struct GSList * D.30226;
  <unnamed-unsigned:15> D.30227;
  int D.30228;
  int log_level.195;
  _Bool D.30234;
  long int D.30235;
  long int D.30236;
  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.30145>; else goto <D.30146>;
  <D.30145>:
  D.30147 = ss_req->req;
  D.30148 = sp->il_offset;
  D.30149 = (long int) D.30148;
  bp = set_breakpoint (method, D.30149, D.30147, 0B);
  D.30150 = ss_req->bps;
  D.30151 = monoeg_g_slist_append (D.30150, bp);
  ss_req->bps = D.30151;
  goto <D.30152>;
  <D.30146>:
  frame_index = 1;
  if (sp == 0B) goto <D.30153>; else goto <D.30155>;
  <D.30155>:
  D.30156 = sp->next_len;
  if (D.30156 == 0) goto <D.30153>; else goto <D.30157>;
  <D.30157>:
  D.30158 = ss_req->depth;
  if (D.30158 == 2) goto <D.30153>; else goto <D.30159>;
  <D.30159>:
  D.30158 = ss_req->depth;
  if (D.30158 == 1) goto <D.30153>; else goto <D.30154>;
  <D.30153>:
  if (ctx != 0B) goto <D.30160>; else goto <D.30161>;
  <D.30160>:
  D.30162 = tls->context.valid;
  if (D.30162 == 0) goto <D.30163>; else goto <D.30164>;
  <D.30163>:
  D.30165 = &tls->context;
  mono_thread_state_init_from_monoctx (D.30165, ctx);
  <D.30164>:
  D.30166 = tls->thread;
  compute_frame_info (D.30166, tls);
  <D.30161>:
  <D.30154>:
  D.30158 = ss_req->depth;
  if (D.30158 == 2) goto <D.30167>; else goto <D.30168>;
  <D.30167>:
  goto <D.26526>;
  <D.26525>:
  {
    struct StackFrame * frame;

    D.30169 = tls->frames;
    D.30170 = (long unsigned int) frame_index;
    D.30171 = D.30170 * 8;
    D.30172 = D.30169 + D.30171;
    frame = *D.30172;
    method = frame->method;
    D.30173 = frame->native_offset;
    D.30174 = (int) D.30173;
    D.30175 = frame->method;
    D.30176 = frame->domain;
    sp = find_prev_seq_point_for_native_offset (D.30176, D.30175, D.30174, &info);
    frame_index = frame_index + 1;
    if (sp != 0B) goto <D.30177>; else goto <D.30178>;
    <D.30177>:
    D.30156 = sp->next_len;
    if (D.30156 != 0) goto <D.26524>; else goto <D.30179>;
    <D.30179>:
    <D.30178>:
  }
  <D.26526>:
  D.30180 = tls->frame_count;
  if (D.30180 > frame_index) goto <D.26525>; else goto <D.26524>;
  <D.26524>:
  goto <D.30181>;
  <D.30168>:
  if (sp != 0B) goto <D.30182>; else goto <D.30183>;
  <D.30182>:
  D.30156 = sp->next_len;
  if (D.30156 == 0) goto <D.30184>; else goto <D.30185>;
  <D.30184>:
  sp = 0B;
  goto <D.26530>;
  <D.26529>:
  {
    struct StackFrame * frame;

    D.30169 = tls->frames;
    D.30170 = (long unsigned int) frame_index;
    D.30171 = D.30170 * 8;
    D.30172 = D.30169 + D.30171;
    frame = *D.30172;
    method = frame->method;
    D.30186 = frame->native_offset;
    D.30187 = (int) D.30186;
    D.30188 = frame->method;
    D.30189 = frame->domain;
    sp = find_prev_seq_point_for_native_offset (D.30189, D.30188, D.30187, &info);
    if (sp != 0B) goto <D.30190>; else goto <D.30191>;
    <D.30190>:
    D.30156 = sp->next_len;
    if (D.30156 != 0) goto <D.26528>; else goto <D.30192>;
    <D.30192>:
    <D.30191>:
    sp = 0B;
    frame_index = frame_index + 1;
  }
  <D.26530>:
  D.30180 = tls->frame_count;
  if (D.30180 > frame_index) goto <D.26529>; else goto <D.26528>;
  <D.26528>:
  <D.30185>:
  <D.30183>:
  <D.30181>:
  if (sp != 0B) goto <D.30193>; else goto <D.30194>;
  <D.30193>:
  D.30156 = sp->next_len;
  if (D.30156 > 0) goto <D.30195>; else goto <D.30196>;
  <D.30195>:
  i = 0;
  goto <D.26532>;
  <D.26531>:
  info.194 = info;
  D.30198 = sp->next;
  D.30199 = (long unsigned int) i;
  D.30200 = D.30199 * 4;
  D.30201 = D.30198 + D.30200;
  D.30202 = *D.30201;
  next_sp = &info.194->seq_points[D.30202];
  D.30147 = ss_req->req;
  D.30203 = next_sp->il_offset;
  D.30204 = (long int) D.30203;
  bp = set_breakpoint (method, D.30204, D.30147, 0B);
  D.30150 = ss_req->bps;
  D.30205 = monoeg_g_slist_append (D.30150, bp);
  ss_req->bps = D.30205;
  i = i + 1;
  <D.26532>:
  D.30156 = sp->next_len;
  if (D.30156 > i) goto <D.26531>; else goto <D.26533>;
  <D.26533>:
  <D.30196>:
  <D.30194>:
  D.30158 = ss_req->depth;
  if (D.30158 == 1) goto <D.30206>; else goto <D.30207>;
  <D.30206>:
  D.30208 = ss_req->nframes;
  if (D.30208 == 0) goto <D.30209>; else goto <D.30210>;
  <D.30209>:
  D.30180 = tls->frame_count;
  ss_req->nframes = D.30180;
  <D.30210>:
  i = 0;
  goto <D.26541>;
  <D.26540>:
  {
    struct StackFrame * frame;

    D.30169 = tls->frames;
    D.30199 = (long unsigned int) i;
    D.30211 = D.30199 * 8;
    D.30212 = D.30169 + D.30211;
    frame = *D.30212;
    D.30213 = frame->ji;
    if (D.30213 != 0B) goto <D.30214>; else goto <D.30215>;
    <D.30214>:
    {
      struct MonoJitInfo * jinfo;

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

        ei = &jinfo->clauses[j];
        D.30216 = ei->handler_start;
        D.30217 = (long int) D.30216;
        D.30218 = jinfo->code_start;
        D.30219 = (long int) D.30218;
        D.30220 = D.30217 - D.30219;
        D.30221 = (int) D.30220;
        D.30222 = frame->method;
        D.30223 = frame->domain;
        sp = find_next_seq_point_for_native_offset (D.30223, D.30222, D.30221, 0B);
        if (sp != 0B) goto <D.30224>; else goto <D.30225>;
        <D.30224>:
        D.30147 = ss_req->req;
        D.30148 = sp->il_offset;
        D.30149 = (long int) D.30148;
        D.30222 = frame->method;
        bp = set_breakpoint (D.30222, D.30149, D.30147, 0B);
        D.30150 = ss_req->bps;
        D.30226 = monoeg_g_slist_append (D.30150, bp);
        ss_req->bps = D.30226;
        <D.30225>:
      }
      j = j + 1;
      <D.26538>:
      D.30227 = jinfo->num_clauses;
      D.30228 = (int) D.30227;
      if (D.30228 > j) goto <D.26537>; else goto <D.26539>;
      <D.26539>:
    }
    <D.30215>:
  }
  i = i + 1;
  <D.26541>:
  D.30180 = tls->frame_count;
  if (D.30180 > i) goto <D.26540>; else goto <D.26542>;
  <D.26542>:
  <D.30207>:
  D.30158 = ss_req->depth;
  if (D.30158 == 0) goto <D.30229>; else goto <D.30230>;
  <D.30229>:
  enable_global = 1;
  <D.30230>:
  tls->context.valid = 0;
  tls->async_state.valid = 0;
  invalidate_frames (tls);
  <D.30152>:
  if (enable_global != 0) goto <D.30231>; else goto <D.30232>;
  <D.30231>:
  log_level.195 = log_level;
  D.30234 = log_level.195 > 0;
  D.30235 = (long int) D.30234;
  D.30236 = __builtin_expect (D.30235, 0);
  if (D.30236 != 0) goto <D.30237>; else goto <D.30238>;
  <D.30237>:
  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.30238>:
  ss_req->global = 1;
  start_single_stepping ();
  goto <D.30240>;
  <D.30232>:
  D.30150 = ss_req->bps;
  if (D.30150 == 0B) goto <D.30241>; else goto <D.30242>;
  <D.30241>:
  log_level.195 = log_level;
  D.30234 = log_level.195 > 0;
  D.30235 = (long int) D.30234;
  D.30236 = __builtin_expect (D.30235, 0);
  if (D.30236 != 0) goto <D.30243>; else goto <D.30244>;
  <D.30243>:
  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.30244>:
  ss_req->global = 1;
  start_single_stepping ();
  goto <D.30245>;
  <D.30242>:
  ss_req->global = 0;
  <D.30245>:
  <D.30240>:
}


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

  val = InterlockedIncrement (&ss_count);
  if (val == 1) goto <D.30246>; else goto <D.30247>;
  <D.30246>:
  mono_arch_start_single_stepping ();
  <D.30247>:
  ss_req.197 = ss_req;
  if (ss_req.197 != 0B) goto <D.30249>; else goto <D.30250>;
  <D.30249>:
  ss_invoke_addr.198 = ss_invoke_addr;
  if (ss_invoke_addr.198 == 0B) goto <D.30252>; else goto <D.30253>;
  <D.30252>:
  {
    struct DebuggerTlsData * tls;

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


set_breakpoint (struct MonoMethod * method, long int il_offset, struct EventRequest * req, struct MonoError * error)
{
  struct GPtrArray * D.30259;
  int log_level.201;
  _Bool D.30261;
  long int D.30262;
  long int D.30263;
  int D.30266;
  const char * iftmp.202;
  const char * iftmp.203;
  int D.30272;
  struct FILE * log_file.204;
  struct GHashTable * domains.205;
  struct MonoDomain * domain.206;
  union mono_mutex_t * D.30279;
  _Bool D.30282;
  long int D.30283;
  long int D.30284;
  void * D.30287;
  struct GHashTable * D.30288;
  struct MonoMethod * m.207;
  int D.30290;
  struct MonoSeqPointInfo * seq_points.208;
  int D.30294;
  _Bool D.30297;
  long int D.30298;
  long int D.30299;
  int D.30302;
  struct GPtrArray * breakpoints.209;
  int D.30306;
  struct MonoBreakpoint * D.30309;
  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.30257>; else goto <D.30258>;
      <D.30257>:
      mono_error_init (error);
      <D.30258>:
      bp = monoeg_malloc0 (32);
      bp->method = method;
      bp->il_offset = il_offset;
      bp->req = req;
      D.30259 = monoeg_g_ptr_array_new ();
      bp->children = D.30259;
      log_level.201 = log_level;
      D.30261 = log_level.201 > 0;
      D.30262 = (long int) D.30261;
      D.30263 = __builtin_expect (D.30262, 0);
      if (D.30263 != 0) goto <D.30264>; else goto <D.30265>;
      <D.30264>:
      D.30266 = (int) il_offset;
      if (method != 0B) goto <D.30268>; else goto <D.30269>;
      <D.30268>:
      iftmp.202 = mono_method_full_name (method, 1);
      goto <D.30270>;
      <D.30269>:
      iftmp.202 = "<all>";
      <D.30270>:
      D.30272 = req->event_kind;
      if (D.30272 == 11) goto <D.30273>; else goto <D.30274>;
      <D.30273>:
      iftmp.203 = "single step ";
      goto <D.30275>;
      <D.30274>:
      iftmp.203 = "";
      <D.30275>:
      log_file.204 = log_file;
      fprintf (log_file.204, "[dbg] Setting %sbreakpoint at %s:0x%x.\n", iftmp.203, iftmp.202, D.30266);
      log_file.204 = log_file;
      fflush (log_file.204);
      <D.30265>:
      mono_loader_lock ();
      domains.205 = domains;
      monoeg_g_hash_table_iter_init (&iter, domains.205);
      goto <D.26321>;
      <D.26320>:
      {
        int ret;

        domain.206 = domain;
        D.30279 = &domain.206->lock.mutex;
        ret = pthread_mutex_lock (D.30279);
        if (ret != 0) goto <D.30280>; else goto <D.30281>;
        <D.30280>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
        <D.30281>:
        D.30282 = ret != 0;
        D.30283 = (long int) D.30282;
        D.30284 = __builtin_expect (D.30283, 0);
        if (D.30284 != 0) goto <D.30285>; else goto <D.30286>;
        <D.30285>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 4353, "ret == 0");
        <D.30286>:
      }
      domain.206 = domain;
      D.30287 = domain.206->runtime_info;
      D.30288 = MEM[(struct MonoJitDomainInfo *)D.30287].seq_points;
      monoeg_g_hash_table_iter_init (&iter2, D.30288);
      goto <D.26317>;
      <D.26316>:
      m.207 = m;
      D.30290 = bp_matches_method (bp, m.207);
      if (D.30290 != 0) goto <D.30291>; else goto <D.30292>;
      <D.30291>:
      seq_points.208 = seq_points;
      m.207 = m;
      domain.206 = domain;
      set_bp_in_method (domain.206, m.207, seq_points.208, bp, error);
      <D.30292>:
      <D.26317>:
      D.30294 = monoeg_g_hash_table_iter_next (&iter2, &m, &seq_points);
      if (D.30294 != 0) goto <D.26316>; else goto <D.26318>;
      <D.26318>:
      {
        int ret;

        domain.206 = domain;
        D.30279 = &domain.206->lock.mutex;
        ret = pthread_mutex_unlock (D.30279);
        if (ret != 0) goto <D.30295>; else goto <D.30296>;
        <D.30295>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.30296>:
        D.30297 = ret != 0;
        D.30298 = (long int) D.30297;
        D.30299 = __builtin_expect (D.30298, 0);
        if (D.30299 != 0) goto <D.30300>; else goto <D.30301>;
        <D.30300>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 4361, "ret == 0");
        <D.30301>:
      }
      <D.26321>:
      D.30302 = monoeg_g_hash_table_iter_next (&iter, &domain, 0B);
      if (D.30302 != 0) goto <D.26320>; else goto <D.26322>;
      <D.26322>:
      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.30304>; else goto <D.30305>;
      <D.30304>:
      D.30306 = mono_error_ok (error);
      if (D.30306 == 0) goto <D.30307>; else goto <D.30308>;
      <D.30307>:
      clear_breakpoint (bp);
      D.30309 = 0B;
      return D.30309;
      <D.30308>:
      <D.30305>:
      D.30309 = bp;
      return D.30309;
    }
  finally
    {
      iter = {CLOBBER};
      iter2 = {CLOBBER};
      domain = {CLOBBER};
      m = {CLOBBER};
      seq_points = {CLOBBER};
    }
}


bp_matches_method (struct MonoBreakpoint * bp, struct MonoMethod * method)
{
  struct MonoMethod * D.30312;
  gboolean D.30315;
  unsigned char D.30318;
  unsigned char D.30319;
  struct MonoMethod * D.30322;
  unsigned char D.30325;
  unsigned char D.30326;
  struct MonoMethod * D.30331;
  struct MonoMethod * D.30332;
  struct MonoGenericInst * D.30335;
  struct MonoGenericInst * D.30336;
  struct MonoGenericInst * D.30339;
  unsigned char D.30342;
  unsigned char D.30343;
  unsigned char D.30346;
  <unnamed-unsigned:22> D.30349;
  int D.30350;
  int i;

  D.30312 = bp->method;
  if (D.30312 == 0B) goto <D.30313>; else goto <D.30314>;
  <D.30313>:
  D.30315 = 1;
  return D.30315;
  <D.30314>:
  D.30312 = bp->method;
  if (D.30312 == method) goto <D.30316>; else goto <D.30317>;
  <D.30316>:
  D.30315 = 1;
  return D.30315;
  <D.30317>:
  D.30318 = BIT_FIELD_REF <*method, 8, 264>;
  D.30319 = D.30318 & 16;
  if (D.30319 != 0) goto <D.30320>; else goto <D.30321>;
  <D.30320>:
  D.30322 = MEM[(struct MonoMethodInflated *)method].declaring;
  D.30312 = bp->method;
  if (D.30322 == D.30312) goto <D.30323>; else goto <D.30324>;
  <D.30323>:
  D.30315 = 1;
  return D.30315;
  <D.30324>:
  <D.30321>:
  D.30312 = bp->method;
  D.30325 = BIT_FIELD_REF <*D.30312, 8, 264>;
  D.30326 = D.30325 & 16;
  if (D.30326 != 0) goto <D.30327>; else goto <D.30328>;
  <D.30327>:
  D.30318 = BIT_FIELD_REF <*method, 8, 264>;
  D.30319 = D.30318 & 16;
  if (D.30319 != 0) goto <D.30329>; else goto <D.30330>;
  <D.30329>:
  {
    struct MonoMethodInflated * bpimethod;
    struct MonoMethodInflated * imethod;

    bpimethod = bp->method;
    imethod = method;
    D.30331 = bpimethod->declaring;
    D.30332 = imethod->declaring;
    if (D.30331 == D.30332) goto <D.30333>; else goto <D.30334>;
    <D.30333>:
    D.30335 = bpimethod->context.class_inst;
    D.30336 = imethod->context.class_inst;
    if (D.30335 == D.30336) goto <D.30337>; else goto <D.30338>;
    <D.30337>:
    D.30339 = bpimethod->context.method_inst;
    if (D.30339 != 0B) goto <D.30340>; else goto <D.30341>;
    <D.30340>:
    D.30339 = bpimethod->context.method_inst;
    D.30342 = BIT_FIELD_REF <*D.30339, 8, 48>;
    D.30343 = D.30342 & 64;
    if (D.30343 != 0) goto <D.30344>; else goto <D.30345>;
    <D.30344>:
    i = 0;
    goto <D.26269>;
    <D.26268>:
    {
      struct MonoType * t1;

      D.30339 = bpimethod->context.method_inst;
      t1 = D.30339->type_argv[i];
      D.30346 = t1->type;
      if (D.30346 != 30) goto <D.30347>; else goto <D.30348>;
      <D.30347>:
      D.30315 = 0;
      return D.30315;
      <D.30348>:
    }
    i = i + 1;
    <D.26269>:
    D.30339 = bpimethod->context.method_inst;
    D.30349 = D.30339->type_argc;
    D.30350 = (int) D.30349;
    if (D.30350 > i) goto <D.26268>; else goto <D.26270>;
    <D.26270>:
    D.30315 = 1;
    return D.30315;
    <D.30345>:
    <D.30341>:
    <D.30338>:
    <D.30334>:
  }
  <D.30330>:
  <D.30328>:
  D.30315 = 0;
  return D.30315;
}


set_bp_in_method (struct MonoDomain * domain, struct MonoMethod * method, struct MonoSeqPointInfo * seq_points, struct MonoBreakpoint * bp, struct MonoError * error)
{
  _Bool D.30356;
  long int D.30357;
  long int D.30358;
  struct MonoJitInfo * ji.210;
  struct MonoJitInfo * ji.211;
  _Bool D.30363;
  long int D.30364;
  long int D.30365;
  void * code;
  struct MonoJitInfo * ji;

  try
    {
      if (error != 0B) goto <D.30352>; else goto <D.30353>;
      <D.30352>:
      mono_error_init (error);
      <D.30353>:
      code = mono_jit_find_compiled_method_with_jit_info (domain, method, &ji);
      if (code == 0B) goto <D.30354>; else goto <D.30355>;
      <D.30354>:
      code = mono_aot_get_method (domain, method);
      D.30356 = code == 0B;
      D.30357 = (long int) D.30356;
      D.30358 = __builtin_expect (D.30357, 0);
      if (D.30358 != 0) goto <D.30359>; else goto <D.30360>;
      <D.30359>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 4301, "code");
      <D.30360>:
      ji.210 = mono_jit_info_table_find (domain, code);
      ji = ji.210;
      ji.211 = ji;
      D.30363 = ji.211 == 0B;
      D.30364 = (long int) D.30363;
      D.30365 = __builtin_expect (D.30364, 0);
      if (D.30365 != 0) goto <D.30366>; else goto <D.30367>;
      <D.30366>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 4303, "ji");
      <D.30367>:
      <D.30355>:
      D.30356 = code == 0B;
      D.30357 = (long int) D.30356;
      D.30358 = __builtin_expect (D.30357, 0);
      if (D.30358 != 0) goto <D.30368>; else goto <D.30369>;
      <D.30368>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 4305, "code");
      <D.30369>:
      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.30372;
  long int D.30373;
  long int D.30374;
  int D.30376;
  int D.30379;
  _Bool D.30380;
  _Bool D.30381;
  _Bool D.30382;
  int D.30385;
  long int D.30386;
  struct MonoMethod * D.30390;
  char * D.30391;
  int log_level.212;
  _Bool D.30393;
  long int D.30394;
  long int D.30395;
  int D.30398;
  struct FILE * log_file.213;
  int D.30402;
  long int D.30403;
  void * D.30404;
  sizetype D.30405;
  guint8 * D.30406;
  struct GPtrArray * D.30407;
  guint8 * D.30408;
  struct GHashTable * bp_locs.214;
  void * D.30410;
  long int D.30411;
  int D.30412;
  long int D.30413;
  void * D.30414;
  int D.30419;
  struct MonoMethod * D.30425;
  char * D.30426;
  int i;
  int count;
  struct BreakpointInstance * inst;
  struct SeqPoint * sp;

  sp = 0B;
  if (error != 0B) goto <D.30370>; else goto <D.30371>;
  <D.30370>:
  mono_error_init (error);
  <D.30371>:
  i = 0;
  goto <D.26246>;
  <D.26245>:
  sp = &seq_points->seq_points[i];
  D.30372 = sp->il_offset;
  D.30373 = (long int) D.30372;
  D.30374 = bp->il_offset;
  if (D.30373 == D.30374) goto <D.26244>; else goto <D.30375>;
  <D.30375>:
  i = i + 1;
  <D.26246>:
  D.30376 = seq_points->len;
  if (D.30376 > i) goto <D.26245>; else goto <D.26244>;
  <D.26244>:
  D.30376 = seq_points->len;
  if (D.30376 == i) goto <D.30377>; else goto <D.30378>;
  <D.30377>:
  i = 0;
  goto <D.26249>;
  <D.26248>:
  sp = &seq_points->seq_points[i];
  D.30379 = sp->il_offset;
  D.30380 = D.30379 != -1;
  D.30381 = D.30379 != 16777215;
  D.30382 = D.30380 & D.30381;
  if (D.30382 != 0) goto <D.30383>; else goto <D.30384>;
  <D.30383>:
  D.30372 = sp->il_offset;
  D.30385 = D.30372 + 1;
  D.30386 = (long int) D.30385;
  D.30374 = bp->il_offset;
  if (D.30386 == D.30374) goto <D.26247>; else goto <D.30387>;
  <D.30387>:
  <D.30384>:
  i = i + 1;
  <D.26249>:
  D.30376 = seq_points->len;
  if (D.30376 > i) goto <D.26248>; else goto <D.26247>;
  <D.26247>:
  <D.30378>:
  D.30376 = seq_points->len;
  if (D.30376 == i) goto <D.30388>; else goto <D.30389>;
  <D.30388>:
  {
    char * s;

    D.30376 = seq_points->len;
    D.30374 = bp->il_offset;
    D.30390 = jinfo_get_method (ji);
    D.30391 = mono_method_full_name (D.30390, 1);
    s = monoeg_g_strdup_printf ("Unable to insert breakpoint at %s:%d, seq_points=%d\n", D.30391, D.30374, D.30376);
    i = 0;
    goto <D.26252>;
    <D.26251>:
    log_level.212 = log_level;
    D.30393 = log_level.212 > 0;
    D.30394 = (long int) D.30393;
    D.30395 = __builtin_expect (D.30394, 0);
    if (D.30395 != 0) goto <D.30396>; else goto <D.30397>;
    <D.30396>:
    D.30398 = seq_points->seq_points[i].il_offset;
    log_file.213 = log_file;
    fprintf (log_file.213, "%d\n", D.30398);
    log_file.213 = log_file;
    fflush (log_file.213);
    <D.30397>:
    i = i + 1;
    <D.26252>:
    D.30376 = seq_points->len;
    if (D.30376 > i) goto <D.26251>; else goto <D.26253>;
    <D.26253>:
    if (error != 0B) goto <D.30400>; else goto <D.30401>;
    <D.30400>:
    mono_error_set_error (error, 9, "%s", s);
    monoeg_g_log (0B, 16, "%s", s);
    monoeg_g_free (s);
    return;
    <D.30401>:
    monoeg_g_log (0B, 16, "%s", s);
    monoeg_g_free (s);
    return;
  }
  <D.30389>:
  inst = monoeg_malloc0 (48);
  inst->sp = sp;
  D.30402 = sp->native_offset;
  D.30403 = (long int) D.30402;
  inst->native_offset = D.30403;
  D.30404 = ji->code_start;
  D.30402 = sp->native_offset;
  D.30405 = (sizetype) D.30402;
  D.30406 = D.30404 + D.30405;
  inst->ip = D.30406;
  inst->ji = ji;
  inst->domain = domain;
  mono_loader_lock ();
  D.30407 = bp->children;
  monoeg_g_ptr_array_add (D.30407, inst);
  D.30408 = inst->ip;
  bp_locs.214 = bp_locs;
  D.30410 = monoeg_g_hash_table_lookup (bp_locs.214, D.30408);
  D.30411 = (long int) D.30410;
  count = (int) D.30411;
  D.30412 = count + 1;
  D.30413 = (long int) D.30412;
  D.30414 = (void *) D.30413;
  D.30408 = inst->ip;
  bp_locs.214 = bp_locs;
  monoeg_g_hash_table_insert_replace (bp_locs.214, D.30408, D.30414, 0);
  mono_loader_unlock ();
  D.30402 = sp->native_offset;
  if (D.30402 == -1) goto <D.30415>; else goto <D.30416>;
  <D.30415>:
  log_level.212 = log_level;
  D.30393 = log_level.212 > 0;
  D.30394 = (long int) D.30393;
  D.30395 = __builtin_expect (D.30394, 0);
  if (D.30395 != 0) goto <D.30417>; else goto <D.30418>;
  <D.30417>:
  D.30374 = bp->il_offset;
  D.30419 = (int) D.30374;
  log_file.213 = log_file;
  fprintf (log_file.213, "[dbg] Attempting to insert seq point at dead IL offset %d, ignoring.\n", D.30419);
  log_file.213 = log_file;
  fflush (log_file.213);
  <D.30418>:
  goto <D.30420>;
  <D.30416>:
  if (count == 0) goto <D.30421>; else goto <D.30422>;
  <D.30421>:
  D.30408 = inst->ip;
  mono_arch_set_breakpoint (ji, D.30408);
  <D.30422>:
  <D.30420>:
  log_level.212 = log_level;
  D.30393 = log_level.212 > 0;
  D.30394 = (long int) D.30393;
  D.30395 = __builtin_expect (D.30394, 0);
  if (D.30395 != 0) goto <D.30423>; else goto <D.30424>;
  <D.30423>:
  D.30372 = sp->il_offset;
  D.30425 = jinfo_get_method (ji);
  D.30426 = mono_method_full_name (D.30425, 1);
  log_file.213 = log_file;
  fprintf (log_file.213, "[dbg] Inserted breakpoint at %s:0x%x.\n", D.30426, D.30372);
  log_file.213 = log_file;
  fflush (log_file.213);
  <D.30424>:
}


domain_commands (int command, guint8 * p, guint8 * end, struct Buffer * buf)
{
  struct MonoDomain * D.30428;
  guint8 * p.215;
  int err.216;
  ErrorCode D.30433;
  char * D.30434;
  unsigned int count.217;
  struct MonoAssembly * D.30440;
  struct MonoAppDomain * D.30443;
  struct MonoVTable * D.30444;
  struct MonoClass * D.30445;
  struct MonoImage * D.30446;
  struct MonoAssembly * D.30447;
  struct MonoDomain * domain2.218;
  _Bool D.30455;
  long int D.30456;
  long int D.30457;
  void * D.30460;
  struct MonoType * D.30461;
  <unnamed type> D.30462;
  int err.219;
  int err;
  struct MonoDomain * domain;

  try
    {
      switch (command) <default: <D.27246>, case 1: <D.27224>, case 2: <D.27226>, case 3: <D.27227>, case 4: <D.27237>, case 5: <D.27239>, case 6: <D.27238>, case 7: <D.27242>>
      <D.27224>:
      D.30428 = mono_get_root_domain ();
      buffer_add_domainid (buf, D.30428);
      goto <D.27225>;
      <D.27226>:
      p.215 = p;
      domain = decode_domainid (p.215, &p, end, 0B, &err);
      err.216 = err;
      if (err.216 != 0) goto <D.30431>; else goto <D.30432>;
      <D.30431>:
      err.216 = err;
      D.30433 = (ErrorCode) err.216;
      return D.30433;
      <D.30432>:
      D.30434 = domain->friendly_name;
      buffer_add_string (buf, D.30434);
      goto <D.27225>;
      <D.27227>:
      {
        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.30435>; else goto <D.30436>;
        <D.30435>:
        err.216 = err;
        D.30433 = (ErrorCode) err.216;
        return D.30433;
        <D.30436>:
        mono_loader_lock ();
        count = 0;
        tmp = domain->domain_assemblies;
        goto <D.27232>;
        <D.27231>:
        count = count + 1;
        tmp = tmp->next;
        <D.27232>:
        if (tmp != 0B) goto <D.27231>; else goto <D.27233>;
        <D.27233>:
        count.217 = (unsigned int) count;
        buffer_add_int (buf, count.217);
        tmp = domain->domain_assemblies;
        goto <D.27235>;
        <D.27234>:
        ass = tmp->data;
        buffer_add_assemblyid (buf, domain, ass);
        tmp = tmp->next;
        <D.27235>:
        if (tmp != 0B) goto <D.27234>; else goto <D.27236>;
        <D.27236>:
        mono_loader_unlock ();
        goto <D.27225>;
      }
      <D.27237>:
      p.215 = p;
      domain = decode_domainid (p.215, &p, end, 0B, &err);
      err.216 = err;
      if (err.216 != 0) goto <D.30438>; else goto <D.30439>;
      <D.30438>:
      err.216 = err;
      D.30433 = (ErrorCode) err.216;
      return D.30433;
      <D.30439>:
      D.30440 = domain->entry_assembly;
      buffer_add_assemblyid (buf, domain, D.30440);
      goto <D.27225>;
      <D.27238>:
      p.215 = p;
      domain = decode_domainid (p.215, &p, end, 0B, &err);
      err.216 = err;
      if (err.216 != 0) goto <D.30441>; else goto <D.30442>;
      <D.30441>:
      err.216 = err;
      D.30433 = (ErrorCode) err.216;
      return D.30433;
      <D.30442>:
      D.30443 = domain->domain;
      D.30444 = D.30443->mbr.obj.vtable;
      D.30445 = D.30444->klass;
      D.30446 = D.30445->image;
      D.30447 = D.30446->assembly;
      buffer_add_assemblyid (buf, domain, D.30447);
      goto <D.27225>;
      <D.27239>:
      {
        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.30448>; else goto <D.30449>;
        <D.30448>:
        err.216 = err;
        D.30433 = (ErrorCode) err.216;
        return D.30433;
        <D.30449>:
        p.215 = p;
        s = decode_string (p.215, &p, end);
        o = mono_string_new (domain, s);
        buffer_add_objid (buf, o);
        goto <D.27225>;
      }
      <D.27242>:
      {
        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.30450>; else goto <D.30451>;
            <D.30450>:
            err.216 = err;
            D.30433 = (ErrorCode) err.216;
            return D.30433;
            <D.30451>:
            p.215 = p;
            klass = decode_typeid (p.215, &p, end, &domain2, &err);
            err.216 = err;
            if (err.216 != 0) goto <D.30452>; else goto <D.30453>;
            <D.30452>:
            err.216 = err;
            D.30433 = (ErrorCode) err.216;
            return D.30433;
            <D.30453>:
            domain2.218 = domain2;
            D.30455 = domain != domain2.218;
            D.30456 = (long int) D.30455;
            D.30457 = __builtin_expect (D.30456, 0);
            if (D.30457 != 0) goto <D.30458>; else goto <D.30459>;
            <D.30458>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 7271, "domain == domain2");
            <D.30459>:
            o = mono_object_new (domain, klass);
            p.215 = p;
            D.30460 = mono_object_unbox (o);
            D.30461 = &klass->byval_arg;
            D.30462 = decode_value (D.30461, domain, D.30460, p.215, &p, end);
            err.219 = (int) D.30462;
            err = err.219;
            err.216 = err;
            if (err.216 != 0) goto <D.30464>; else goto <D.30465>;
            <D.30464>:
            err.216 = err;
            D.30433 = (ErrorCode) err.216;
            return D.30433;
            <D.30465>:
            buffer_add_objid (buf, o);
            goto <D.27225>;
          }
        finally
          {
            domain2 = {CLOBBER};
          }
      }
      <D.27246>:
      D.30433 = 100;
      return D.30433;
      <D.27225>:
      D.30433 = 0;
      return D.30433;
    }
  finally
    {
      err = {CLOBBER};
    }
}


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

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


decode_value (struct MonoType * t, struct MonoDomain * domain, guint8 * addr, guint8 * buf, guint8 * * endbuf, guint8 * limit)
{
  guint8 * buf.220;
  unsigned char D.30473;
  struct MonoClass * D.30476;
  int D.30477;
  struct MonoGenericClass * D.30480;
  struct MonoGenericInst * D.30481;
  <unnamed type> D.30482;
  ErrorCode D.30485;
  unsigned char D.30486;
  int D.30487;
  struct MonoClass * D.30490;
  int D.30491;
  long unsigned int D.30492;
  <unnamed type> D.30493;
  struct MonoClass * D.30496;
  struct MonoClass * D.30497;
  struct MonoObject * D.30498;
  struct MonoClass * D.30501;
  int err;
  int type;

  buf.220 = buf;
  type = decode_byte (buf.220, &buf, limit);
  D.30473 = t->type;
  if (D.30473 == 21) goto <D.30474>; else goto <D.30475>;
  <D.30474>:
  D.30476 = mono_class_from_mono_type (t);
  D.30477 = mono_class_is_nullable (D.30476);
  if (D.30477 != 0) goto <D.30478>; else goto <D.30479>;
  <D.30478>:
  {
    struct MonoType * targ;
    guint8 * nullable_buf;

    D.30480 = t->data.generic_class;
    D.30481 = D.30480->context.class_inst;
    targ = D.30481->type_argv[0];
    buf.220 = buf;
    D.30482 = decode_value_internal (t, type, domain, addr, buf.220, endbuf, limit);
    err = (int) D.30482;
    if (err == 0) goto <D.30483>; else goto <D.30484>;
    <D.30483>:
    D.30485 = (ErrorCode) err;
    return D.30485;
    <D.30484>:
    D.30486 = targ->type;
    D.30487 = (int) D.30486;
    if (D.30487 == type) goto <D.30488>; else goto <D.30489>;
    <D.30488>:
    D.30490 = mono_class_from_mono_type (targ);
    D.30491 = mono_class_instance_size (D.30490);
    D.30492 = (long unsigned int) D.30491;
    nullable_buf = monoeg_malloc (D.30492);
    buf.220 = buf;
    D.30493 = decode_value_internal (targ, type, domain, nullable_buf, buf.220, endbuf, limit);
    err = (int) D.30493;
    if (err != 0) goto <D.30494>; else goto <D.30495>;
    <D.30494>:
    monoeg_g_free (nullable_buf);
    D.30485 = (ErrorCode) err;
    return D.30485;
    <D.30495>:
    D.30496 = mono_class_from_mono_type (t);
    D.30497 = mono_class_from_mono_type (targ);
    D.30498 = mono_value_box (domain, D.30497, nullable_buf);
    mono_nullable_init (addr, D.30498, D.30496);
    monoeg_g_free (nullable_buf);
    buf.220 = buf;
    *endbuf = buf.220;
    D.30485 = 0;
    return D.30485;
    <D.30489>:
    if (type == 240) goto <D.30499>; else goto <D.30500>;
    <D.30499>:
    D.30501 = mono_class_from_mono_type (t);
    mono_nullable_init (addr, 0B, D.30501);
    buf.220 = buf;
    *endbuf = buf.220;
    D.30485 = 0;
    return D.30485;
    <D.30500>:
  }
  <D.30479>:
  <D.30475>:
  buf.220 = buf;
  D.30485 = decode_value_internal (t, type, domain, addr, buf.220, endbuf, limit);
  return D.30485;
}


decode_value_internal (struct MonoType * t, int type, struct MonoDomain * domain, guint8 * addr, guint8 * buf, guint8 * * endbuf, guint8 * limit)
{
  unsigned char D.30508;
  int D.30509;
  int D.30512;
  int log_level.221;
  _Bool D.30520;
  long int D.30521;
  long int D.30522;
  long unsigned int D.30525;
  void * D.30526;
  struct FILE * log_file.222;
  ErrorCode D.30528;
  guint8 * buf.223;
  int D.30530;
  unsigned char D.30531;
  int D.30532;
  short unsigned int D.30533;
  int D.30534;
  signed char D.30535;
  int D.30536;
  unsigned char D.30537;
  int D.30538;
  short int D.30539;
  int D.30540;
  short unsigned int D.30541;
  int D.30542;
  int D.30543;
  unsigned int D.30544;
  long int D.30545;
  long int D.30546;
  long unsigned int D.30547;
  int D.30548;
  unsigned int D.30549;
  long int D.30550;
  long unsigned int D.30551;
  _Bool D.30552;
  long int D.30553;
  long int D.30554;
  long int D.30557;
  int D.30558;
  _Bool D.30559;
  long int D.30560;
  long int D.30561;
  <unnamed type> D.30564;
  int err.224;
  int err.225;
  int D.30569;
  <unnamed type> D.30574;
  struct MonoObject * obj.226;
  int D.30580;
  struct MonoVTable * D.30585;
  struct MonoClass * D.30586;
  const char * D.30587;
  char * D.30588;
  struct MonoDomain * D.30591;
  long unsigned int D.30604;
  _Bool D.30605;
  long int D.30606;
  long int D.30607;
  <unnamed type> D.30610;
  int err.227;
  struct MonoDomain * d.228;
  struct MonoObject * D.30615;
  long unsigned int D.30619;
  void * D.30620;
  int err;
  void handle_vtype = <<< error >>>;
  void handle_ref = <<< error >>>;

  try
    {
      D.30508 = t->type;
      D.30509 = (int) D.30508;
      if (D.30509 != type) goto <D.30510>; else goto <D.30511>;
      <D.30510>:
      D.30512 = mono_type_is_reference (t);
      if (D.30512 == 0) goto <D.30513>; else goto <D.30514>;
      <D.30513>:
      D.30508 = t->type;
      if (D.30508 != 24) goto <D.30507>; else goto <D.30515>;
      <D.30515>:
      if (type != 17) goto <D.30507>; else goto <D.30504>;
      <D.30507>:
      D.30508 = t->type;
      if (D.30508 != 25) goto <D.30506>; else goto <D.30516>;
      <D.30516>:
      if (type != 17) goto <D.30506>; else goto <D.30504>;
      <D.30506>:
      D.30508 = t->type;
      if (D.30508 != 15) goto <D.30505>; else goto <D.30517>;
      <D.30517>:
      if (type != 10) goto <D.30505>; else goto <D.30504>;
      <D.30505>:
      D.30508 = t->type;
      if (D.30508 != 21) goto <D.30503>; else goto <D.30518>;
      <D.30518>:
      if (type != 17) goto <D.30503>; else goto <D.30504>;
      <D.30503>:
      {
        char * name;

        name = mono_type_full_name (t);
        log_level.221 = log_level;
        D.30520 = log_level.221 > 0;
        D.30521 = (long int) D.30520;
        D.30522 = __builtin_expect (D.30521, 0);
        if (D.30522 != 0) goto <D.30523>; else goto <D.30524>;
        <D.30523>:
        D.30525 = GetCurrentThreadId ();
        D.30526 = (void *) D.30525;
        log_file.222 = log_file;
        fprintf (log_file.222, "[%p] Expected value of type %s, got 0x%0x.\n", D.30526, name, type);
        log_file.222 = log_file;
        fflush (log_file.222);
        <D.30524>:
        monoeg_g_free (name);
        D.30528 = 102;
        return D.30528;
      }
      <D.30504>:
      <D.30514>:
      <D.30511>:
      D.30508 = t->type;
      D.30509 = (int) D.30508;
      switch (D.30509) <default: <D.26801>, case 2: <D.26781>, case 3: <D.26783>, case 4: <D.26784>, case 5: <D.26785>, case 6: <D.26786>, case 7: <D.26787>, case 8: <D.26788>, case 9: <D.26789>, case 10: <D.26790>, case 11: <D.26791>, case 12: <D.26792>, case 13: <D.26793>, case 15: <D.26794>, case 17: <D.26800>, case 21: <D.26795>, case 24: <D.26798>, case 25: <D.26799>>
      <D.26781>:
      buf.223 = buf;
      D.30530 = decode_int (buf.223, &buf, limit);
      D.30531 = (unsigned char) D.30530;
      *addr = D.30531;
      goto <D.26782>;
      <D.26783>:
      buf.223 = buf;
      D.30532 = decode_int (buf.223, &buf, limit);
      D.30533 = (short unsigned int) D.30532;
      MEM[(gunichar2 *)addr] = D.30533;
      goto <D.26782>;
      <D.26784>:
      buf.223 = buf;
      D.30534 = decode_int (buf.223, &buf, limit);
      D.30535 = (signed char) D.30534;
      MEM[(gint8 *)addr] = D.30535;
      goto <D.26782>;
      <D.26785>:
      buf.223 = buf;
      D.30536 = decode_int (buf.223, &buf, limit);
      D.30537 = (unsigned char) D.30536;
      *addr = D.30537;
      goto <D.26782>;
      <D.26786>:
      buf.223 = buf;
      D.30538 = decode_int (buf.223, &buf, limit);
      D.30539 = (short int) D.30538;
      MEM[(gint16 *)addr] = D.30539;
      goto <D.26782>;
      <D.26787>:
      buf.223 = buf;
      D.30540 = decode_int (buf.223, &buf, limit);
      D.30541 = (short unsigned int) D.30540;
      MEM[(guint16 *)addr] = D.30541;
      goto <D.26782>;
      <D.26788>:
      buf.223 = buf;
      D.30542 = decode_int (buf.223, &buf, limit);
      MEM[(gint32 *)addr] = D.30542;
      goto <D.26782>;
      <D.26789>:
      buf.223 = buf;
      D.30543 = decode_int (buf.223, &buf, limit);
      D.30544 = (unsigned int) D.30543;
      MEM[(guint32 *)addr] = D.30544;
      goto <D.26782>;
      <D.26790>:
      buf.223 = buf;
      D.30545 = decode_long (buf.223, &buf, limit);
      MEM[(gint64 *)addr] = D.30545;
      goto <D.26782>;
      <D.26791>:
      buf.223 = buf;
      D.30546 = decode_long (buf.223, &buf, limit);
      D.30547 = (long unsigned int) D.30546;
      MEM[(guint64 *)addr] = D.30547;
      goto <D.26782>;
      <D.26792>:
      buf.223 = buf;
      D.30548 = decode_int (buf.223, &buf, limit);
      D.30549 = (unsigned int) D.30548;
      MEM[(guint32 *)addr] = D.30549;
      goto <D.26782>;
      <D.26793>:
      buf.223 = buf;
      D.30550 = decode_long (buf.223, &buf, limit);
      D.30551 = (long unsigned int) D.30550;
      MEM[(guint64 *)addr] = D.30551;
      goto <D.26782>;
      <D.26794>:
      D.30552 = type != 10;
      D.30553 = (long int) D.30552;
      D.30554 = __builtin_expect (D.30553, 0);
      if (D.30554 != 0) goto <D.30555>; else goto <D.30556>;
      <D.30555>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 5775, "type == MONO_TYPE_I8");
      <D.30556>:
      buf.223 = buf;
      D.30557 = decode_long (buf.223, &buf, limit);
      MEM[(gssize *)addr] = D.30557;
      goto <D.26782>;
      <D.26795>:
      D.30558 = mono_type_is_struct (t);
      if (D.30558 != 0) goto handle_vtype; else goto handle_ref;
      <D.26798>:
      <D.26799>:
      D.30559 = type != 17;
      D.30560 = (long int) D.30559;
      D.30561 = __builtin_expect (D.30560, 0);
      if (D.30561 != 0) goto <D.30562>; else goto <D.30563>;
      <D.30562>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 5789, "type == MONO_TYPE_VALUETYPE");
      <D.30563>:
      handle_vtype:
      <D.26800>:
      buf.223 = buf;
      D.30564 = decode_vtype (t, domain, addr, buf.223, &buf, limit);
      err.224 = (int) D.30564;
      err = err.224;
      err.225 = err;
      if (err.225 != 0) goto <D.30567>; else goto <D.30568>;
      <D.30567>:
      err.225 = err;
      D.30528 = (ErrorCode) err.225;
      return D.30528;
      <D.30568>:
      goto <D.26782>;
      handle_ref:
      <D.26801>:
      D.30569 = mono_type_is_reference (t);
      if (D.30569 != 0) goto <D.30570>; else goto <D.30571>;
      <D.30570>:
      if (type == 28) goto <D.30572>; else goto <D.30573>;
      <D.30572>:
      {
        int objid;
        int err;
        struct MonoObject * obj;

        try
          {
            buf.223 = buf;
            objid = decode_objid (buf.223, &buf, limit);
            D.30574 = get_object (objid, &obj);
            err = (int) D.30574;
            if (err != 0) goto <D.30575>; else goto <D.30576>;
            <D.30575>:
            D.30528 = (ErrorCode) err;
            return D.30528;
            <D.30576>:
            obj.226 = obj;
            if (obj.226 != 0B) goto <D.30578>; else goto <D.30579>;
            <D.30578>:
            obj.226 = obj;
            D.30580 = obj_is_of_type (obj.226, t);
            if (D.30580 == 0) goto <D.30581>; else goto <D.30582>;
            <D.30581>:
            log_level.221 = log_level;
            D.30520 = log_level.221 > 0;
            D.30521 = (long int) D.30520;
            D.30522 = __builtin_expect (D.30521, 0);
            if (D.30522 != 0) goto <D.30583>; else goto <D.30584>;
            <D.30583>:
            obj.226 = obj;
            D.30585 = obj.226->vtable;
            D.30586 = D.30585->klass;
            D.30587 = D.30586->name;
            D.30588 = mono_type_full_name (t);
            log_file.222 = log_file;
            fprintf (log_file.222, "Expected type \'%s\', got \'%s\'\n", D.30588, D.30587);
            log_file.222 = log_file;
            fflush (log_file.222);
            <D.30584>:
            D.30528 = 102;
            return D.30528;
            <D.30582>:
            <D.30579>:
            obj.226 = obj;
            if (obj.226 != 0B) goto <D.30589>; else goto <D.30590>;
            <D.30589>:
            obj.226 = obj;
            D.30585 = obj.226->vtable;
            D.30591 = D.30585->domain;
            if (D.30591 != domain) goto <D.30592>; else goto <D.30593>;
            <D.30592>:
            D.30528 = 102;
            return D.30528;
            <D.30593>:
            <D.30590>:
            obj.226 = obj;
            mono_gc_wbarrier_generic_store (addr, obj.226);
          }
        finally
          {
            obj = {CLOBBER};
          }
      }
      goto <D.30594>;
      <D.30573>:
      if (type == 240) goto <D.30595>; else goto <D.30596>;
      <D.30595>:
      MEM[(struct MonoObject * *)addr] = 0B;
      goto <D.30597>;
      <D.30596>:
      if (type == 17) goto <D.30598>; else goto <D.30599>;
      <D.30598>:
      {
        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.30600>; else goto <D.30601>;
            <D.30600>:
            D.30528 = 100;
            return D.30528;
            <D.30601>:
            buf.223 = buf;
            klass = decode_typeid (buf.223, &buf, limit, &d, &err);
            err.225 = err;
            if (err.225 != 0) goto <D.30602>; else goto <D.30603>;
            <D.30602>:
            err.225 = err;
            D.30528 = (ErrorCode) err.225;
            return D.30528;
            <D.30603>:
            vtype_buf_size = mono_class_value_size (klass, 0B);
            D.30604 = (long unsigned int) vtype_buf_size;
            vtype_buf = monoeg_malloc0 (D.30604);
            D.30605 = vtype_buf == 0B;
            D.30606 = (long int) D.30605;
            D.30607 = __builtin_expect (D.30606, 0);
            if (D.30607 != 0) goto <D.30608>; else goto <D.30609>;
            <D.30608>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 5845, "vtype_buf");
            <D.30609>:
            buf = buf2;
            buf.223 = buf;
            D.30610 = decode_vtype (0B, domain, vtype_buf, buf.223, &buf, limit);
            err.227 = (int) D.30610;
            err = err.227;
            err.225 = err;
            if (err.225 != 0) goto <D.30612>; else goto <D.30613>;
            <D.30612>:
            monoeg_g_free (vtype_buf);
            err.225 = err;
            D.30528 = (ErrorCode) err.225;
            return D.30528;
            <D.30613>:
            d.228 = d;
            D.30615 = mono_value_box (d.228, klass, vtype_buf);
            MEM[(struct MonoObject * *)addr] = D.30615;
            monoeg_g_free (vtype_buf);
          }
        finally
          {
            d = {CLOBBER};
          }
      }
      goto <D.30616>;
      <D.30599>:
      {
        char * name;

        name = mono_type_full_name (t);
        log_level.221 = log_level;
        D.30520 = log_level.221 > 0;
        D.30521 = (long int) D.30520;
        D.30522 = __builtin_expect (D.30521, 0);
        if (D.30522 != 0) goto <D.30617>; else goto <D.30618>;
        <D.30617>:
        D.30619 = GetCurrentThreadId ();
        D.30620 = (void *) D.30619;
        log_file.222 = log_file;
        fprintf (log_file.222, "[%p] Expected value of type %s, got 0x%0x.\n", D.30620, name, type);
        log_file.222 = log_file;
        fflush (log_file.222);
        <D.30618>:
        monoeg_g_free (name);
        D.30528 = 102;
        return D.30528;
      }
      <D.30616>:
      <D.30597>:
      <D.30594>:
      goto <D.30621>;
      <D.30571>:
      monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "debugger-agent.c", 5862);
      <D.30621>:
      goto <D.26782>;
      <D.26782>:
      buf.223 = buf;
      *endbuf = buf.223;
      D.30528 = 0;
      return D.30528;
    }
  finally
    {
      err = {CLOBBER};
    }
}


obj_is_of_type (struct MonoObject * obj, struct MonoType * t)
{
  struct MonoVTable * D.30628;
  struct MonoClass * D.30629;
  int D.30630;
  struct MonoClass * D.30633;
  struct MonoRemoteClass * D.30636;
  struct MonoClass * D.30637;
  int D.30638;
  gboolean D.30641;
  struct MonoClass * klass;

  D.30628 = obj->vtable;
  klass = D.30628->klass;
  D.30629 = mono_class_from_mono_type (t);
  D.30630 = mono_class_is_assignable_from (D.30629, klass);
  if (D.30630 == 0) goto <D.30631>; else goto <D.30632>;
  <D.30631>:
  D.30633 = mono_defaults.transparent_proxy_class;
  if (D.30633 == klass) goto <D.30634>; else goto <D.30635>;
  <D.30634>:
  D.30636 = MEM[(struct MonoTransparentProxy *)obj].remote_class;
  klass = D.30636->proxy_class;
  D.30637 = mono_class_from_mono_type (t);
  D.30638 = mono_class_is_assignable_from (D.30637, klass);
  if (D.30638 != 0) goto <D.30639>; else goto <D.30640>;
  <D.30639>:
  D.30641 = 1;
  return D.30641;
  <D.30640>:
  <D.30635>:
  D.30641 = 0;
  return D.30641;
  <D.30632>:
  D.30641 = 1;
  return D.30641;
}


decode_vtype (struct MonoType * t, struct MonoDomain * domain, guint8 * addr, guint8 * buf, guint8 * * endbuf, guint8 * limit)
{
  guint8 * buf.229;
  ErrorCode D.30646;
  int err.230;
  struct MonoClass * D.30652;
  struct MonoType * D.30655;
  int log_level.231;
  _Bool D.30657;
  long int D.30658;
  long int D.30659;
  long unsigned int D.30662;
  void * D.30663;
  struct FILE * log_file.232;
  struct MonoType * D.30665;
  short unsigned int D.30666;
  int D.30667;
  int D.30668;
  int D.30671;
  int D.26767;
  int iftmp.233;
  int D.26766;
  const char[9] * D.30677;
  unsigned char D.30678;
  int D.30679;
  unsigned char D.30680;
  int D.30681;
  _Bool D.30682;
  _Bool D.30683;
  _Bool D.30684;
  const unsigned char * D.30687;
  unsigned char D.30688;
  int D.30689;
  const unsigned char * D.30690;
  unsigned char D.30691;
  int D.30692;
  _Bool D.30693;
  _Bool D.30694;
  const unsigned char * D.30697;
  unsigned char D.30698;
  int D.30699;
  const unsigned char * D.30700;
  unsigned char D.30701;
  int D.30702;
  _Bool D.30703;
  _Bool D.30704;
  const unsigned char * D.30707;
  unsigned char D.30708;
  int D.30709;
  const unsigned char * D.30710;
  unsigned char D.30711;
  int D.30712;
  const char * D.30714;
  int D.30717;
  sizetype D.30718;
  sizetype D.30719;
  guint8 * D.30720;
  <unnamed type> D.30721;
  int err.234;
  _Bool D.30725;
  long int D.30726;
  long int D.30727;
  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.30644>; else goto <D.30645>;
      <D.30644>:
      D.30646 = 100;
      return D.30646;
      <D.30645>:
      buf.229 = buf;
      klass = decode_typeid (buf.229, &buf, limit, &d, &err);
      err.230 = err;
      if (err.230 != 0) goto <D.30648>; else goto <D.30649>;
      <D.30648>:
      err.230 = err;
      D.30646 = (ErrorCode) err.230;
      return D.30646;
      <D.30649>:
      if (t != 0B) goto <D.30650>; else goto <D.30651>;
      <D.30650>:
      D.30652 = mono_class_from_mono_type (t);
      if (D.30652 != klass) goto <D.30653>; else goto <D.30654>;
      <D.30653>:
      {
        char * name;
        char * name2;

        name = mono_type_full_name (t);
        D.30655 = &klass->byval_arg;
        name2 = mono_type_full_name (D.30655);
        log_level.231 = log_level;
        D.30657 = log_level.231 > 0;
        D.30658 = (long int) D.30657;
        D.30659 = __builtin_expect (D.30658, 0);
        if (D.30659 != 0) goto <D.30660>; else goto <D.30661>;
        <D.30660>:
        D.30662 = GetCurrentThreadId ();
        D.30663 = (void *) D.30662;
        log_file.232 = log_file;
        fprintf (log_file.232, "[%p] Expected value of type %s, got %s.\n", D.30663, name, name2);
        log_file.232 = log_file;
        fflush (log_file.232);
        <D.30661>:
        monoeg_g_free (name);
        monoeg_g_free (name2);
        D.30646 = 102;
        return D.30646;
      }
      <D.30654>:
      <D.30651>:
      buf.229 = buf;
      nfields = decode_int (buf.229, &buf, limit);
      goto <D.26758>;
      <D.26768>:
      D.30665 = f->type;
      D.30666 = D.30665->attrs;
      D.30667 = (int) D.30666;
      D.30668 = D.30667 & 16;
      if (D.30668 != 0) goto <D.30669>; else goto <D.30670>;
      <D.30669>:
      // predicted unlikely by continue predictor.
      goto <D.26758>;
      <D.30670>:
      D.30665 = f->type;
      D.30666 = D.30665->attrs;
      D.30667 = (int) D.30666;
      D.30671 = D.30667 & 1536;
      if (D.30671 != 0) goto <D.30672>; else goto <D.30673>;
      <D.30672>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          __s2 = mono_field_get_name (f);
          D.30677 = "_Deleted";
          D.30678 = MEM[(const unsigned char *)D.30677];
          D.30679 = (int) D.30678;
          D.30680 = *__s2;
          D.30681 = (int) D.30680;
          __result = D.30679 - D.30681;
          {
            D.30682 = __s2_len != 0;
            D.30683 = __result == 0;
            D.30684 = D.30682 & D.30683;
            if (D.30684 != 0) goto <D.30685>; else goto <D.30686>;
            <D.30685>:
            D.30687 = &MEM[(void *)"_Deleted" + 1B];
            D.30688 = *D.30687;
            D.30689 = (int) D.30688;
            D.30690 = __s2 + 1;
            D.30691 = *D.30690;
            D.30692 = (int) D.30691;
            __result = D.30689 - D.30692;
            D.30693 = __s2_len > 1;
            D.30683 = __result == 0;
            D.30694 = D.30693 & D.30683;
            if (D.30694 != 0) goto <D.30695>; else goto <D.30696>;
            <D.30695>:
            D.30697 = &MEM[(void *)"_Deleted" + 2B];
            D.30698 = *D.30697;
            D.30699 = (int) D.30698;
            D.30700 = __s2 + 2;
            D.30701 = *D.30700;
            D.30702 = (int) D.30701;
            __result = D.30699 - D.30702;
            D.30703 = __s2_len > 2;
            D.30683 = __result == 0;
            D.30704 = D.30703 & D.30683;
            if (D.30704 != 0) goto <D.30705>; else goto <D.30706>;
            <D.30705>:
            D.30707 = &MEM[(void *)"_Deleted" + 3B];
            D.30708 = *D.30707;
            D.30709 = (int) D.30708;
            D.30710 = __s2 + 3;
            D.30711 = *D.30710;
            D.30712 = (int) D.30711;
            __result = D.30709 - D.30712;
            <D.30706>:
            <D.30696>:
            <D.30686>:
          }
          D.26766 = __result;
        }
        iftmp.233 = -D.26766;
        goto <D.30713>;
        <D.30676>:
        D.30714 = mono_field_get_name (f);
        iftmp.233 = __builtin_strcmp (D.30714, "_Deleted");
        <D.30713>:
        D.26767 = iftmp.233;
      }
      if (D.26767 == 0) goto <D.30715>; else goto <D.30716>;
      <D.30715>:
      // predicted unlikely by continue predictor.
      goto <D.26758>;
      <D.30716>:
      <D.30673>:
      buf.229 = buf;
      D.30717 = f->offset;
      D.30718 = (sizetype) D.30717;
      D.30719 = D.30718 + 18446744073709551600;
      D.30720 = addr + D.30719;
      D.30665 = f->type;
      D.30721 = decode_value (D.30665, domain, D.30720, buf.229, &buf, limit);
      err.234 = (int) D.30721;
      err = err.234;
      err.230 = err;
      if (err.230 != 0) goto <D.30723>; else goto <D.30724>;
      <D.30723>:
      err.230 = err;
      D.30646 = (ErrorCode) err.230;
      return D.30646;
      <D.30724>:
      nfields = nfields + -1;
      <D.26758>:
      f = mono_class_get_fields (klass, &iter);
      if (f != 0B) goto <D.26768>; else goto <D.26769>;
      <D.26769>:
      D.30725 = nfields != 0;
      D.30726 = (long int) D.30725;
      D.30727 = __builtin_expect (D.30726, 0);
      if (D.30727 != 0) goto <D.30728>; else goto <D.30729>;
      <D.30728>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 5713, "nfields == 0");
      <D.30729>:
      buf.229 = buf;
      *endbuf = buf.229;
      D.30646 = 0;
      return D.30646;
    }
  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.30736;
  struct MonoImage * D.30737;
  const char * D.30738;
  unsigned char D.30739;
  unsigned char D.30740;
  struct MonoDomain * domain.237;
  _Bool D.30748;
  long int D.30749;
  long int D.30750;
  int D.30753;
  const char * D.30757;
  struct MonoClass * iftmp.238;
  const char * iftmp.239;
  unsigned int D.30765;
  unsigned int D.30766;
  const char * iftmp.240;
  unsigned char D.30771;
  const char * iftmp.241;
  const char * D.30778;
  char D.30780;
  short unsigned int D.30782;
  int D.30783;
  short unsigned int D.30784;
  int D.30785;
  short unsigned int D.30786;
  int D.30787;
  short unsigned int D.30788;
  int D.30789;
  const char * D.30790;
  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.30734>; else goto <D.30735>;
      <D.30734>:
      err.236 = err;
      D.30736 = (ErrorCode) err.236;
      return D.30736;
      <D.30735>:
      switch (command) <default: <D.27275>, case 1: <D.27256>, case 2: <D.27258>, case 3: <D.27261>, case 4: <D.27262>, case 5: <D.27264>, case 6: <D.27272>>
      <D.27256>:
      D.30737 = ass->image;
      D.30738 = mono_image_get_filename (D.30737);
      buffer_add_string (buf, D.30738);
      goto <D.27257>;
      <D.27258>:
      {
        guint32 token;
        struct MonoMethod * m;

        D.30737 = ass->image;
        D.30739 = BIT_FIELD_REF <*D.30737, 8, 224>;
        D.30740 = D.30739 & 8;
        if (D.30740 != 0) goto <D.30741>; else goto <D.30742>;
        <D.30741>:
        buffer_add_id (buf, 0);
        goto <D.30743>;
        <D.30742>:
        D.30737 = ass->image;
        token = mono_image_get_entry_point (D.30737);
        if (token == 0) goto <D.30744>; else goto <D.30745>;
        <D.30744>:
        buffer_add_id (buf, 0);
        goto <D.30746>;
        <D.30745>:
        D.30737 = ass->image;
        m = mono_get_method (D.30737, token, 0B);
        domain.237 = domain;
        buffer_add_methodid (buf, domain.237, m);
        <D.30746>:
        <D.30743>:
        goto <D.27257>;
      }
      <D.27261>:
      D.30737 = ass->image;
      domain.237 = domain;
      buffer_add_moduleid (buf, domain.237, D.30737);
      goto <D.27257>;
      <D.27262>:
      {
        struct MonoObject * o;

        domain.237 = domain;
        o = mono_assembly_get_object (domain.237, ass);
        buffer_add_objid (buf, o);
        goto <D.27257>;
      }
      <D.27264>:
      {
        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.30748 = res == 0;
            D.30749 = (long int) D.30748;
            D.30750 = __builtin_expect (D.30749, 0);
            if (D.30750 != 0) goto <D.30751>; else goto <D.30752>;
            <D.30751>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 7341, "res");
            <D.30752>:
            D.30753 = mono_reflection_parse_type (s, &info);
            if (D.30753 == 0) goto <D.30754>; else goto <D.30755>;
            <D.30754>:
            t = 0B;
            goto <D.30756>;
            <D.30755>:
            D.30757 = info.assembly.name;
            if (D.30757 != 0B) goto <D.30758>; else goto <D.30759>;
            <D.30758>:
            monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "debugger-agent.c", 7347);
            <D.30759>:
            D.30737 = ass->image;
            t = mono_reflection_get_type (D.30737, &info, ignorecase, &type_resolve);
            <D.30756>:
            if (t != 0B) goto <D.30761>; else goto <D.30762>;
            <D.30761>:
            iftmp.238 = mono_class_from_mono_type (t);
            goto <D.30763>;
            <D.30762>:
            iftmp.238 = 0B;
            <D.30763>:
            domain.237 = domain;
            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.27257>;
          }
        finally
          {
            info = {CLOBBER};
            type_resolve = {CLOBBER};
          }
      }
      <D.27272>:
      {
        gchar * name;
        struct MonoAssembly * mass;

        mass = ass;
        D.30765 = mass->aname.flags;
        D.30766 = D.30765 & 256;
        if (D.30766 != 0) goto <D.30767>; else goto <D.30768>;
        <D.30767>:
        iftmp.239 = ", Retargetable=Yes";
        goto <D.30769>;
        <D.30768>:
        iftmp.239 = "";
        <D.30769>:
        D.30771 = mass->aname.public_key_token[0];
        if (D.30771 != 0) goto <D.30772>; else goto <D.30773>;
        <D.30772>:
        iftmp.240 = &mass->aname.public_key_token;
        goto <D.30774>;
        <D.30773>:
        iftmp.240 = "null";
        <D.30774>:
        D.30778 = mass->aname.culture;
        if (D.30778 != 0B) goto <D.30779>; else goto <D.30776>;
        <D.30779>:
        D.30778 = mass->aname.culture;
        D.30780 = *D.30778;
        if (D.30780 != 0) goto <D.30781>; else goto <D.30776>;
        <D.30781>:
        iftmp.241 = mass->aname.culture;
        goto <D.30777>;
        <D.30776>:
        iftmp.241 = "neutral";
        <D.30777>:
        D.30782 = mass->aname.revision;
        D.30783 = (int) D.30782;
        D.30784 = mass->aname.build;
        D.30785 = (int) D.30784;
        D.30786 = mass->aname.minor;
        D.30787 = (int) D.30786;
        D.30788 = mass->aname.major;
        D.30789 = (int) D.30788;
        D.30790 = mass->aname.name;
        name = monoeg_g_strdup_printf ("%s, Version=%d.%d.%d.%d, Culture=%s, PublicKeyToken=%s%s", D.30790, D.30789, D.30787, D.30785, D.30783, iftmp.241, iftmp.240, iftmp.239);
        buffer_add_string (buf, name);
        monoeg_g_free (name);
        goto <D.27257>;
      }
      <D.27275>:
      D.30736 = 100;
      return D.30736;
      <D.27257>:
      D.30736 = 0;
      return D.30736;
    }
  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.30795;
  const char * D.30796;
  const char * D.30797;
  struct MonoAssembly * D.30798;
  struct MonoDomain * domain.243;
  ErrorCode D.30800;
  int err;
  struct MonoDomain * domain;

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

        p.242 = p;
        image = decode_moduleid (p.242, &p, end, &domain, &err);
        D.30795 = image->name;
        basename = monoeg_g_path_get_basename (D.30795);
        buffer_add_string (buf, basename);
        D.30796 = image->module_name;
        buffer_add_string (buf, D.30796);
        D.30795 = image->name;
        buffer_add_string (buf, D.30795);
        D.30797 = mono_image_get_guid (image);
        buffer_add_string (buf, D.30797);
        D.30798 = image->assembly;
        domain.243 = domain;
        buffer_add_assemblyid (buf, domain.243, D.30798);
        monoeg_g_free (basename);
        goto <D.27287>;
      }
      <D.27288>:
      D.30800 = 100;
      return D.30800;
      <D.27287>:
      D.30800 = 0;
      return D.30800;
    }
  finally
    {
      err = {CLOBBER};
      domain = {CLOBBER};
    }
}


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

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


type_commands (int command, guint8 * p, guint8 * end, struct Buffer * buf)
{
  guint8 * p.244;
  int err.245;
  ErrorCode D.30809;
  struct MonoDomain * domain.246;
  <unnamed type> D.30811;
  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.30807>; else goto <D.30808>;
      <D.30807>:
      err.245 = err;
      D.30809 = (ErrorCode) err.245;
      return D.30809;
      <D.30808>:
      old_domain = mono_domain_get ();
      domain.246 = domain;
      mono_domain_set (domain.246, 1);
      p.244 = p;
      domain.246 = domain;
      D.30811 = type_commands_internal (command, klass, domain.246, p.244, end, buf);
      err.247 = (int) D.30811;
      err = err.247;
      mono_domain_set (old_domain, 1);
      err.245 = err;
      D.30809 = (ErrorCode) err.245;
      return D.30809;
    }
  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.30815;
  const char * D.30816;
  struct MonoType * D.30817;
  struct MonoImage * D.30818;
  struct MonoAssembly * D.30819;
  struct MonoClass * D.30820;
  unsigned char D.30824;
  unsigned char D.30826;
  struct MonoClass * D.30827;
  unsigned int D.30828;
  int D.30829;
  unsigned int D.30830;
  unsigned char D.30833;
  unsigned char D.30838;
  unsigned char D.30839;
  unsigned char D.30842;
  unsigned char D.30843;
  _Bool D.30844;
  _Bool D.30845;
  _Bool D.30846;
  unsigned char D.30850;
  unsigned char D.30851;
  struct MonoGenericContainer * D.30854;
  struct MonoGenericClass * D.30860;
  int D.30861;
  unsigned int nnested.248;
  int protocol_version_set.249;
  int major_version.250;
  int minor_version.251;
  struct MonoClass * D.30877;
  <unnamed-unsigned:22> D.30887;
  unsigned int count.252;
  struct MonoType * D.30889;
  struct MonoClass * D.30890;
  <unnamed-signed:31> D.30894;
  struct MonoGenericParamFull * D.30895;
  long unsigned int D.30896;
  long unsigned int D.30897;
  struct MonoGenericParam * D.30898;
  unsigned int nmethods.253;
  _Bool D.30901;
  long int D.30902;
  long int D.30903;
  unsigned int nfields.254;
  const char * D.30907;
  struct MonoType * D.30908;
  struct MonoClass * D.30909;
  short unsigned int D.30910;
  unsigned int D.30911;
  _Bool D.30912;
  long int D.30913;
  long int D.30914;
  unsigned int nprops.255;
  const char * D.30918;
  struct MonoMethod * D.30919;
  struct MonoMethod * D.30920;
  unsigned int D.30921;
  _Bool D.30922;
  long int D.30923;
  long int D.30924;
  guint8 * p.256;
  int err.257;
  ErrorCode D.30931;
  <unnamed type> D.30942;
  struct MonoThread * thread_obj.258;
  struct MonoType * D.30948;
  short unsigned int D.30949;
  int D.30950;
  int D.30951;
  _Bool D.30956;
  _Bool D.30957;
  _Bool D.30958;
  struct MonoClass * D.30961;
  struct MonoClass * D.30966;
  int D.30967;
  long unsigned int D.30968;
  struct MonoInternalThread * iftmp.259;
  struct MonoType * D.30975;
  short unsigned int D.30976;
  int D.30977;
  int D.30978;
  int D.30981;
  struct MonoClass * D.30984;
  struct MonoClass * D.30989;
  int D.30990;
  long unsigned int D.30991;
  <unnamed type> D.30992;
  int err.260;
  int D.30996;
  void * D.30999;
  unsigned int D.31001;
  void * * D.31002;
  long unsigned int D.31003;
  long unsigned int D.31004;
  void * * D.31005;
  unsigned int i.261;
  int D.31012;
  int D.31016;
  _Bool D.31017;
  int D.31018;
  unsigned int flags.262;
  unsigned int D.31020;
  unsigned int D.31023;
  void * * D.31024;
  long unsigned int D.31025;
  long unsigned int D.31026;
  void * * D.31027;
  unsigned int i.263;
  int D.31029;
  int D.31032;
  unsigned int D.31035;
  struct MonoClass * iface.264;
  int D.31037;
  unsigned int nmethods.265;
  struct MonoMethod * * D.31043;
  int D.31044;
  long unsigned int D.31045;
  long unsigned int D.31046;
  struct MonoMethod * * D.31047;
  struct MonoMethod * D.31048;
  unsigned char D.31051;
  unsigned char D.31052;
  _Bool D.31053;
  unsigned int D.31054;
  struct MonoClass * nested;
  struct MonoType * type;
  void * iter;
  guint8 b;
  int err;
  int nnested;
  char * name;

  try
    {
      switch (command) <default: <D.27495>, case 1: <D.27350>, case 2: <D.27369>, case 3: <D.27377>, case 4: <D.27404>, case 5: <D.27438>, case 6: <D.27440>, case 7: <D.27424>, case 8: <D.27449>, case 9: <D.27385>, case 10: <D.27393>, case 11: <D.27396>, case 12: <D.27400>, case 13: <D.27441>, case 14: <D.27405>, case 15: <D.27451>, case 16: <D.27461>, case 17: <D.27474>, case 18: <D.27493>>
      <D.27350>:
      D.30815 = klass->name_space;
      buffer_add_string (buf, D.30815);
      D.30816 = klass->name;
      buffer_add_string (buf, D.30816);
      D.30817 = &klass->byval_arg;
      name = mono_type_get_name_full (D.30817, 2);
      buffer_add_string (buf, name);
      monoeg_g_free (name);
      D.30818 = klass->image;
      D.30819 = D.30818->assembly;
      buffer_add_assemblyid (buf, domain, D.30819);
      D.30818 = klass->image;
      buffer_add_moduleid (buf, domain, D.30818);
      D.30820 = klass->parent;
      buffer_add_typeid (buf, domain, D.30820);
      D.30824 = klass->rank;
      if (D.30824 != 0) goto <D.30821>; else goto <D.30825>;
      <D.30825>:
      D.30826 = klass->byval_arg.type;
      if (D.30826 == 15) goto <D.30821>; else goto <D.30822>;
      <D.30821>:
      D.30827 = klass->element_class;
      buffer_add_typeid (buf, domain, D.30827);
      goto <D.30823>;
      <D.30822>:
      buffer_add_id (buf, 0);
      <D.30823>:
      D.30828 = klass->type_token;
      buffer_add_int (buf, D.30828);
      D.30824 = klass->rank;
      D.30829 = (int) D.30824;
      buffer_add_byte (buf, D.30829);
      D.30830 = klass->flags;
      buffer_add_int (buf, D.30830);
      b = 0;
      type = &klass->byval_arg;
      if (0 != 0) goto <D.30831>; else goto <D.30832>;
      <D.30831>:
      b = b | 1;
      <D.30832>:
      D.30833 = type->type;
      if (D.30833 == 15) goto <D.30834>; else goto <D.30835>;
      <D.30834>:
      b = b | 2;
      <D.30835>:
      D.30838 = BIT_FIELD_REF <*type, 8, 88>;
      D.30839 = D.30838 & 64;
      if (D.30839 == 0) goto <D.30840>; else goto <D.30841>;
      <D.30840>:
      D.30842 = type->type;
      D.30843 = D.30842 + 254;
      D.30844 = D.30843 <= 11;
      D.30845 = D.30842 == 24;
      D.30846 = D.30844 | D.30845;
      if (D.30846 != 0) goto <D.30836>; else goto <D.30847>;
      <D.30847>:
      D.30833 = type->type;
      if (D.30833 == 25) goto <D.30836>; else goto <D.30837>;
      <D.30836>:
      b = b | 4;
      <D.30837>:
      <D.30841>:
      D.30833 = type->type;
      if (D.30833 == 17) goto <D.30848>; else goto <D.30849>;
      <D.30848>:
      b = b | 8;
      <D.30849>:
      D.30850 = BIT_FIELD_REF <*klass, 8, 256>;
      D.30851 = D.30850 & 16;
      if (D.30851 != 0) goto <D.30852>; else goto <D.30853>;
      <D.30852>:
      b = b | 16;
      <D.30853>:
      D.30854 = klass->generic_container;
      if (D.30854 != 0B) goto <D.30855>; else goto <D.30856>;
      <D.30855>:
      b = b | 32;
      <D.30856>:
      D.30854 = klass->generic_container;
      if (D.30854 != 0B) goto <D.30857>; else goto <D.30859>;
      <D.30859>:
      D.30860 = klass->generic_class;
      if (D.30860 != 0B) goto <D.30857>; else goto <D.30858>;
      <D.30857>:
      b = b | 64;
      <D.30858>:
      D.30861 = (int) b;
      buffer_add_byte (buf, D.30861);
      nnested = 0;
      iter = 0B;
      goto <D.27352>;
      <D.27351>:
      nnested = nnested + 1;
      <D.27352>:
      nested = mono_class_get_nested_types (klass, &iter);
      if (nested != 0B) goto <D.27351>; else goto <D.27353>;
      <D.27353>:
      nnested.248 = (unsigned int) nnested;
      buffer_add_int (buf, nnested.248);
      iter = 0B;
      goto <D.27355>;
      <D.27354>:
      buffer_add_typeid (buf, domain, nested);
      <D.27355>:
      nested = mono_class_get_nested_types (klass, &iter);
      if (nested != 0B) goto <D.27354>; else goto <D.27356>;
      <D.27356>:
      protocol_version_set.249 = protocol_version_set;
      if (protocol_version_set.249 != 0) goto <D.30866>; else goto <D.30867>;
      <D.30866>:
      major_version.250 = major_version;
      if (major_version.250 > 2) goto <D.30863>; else goto <D.30869>;
      <D.30869>:
      major_version.250 = major_version;
      if (major_version.250 == 2) goto <D.30870>; else goto <D.30864>;
      <D.30870>:
      minor_version.251 = minor_version;
      if (minor_version.251 > 11) goto <D.30863>; else goto <D.30864>;
      <D.30863>:
      D.30854 = klass->generic_container;
      if (D.30854 != 0B) goto <D.30872>; else goto <D.30873>;
      <D.30872>:
      buffer_add_typeid (buf, domain, klass);
      goto <D.30874>;
      <D.30873>:
      D.30860 = klass->generic_class;
      if (D.30860 != 0B) goto <D.30875>; else goto <D.30876>;
      <D.30875>:
      D.30860 = klass->generic_class;
      D.30877 = D.30860->container_class;
      buffer_add_typeid (buf, domain, D.30877);
      goto <D.30878>;
      <D.30876>:
      buffer_add_id (buf, 0);
      <D.30878>:
      <D.30874>:
      <D.30864>:
      <D.30867>:
      protocol_version_set.249 = protocol_version_set;
      if (protocol_version_set.249 != 0) goto <D.30881>; else goto <D.30882>;
      <D.30881>:
      major_version.250 = major_version;
      if (major_version.250 > 2) goto <D.30879>; else goto <D.30883>;
      <D.30883>:
      major_version.250 = major_version;
      if (major_version.250 == 2) goto <D.30884>; else goto <D.30880>;
      <D.30884>:
      minor_version.251 = minor_version;
      if (minor_version.251 > 14) goto <D.30879>; else goto <D.30880>;
      <D.30879>:
      {
        int count;
        int i;

        D.30860 = klass->generic_class;
        if (D.30860 != 0B) goto <D.30885>; else goto <D.30886>;
        <D.30885>:
        {
          struct MonoGenericInst * inst;

          D.30860 = klass->generic_class;
          inst = D.30860->context.class_inst;
          D.30887 = inst->type_argc;
          count = (int) D.30887;
          count.252 = (unsigned int) count;
          buffer_add_int (buf, count.252);
          i = 0;
          goto <D.27361>;
          <D.27360>:
          D.30889 = inst->type_argv[i];
          D.30890 = mono_class_from_mono_type (D.30889);
          buffer_add_typeid (buf, domain, D.30890);
          i = i + 1;
          <D.27361>:
          if (i < count) goto <D.27360>; else goto <D.27362>;
          <D.27362>:
        }
        goto <D.30891>;
        <D.30886>:
        D.30854 = klass->generic_container;
        if (D.30854 != 0B) goto <D.30892>; else goto <D.30893>;
        <D.30892>:
        {
          struct MonoGenericContainer * container;
          struct MonoClass * pklass;

          container = klass->generic_container;
          D.30894 = container->type_argc;
          count = (int) D.30894;
          count.252 = (unsigned int) count;
          buffer_add_int (buf, count.252);
          i = 0;
          goto <D.27366>;
          <D.27365>:
          D.30818 = klass->image;
          D.30895 = container->type_params;
          D.30896 = (long unsigned int) i;
          D.30897 = D.30896 * 56;
          D.30898 = D.30895 + D.30897;
          pklass = mono_class_from_generic_parameter (D.30898, D.30818, 0);
          buffer_add_typeid (buf, domain, pklass);
          i = i + 1;
          <D.27366>:
          if (i < count) goto <D.27365>; else goto <D.27367>;
          <D.27367>:
        }
        goto <D.30899>;
        <D.30893>:
        buffer_add_int (buf, 0);
        <D.30899>:
        <D.30891>:
      }
      <D.30880>:
      <D.30882>:
      goto <D.27368>;
      <D.27369>:
      {
        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.27375>;
            <D.27374>:
            buffer_add_methodid (buf, domain, m);
            i = i + 1;
            <D.27375>:
            m = mono_class_get_methods (klass, &iter);
            if (m != 0B) goto <D.27374>; else goto <D.27376>;
            <D.27376>:
            D.30901 = i != nmethods;
            D.30902 = (long int) D.30901;
            D.30903 = __builtin_expect (D.30902, 0);
            if (D.30903 != 0) goto <D.30904>; else goto <D.30905>;
            <D.30904>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 7618, "i == nmethods");
            <D.30905>:
            goto <D.27368>;
          }
        finally
          {
            iter = {CLOBBER};
          }
      }
      <D.27377>:
      {
        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.27383>;
            <D.27382>:
            buffer_add_fieldid (buf, domain, f);
            D.30907 = f->name;
            buffer_add_string (buf, D.30907);
            D.30908 = f->type;
            D.30909 = mono_class_from_mono_type (D.30908);
            buffer_add_typeid (buf, domain, D.30909);
            D.30908 = f->type;
            D.30910 = D.30908->attrs;
            D.30911 = (unsigned int) D.30910;
            buffer_add_int (buf, D.30911);
            i = i + 1;
            <D.27383>:
            f = mono_class_get_fields (klass, &iter);
            if (f != 0B) goto <D.27382>; else goto <D.27384>;
            <D.27384>:
            D.30912 = i != nfields;
            D.30913 = (long int) D.30912;
            D.30914 = __builtin_expect (D.30913, 0);
            if (D.30914 != 0) goto <D.30915>; else goto <D.30916>;
            <D.30915>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 7638, "i == nfields");
            <D.30916>:
            goto <D.27368>;
          }
        finally
          {
            iter = {CLOBBER};
          }
      }
      <D.27385>:
      {
        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.27391>;
            <D.27390>:
            buffer_add_propertyid (buf, domain, p);
            D.30918 = p->name;
            buffer_add_string (buf, D.30918);
            D.30919 = p->get;
            buffer_add_methodid (buf, domain, D.30919);
            D.30920 = p->set;
            buffer_add_methodid (buf, domain, D.30920);
            D.30921 = p->attrs;
            buffer_add_int (buf, D.30921);
            i = i + 1;
            <D.27391>:
            p = mono_class_get_properties (klass, &iter);
            if (p != 0B) goto <D.27390>; else goto <D.27392>;
            <D.27392>:
            D.30922 = i != nprops;
            D.30923 = (long int) D.30922;
            D.30924 = __builtin_expect (D.30923, 0);
            if (D.30924 != 0) goto <D.30925>; else goto <D.30926>;
            <D.30925>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 7659, "i == nprops");
            <D.30926>:
            goto <D.27368>;
          }
        finally
          {
            iter = {CLOBBER};
          }
      }
      <D.27393>:
      {
        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.30929>; else goto <D.30930>;
        <D.30929>:
        err.257 = err;
        D.30931 = (ErrorCode) err.257;
        return D.30931;
        <D.30930>:
        cinfo = mono_custom_attrs_from_class (klass);
        D.30818 = klass->image;
        buffer_add_cattrs (buf, domain, D.30818, attr_klass, cinfo);
        goto <D.27368>;
      }
      <D.27396>:
      {
        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.30932>; else goto <D.30933>;
        <D.30932>:
        err.257 = err;
        D.30931 = (ErrorCode) err.257;
        return D.30931;
        <D.30933>:
        p.256 = p;
        attr_klass = decode_typeid (p.256, &p, end, 0B, &err);
        err.257 = err;
        if (err.257 != 0) goto <D.30934>; else goto <D.30935>;
        <D.30934>:
        err.257 = err;
        D.30931 = (ErrorCode) err.257;
        return D.30931;
        <D.30935>:
        cinfo = mono_custom_attrs_from_field (klass, field);
        D.30818 = klass->image;
        buffer_add_cattrs (buf, domain, D.30818, attr_klass, cinfo);
        goto <D.27368>;
      }
      <D.27400>:
      {
        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.30936>; else goto <D.30937>;
        <D.30936>:
        err.257 = err;
        D.30931 = (ErrorCode) err.257;
        return D.30931;
        <D.30937>:
        p.256 = p;
        attr_klass = decode_typeid (p.256, &p, end, 0B, &err);
        err.257 = err;
        if (err.257 != 0) goto <D.30938>; else goto <D.30939>;
        <D.30938>:
        err.257 = err;
        D.30931 = (ErrorCode) err.257;
        return D.30931;
        <D.30939>:
        cinfo = mono_custom_attrs_from_property (klass, prop);
        D.30818 = klass->image;
        buffer_add_cattrs (buf, domain, D.30818, attr_klass, cinfo);
        goto <D.27368>;
      }
      <D.27404>:
      <D.27405>:
      {
        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.30940>; else goto <D.30941>;
            <D.30940>:
            {
              int objid;
              int err;

              p.256 = p;
              objid = decode_objid (p.256, &p, end);
              D.30942 = get_object (objid, &thread_obj);
              err = (int) D.30942;
              if (err != 0) goto <D.30943>; else goto <D.30944>;
              <D.30943>:
              D.30931 = (ErrorCode) err;
              return D.30931;
              <D.30944>:
              thread_obj.258 = thread_obj;
              thread = thread_obj.258->internal_thread;
            }
            <D.30941>:
            p.256 = p;
            len = decode_int (p.256, &p, end);
            i = 0;
            goto <D.27422>;
            <D.27421>:
            p.256 = p;
            f = decode_fieldid (p.256, &p, end, 0B, &err);
            err.257 = err;
            if (err.257 != 0) goto <D.30946>; else goto <D.30947>;
            <D.30946>:
            err.257 = err;
            D.30931 = (ErrorCode) err.257;
            return D.30931;
            <D.30947>:
            D.30948 = f->type;
            D.30949 = D.30948->attrs;
            D.30950 = (int) D.30949;
            D.30951 = D.30950 & 16;
            if (D.30951 == 0) goto <D.30952>; else goto <D.30953>;
            <D.30952>:
            D.30931 = 25;
            return D.30931;
            <D.30953>:
            special_static_type = mono_class_field_get_special_static_type (f);
            if (special_static_type != 0) goto <D.30954>; else goto <D.30955>;
            <D.30954>:
            D.30956 = thread == 0B;
            D.30957 = special_static_type != 1;
            D.30958 = D.30956 | D.30957;
            if (D.30958 != 0) goto <D.30959>; else goto <D.30960>;
            <D.30959>:
            D.30931 = 25;
            return D.30931;
            <D.30960>:
            <D.30955>:
            found = 0;
            k = klass;
            goto <D.27420>;
            <D.27419>:
            D.30961 = f->parent;
            if (D.30961 == k) goto <D.30962>; else goto <D.30963>;
            <D.30962>:
            found = 1;
            goto <D.27418>;
            <D.30963>:
            k = k->parent;
            <D.27420>:
            if (k != 0B) goto <D.27419>; else goto <D.27418>;
            <D.27418>:
            if (found == 0) goto <D.30964>; else goto <D.30965>;
            <D.30964>:
            D.30931 = 25;
            return D.30931;
            <D.30965>:
            D.30961 = f->parent;
            vtable = mono_class_vtable (domain, D.30961);
            D.30948 = f->type;
            D.30966 = mono_class_from_mono_type (D.30948);
            D.30967 = mono_class_instance_size (D.30966);
            D.30968 = (long unsigned int) D.30967;
            val = monoeg_malloc (D.30968);
            if (thread == 0B) goto <D.30970>; else goto <D.30971>;
            <D.30970>:
            iftmp.259 = mono_thread_internal_current ();
            goto <D.30972>;
            <D.30971>:
            iftmp.259 = thread;
            <D.30972>:
            mono_field_static_get_value_for_thread (iftmp.259, vtable, f, val);
            D.30948 = f->type;
            buffer_add_value (buf, D.30948, val, domain);
            monoeg_g_free (val);
            i = i + 1;
            <D.27422>:
            if (i < len) goto <D.27421>; else goto <D.27423>;
            <D.27423>:
            goto <D.27368>;
          }
        finally
          {
            thread_obj = {CLOBBER};
          }
      }
      <D.27424>:
      {
        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.27436>;
        <D.27435>:
        p.256 = p;
        f = decode_fieldid (p.256, &p, end, 0B, &err);
        err.257 = err;
        if (err.257 != 0) goto <D.30973>; else goto <D.30974>;
        <D.30973>:
        err.257 = err;
        D.30931 = (ErrorCode) err.257;
        return D.30931;
        <D.30974>:
        D.30975 = f->type;
        D.30976 = D.30975->attrs;
        D.30977 = (int) D.30976;
        D.30978 = D.30977 & 16;
        if (D.30978 == 0) goto <D.30979>; else goto <D.30980>;
        <D.30979>:
        D.30931 = 25;
        return D.30931;
        <D.30980>:
        D.30981 = mono_class_field_is_special_static (f);
        if (D.30981 != 0) goto <D.30982>; else goto <D.30983>;
        <D.30982>:
        D.30931 = 25;
        return D.30931;
        <D.30983>:
        found = 0;
        k = klass;
        goto <D.27434>;
        <D.27433>:
        D.30984 = f->parent;
        if (D.30984 == k) goto <D.30985>; else goto <D.30986>;
        <D.30985>:
        found = 1;
        goto <D.27432>;
        <D.30986>:
        k = k->parent;
        <D.27434>:
        if (k != 0B) goto <D.27433>; else goto <D.27432>;
        <D.27432>:
        if (found == 0) goto <D.30987>; else goto <D.30988>;
        <D.30987>:
        D.30931 = 25;
        return D.30931;
        <D.30988>:
        D.30984 = f->parent;
        vtable = mono_class_vtable (domain, D.30984);
        D.30975 = f->type;
        D.30989 = mono_class_from_mono_type (D.30975);
        D.30990 = mono_class_instance_size (D.30989);
        D.30991 = (long unsigned int) D.30990;
        val = monoeg_malloc (D.30991);
        p.256 = p;
        D.30975 = f->type;
        D.30992 = decode_value (D.30975, domain, val, p.256, &p, end);
        err.260 = (int) D.30992;
        err = err.260;
        err.257 = err;
        if (err.257 != 0) goto <D.30994>; else goto <D.30995>;
        <D.30994>:
        monoeg_g_free (val);
        err.257 = err;
        D.30931 = (ErrorCode) err.257;
        return D.30931;
        <D.30995>:
        D.30975 = f->type;
        D.30996 = mono_type_is_reference (D.30975);
        if (D.30996 != 0) goto <D.30997>; else goto <D.30998>;
        <D.30997>:
        D.30999 = MEM[(void * *)val];
        mono_field_static_set_value (vtable, f, D.30999);
        goto <D.31000>;
        <D.30998>:
        mono_field_static_set_value (vtable, f, val);
        <D.31000>:
        monoeg_g_free (val);
        i = i + 1;
        <D.27436>:
        if (i < len) goto <D.27435>; else goto <D.27437>;
        <D.27437>:
        goto <D.27368>;
      }
      <D.27438>:
      {
        struct MonoObject * o;

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

        files = get_source_files_for_type (klass);
        D.31001 = files->len;
        buffer_add_int (buf, D.31001);
        i = 0;
        goto <D.27447>;
        <D.27446>:
        D.31002 = files->pdata;
        D.31003 = (long unsigned int) i;
        D.31004 = D.31003 * 8;
        D.31005 = D.31002 + D.31004;
        source_file = *D.31005;
        if (command == 13) goto <D.31006>; else goto <D.31007>;
        <D.31006>:
        buffer_add_string (buf, source_file);
        goto <D.31008>;
        <D.31007>:
        base = monoeg_g_path_get_basename (source_file);
        buffer_add_string (buf, base);
        monoeg_g_free (base);
        <D.31008>:
        monoeg_g_free (source_file);
        i = i + 1;
        <D.27447>:
        i.261 = (unsigned int) i;
        D.31001 = files->len;
        if (i.261 < D.31001) goto <D.27446>; else goto <D.27448>;
        <D.27448>:
        monoeg_g_ptr_array_free (files, 1);
        goto <D.27368>;
      }
      <D.27449>:
      {
        struct MonoClass * oklass;

        p.256 = p;
        oklass = decode_typeid (p.256, &p, end, 0B, &err);
        err.257 = err;
        if (err.257 != 0) goto <D.31010>; else goto <D.31011>;
        <D.31010>:
        err.257 = err;
        D.30931 = (ErrorCode) err.257;
        return D.30931;
        <D.31011>:
        D.31012 = mono_class_is_assignable_from (klass, oklass);
        if (D.31012 != 0) goto <D.31013>; else goto <D.31014>;
        <D.31013>:
        buffer_add_byte (buf, 1);
        goto <D.31015>;
        <D.31014>:
        buffer_add_byte (buf, 0);
        <D.31015>:
        goto <D.27368>;
      }
      <D.27451>:
      {
        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;
            D.31016 = flags & 1879048192;
            D.31017 = D.31016 != 0;
            D.31018 = (int) D.31017;
            flags.262 = (unsigned int) flags;
            D.31020 = flags.262 & 2415919103;
            array = mono_class_get_methods_by_name (klass, name, D.31020, D.31018, 1, &ex);
            if (array == 0B) goto <D.31021>; else goto <D.31022>;
            <D.31021>:
            D.30931 = 200;
            return D.30931;
            <D.31022>:
            D.31023 = array->len;
            buffer_add_int (buf, D.31023);
            i = 0;
            goto <D.27459>;
            <D.27458>:
            {
              struct MonoMethod * method;

              D.31024 = array->pdata;
              D.31025 = (long unsigned int) i;
              D.31026 = D.31025 * 8;
              D.31027 = D.31024 + D.31026;
              method = *D.31027;
              buffer_add_methodid (buf, domain, method);
            }
            i = i + 1;
            <D.27459>:
            i.263 = (unsigned int) i;
            D.31023 = array->len;
            if (i.263 < D.31023) goto <D.27458>; else goto <D.27460>;
            <D.27460>:
            monoeg_g_ptr_array_free (array, 1);
            monoeg_g_free (name);
            goto <D.27368>;
          }
        finally
          {
            ex = {CLOBBER};
          }
      }
      <D.27461>:
      {
        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.27469>;
            <D.27468>:
            mono_class_setup_interfaces (parent, &error);
            D.31029 = mono_error_ok (&error);
            if (D.31029 == 0) goto <D.31030>; else goto <D.31031>;
            <D.31030>:
            D.30931 = 200;
            return D.30931;
            <D.31031>:
            collect_interfaces (parent, iface_hash, &error);
            D.31032 = mono_error_ok (&error);
            if (D.31032 == 0) goto <D.31033>; else goto <D.31034>;
            <D.31033>:
            D.30931 = 200;
            return D.30931;
            <D.31034>:
            parent = parent->parent;
            <D.27469>:
            if (parent != 0B) goto <D.27468>; else goto <D.27470>;
            <D.27470>:
            D.31035 = monoeg_g_hash_table_size (iface_hash);
            buffer_add_int (buf, D.31035);
            monoeg_g_hash_table_iter_init (&iter, iface_hash);
            goto <D.27472>;
            <D.27471>:
            iface.264 = iface;
            buffer_add_typeid (buf, domain, iface.264);
            <D.27472>:
            D.31037 = monoeg_g_hash_table_iter_next (&iter, 0B, &iface);
            if (D.31037 != 0) goto <D.27471>; else goto <D.27473>;
            <D.27473>:
            monoeg_g_hash_table_destroy (iface_hash);
            goto <D.27368>;
          }
        finally
          {
            error = {CLOBBER};
            iface = {CLOBBER};
            iter = {CLOBBER};
          }
      }
      <D.27474>:
      {
        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.27491>;
            <D.27490>:
            p.256 = p;
            iclass = decode_typeid (p.256, &p, end, 0B, &err);
            err.257 = err;
            if (err.257 != 0) goto <D.31038>; else goto <D.31039>;
            <D.31038>:
            err.257 = err;
            D.30931 = (ErrorCode) err.257;
            return D.30931;
            <D.31039>:
            ioffset = mono_class_interface_offset_with_variance (klass, iclass, &variance_used);
            if (ioffset == -1) goto <D.31040>; else goto <D.31041>;
            <D.31040>:
            D.30931 = 102;
            return D.30931;
            <D.31041>:
            nmethods = mono_class_num_methods (iclass);
            nmethods.265 = (unsigned int) nmethods;
            buffer_add_int (buf, nmethods.265);
            iter = 0B;
            goto <D.27485>;
            <D.27484>:
            buffer_add_methodid (buf, domain, method);
            <D.27485>:
            method = mono_class_get_methods (iclass, &iter);
            if (method != 0B) goto <D.27484>; else goto <D.27486>;
            <D.27486>:
            i = 0;
            goto <D.27488>;
            <D.27487>:
            D.31043 = klass->vtable;
            D.31044 = i + ioffset;
            D.31045 = (long unsigned int) D.31044;
            D.31046 = D.31045 * 8;
            D.31047 = D.31043 + D.31046;
            D.31048 = *D.31047;
            buffer_add_methodid (buf, domain, D.31048);
            i = i + 1;
            <D.27488>:
            if (i < nmethods) goto <D.27487>; else goto <D.27489>;
            <D.27489>:
            tindex = tindex + 1;
            <D.27491>:
            if (tindex < len) goto <D.27490>; else goto <D.27492>;
            <D.27492>:
            goto <D.27368>;
          }
        finally
          {
            variance_used = {CLOBBER};
            iter = {CLOBBER};
          }
      }
      <D.27493>:
      {
        struct MonoVTable * vtable;

        vtable = mono_class_vtable (domain, klass);
        if (vtable != 0B) goto <D.31049>; else goto <D.31050>;
        <D.31049>:
        D.31051 = BIT_FIELD_REF <*vtable, 8, 344>;
        D.31052 = D.31051 & 6;
        D.31053 = D.31052 != 0;
        D.31054 = (unsigned int) D.31053;
        buffer_add_int (buf, D.31054);
        goto <D.31055>;
        <D.31050>:
        buffer_add_int (buf, 0);
        <D.31055>:
        goto <D.27368>;
      }
      <D.27495>:
      D.30931 = 100;
      return D.30931;
      <D.27368>:
      D.30931 = 0;
      return D.30931;
    }
  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.31069;

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


buffer_add_cattrs (struct Buffer * buf, struct MonoDomain * domain, struct MonoImage * image, struct MonoClass * attr_klass, struct MonoCustomAttrInfo * cinfo)
{
  struct MonoMethod * D.31076;
  struct MonoClass * D.31077;
  int D.31078;
  int D.31079;
  unsigned int nattrs.266;
  struct MonoMethod * D.31084;
  struct MonoClass * D.31085;
  int D.31086;
  unsigned int D.31087;
  const mono_byte * D.31088;
  int D.31089;
  _Bool D.31090;
  long int D.31091;
  long int D.31092;
  struct MonoArray * typed_args.267;
  long unsigned int D.31098;
  unsigned int D.31099;
  long unsigned int D.31100;
  char * D.31101;
  struct MonoMethodSignature * D.31102;
  long unsigned int D.31103;
  struct MonoArray * named_args.268;
  long unsigned int D.31108;
  unsigned int D.31109;
  char * D.31110;
  struct CattrNamedArg * arginfo.269;
  long unsigned int D.31112;
  long unsigned int D.31113;
  struct CattrNamedArg * D.31114;
  struct MonoProperty * D.31115;
  struct MonoClassField * D.31119;
  struct MonoType * D.31123;
  long unsigned int D.31124;
  int i;
  int j;
  int nattrs;

  nattrs = 0;
  if (cinfo == 0B) goto <D.31071>; else goto <D.31072>;
  <D.31071>:
  buffer_add_int (buf, 0);
  return;
  <D.31072>:
  i = 0;
  goto <D.27306>;
  <D.27305>:
  if (attr_klass == 0B) goto <D.31073>; else goto <D.31075>;
  <D.31075>:
  D.31076 = cinfo->attrs[i].ctor;
  D.31077 = D.31076->klass;
  D.31078 = mono_class_has_parent (D.31077, attr_klass);
  if (D.31078 != 0) goto <D.31073>; else goto <D.31074>;
  <D.31073>:
  nattrs = nattrs + 1;
  <D.31074>:
  i = i + 1;
  <D.27306>:
  D.31079 = cinfo->num_attrs;
  if (D.31079 > i) goto <D.27305>; else goto <D.27307>;
  <D.27307>:
  nattrs.266 = (unsigned int) nattrs;
  buffer_add_int (buf, nattrs.266);
  i = 0;
  goto <D.27323>;
  <D.27322>:
  {
    struct MonoCustomAttrEntry * attr;

    attr = &cinfo->attrs[i];
    if (attr_klass == 0B) goto <D.31081>; else goto <D.31083>;
    <D.31083>:
    D.31084 = attr->ctor;
    D.31085 = D.31084->klass;
    D.31086 = mono_class_has_parent (D.31085, attr_klass);
    if (D.31086 != 0) goto <D.31081>; else goto <D.31082>;
    <D.31081>:
    {
      struct MonoArray * typed_args;
      struct MonoArray * named_args;
      struct MonoType * t;
      struct CattrNamedArg * arginfo;
      struct MonoError error;

      try
        {
          arginfo = 0B;
          D.31087 = attr->data_size;
          D.31088 = attr->data;
          D.31084 = attr->ctor;
          mono_reflection_create_custom_attr_data_args (image, D.31084, D.31088, D.31087, &typed_args, &named_args, &arginfo, &error);
          D.31089 = mono_error_ok (&error);
          D.31090 = D.31089 == 0;
          D.31091 = (long int) D.31090;
          D.31092 = __builtin_expect (D.31091, 0);
          if (D.31092 != 0) goto <D.31093>; else goto <D.31094>;
          <D.31093>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 7448, "mono_error_ok (&error)");
          <D.31094>:
          D.31084 = attr->ctor;
          buffer_add_methodid (buf, domain, D.31084);
          typed_args.267 = typed_args;
          if (typed_args.267 != 0B) goto <D.31096>; else goto <D.31097>;
          <D.31096>:
          typed_args.267 = typed_args;
          D.31098 = mono_array_length (typed_args.267);
          D.31099 = (unsigned int) D.31098;
          buffer_add_int (buf, D.31099);
          j = 0;
          goto <D.27316>;
          <D.27315>:
          {
            struct MonoObject * val;

            D.31100 = (long unsigned int) j;
            typed_args.267 = typed_args;
            D.31101 = mono_array_addr_with_size (typed_args.267, 8, D.31100);
            val = MEM[(struct MonoObject * *)D.31101];
            D.31084 = attr->ctor;
            D.31102 = mono_method_signature (D.31084);
            t = D.31102->params[j];
            buffer_add_cattr_arg (buf, t, domain, val);
          }
          j = j + 1;
          <D.27316>:
          D.31100 = (long unsigned int) j;
          typed_args.267 = typed_args;
          D.31103 = mono_array_length (typed_args.267);
          if (D.31100 < D.31103) goto <D.27315>; else goto <D.27317>;
          <D.27317>:
          goto <D.31104>;
          <D.31097>:
          buffer_add_int (buf, 0);
          <D.31104>:
          named_args.268 = named_args;
          if (named_args.268 != 0B) goto <D.31106>; else goto <D.31107>;
          <D.31106>:
          named_args.268 = named_args;
          D.31108 = mono_array_length (named_args.268);
          D.31109 = (unsigned int) D.31108;
          buffer_add_int (buf, D.31109);
          j = 0;
          goto <D.27320>;
          <D.27319>:
          {
            struct MonoObject * val;

            D.31100 = (long unsigned int) j;
            named_args.268 = named_args;
            D.31110 = mono_array_addr_with_size (named_args.268, 8, D.31100);
            val = MEM[(struct MonoObject * *)D.31110];
            arginfo.269 = arginfo;
            D.31112 = (long unsigned int) j;
            D.31113 = D.31112 * 24;
            D.31114 = arginfo.269 + D.31113;
            D.31115 = D.31114->prop;
            if (D.31115 != 0B) goto <D.31116>; else goto <D.31117>;
            <D.31116>:
            buffer_add_byte (buf, 84);
            arginfo.269 = arginfo;
            D.31112 = (long unsigned int) j;
            D.31113 = D.31112 * 24;
            D.31114 = arginfo.269 + D.31113;
            D.31115 = D.31114->prop;
            buffer_add_propertyid (buf, domain, D.31115);
            goto <D.31118>;
            <D.31117>:
            arginfo.269 = arginfo;
            D.31112 = (long unsigned int) j;
            D.31113 = D.31112 * 24;
            D.31114 = arginfo.269 + D.31113;
            D.31119 = D.31114->field;
            if (D.31119 != 0B) goto <D.31120>; else goto <D.31121>;
            <D.31120>:
            buffer_add_byte (buf, 83);
            arginfo.269 = arginfo;
            D.31112 = (long unsigned int) j;
            D.31113 = D.31112 * 24;
            D.31114 = arginfo.269 + D.31113;
            D.31119 = D.31114->field;
            buffer_add_fieldid (buf, domain, D.31119);
            goto <D.31122>;
            <D.31121>:
            monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "debugger-agent.c", 7480);
            <D.31122>:
            <D.31118>:
            arginfo.269 = arginfo;
            D.31112 = (long unsigned int) j;
            D.31113 = D.31112 * 24;
            D.31114 = arginfo.269 + D.31113;
            D.31123 = D.31114->type;
            buffer_add_cattr_arg (buf, D.31123, domain, val);
          }
          j = j + 1;
          <D.27320>:
          D.31100 = (long unsigned int) j;
          named_args.268 = named_args;
          D.31124 = mono_array_length (named_args.268);
          if (D.31100 < D.31124) goto <D.27319>; else goto <D.27321>;
          <D.27321>:
          goto <D.31125>;
          <D.31107>:
          buffer_add_int (buf, 0);
          <D.31125>:
          arginfo.269 = arginfo;
          monoeg_g_free (arginfo.269);
        }
      finally
        {
          typed_args = {CLOBBER};
          named_args = {CLOBBER};
          arginfo = {CLOBBER};
          error = {CLOBBER};
        }
    }
    <D.31082>:
  }
  i = i + 1;
  <D.27323>:
  D.31079 = cinfo->num_attrs;
  if (D.31079 > i) goto <D.27322>; else goto <D.27324>;
  <D.27324>:
}


mono_class_has_parent (struct MonoClass * klass, struct MonoClass * parent)
{
  struct MonoClass * * D.31127;
  _Bool D.31128;
  long int D.31129;
  long int D.31130;
  struct MonoClass * * D.31133;
  _Bool D.31134;
  long int D.31135;
  long int D.31136;
  gboolean D.31139;

  D.31127 = klass->supertypes;
  D.31128 = D.31127 == 0B;
  D.31129 = (long int) D.31128;
  D.31130 = __builtin_expect (D.31129, 0);
  if (D.31130 != 0) goto <D.31131>; else goto <D.31132>;
  <D.31131>:
  mono_class_setup_supertypes (klass);
  <D.31132>:
  D.31133 = parent->supertypes;
  D.31134 = D.31133 == 0B;
  D.31135 = (long int) D.31134;
  D.31136 = __builtin_expect (D.31135, 0);
  if (D.31136 != 0) goto <D.31137>; else goto <D.31138>;
  <D.31137>:
  mono_class_setup_supertypes (parent);
  <D.31138>:
  D.31139 = mono_class_has_parent_fast (klass, parent);
  return D.31139;
}


mono_class_has_parent_fast (struct MonoClass * klass, struct MonoClass * parent)
{
  gboolean D.31141;
  int iftmp.270;
  short unsigned int D.31145;
  short unsigned int D.31146;
  struct MonoClass * * D.31148;
  long unsigned int D.31149;
  long unsigned int D.31150;
  sizetype D.31151;
  struct MonoClass * * D.31152;
  struct MonoClass * D.31153;

  D.31145 = klass->idepth;
  D.31146 = parent->idepth;
  if (D.31145 >= D.31146) goto <D.31147>; else goto <D.31143>;
  <D.31147>:
  D.31148 = klass->supertypes;
  D.31146 = parent->idepth;
  D.31149 = (long unsigned int) D.31146;
  D.31150 = D.31149 * 8;
  D.31151 = D.31150 + 18446744073709551608;
  D.31152 = D.31148 + D.31151;
  D.31153 = *D.31152;
  if (D.31153 == parent) goto <D.31154>; else goto <D.31143>;
  <D.31154>:
  iftmp.270 = 1;
  goto <D.31144>;
  <D.31143>:
  iftmp.270 = 0;
  <D.31144>:
  D.31141 = iftmp.270;
  return D.31141;
}


buffer_add_cattr_arg (struct Buffer * buf, struct MonoType * t, struct MonoDomain * domain, struct MonoObject * val)
{
  struct MonoObject * val.271;
  struct MonoVTable * D.31160;
  struct MonoClass * D.31161;
  struct MonoClass * D.31162;
  struct MonoType * D.31164;
  struct MonoClass * D.31165;
  int D.31166;
  void * D.31170;

  val.271 = val;
  if (val.271 != 0B) goto <D.31159>; else goto <D.31156>;
  <D.31159>:
  val.271 = val;
  D.31160 = val.271->vtable;
  D.31161 = D.31160->klass;
  D.31162 = mono_defaults.monotype_class;
  if (D.31161 == D.31162) goto <D.31163>; else goto <D.31156>;
  <D.31163>:
  buffer_add_byte (buf, 241);
  val.271 = val;
  D.31164 = MEM[(struct MonoReflectionType *)val.271].type;
  D.31165 = mono_class_from_mono_type (D.31164);
  buffer_add_typeid (buf, domain, D.31165);
  goto <D.31157>;
  <D.31156>:
  D.31166 = mono_type_is_reference (t);
  if (D.31166 != 0) goto <D.31167>; else goto <D.31168>;
  <D.31167>:
  buffer_add_value (buf, t, &val, domain);
  goto <D.31169>;
  <D.31168>:
  val.271 = val;
  D.31170 = mono_object_unbox (val.271);
  buffer_add_value (buf, t, D.31170, domain);
  <D.31169>:
  <D.31157>:
}


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


buffer_add_value_full (struct Buffer * buf, struct MonoType * t, void * addr, struct MonoDomain * domain, gboolean as_vtype)
{
  unsigned char D.31171;
  unsigned char D.31172;
  void * D.31175;
  _Bool D.31178;
  long int D.31179;
  long int D.31180;
  unsigned char D.31185;
  int D.31186;
  signed char D.31187;
  unsigned int D.31188;
  short int D.31189;
  unsigned int D.31190;
  int D.31191;
  unsigned int D.31192;
  long int D.31193;
  long unsigned int D.31194;
  long unsigned int val.272;
  struct MonoVTable * D.31199;
  struct MonoClass * D.31200;
  unsigned char D.31201;
  unsigned char D.31202;
  unsigned char D.31205;
  unsigned char D.31208;
  int D.31209;
  <unnamed-unsigned:1> D.31214;
  int D.31215;
  struct MonoType * D.31216;
  short unsigned int D.31217;
  int D.31218;
  int D.31219;
  int D.31222;
  int D.26706;
  int iftmp.273;
  int D.26705;
  const char[9] * D.31228;
  unsigned char D.31229;
  int D.31230;
  unsigned char D.31231;
  int D.31232;
  _Bool D.31233;
  _Bool D.31234;
  _Bool D.31235;
  const unsigned char * D.31238;
  unsigned char D.31239;
  int D.31240;
  const unsigned char * D.31241;
  unsigned char D.31242;
  int D.31243;
  _Bool D.31244;
  _Bool D.31245;
  const unsigned char * D.31248;
  unsigned char D.31249;
  int D.31250;
  const unsigned char * D.31251;
  unsigned char D.31252;
  int D.31253;
  _Bool D.31254;
  _Bool D.31255;
  const unsigned char * D.31258;
  unsigned char D.31259;
  int D.31260;
  const unsigned char * D.31261;
  unsigned char D.31262;
  int D.31263;
  const char * D.31265;
  unsigned int nfields.274;
  int D.26718;
  int iftmp.275;
  int D.26717;
  unsigned char D.31276;
  int D.31277;
  _Bool D.31278;
  _Bool D.31279;
  _Bool D.31280;
  const unsigned char * D.31283;
  unsigned char D.31284;
  int D.31285;
  _Bool D.31286;
  _Bool D.31287;
  const unsigned char * D.31290;
  unsigned char D.31291;
  int D.31292;
  _Bool D.31293;
  _Bool D.31294;
  const unsigned char * D.31297;
  unsigned char D.31298;
  int D.31299;
  const char * D.31301;
  int D.31304;
  sizetype D.31305;
  sizetype D.31306;
  void * D.31307;
  int D.31308;
  struct MonoObject * obj;
  void handle_vtype = <<< error >>>;
  void handle_ref = <<< error >>>;

  D.31171 = BIT_FIELD_REF <*t, 8, 88>;
  D.31172 = D.31171 & 64;
  if (D.31172 != 0) goto <D.31173>; else goto <D.31174>;
  <D.31173>:
  D.31175 = MEM[(void * *)addr];
  if (D.31175 == 0B) goto <D.31176>; else goto <D.31177>;
  <D.31176>:
  buffer_add_byte (buf, 240);
  return;
  <D.31177>:
  D.31175 = MEM[(void * *)addr];
  D.31178 = D.31175 == 0B;
  D.31179 = (long int) D.31178;
  D.31180 = __builtin_expect (D.31179, 0);
  if (D.31180 != 0) goto <D.31181>; else goto <D.31182>;
  <D.31181>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 5513, "*(void**)addr");
  <D.31182>:
  addr = MEM[(void * *)addr];
  <D.31174>:
  if (as_vtype != 0) goto <D.31183>; else goto <D.31184>;
  <D.31183>:
  D.31185 = t->type;
  D.31186 = (int) D.31185;
  switch (D.31186) <default: <D.26666>, case 2: <D.26650>, case 3: <D.26653>, case 4: <D.26651>, case 5: <D.26652>, case 6: <D.26654>, case 7: <D.26655>, case 8: <D.26656>, case 9: <D.26657>, case 10: <D.26659>, case 11: <D.26660>, case 12: <D.26658>, case 13: <D.26661>, case 15: <D.26664>, case 24: <D.26662>, case 25: <D.26663>>
  <D.26650>:
  <D.26651>:
  <D.26652>:
  <D.26653>:
  <D.26654>:
  <D.26655>:
  <D.26656>:
  <D.26657>:
  <D.26658>:
  <D.26659>:
  <D.26660>:
  <D.26661>:
  <D.26662>:
  <D.26663>:
  <D.26664>:
  goto handle_vtype;
  <D.26666>:
  goto <D.26667>;
  <D.26667>:
  <D.31184>:
  D.31185 = t->type;
  D.31186 = (int) D.31185;
  switch (D.31186) <default: <D.26722>, case 1: <D.26668>, case 2: <D.26670>, case 3: <D.26673>, case 4: <D.26671>, case 5: <D.26672>, case 6: <D.26674>, case 7: <D.26675>, case 8: <D.26676>, case 9: <D.26677>, case 10: <D.26679>, case 11: <D.26680>, case 12: <D.26678>, case 13: <D.26681>, case 14: <D.26687>, case 15: <D.26684>, case 17: <D.26692>, case 18: <D.26690>, case 20: <D.26691>, case 21: <D.26721>, case 24: <D.26682>, case 25: <D.26683>, case 28: <D.26689>, case 29: <D.26688>>
  <D.26668>:
  D.31185 = t->type;
  D.31186 = (int) D.31185;
  buffer_add_byte (buf, D.31186);
  goto <D.26669>;
  <D.26670>:
  <D.26671>:
  <D.26672>:
  D.31185 = t->type;
  D.31186 = (int) D.31185;
  buffer_add_byte (buf, D.31186);
  D.31187 = MEM[(gint8 *)addr];
  D.31188 = (unsigned int) D.31187;
  buffer_add_int (buf, D.31188);
  goto <D.26669>;
  <D.26673>:
  <D.26674>:
  <D.26675>:
  D.31185 = t->type;
  D.31186 = (int) D.31185;
  buffer_add_byte (buf, D.31186);
  D.31189 = MEM[(gint16 *)addr];
  D.31190 = (unsigned int) D.31189;
  buffer_add_int (buf, D.31190);
  goto <D.26669>;
  <D.26676>:
  <D.26677>:
  <D.26678>:
  D.31185 = t->type;
  D.31186 = (int) D.31185;
  buffer_add_byte (buf, D.31186);
  D.31191 = MEM[(gint32 *)addr];
  D.31192 = (unsigned int) D.31191;
  buffer_add_int (buf, D.31192);
  goto <D.26669>;
  <D.26679>:
  <D.26680>:
  <D.26681>:
  D.31185 = t->type;
  D.31186 = (int) D.31185;
  buffer_add_byte (buf, D.31186);
  D.31193 = MEM[(gint64 *)addr];
  D.31194 = (long unsigned int) D.31193;
  buffer_add_long (buf, D.31194);
  goto <D.26669>;
  <D.26682>:
  <D.26683>:
  goto handle_vtype;
  <D.26684>:
  {
    gssize val;

    val = MEM[(gssize *)addr];
    D.31185 = t->type;
    D.31186 = (int) D.31185;
    buffer_add_byte (buf, D.31186);
    val.272 = (long unsigned int) val;
    buffer_add_long (buf, val.272);
    goto <D.26669>;
  }
  handle_ref:
  <D.26687>:
  <D.26688>:
  <D.26689>:
  <D.26690>:
  <D.26691>:
  obj = MEM[(struct MonoObject * *)addr];
  if (obj == 0B) goto <D.31196>; else goto <D.31197>;
  <D.31196>:
  buffer_add_byte (buf, 240);
  goto <D.31198>;
  <D.31197>:
  D.31199 = obj->vtable;
  D.31200 = D.31199->klass;
  D.31201 = BIT_FIELD_REF <*D.31200, 8, 256>;
  D.31202 = D.31201 & 8;
  if (D.31202 != 0) goto <D.31203>; else goto <D.31204>;
  <D.31203>:
  D.31199 = obj->vtable;
  D.31200 = D.31199->klass;
  t = &D.31200->byval_arg;
  addr = mono_object_unbox (obj);
  goto handle_vtype;
  <D.31204>:
  D.31199 = obj->vtable;
  D.31200 = D.31199->klass;
  D.31205 = D.31200->rank;
  if (D.31205 != 0) goto <D.31206>; else goto <D.31207>;
  <D.31206>:
  D.31199 = obj->vtable;
  D.31200 = D.31199->klass;
  D.31208 = D.31200->byval_arg.type;
  D.31209 = (int) D.31208;
  buffer_add_byte (buf, D.31209);
  goto <D.31210>;
  <D.31207>:
  D.31199 = obj->vtable;
  D.31200 = D.31199->klass;
  D.31208 = D.31200->byval_arg.type;
  if (D.31208 == 21) goto <D.31211>; else goto <D.31212>;
  <D.31211>:
  buffer_add_byte (buf, 18);
  goto <D.31213>;
  <D.31212>:
  D.31199 = obj->vtable;
  D.31200 = D.31199->klass;
  D.31208 = D.31200->byval_arg.type;
  D.31209 = (int) D.31208;
  buffer_add_byte (buf, D.31209);
  <D.31213>:
  <D.31210>:
  buffer_add_objid (buf, obj);
  <D.31198>:
  goto <D.26669>;
  handle_vtype:
  <D.26692>:
  {
    int nfields;
    void * iter;
    struct MonoClassField * f;
    struct MonoClass * klass;

    try
      {
        klass = mono_class_from_mono_type (t);
        buffer_add_byte (buf, 17);
        D.31214 = klass->enumtype;
        D.31215 = (int) D.31214;
        buffer_add_byte (buf, D.31215);
        buffer_add_typeid (buf, domain, klass);
        nfields = 0;
        iter = 0B;
        goto <D.26697>;
        <D.26707>:
        D.31216 = f->type;
        D.31217 = D.31216->attrs;
        D.31218 = (int) D.31217;
        D.31219 = D.31218 & 16;
        if (D.31219 != 0) goto <D.31220>; else goto <D.31221>;
        <D.31220>:
        // predicted unlikely by continue predictor.
        goto <D.26697>;
        <D.31221>:
        D.31216 = f->type;
        D.31217 = D.31216->attrs;
        D.31218 = (int) D.31217;
        D.31222 = D.31218 & 1536;
        if (D.31222 != 0) goto <D.31223>; else goto <D.31224>;
        <D.31223>:
        {
          size_t __s1_len;
          size_t __s2_len;

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

            __s2 = mono_field_get_name (f);
            D.31228 = "_Deleted";
            D.31229 = MEM[(const unsigned char *)D.31228];
            D.31230 = (int) D.31229;
            D.31231 = *__s2;
            D.31232 = (int) D.31231;
            __result = D.31230 - D.31232;
            {
              D.31233 = __s2_len != 0;
              D.31234 = __result == 0;
              D.31235 = D.31233 & D.31234;
              if (D.31235 != 0) goto <D.31236>; else goto <D.31237>;
              <D.31236>:
              D.31238 = &MEM[(void *)"_Deleted" + 1B];
              D.31239 = *D.31238;
              D.31240 = (int) D.31239;
              D.31241 = __s2 + 1;
              D.31242 = *D.31241;
              D.31243 = (int) D.31242;
              __result = D.31240 - D.31243;
              D.31244 = __s2_len > 1;
              D.31234 = __result == 0;
              D.31245 = D.31244 & D.31234;
              if (D.31245 != 0) goto <D.31246>; else goto <D.31247>;
              <D.31246>:
              D.31248 = &MEM[(void *)"_Deleted" + 2B];
              D.31249 = *D.31248;
              D.31250 = (int) D.31249;
              D.31251 = __s2 + 2;
              D.31252 = *D.31251;
              D.31253 = (int) D.31252;
              __result = D.31250 - D.31253;
              D.31254 = __s2_len > 2;
              D.31234 = __result == 0;
              D.31255 = D.31254 & D.31234;
              if (D.31255 != 0) goto <D.31256>; else goto <D.31257>;
              <D.31256>:
              D.31258 = &MEM[(void *)"_Deleted" + 3B];
              D.31259 = *D.31258;
              D.31260 = (int) D.31259;
              D.31261 = __s2 + 3;
              D.31262 = *D.31261;
              D.31263 = (int) D.31262;
              __result = D.31260 - D.31263;
              <D.31257>:
              <D.31247>:
              <D.31237>:
            }
            D.26705 = __result;
          }
          iftmp.273 = -D.26705;
          goto <D.31264>;
          <D.31227>:
          D.31265 = mono_field_get_name (f);
          iftmp.273 = __builtin_strcmp (D.31265, "_Deleted");
          <D.31264>:
          D.26706 = iftmp.273;
        }
        if (D.26706 == 0) goto <D.31266>; else goto <D.31267>;
        <D.31266>:
        // predicted unlikely by continue predictor.
        goto <D.26697>;
        <D.31267>:
        <D.31224>:
        nfields = nfields + 1;
        <D.26697>:
        f = mono_class_get_fields (klass, &iter);
        if (f != 0B) goto <D.26707>; else goto <D.26708>;
        <D.26708>:
        nfields.274 = (unsigned int) nfields;
        buffer_add_int (buf, nfields.274);
        iter = 0B;
        goto <D.26709>;
        <D.26719>:
        D.31216 = f->type;
        D.31217 = D.31216->attrs;
        D.31218 = (int) D.31217;
        D.31219 = D.31218 & 16;
        if (D.31219 != 0) goto <D.31269>; else goto <D.31270>;
        <D.31269>:
        // predicted unlikely by continue predictor.
        goto <D.26709>;
        <D.31270>:
        D.31216 = f->type;
        D.31217 = D.31216->attrs;
        D.31218 = (int) D.31217;
        D.31222 = D.31218 & 1536;
        if (D.31222 != 0) goto <D.31271>; else goto <D.31272>;
        <D.31271>:
        {
          size_t __s1_len;
          size_t __s2_len;

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

            __s2 = mono_field_get_name (f);
            D.31228 = "_Deleted";
            D.31229 = MEM[(const unsigned char *)D.31228];
            D.31230 = (int) D.31229;
            D.31276 = *__s2;
            D.31277 = (int) D.31276;
            __result = D.31230 - D.31277;
            {
              D.31278 = __s2_len != 0;
              D.31279 = __result == 0;
              D.31280 = D.31278 & D.31279;
              if (D.31280 != 0) goto <D.31281>; else goto <D.31282>;
              <D.31281>:
              D.31238 = &MEM[(void *)"_Deleted" + 1B];
              D.31239 = *D.31238;
              D.31240 = (int) D.31239;
              D.31283 = __s2 + 1;
              D.31284 = *D.31283;
              D.31285 = (int) D.31284;
              __result = D.31240 - D.31285;
              D.31286 = __s2_len > 1;
              D.31279 = __result == 0;
              D.31287 = D.31286 & D.31279;
              if (D.31287 != 0) goto <D.31288>; else goto <D.31289>;
              <D.31288>:
              D.31248 = &MEM[(void *)"_Deleted" + 2B];
              D.31249 = *D.31248;
              D.31250 = (int) D.31249;
              D.31290 = __s2 + 2;
              D.31291 = *D.31290;
              D.31292 = (int) D.31291;
              __result = D.31250 - D.31292;
              D.31293 = __s2_len > 2;
              D.31279 = __result == 0;
              D.31294 = D.31293 & D.31279;
              if (D.31294 != 0) goto <D.31295>; else goto <D.31296>;
              <D.31295>:
              D.31258 = &MEM[(void *)"_Deleted" + 3B];
              D.31259 = *D.31258;
              D.31260 = (int) D.31259;
              D.31297 = __s2 + 3;
              D.31298 = *D.31297;
              D.31299 = (int) D.31298;
              __result = D.31260 - D.31299;
              <D.31296>:
              <D.31289>:
              <D.31282>:
            }
            D.26717 = __result;
          }
          iftmp.275 = -D.26717;
          goto <D.31300>;
          <D.31275>:
          D.31301 = mono_field_get_name (f);
          iftmp.275 = __builtin_strcmp (D.31301, "_Deleted");
          <D.31300>:
          D.26718 = iftmp.275;
        }
        if (D.26718 == 0) goto <D.31302>; else goto <D.31303>;
        <D.31302>:
        // predicted unlikely by continue predictor.
        goto <D.26709>;
        <D.31303>:
        <D.31272>:
        D.31304 = f->offset;
        D.31305 = (sizetype) D.31304;
        D.31306 = D.31305 + 18446744073709551600;
        D.31307 = addr + D.31306;
        D.31216 = f->type;
        buffer_add_value_full (buf, D.31216, D.31307, domain, 0);
        <D.26709>:
        f = mono_class_get_fields (klass, &iter);
        if (f != 0B) goto <D.26719>; else goto <D.26720>;
        <D.26720>:
        goto <D.26669>;
      }
    finally
      {
        iter = {CLOBBER};
      }
  }
  <D.26721>:
  D.31308 = mono_type_generic_inst_is_valuetype (t);
  if (D.31308 != 0) goto handle_vtype; else goto handle_ref;
  <D.26722>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "debugger-agent.c", 5645);
  <D.26669>:
}


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

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


collect_interfaces (struct MonoClass * klass, struct GHashTable * ifaces, struct MonoError * error)
{
  int D.31314;
  struct MonoClass * * D.31317;
  long unsigned int D.31318;
  long unsigned int D.31319;
  struct MonoClass * * D.31320;
  int D.31321;
  short unsigned int D.31324;
  int D.31325;
  int i;
  struct MonoClass * ic;

  mono_class_setup_interfaces (klass, error);
  D.31314 = mono_error_ok (error);
  if (D.31314 == 0) goto <D.31315>; else goto <D.31316>;
  <D.31315>:
  return;
  <D.31316>:
  i = 0;
  goto <D.27333>;
  <D.27332>:
  D.31317 = klass->interfaces;
  D.31318 = (long unsigned int) i;
  D.31319 = D.31318 * 8;
  D.31320 = D.31317 + D.31319;
  ic = *D.31320;
  monoeg_g_hash_table_insert_replace (ifaces, ic, ic, 0);
  collect_interfaces (ic, ifaces, error);
  D.31321 = mono_error_ok (error);
  if (D.31321 == 0) goto <D.31322>; else goto <D.31323>;
  <D.31322>:
  return;
  <D.31323>:
  i = i + 1;
  <D.27333>:
  D.31324 = klass->interface_count;
  D.31325 = (int) D.31324;
  if (D.31325 > i) goto <D.27332>; else goto <D.27334>;
  <D.27334>:
}


method_commands (int command, guint8 * p, guint8 * end, struct Buffer * buf)
{
  guint8 * p.276;
  int err.277;
  ErrorCode D.31331;
  struct MonoDomain * domain.278;
  <unnamed type> D.31333;
  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.31329>; else goto <D.31330>;
      <D.31329>:
      err.277 = err;
      D.31331 = (ErrorCode) err.277;
      return D.31331;
      <D.31330>:
      old_domain = mono_domain_get ();
      domain.278 = domain;
      mono_domain_set (domain.278, 1);
      p.276 = p;
      domain.278 = domain;
      D.31333 = method_commands_internal (command, method, domain.278, p.276, end, buf);
      err.279 = (int) D.31333;
      err = err.279;
      mono_domain_set (old_domain, 1);
      err.277 = err;
      D.31331 = (ErrorCode) err.277;
      return D.31331;
    }
  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.31337;
  struct MonoClass * D.31338;
  unsigned int D.31343;
  int protocol_version_set.280;
  int major_version.281;
  int minor_version.282;
  struct GPtrArray * source_file_list.283;
  unsigned int D.31354;
  void * * D.31355;
  long unsigned int D.31356;
  long unsigned int D.31357;
  void * * D.31358;
  char * D.31359;
  guint8 * D.31365;
  sizetype D.31366;
  guint8 * D.31367;
  unsigned char D.31368;
  int D.31369;
  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.31375;
  long int D.31376;
  long int D.31377;
  char * D.31380;
  struct FILE * log_file.289;
  int * source_files.290;
  long unsigned int D.31383;
  int * D.31384;
  int D.31385;
  long unsigned int D.31388;
  long unsigned int D.31389;
  void * * D.31390;
  int iftmp.291;
  int * column_numbers.292;
  int * D.31397;
  int * line_numbers.293;
  int * D.31400;
  int D.31401;
  int * il_offsets.294;
  int * D.31403;
  int D.31404;
  unsigned int D.31405;
  unsigned int D.31406;
  unsigned int D.31413;
  guint32 iftmp.295;
  int D.31423;
  <unnamed-unsigned:6> D.31425;
  unsigned int D.31426;
  short unsigned int D.31427;
  unsigned int D.31428;
  short unsigned int D.31429;
  unsigned int D.31430;
  struct MonoType * D.31431;
  struct MonoClass * D.31432;
  struct MonoType * D.31433;
  struct MonoClass * D.31434;
  long unsigned int D.31435;
  long unsigned int D.31436;
  long unsigned int D.31437;
  long unsigned int D.31438;
  char * * D.31439;
  char * D.31440;
  ErrorCode D.31443;
  short unsigned int D.31444;
  unsigned int D.31445;
  struct MonoType * D.31446;
  struct MonoClass * D.31447;
  int D.31448;
  struct MonoDebugLocalVar * D.31452;
  long unsigned int D.31453;
  long unsigned int D.31454;
  struct MonoDebugLocalVar * D.31455;
  int D.31456;
  char * D.31460;
  struct MonoDebugCodeBlock * D.31466;
  int D.31468;
  unsigned int D.31469;
  int D.31470;
  unsigned int D.31471;
  short unsigned int D.31474;
  unsigned int D.31475;
  short unsigned int D.31476;
  unsigned int D.31477;
  unsigned int D.31478;
  unsigned char D.31485;
  unsigned char D.31486;
  struct MonoMethodSignature * D.31489;
  short unsigned int D.31490;
  int D.31493;
  unsigned char D.31494;
  struct MonoGenericInst * D.31500;
  struct MonoGenericContext * D.31503;
  struct MonoGenericContext * D.31506;
  struct MonoMethodSignature * D.31514;
  short unsigned int D.31515;
  unsigned char D.31518;
  struct MonoGenericContext * D.31521;
  <unnamed-unsigned:22> D.31524;
  unsigned int count.296;
  struct MonoType * D.31526;
  struct MonoClass * D.31527;
  struct MonoMethodSignature * D.31532;
  short unsigned int D.31533;
  struct MonoGenericParamFull * D.31534;
  long unsigned int D.31535;
  long unsigned int D.31536;
  struct MonoImage * D.31537;
  const unsigned char * D.31549;
  sizetype D.31550;
  const unsigned char * D.31551;
  unsigned char D.31552;
  int D.31553;
  unsigned int i.297;
  <unnamed-unsigned:15> D.31560;
  unsigned int D.31561;
  struct MonoExceptionClause * D.31562;
  long unsigned int D.31563;
  long unsigned int D.31564;
  unsigned int D.31565;
  unsigned int D.31566;
  unsigned int D.31567;
  unsigned int D.31568;
  unsigned int D.31569;
  struct MonoClass * D.31572;
  unsigned int D.31576;
  int D.31577;
  guint8 * p.298;
  int D.31579;
  unsigned int D.31580;
  unsigned int D.31581;
  _Bool D.31582;
  long int D.31583;
  long int D.31584;
  unsigned char D.31587;
  unsigned char D.31588;
  unsigned int D.31591;
  void * handle_class.299;
  struct MonoClass * handle_class.300;
  _Bool D.31597;
  long int D.31598;
  long int D.31599;
  struct MonoClass * D.31602;
  struct MonoClass * D.31608;
  struct MonoClass * D.31610;
  struct MonoClass * D.31614;
  struct MonoClass * D.31618;
  int err.301;
  long unsigned int D.31625;
  long unsigned int D.31626;
  struct MonoDomain * d.302;
  long unsigned int D.31632;
  long unsigned int D.31633;
  struct MonoType * * D.31634;
  struct MonoType * D.31635;
  struct MonoGenericInst * iftmp.303;
  struct MonoGenericClass * D.31637;
  int D.31641;
  struct MonoMethodHeader * header;
  int err;

  try
    {
      switch (command) <default: <D.27623>, case 1: <D.27516>, case 2: <D.27518>, case 3: <D.27519>, case 4: <D.27542>, case 5: <D.27552>, case 6: <D.27572>, case 7: <D.27589>, case 8: <D.27598>, case 9: <D.27608>, case 10: <D.27611>>
      <D.27516>:
      D.31337 = method->name;
      buffer_add_string (buf, D.31337);
      goto <D.27517>;
      <D.27518>:
      D.31338 = method->klass;
      buffer_add_typeid (buf, domain, D.31338);
      goto <D.27517>;
      <D.27519>:
      {
        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.31339>; else goto <D.31340>;
            <D.31339>:
            buffer_add_int (buf, 0);
            buffer_add_string (buf, "");
            buffer_add_int (buf, 0);
            goto <D.27517>;
            <D.31340>:
            minfo = mono_debug_lookup_method (method);
            if (minfo == 0B) goto <D.31341>; else goto <D.31342>;
            <D.31341>:
            D.31343 = header->code_size;
            buffer_add_int (buf, D.31343);
            buffer_add_string (buf, "");
            buffer_add_int (buf, 0);
            mono_metadata_free_mh (header);
            goto <D.27517>;
            <D.31342>:
            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.31343 = header->code_size;
            buffer_add_int (buf, D.31343);
            protocol_version_set.280 = protocol_version_set;
            if (protocol_version_set.280 != 0) goto <D.31348>; else goto <D.31344>;
            <D.31348>:
            major_version.281 = major_version;
            if (major_version.281 > 2) goto <D.31345>; else goto <D.31350>;
            <D.31350>:
            major_version.281 = major_version;
            if (major_version.281 == 2) goto <D.31351>; else goto <D.31344>;
            <D.31351>:
            minor_version.282 = minor_version;
            if (minor_version.282 > 12) goto <D.31345>; else goto <D.31344>;
            <D.31345>:
            source_file_list.283 = source_file_list;
            D.31354 = source_file_list.283->len;
            buffer_add_int (buf, D.31354);
            i = 0;
            goto <D.27535>;
            <D.27534>:
            {
              struct MonoDebugSourceInfo * sinfo;

              source_file_list.283 = source_file_list;
              D.31355 = source_file_list.283->pdata;
              D.31356 = (long unsigned int) i;
              D.31357 = D.31356 * 8;
              D.31358 = D.31355 + D.31357;
              sinfo = *D.31358;
              D.31359 = sinfo->source_file;
              buffer_add_string (buf, D.31359);
              protocol_version_set.280 = protocol_version_set;
              if (protocol_version_set.280 != 0) goto <D.31361>; else goto <D.31362>;
              <D.31361>:
              major_version.281 = major_version;
              if (major_version.281 > 2) goto <D.31360>; else goto <D.31363>;
              <D.31363>:
              major_version.281 = major_version;
              if (major_version.281 == 2) goto <D.31364>; else goto <D.27533>;
              <D.31364>:
              minor_version.282 = minor_version;
              if (minor_version.282 > 13) goto <D.31360>; else goto <D.27533>;
              <D.31360>:
              j = 0;
              goto <D.27532>;
              <D.27531>:
              D.31365 = sinfo->hash;
              D.31366 = (sizetype) j;
              D.31367 = D.31365 + D.31366;
              D.31368 = *D.31367;
              D.31369 = (int) D.31368;
              buffer_add_byte (buf, D.31369);
              j = j + 1;
              <D.27532>:
              if (j <= 15) goto <D.27531>; else goto <D.27533>;
              <D.27533>:
              <D.31362>:
            }
            i = i + 1;
            <D.27535>:
            i.284 = (unsigned int) i;
            source_file_list.283 = source_file_list;
            D.31354 = source_file_list.283->len;
            if (i.284 < D.31354) goto <D.27534>; else goto <D.27536>;
            <D.27536>:
            goto <D.31346>;
            <D.31344>:
            source_file.285 = source_file;
            buffer_add_string (buf, source_file.285);
            <D.31346>:
            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.31375 = log_level.288 > 9;
            D.31376 = (long int) D.31375;
            D.31377 = __builtin_expect (D.31376, 0);
            if (D.31377 != 0) goto <D.31378>; else goto <D.31379>;
            <D.31378>:
            D.31380 = mono_method_full_name (method, 1);
            log_file.289 = log_file;
            fprintf (log_file.289, "Line number table for method %s:\n", D.31380);
            log_file.289 = log_file;
            fflush (log_file.289);
            <D.31379>:
            i = 0;
            goto <D.27540>;
            <D.27539>:
            {
              const char * srcfile;

              srcfile = "";
              source_files.290 = source_files;
              D.31356 = (long unsigned int) i;
              D.31383 = D.31356 * 4;
              D.31384 = source_files.290 + D.31383;
              D.31385 = *D.31384;
              if (D.31385 != -1) goto <D.31386>; else goto <D.31387>;
              <D.31386>:
              {
                struct MonoDebugSourceInfo * sinfo;

                source_file_list.283 = source_file_list;
                D.31355 = source_file_list.283->pdata;
                source_files.290 = source_files;
                D.31356 = (long unsigned int) i;
                D.31383 = D.31356 * 4;
                D.31384 = source_files.290 + D.31383;
                D.31385 = *D.31384;
                D.31388 = (long unsigned int) D.31385;
                D.31389 = D.31388 * 8;
                D.31390 = D.31355 + D.31389;
                sinfo = *D.31390;
                srcfile = sinfo->source_file;
              }
              <D.31387>:
              log_level.288 = log_level;
              D.31375 = log_level.288 > 9;
              D.31376 = (long int) D.31375;
              D.31377 = __builtin_expect (D.31376, 0);
              if (D.31377 != 0) goto <D.31391>; else goto <D.31392>;
              <D.31391>:
              column_numbers.292 = column_numbers;
              if (column_numbers.292 != 0B) goto <D.31395>; else goto <D.31396>;
              <D.31395>:
              column_numbers.292 = column_numbers;
              D.31356 = (long unsigned int) i;
              D.31383 = D.31356 * 4;
              D.31397 = column_numbers.292 + D.31383;
              iftmp.291 = *D.31397;
              goto <D.31398>;
              <D.31396>:
              iftmp.291 = -1;
              <D.31398>:
              line_numbers.293 = line_numbers;
              D.31356 = (long unsigned int) i;
              D.31383 = D.31356 * 4;
              D.31400 = line_numbers.293 + D.31383;
              D.31401 = *D.31400;
              il_offsets.294 = il_offsets;
              D.31356 = (long unsigned int) i;
              D.31383 = D.31356 * 4;
              D.31403 = il_offsets.294 + D.31383;
              D.31404 = *D.31403;
              log_file.289 = log_file;
              fprintf (log_file.289, "IL%x -> %s:%d %d\n", D.31404, srcfile, D.31401, iftmp.291);
              log_file.289 = log_file;
              fflush (log_file.289);
              <D.31392>:
              il_offsets.294 = il_offsets;
              D.31356 = (long unsigned int) i;
              D.31383 = D.31356 * 4;
              D.31403 = il_offsets.294 + D.31383;
              D.31404 = *D.31403;
              D.31405 = (unsigned int) D.31404;
              buffer_add_int (buf, D.31405);
              line_numbers.293 = line_numbers;
              D.31356 = (long unsigned int) i;
              D.31383 = D.31356 * 4;
              D.31400 = line_numbers.293 + D.31383;
              D.31401 = *D.31400;
              D.31406 = (unsigned int) D.31401;
              buffer_add_int (buf, D.31406);
              protocol_version_set.280 = protocol_version_set;
              if (protocol_version_set.280 != 0) goto <D.31409>; else goto <D.31410>;
              <D.31409>:
              major_version.281 = major_version;
              if (major_version.281 > 2) goto <D.31407>; else goto <D.31411>;
              <D.31411>:
              major_version.281 = major_version;
              if (major_version.281 == 2) goto <D.31412>; else goto <D.31408>;
              <D.31412>:
              minor_version.282 = minor_version;
              if (minor_version.282 > 12) goto <D.31407>; else goto <D.31408>;
              <D.31407>:
              source_files.290 = source_files;
              D.31356 = (long unsigned int) i;
              D.31383 = D.31356 * 4;
              D.31384 = source_files.290 + D.31383;
              D.31385 = *D.31384;
              D.31413 = (unsigned int) D.31385;
              buffer_add_int (buf, D.31413);
              <D.31408>:
              <D.31410>:
              protocol_version_set.280 = protocol_version_set;
              if (protocol_version_set.280 != 0) goto <D.31416>; else goto <D.31417>;
              <D.31416>:
              major_version.281 = major_version;
              if (major_version.281 > 2) goto <D.31414>; else goto <D.31418>;
              <D.31418>:
              major_version.281 = major_version;
              if (major_version.281 == 2) goto <D.31419>; else goto <D.31415>;
              <D.31419>:
              minor_version.282 = minor_version;
              if (minor_version.282 > 18) goto <D.31414>; else goto <D.31415>;
              <D.31414>:
              column_numbers.292 = column_numbers;
              if (column_numbers.292 != 0B) goto <D.31421>; else goto <D.31422>;
              <D.31421>:
              column_numbers.292 = column_numbers;
              D.31356 = (long unsigned int) i;
              D.31383 = D.31356 * 4;
              D.31397 = column_numbers.292 + D.31383;
              D.31423 = *D.31397;
              iftmp.295 = (guint32) D.31423;
              goto <D.31424>;
              <D.31422>:
              iftmp.295 = 4294967295;
              <D.31424>:
              buffer_add_int (buf, iftmp.295);
              <D.31415>:
              <D.31417>:
            }
            i = i + 1;
            <D.27540>:
            n_il_offsets.286 = n_il_offsets;
            if (i < n_il_offsets.286) goto <D.27539>; else goto <D.27541>;
            <D.27541>:
            source_file.285 = source_file;
            monoeg_g_free (source_file.285);
            il_offsets.294 = il_offsets;
            monoeg_g_free (il_offsets.294);
            line_numbers.293 = line_numbers;
            monoeg_g_free (line_numbers.293);
            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.27517>;
          }
        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.27542>:
      {
        struct MonoMethodSignature * sig;
        guint32 i;
        char * * names;

        sig = mono_method_signature (method);
        D.31425 = sig->call_convention;
        D.31426 = (unsigned int) D.31425;
        buffer_add_int (buf, D.31426);
        D.31427 = sig->param_count;
        D.31428 = (unsigned int) D.31427;
        buffer_add_int (buf, D.31428);
        D.31429 = sig->generic_param_count;
        D.31430 = (unsigned int) D.31429;
        buffer_add_int (buf, D.31430);
        D.31431 = sig->ret;
        D.31432 = mono_class_from_mono_type (D.31431);
        buffer_add_typeid (buf, domain, D.31432);
        i = 0;
        goto <D.27547>;
        <D.27546>:
        D.31433 = sig->params[i];
        D.31434 = mono_class_from_mono_type (D.31433);
        buffer_add_typeid (buf, domain, D.31434);
        i = i + 1;
        <D.27547>:
        D.31427 = sig->param_count;
        D.31428 = (unsigned int) D.31427;
        if (D.31428 > i) goto <D.27546>; else goto <D.27548>;
        <D.27548>:
        D.31427 = sig->param_count;
        D.31435 = (long unsigned int) D.31427;
        D.31436 = D.31435 * 8;
        names = monoeg_malloc (D.31436);
        mono_method_get_param_names (method, names);
        i = 0;
        goto <D.27550>;
        <D.27549>:
        D.31437 = (long unsigned int) i;
        D.31438 = D.31437 * 8;
        D.31439 = names + D.31438;
        D.31440 = *D.31439;
        buffer_add_string (buf, D.31440);
        i = i + 1;
        <D.27550>:
        D.31427 = sig->param_count;
        D.31428 = (unsigned int) D.31427;
        if (D.31428 > i) goto <D.27549>; else goto <D.27551>;
        <D.27551>:
        monoeg_g_free (names);
        goto <D.27517>;
      }
      <D.27552>:
      {
        int i;
        int j;
        int num_locals;
        struct MonoDebugLocalsInfo * locals;

        header = mono_method_get_header (method);
        if (header == 0B) goto <D.31441>; else goto <D.31442>;
        <D.31441>:
        D.31443 = 102;
        return D.31443;
        <D.31442>:
        D.31444 = header->num_locals;
        D.31445 = (unsigned int) D.31444;
        buffer_add_int (buf, D.31445);
        i = 0;
        goto <D.27558>;
        <D.27557>:
        D.31446 = header->locals[i];
        D.31447 = mono_class_from_mono_type (D.31446);
        buffer_add_typeid (buf, domain, D.31447);
        i = i + 1;
        <D.27558>:
        D.31444 = header->num_locals;
        D.31448 = (int) D.31444;
        if (D.31448 > i) goto <D.27557>; else goto <D.27559>;
        <D.27559>:
        locals = mono_debug_lookup_locals (method);
        if (locals != 0B) goto <D.31449>; else goto <D.31450>;
        <D.31449>:
        num_locals = locals->num_locals;
        goto <D.31451>;
        <D.31450>:
        num_locals = 0;
        <D.31451>:
        i = 0;
        goto <D.27564>;
        <D.27563>:
        j = 0;
        goto <D.27562>;
        <D.27561>:
        D.31452 = locals->locals;
        D.31453 = (long unsigned int) j;
        D.31454 = D.31453 * 24;
        D.31455 = D.31452 + D.31454;
        D.31456 = D.31455->index;
        if (D.31456 == i) goto <D.27560>; else goto <D.31457>;
        <D.31457>:
        j = j + 1;
        <D.27562>:
        if (j < num_locals) goto <D.27561>; else goto <D.27560>;
        <D.27560>:
        if (j < num_locals) goto <D.31458>; else goto <D.31459>;
        <D.31458>:
        D.31452 = locals->locals;
        D.31453 = (long unsigned int) j;
        D.31454 = D.31453 * 24;
        D.31455 = D.31452 + D.31454;
        D.31460 = D.31455->name;
        buffer_add_string (buf, D.31460);
        goto <D.31461>;
        <D.31459>:
        buffer_add_string (buf, "");
        <D.31461>:
        i = i + 1;
        <D.27564>:
        D.31444 = header->num_locals;
        D.31448 = (int) D.31444;
        if (D.31448 > i) goto <D.27563>; else goto <D.27565>;
        <D.27565>:
        i = 0;
        goto <D.27570>;
        <D.27569>:
        j = 0;
        goto <D.27568>;
        <D.27567>:
        D.31452 = locals->locals;
        D.31453 = (long unsigned int) j;
        D.31454 = D.31453 * 24;
        D.31455 = D.31452 + D.31454;
        D.31456 = D.31455->index;
        if (D.31456 == i) goto <D.27566>; else goto <D.31462>;
        <D.31462>:
        j = j + 1;
        <D.27568>:
        if (j < num_locals) goto <D.27567>; else goto <D.27566>;
        <D.27566>:
        if (j < num_locals) goto <D.31465>; else goto <D.31463>;
        <D.31465>:
        D.31452 = locals->locals;
        D.31453 = (long unsigned int) j;
        D.31454 = D.31453 * 24;
        D.31455 = D.31452 + D.31454;
        D.31466 = D.31455->block;
        if (D.31466 != 0B) goto <D.31467>; else goto <D.31463>;
        <D.31467>:
        D.31452 = locals->locals;
        D.31453 = (long unsigned int) j;
        D.31454 = D.31453 * 24;
        D.31455 = D.31452 + D.31454;
        D.31466 = D.31455->block;
        D.31468 = D.31466->start_offset;
        D.31469 = (unsigned int) D.31468;
        buffer_add_int (buf, D.31469);
        D.31452 = locals->locals;
        D.31453 = (long unsigned int) j;
        D.31454 = D.31453 * 24;
        D.31455 = D.31452 + D.31454;
        D.31466 = D.31455->block;
        D.31470 = D.31466->end_offset;
        D.31471 = (unsigned int) D.31470;
        buffer_add_int (buf, D.31471);
        goto <D.31464>;
        <D.31463>:
        buffer_add_int (buf, 0);
        D.31343 = header->code_size;
        buffer_add_int (buf, D.31343);
        <D.31464>:
        i = i + 1;
        <D.27570>:
        D.31444 = header->num_locals;
        D.31448 = (int) D.31444;
        if (D.31448 > i) goto <D.27569>; else goto <D.27571>;
        <D.27571>:
        mono_metadata_free_mh (header);
        if (locals != 0B) goto <D.31472>; else goto <D.31473>;
        <D.31472>:
        mono_debug_symfile_free_locals (locals);
        <D.31473>:
        goto <D.27517>;
      }
      <D.27572>:
      D.31474 = method->flags;
      D.31475 = (unsigned int) D.31474;
      buffer_add_int (buf, D.31475);
      D.31476 = method->iflags;
      D.31477 = (unsigned int) D.31476;
      buffer_add_int (buf, D.31477);
      D.31478 = method->token;
      buffer_add_int (buf, D.31478);
      protocol_version_set.280 = protocol_version_set;
      if (protocol_version_set.280 != 0) goto <D.31481>; else goto <D.31482>;
      <D.31481>:
      major_version.281 = major_version;
      if (major_version.281 > 2) goto <D.31479>; else goto <D.31483>;
      <D.31483>:
      major_version.281 = major_version;
      if (major_version.281 == 2) goto <D.31484>; else goto <D.31480>;
      <D.31484>:
      minor_version.282 = minor_version;
      if (minor_version.282 > 11) goto <D.31479>; else goto <D.31480>;
      <D.31479>:
      {
        guint8 attrs;

        attrs = 0;
        D.31485 = BIT_FIELD_REF <*method, 8, 264>;
        D.31486 = D.31485 & 8;
        if (D.31486 != 0) goto <D.31487>; else goto <D.31488>;
        <D.31487>:
        attrs = attrs | 1;
        <D.31488>:
        D.31489 = mono_method_signature (method);
        D.31490 = D.31489->generic_param_count;
        if (D.31490 != 0) goto <D.31491>; else goto <D.31492>;
        <D.31491>:
        attrs = attrs | 2;
        <D.31492>:
        D.31493 = (int) attrs;
        buffer_add_byte (buf, D.31493);
        D.31485 = BIT_FIELD_REF <*method, 8, 264>;
        D.31494 = D.31485 & 24;
        if (D.31494 != 0) goto <D.31495>; else goto <D.31496>;
        <D.31495>:
        {
          struct MonoMethod * result;

          D.31485 = BIT_FIELD_REF <*method, 8, 264>;
          D.31486 = D.31485 & 8;
          if (D.31486 != 0) goto <D.31497>; else goto <D.31498>;
          <D.31497>:
          result = method;
          goto <D.31499>;
          <D.31498>:
          {
            struct MonoMethodInflated * imethod;

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

              klass = MEM[(struct MonoMethod *)imethod].klass;
              D.31503 = mono_class_get_context (klass);
              if (D.31503 != 0B) goto <D.31504>; else goto <D.31505>;
              <D.31504>:
              D.31506 = mono_class_get_context (klass);
              result = mono_class_inflate_generic_method_full (result, klass, D.31506);
              <D.31505>:
            }
            <D.31502>:
          }
          <D.31499>:
          buffer_add_methodid (buf, domain, result);
        }
        goto <D.31507>;
        <D.31496>:
        buffer_add_id (buf, 0);
        <D.31507>:
        protocol_version_set.280 = protocol_version_set;
        if (protocol_version_set.280 != 0) goto <D.31510>; else goto <D.31511>;
        <D.31510>:
        major_version.281 = major_version;
        if (major_version.281 > 2) goto <D.31508>; else goto <D.31512>;
        <D.31512>:
        major_version.281 = major_version;
        if (major_version.281 == 2) goto <D.31513>; else goto <D.31509>;
        <D.31513>:
        minor_version.282 = minor_version;
        if (minor_version.282 > 14) goto <D.31508>; else goto <D.31509>;
        <D.31508>:
        D.31514 = mono_method_signature (method);
        D.31515 = D.31514->generic_param_count;
        if (D.31515 != 0) goto <D.31516>; else goto <D.31517>;
        <D.31516>:
        {
          int count;
          int i;

          D.31485 = BIT_FIELD_REF <*method, 8, 264>;
          D.31518 = D.31485 & 16;
          if (D.31518 != 0) goto <D.31519>; else goto <D.31520>;
          <D.31519>:
          {
            struct MonoGenericInst * inst;

            D.31521 = mono_method_get_context (method);
            inst = D.31521->method_inst;
            if (inst != 0B) goto <D.31522>; else goto <D.31523>;
            <D.31522>:
            D.31524 = inst->type_argc;
            count = (int) D.31524;
            count.296 = (unsigned int) count;
            buffer_add_int (buf, count.296);
            i = 0;
            goto <D.27581>;
            <D.27580>:
            D.31526 = inst->type_argv[i];
            D.31527 = mono_class_from_mono_type (D.31526);
            buffer_add_typeid (buf, domain, D.31527);
            i = i + 1;
            <D.27581>:
            if (i < count) goto <D.27580>; else goto <D.27582>;
            <D.27582>:
            goto <D.31528>;
            <D.31523>:
            buffer_add_int (buf, 0);
            <D.31528>:
          }
          goto <D.31529>;
          <D.31520>:
          D.31485 = BIT_FIELD_REF <*method, 8, 264>;
          D.31486 = D.31485 & 8;
          if (D.31486 != 0) goto <D.31530>; else goto <D.31531>;
          <D.31530>:
          {
            struct MonoGenericContainer * container;

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

              D.31534 = container->type_params;
              D.31535 = (long unsigned int) i;
              D.31536 = D.31535 * 56;
              param = D.31534 + D.31536;
              D.31338 = method->klass;
              D.31537 = D.31338->image;
              pklass = mono_class_from_generic_parameter (param, D.31537, 1);
              buffer_add_typeid (buf, domain, pklass);
            }
            i = i + 1;
            <D.27587>:
            if (i < count) goto <D.27586>; else goto <D.27588>;
            <D.27588>:
          }
          goto <D.31538>;
          <D.31531>:
          buffer_add_int (buf, 0);
          <D.31538>:
          <D.31529>:
        }
        goto <D.31539>;
        <D.31517>:
        buffer_add_int (buf, 0);
        <D.31539>:
        <D.31509>:
        <D.31511>:
      }
      <D.31480>:
      <D.31482>:
      goto <D.27517>;
      <D.27589>:
      {
        int i;

        header = mono_method_get_header (method);
        if (header == 0B) goto <D.31540>; else goto <D.31541>;
        <D.31540>:
        buffer_add_int (buf, 0);
        protocol_version_set.280 = protocol_version_set;
        if (protocol_version_set.280 != 0) goto <D.31544>; else goto <D.31545>;
        <D.31544>:
        major_version.281 = major_version;
        if (major_version.281 > 2) goto <D.31542>; else goto <D.31546>;
        <D.31546>:
        major_version.281 = major_version;
        if (major_version.281 == 2) goto <D.31547>; else goto <D.31543>;
        <D.31547>:
        minor_version.282 = minor_version;
        if (minor_version.282 > 17) goto <D.31542>; else goto <D.31543>;
        <D.31542>:
        buffer_add_int (buf, 0);
        <D.31543>:
        <D.31545>:
        goto <D.31548>;
        <D.31541>:
        D.31343 = header->code_size;
        buffer_add_int (buf, D.31343);
        i = 0;
        goto <D.27592>;
        <D.27591>:
        D.31549 = header->code;
        D.31550 = (sizetype) i;
        D.31551 = D.31549 + D.31550;
        D.31552 = *D.31551;
        D.31553 = (int) D.31552;
        buffer_add_byte (buf, D.31553);
        i = i + 1;
        <D.27592>:
        i.297 = (unsigned int) i;
        D.31343 = header->code_size;
        if (i.297 < D.31343) goto <D.27591>; else goto <D.27593>;
        <D.27593>:
        protocol_version_set.280 = protocol_version_set;
        if (protocol_version_set.280 != 0) goto <D.31556>; else goto <D.31557>;
        <D.31556>:
        major_version.281 = major_version;
        if (major_version.281 > 2) goto <D.31555>; else goto <D.31558>;
        <D.31558>:
        major_version.281 = major_version;
        if (major_version.281 == 2) goto <D.31559>; else goto <D.27597>;
        <D.31559>:
        minor_version.282 = minor_version;
        if (minor_version.282 > 17) goto <D.31555>; else goto <D.27597>;
        <D.31555>:
        D.31560 = header->num_clauses;
        D.31561 = (unsigned int) D.31560;
        buffer_add_int (buf, D.31561);
        i = 0;
        goto <D.27596>;
        <D.27595>:
        {
          struct MonoExceptionClause * clause;

          D.31562 = header->clauses;
          D.31563 = (long unsigned int) i;
          D.31564 = D.31563 * 32;
          clause = D.31562 + D.31564;
          D.31565 = clause->flags;
          buffer_add_int (buf, D.31565);
          D.31566 = clause->try_offset;
          buffer_add_int (buf, D.31566);
          D.31567 = clause->try_len;
          buffer_add_int (buf, D.31567);
          D.31568 = clause->handler_offset;
          buffer_add_int (buf, D.31568);
          D.31569 = clause->handler_len;
          buffer_add_int (buf, D.31569);
          D.31565 = clause->flags;
          if (D.31565 == 0) goto <D.31570>; else goto <D.31571>;
          <D.31570>:
          D.31572 = clause->data.catch_class;
          buffer_add_typeid (buf, domain, D.31572);
          goto <D.31573>;
          <D.31571>:
          D.31565 = clause->flags;
          if (D.31565 == 1) goto <D.31574>; else goto <D.31575>;
          <D.31574>:
          D.31576 = clause->data.filter_offset;
          buffer_add_int (buf, D.31576);
          <D.31575>:
          <D.31573>:
        }
        i = i + 1;
        <D.27596>:
        D.31560 = header->num_clauses;
        D.31577 = (int) D.31560;
        if (D.31577 > i) goto <D.27595>; else goto <D.27597>;
        <D.27597>:
        <D.31557>:
        mono_metadata_free_mh (header);
        <D.31548>:
        goto <D.27517>;
      }
      <D.27598>:
      {
        guint32 token;

        p.298 = p;
        D.31579 = decode_int (p.298, &p, end);
        token = (guint32) D.31579;
        D.31580 = token & 4278190080;
        switch (D.31580) <default: <D.27604>, case 1879048192: <D.27600>>
        <D.27600>:
        {
          struct MonoString * s;
          char * s2;

          D.31581 = token & 16777215;
          D.31338 = method->klass;
          D.31537 = D.31338->image;
          s = mono_ldstr (domain, D.31537, D.31581);
          D.31582 = s == 0B;
          D.31583 = (long int) D.31582;
          D.31584 = __builtin_expect (D.31583, 0);
          if (D.31584 != 0) goto <D.31585>; else goto <D.31586>;
          <D.31585>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 8237, "s");
          <D.31586>:
          s2 = mono_string_to_utf8 (s);
          buffer_add_byte (buf, 0);
          buffer_add_string (buf, s2);
          monoeg_g_free (s2);
          goto <D.27603>;
        }
        <D.27604>:
        {
          void * val;
          struct MonoClass * handle_class;

          try
            {
              D.31587 = BIT_FIELD_REF <*method, 8, 256>;
              D.31588 = D.31587 & 124;
              if (D.31588 == 68) goto <D.31589>; else goto <D.31590>;
              <D.31589>:
              val = mono_method_get_wrapper_data (method, token);
              D.31591 = token + 1;
              handle_class.299 = mono_method_get_wrapper_data (method, D.31591);
              handle_class = handle_class.299;
              handle_class.300 = handle_class;
              if (handle_class.300 == 0B) goto <D.31594>; else goto <D.31595>;
              <D.31594>:
              buffer_add_byte (buf, 4);
              goto <D.27603>;
              <D.31595>:
              goto <D.31596>;
              <D.31590>:
              D.31338 = method->klass;
              D.31537 = D.31338->image;
              val = mono_ldtoken (D.31537, token, &handle_class, 0B);
              D.31597 = val == 0B;
              D.31598 = (long int) D.31597;
              D.31599 = __builtin_expect (D.31598, 0);
              if (D.31599 != 0) goto <D.31600>; else goto <D.31601>;
              <D.31600>:
              monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 8261, "val");
              <D.31601>:
              <D.31596>:
              D.31602 = mono_defaults.typehandle_class;
              handle_class.300 = handle_class;
              if (D.31602 == handle_class.300) goto <D.31603>; else goto <D.31604>;
              <D.31603>:
              buffer_add_byte (buf, 1);
              D.31587 = BIT_FIELD_REF <*method, 8, 256>;
              D.31588 = D.31587 & 124;
              if (D.31588 == 68) goto <D.31605>; else goto <D.31606>;
              <D.31605>:
              buffer_add_typeid (buf, domain, val);
              goto <D.31607>;
              <D.31606>:
              D.31608 = mono_class_from_mono_type (val);
              buffer_add_typeid (buf, domain, D.31608);
              <D.31607>:
              goto <D.31609>;
              <D.31604>:
              D.31610 = mono_defaults.fieldhandle_class;
              handle_class.300 = handle_class;
              if (D.31610 == handle_class.300) goto <D.31611>; else goto <D.31612>;
              <D.31611>:
              buffer_add_byte (buf, 2);
              buffer_add_fieldid (buf, domain, val);
              goto <D.31613>;
              <D.31612>:
              D.31614 = mono_defaults.methodhandle_class;
              handle_class.300 = handle_class;
              if (D.31614 == handle_class.300) goto <D.31615>; else goto <D.31616>;
              <D.31615>:
              buffer_add_byte (buf, 3);
              buffer_add_methodid (buf, domain, val);
              goto <D.31617>;
              <D.31616>:
              D.31618 = mono_defaults.string_class;
              handle_class.300 = handle_class;
              if (D.31618 == handle_class.300) goto <D.31619>; else goto <D.31620>;
              <D.31619>:
              {
                char * s;

                s = mono_string_to_utf8 (val);
                buffer_add_byte (buf, 0);
                buffer_add_string (buf, s);
                monoeg_g_free (s);
              }
              goto <D.31621>;
              <D.31620>:
              monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "debugger-agent.c", 8284);
              <D.31621>:
              <D.31617>:
              <D.31613>:
              <D.31609>:
              goto <D.27603>;
            }
          finally
            {
              handle_class = {CLOBBER};
            }
        }
        <D.27603>:
        goto <D.27517>;
      }
      <D.27608>:
      {
        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.31623>; else goto <D.31624>;
        <D.31623>:
        err.301 = err;
        D.31443 = (ErrorCode) err.301;
        return D.31443;
        <D.31624>:
        cinfo = mono_custom_attrs_from_method (method);
        D.31338 = method->klass;
        D.31537 = D.31338->image;
        buffer_add_cattrs (buf, domain, D.31537, attr_klass, cinfo);
        goto <D.27517>;
      }
      <D.27611>:
      {
        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.31625 = (long unsigned int) type_argc;
            D.31626 = D.31625 * 8;
            type_argv = monoeg_malloc0 (D.31626);
            i = 0;
            goto <D.27621>;
            <D.27620>:
            p.298 = p;
            klass = decode_typeid (p.298, &p, end, &d, &err);
            err.301 = err;
            if (err.301 != 0) goto <D.31627>; else goto <D.31628>;
            <D.31627>:
            monoeg_g_free (type_argv);
            err.301 = err;
            D.31443 = (ErrorCode) err.301;
            return D.31443;
            <D.31628>:
            d.302 = d;
            if (domain != d.302) goto <D.31630>; else goto <D.31631>;
            <D.31630>:
            monoeg_g_free (type_argv);
            D.31443 = 102;
            return D.31443;
            <D.31631>:
            D.31632 = (long unsigned int) i;
            D.31633 = D.31632 * 8;
            D.31634 = type_argv + D.31633;
            D.31635 = &klass->byval_arg;
            *D.31634 = D.31635;
            i = i + 1;
            <D.27621>:
            if (i < type_argc) goto <D.27620>; else goto <D.27622>;
            <D.27622>:
            ginst = mono_metadata_get_generic_inst (type_argc, type_argv);
            monoeg_g_free (type_argv);
            D.31338 = method->klass;
            D.31637 = D.31338->generic_class;
            if (D.31637 != 0B) goto <D.31638>; else goto <D.31639>;
            <D.31638>:
            D.31338 = method->klass;
            D.31637 = D.31338->generic_class;
            iftmp.303 = D.31637->context.class_inst;
            goto <D.31640>;
            <D.31639>:
            iftmp.303 = 0B;
            <D.31640>:
            tmp_context.class_inst = iftmp.303;
            tmp_context.method_inst = ginst;
            inflated = mono_class_inflate_generic_method (method, &tmp_context);
            D.31641 = mono_verifier_is_method_valid_generic_instantiation (inflated);
            if (D.31641 == 0) goto <D.31642>; else goto <D.31643>;
            <D.31642>:
            D.31443 = 102;
            return D.31443;
            <D.31643>:
            buffer_add_methodid (buf, domain, inflated);
            goto <D.27517>;
          }
        finally
          {
            d = {CLOBBER};
            tmp_context = {CLOBBER};
          }
      }
      <D.27623>:
      D.31443 = 100;
      return D.31443;
      <D.27517>:
      D.31443 = 0;
      return D.31443;
    }
  finally
    {
      err = {CLOBBER};
    }
}


thread_commands (int command, guint8 * p, guint8 * end, struct Buffer * buf)
{
  guint8 * p.304;
  <unnamed type> D.31651;
  ErrorCode D.31654;
  struct MonoThread * thread_obj.305;
  unsigned int name_len.306;
  long int D.31660;
  _Bool D.31661;
  long int D.31662;
  long int D.31663;
  long int len.307;
  unsigned int D.31667;
  int D.31668;
  int suspend_count.308;
  int D.31672;
  _Bool D.31673;
  _Bool D.31674;
  _Bool D.31675;
  struct MonoGHashTable * thread_to_tls.309;
  _Bool D.31679;
  long int D.31680;
  long int D.31681;
  int D.31684;
  unsigned int D.31685;
  struct StackFrame * * D.31686;
  long unsigned int D.31687;
  long unsigned int D.31688;
  struct StackFrame * * D.31689;
  struct StackFrame * D.31690;
  int D.31691;
  unsigned int D.31692;
  struct MonoMethod * D.31693;
  struct MonoDomain * D.31694;
  unsigned int D.31695;
  int D.31696;
  unsigned char D.31697;
  int D.31698;
  unsigned int D.31699;
  unsigned char D.31700;
  int D.31701;
  long unsigned int thread.310;
  long unsigned int D.31703;
  int objid;
  int err;
  struct MonoThread * thread_obj;
  struct MonoInternalThread * thread;

  try
    {
      p.304 = p;
      objid = decode_objid (p.304, &p, end);
      D.31651 = get_object (objid, &thread_obj);
      err = (int) D.31651;
      if (err != 0) goto <D.31652>; else goto <D.31653>;
      <D.31652>:
      D.31654 = (ErrorCode) err;
      return D.31654;
      <D.31653>:
      thread_obj.305 = thread_obj;
      thread = thread_obj.305->internal_thread;
      switch (command) <default: <D.27665>, case 1: <D.27650>, case 2: <D.27644>, case 3: <D.27661>, case 4: <D.27662>, case 5: <D.27663>, case 6: <D.27664>>
      <D.27644>:
      {
        guint32 name_len;
        gunichar2 * s;

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

              try
                {
                  name_len.306 = name_len;
                  D.31660 = (long int) name_len.306;
                  name = monoeg_g_utf16_to_utf8 (s, D.31660, 0B, &len, 0B);
                  D.31661 = name == 0B;
                  D.31662 = (long int) D.31661;
                  D.31663 = __builtin_expect (D.31662, 0);
                  if (D.31663 != 0) goto <D.31664>; else goto <D.31665>;
                  <D.31664>:
                  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 8395, "name");
                  <D.31665>:
                  len.307 = len;
                  D.31667 = (unsigned int) len.307;
                  buffer_add_int (buf, D.31667);
                  len.307 = len;
                  D.31668 = (int) len.307;
                  buffer_add_data (buf, name, D.31668);
                  monoeg_g_free (s);
                }
              finally
                {
                  len = {CLOBBER};
                }
            }
            <D.31658>:
            goto <D.27649>;
          }
        finally
          {
            name_len = {CLOBBER};
          }
      }
      <D.27650>:
      {
        struct DebuggerTlsData * tls;
        int i;
        int start_frame;
        int length;

        goto <D.27656>;
        <D.27655>:
        suspend_count.308 = suspend_count;
        if (suspend_count.308 != 0) goto <D.31670>; else goto <D.31671>;
        <D.31670>:
        wait_for_suspend ();
        <D.31671>:
        <D.27656>:
        D.31672 = is_suspended ();
        if (D.31672 == 0) goto <D.27655>; else goto <D.27657>;
        <D.27657>:
        p.304 = p;
        start_frame = decode_int (p.304, &p, end);
        p.304 = p;
        length = decode_int (p.304, &p, end);
        D.31673 = start_frame != 0;
        D.31674 = length != -1;
        D.31675 = D.31673 | D.31674;
        if (D.31675 != 0) goto <D.31676>; else goto <D.31677>;
        <D.31676>:
        D.31654 = 100;
        return D.31654;
        <D.31677>:
        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.31679 = tls == 0B;
        D.31680 = (long int) D.31679;
        D.31681 = __builtin_expect (D.31680, 0);
        if (D.31681 != 0) goto <D.31682>; else goto <D.31683>;
        <D.31682>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 8428, "tls");
        <D.31683>:
        compute_frame_info (thread, tls);
        D.31684 = tls->frame_count;
        D.31685 = (unsigned int) D.31684;
        buffer_add_int (buf, D.31685);
        i = 0;
        goto <D.27659>;
        <D.27658>:
        D.31686 = tls->frames;
        D.31687 = (long unsigned int) i;
        D.31688 = D.31687 * 8;
        D.31689 = D.31686 + D.31688;
        D.31690 = *D.31689;
        D.31691 = D.31690->id;
        D.31692 = (unsigned int) D.31691;
        buffer_add_int (buf, D.31692);
        D.31686 = tls->frames;
        D.31687 = (long unsigned int) i;
        D.31688 = D.31687 * 8;
        D.31689 = D.31686 + D.31688;
        D.31690 = *D.31689;
        D.31693 = D.31690->actual_method;
        D.31686 = tls->frames;
        D.31687 = (long unsigned int) i;
        D.31688 = D.31687 * 8;
        D.31689 = D.31686 + D.31688;
        D.31690 = *D.31689;
        D.31694 = D.31690->domain;
        buffer_add_methodid (buf, D.31694, D.31693);
        D.31686 = tls->frames;
        D.31687 = (long unsigned int) i;
        D.31688 = D.31687 * 8;
        D.31689 = D.31686 + D.31688;
        D.31690 = *D.31689;
        D.31695 = D.31690->il_offset;
        buffer_add_int (buf, D.31695);
        D.31686 = tls->frames;
        D.31687 = (long unsigned int) i;
        D.31688 = D.31687 * 8;
        D.31689 = D.31686 + D.31688;
        D.31690 = *D.31689;
        D.31696 = D.31690->flags;
        D.31697 = (unsigned char) D.31696;
        D.31698 = (int) D.31697;
        buffer_add_byte (buf, D.31698);
        i = i + 1;
        <D.27659>:
        D.31684 = tls->frame_count;
        if (D.31684 > i) goto <D.27658>; else goto <D.27660>;
        <D.27660>:
        goto <D.27649>;
      }
      <D.27661>:
      D.31699 = thread->state;
      buffer_add_int (buf, D.31699);
      goto <D.27649>;
      <D.27662>:
      D.31700 = thread->threadpool_thread;
      D.31701 = (int) D.31700;
      buffer_add_byte (buf, D.31701);
      goto <D.27649>;
      <D.27663>:
      thread.310 = (long unsigned int) thread;
      buffer_add_long (buf, thread.310);
      goto <D.27649>;
      <D.27664>:
      D.31703 = thread->tid;
      buffer_add_long (buf, D.31703);
      goto <D.27649>;
      <D.27665>:
      D.31654 = 100;
      return D.31654;
      <D.27649>:
      D.31654 = 0;
      return D.31654;
    }
  finally
    {
      thread_obj = {CLOBBER};
    }
}


frame_commands (int command, guint8 * p, guint8 * end, struct Buffer * buf)
{
  guint8 * p.311;
  <unnamed type> D.31709;
  ErrorCode D.31712;
  struct MonoThread * thread_obj.312;
  int D.31714;
  struct MonoGHashTable * thread_to_tls.313;
  _Bool D.31716;
  long int D.31717;
  long int D.31718;
  struct StackFrame * * D.31721;
  long unsigned int D.31722;
  long unsigned int D.31723;
  struct StackFrame * * D.31724;
  struct StackFrame * D.31725;
  int D.31726;
  long int D.31727;
  int D.31729;
  long unsigned int D.31732;
  long unsigned int D.31733;
  struct StackFrame * * D.31734;
  int D.31735;
  struct MonoDebugMethodJitInfo * D.31738;
  struct MonoDomain * D.31741;
  struct MonoMethod * D.31742;
  struct MonoDebugMethodJitInfo * D.31743;
  unsigned char D.31746;
  unsigned char D.31747;
  struct MonoMethod * D.31750;
  struct MonoDebugMethodJitInfo * D.31751;
  int log_level.314;
  _Bool D.31755;
  long int D.31756;
  long int D.31757;
  struct FILE * log_file.315;
  struct MonoMethod * D.31761;
  struct MonoSeqPointInfo * D.31762;
  int iftmp.316;
  unsigned int pos.317;
  unsigned int D.31773;
  _Bool D.31774;
  long int D.31775;
  long int D.31776;
  struct MonoDebugVarInfo * D.31779;
  long unsigned int D.31780;
  long unsigned int D.31781;
  struct MonoContext * D.31782;
  struct MonoDebugVarInfo * D.31783;
  struct MonoType * D.31784;
  int iftmp.318;
  unsigned int D.31791;
  _Bool D.31792;
  long int D.31793;
  long int D.31794;
  struct MonoDebugVarInfo * D.31797;
  struct MonoDebugVarInfo * D.31798;
  struct MonoType * D.31799;
  struct MonoClass * D.31800;
  unsigned char D.31801;
  unsigned char D.31802;
  unsigned char D.31805;
  unsigned char D.31806;
  struct MonoClass * D.31809;
  struct MonoType * D.31810;
  struct MonoDebugVarInfo * D.31812;
  struct MonoClass * D.31813;
  struct MonoType * D.31814;
  struct MonoType * D.31818;
  struct MonoType * D.31820;
  int iftmp.319;
  _Bool D.31828;
  long int D.31829;
  long int D.31830;
  int iftmp.320;
  _Bool D.31839;
  long int D.31840;
  long int D.31841;
  int D.31844;
  struct MonoClass * D.31848;
  int D.31849;
  long unsigned int D.31850;
  <unnamed type> D.31851;
  struct MonoContext * D.31854;
  mgreg_t *[16] * D.31855;
  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.31709 = get_object (objid, &thread_obj);
      err = (int) D.31709;
      if (err != 0) goto <D.31710>; else goto <D.31711>;
      <D.31710>:
      D.31712 = (ErrorCode) err;
      return D.31712;
      <D.31711>:
      thread_obj.312 = thread_obj;
      thread = thread_obj.312->internal_thread;
      p.311 = p;
      D.31714 = decode_id (p.311, &p, end);
      id = (gssize) D.31714;
      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.31716 = tls == 0B;
      D.31717 = (long int) D.31716;
      D.31718 = __builtin_expect (D.31717, 0);
      if (D.31718 != 0) goto <D.31719>; else goto <D.31720>;
      <D.31719>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 8495, "tls");
      <D.31720>:
      i = 0;
      goto <D.27689>;
      <D.27688>:
      D.31721 = tls->frames;
      D.31722 = (long unsigned int) i;
      D.31723 = D.31722 * 8;
      D.31724 = D.31721 + D.31723;
      D.31725 = *D.31724;
      D.31726 = D.31725->id;
      D.31727 = (long int) D.31726;
      if (D.31727 == id) goto <D.27687>; else goto <D.31728>;
      <D.31728>:
      i = i + 1;
      <D.27689>:
      D.31729 = tls->frame_count;
      if (D.31729 > i) goto <D.27688>; else goto <D.27687>;
      <D.27687>:
      D.31729 = tls->frame_count;
      if (D.31729 == i) goto <D.31730>; else goto <D.31731>;
      <D.31730>:
      D.31712 = 30;
      return D.31712;
      <D.31731>:
      frame_idx = i;
      D.31721 = tls->frames;
      D.31732 = (long unsigned int) frame_idx;
      D.31733 = D.31732 * 8;
      D.31734 = D.31721 + D.31733;
      frame = *D.31734;
      D.31735 = frame->has_ctx;
      if (D.31735 == 0) goto <D.31736>; else goto <D.31737>;
      <D.31736>:
      D.31712 = 105;
      return D.31712;
      <D.31737>:
      D.31738 = frame->jit;
      if (D.31738 == 0B) goto <D.31739>; else goto <D.31740>;
      <D.31739>:
      D.31741 = frame->domain;
      D.31742 = frame->api_method;
      D.31743 = mono_debug_find_method (D.31742, D.31741);
      frame->jit = D.31743;
      D.31738 = frame->jit;
      if (D.31738 == 0B) goto <D.31744>; else goto <D.31745>;
      <D.31744>:
      D.31742 = frame->api_method;
      D.31746 = BIT_FIELD_REF <*D.31742, 8, 264>;
      D.31747 = D.31746 & 16;
      if (D.31747 != 0) goto <D.31748>; else goto <D.31749>;
      <D.31748>:
      D.31741 = frame->domain;
      D.31742 = frame->api_method;
      D.31750 = mono_method_get_declaring_generic_method (D.31742);
      D.31751 = mono_debug_find_method (D.31750, D.31741);
      frame->jit = D.31751;
      <D.31749>:
      <D.31745>:
      D.31738 = frame->jit;
      if (D.31738 == 0B) goto <D.31752>; else goto <D.31753>;
      <D.31752>:
      {
        char * s;

        D.31742 = frame->api_method;
        s = mono_method_full_name (D.31742, 1);
        log_level.314 = log_level;
        D.31755 = log_level.314 > 0;
        D.31756 = (long int) D.31755;
        D.31757 = __builtin_expect (D.31756, 0);
        if (D.31757 != 0) goto <D.31758>; else goto <D.31759>;
        <D.31758>:
        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.31759>:
        monoeg_g_free (s);
        D.31712 = 105;
        return D.31712;
      }
      <D.31753>:
      <D.31740>:
      jit = frame->jit;
      D.31761 = frame->actual_method;
      sig = mono_method_signature (D.31761);
      D.31761 = frame->actual_method;
      D.31741 = frame->domain;
      D.31762 = get_seq_points (D.31741, D.31761);
      if (D.31762 == 0B) goto <D.31763>; else goto <D.31764>;
      <D.31763>:
      D.31712 = 105;
      return D.31712;
      <D.31764>:
      switch (command) <default: <D.27706>, case 1: <D.27691>, case 2: <D.27696>, case 3: <D.27699>>
      <D.27691>:
      p.311 = p;
      len = decode_int (p.311, &p, end);
      D.31761 = frame->actual_method;
      header = mono_method_get_header (D.31761);
      i = 0;
      goto <D.27693>;
      <D.27692>:
      p.311 = p;
      pos = decode_int (p.311, &p, end);
      if (pos < 0) goto <D.31765>; else goto <D.31766>;
      <D.31765>:
      pos = ~pos;
      if (pos < 0) goto <D.31768>; else goto <D.31771>;
      <D.31771>:
      pos.317 = (unsigned int) pos;
      D.31773 = jit->num_params;
      if (pos.317 >= D.31773) goto <D.31768>; else goto <D.31769>;
      <D.31768>:
      iftmp.316 = 1;
      goto <D.31770>;
      <D.31769>:
      iftmp.316 = 0;
      <D.31770>:
      D.31774 = iftmp.316 != 0;
      D.31775 = (long int) D.31774;
      D.31776 = __builtin_expect (D.31775, 0);
      if (D.31776 != 0) goto <D.31777>; else goto <D.31778>;
      <D.31777>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 8545, "pos >= 0 && pos < jit->num_params");
      <D.31778>:
      D.31779 = jit->params;
      D.31780 = (long unsigned int) pos;
      D.31781 = D.31780 * 32;
      var = D.31779 + D.31781;
      D.31741 = frame->domain;
      D.31782 = &frame->ctx;
      D.31779 = jit->params;
      D.31780 = (long unsigned int) pos;
      D.31781 = D.31780 * 32;
      D.31783 = D.31779 + D.31781;
      D.31784 = sig->params[pos];
      add_var (buf, jit, D.31784, D.31783, D.31782, D.31741, 0);
      goto <D.31785>;
      <D.31766>:
      if (pos < 0) goto <D.31787>; else goto <D.31790>;
      <D.31790>:
      pos.317 = (unsigned int) pos;
      D.31791 = jit->num_locals;
      if (pos.317 >= D.31791) goto <D.31787>; else goto <D.31788>;
      <D.31787>:
      iftmp.318 = 1;
      goto <D.31789>;
      <D.31788>:
      iftmp.318 = 0;
      <D.31789>:
      D.31792 = iftmp.318 != 0;
      D.31793 = (long int) D.31792;
      D.31794 = __builtin_expect (D.31793, 0);
      if (D.31794 != 0) goto <D.31795>; else goto <D.31796>;
      <D.31795>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 8551, "pos >= 0 && pos < jit->num_locals");
      <D.31796>:
      D.31797 = jit->locals;
      D.31780 = (long unsigned int) pos;
      D.31781 = D.31780 * 32;
      var = D.31797 + D.31781;
      D.31741 = frame->domain;
      D.31782 = &frame->ctx;
      D.31797 = jit->locals;
      D.31780 = (long unsigned int) pos;
      D.31781 = D.31780 * 32;
      D.31798 = D.31797 + D.31781;
      D.31799 = header->locals[pos];
      add_var (buf, jit, D.31799, D.31798, D.31782, D.31741, 0);
      <D.31785>:
      i = i + 1;
      <D.27693>:
      if (i < len) goto <D.27692>; else goto <D.27694>;
      <D.27694>:
      mono_metadata_free_mh (header);
      goto <D.27695>;
      <D.27696>:
      D.31742 = frame->api_method;
      D.31800 = D.31742->klass;
      D.31801 = BIT_FIELD_REF <*D.31800, 8, 256>;
      D.31802 = D.31801 & 8;
      if (D.31802 != 0) goto <D.31803>; else goto <D.31804>;
      <D.31803>:
      D.31805 = BIT_FIELD_REF <*sig, 8, 112>;
      D.31806 = D.31805 & 64;
      if (D.31806 == 0) goto <D.31807>; else goto <D.31808>;
      <D.31807>:
      {
        struct MonoObject * p;

        try
          {
            p = 0B;
            D.31741 = frame->domain;
            D.31809 = mono_defaults.object_class;
            D.31810 = &D.31809->byval_arg;
            buffer_add_value (buf, D.31810, &p, D.31741);
          }
        finally
          {
            p = {CLOBBER};
          }
      }
      goto <D.31811>;
      <D.31808>:
      D.31741 = frame->domain;
      D.31782 = &frame->ctx;
      D.31812 = jit->this_var;
      D.31761 = frame->actual_method;
      D.31813 = D.31761->klass;
      D.31814 = &D.31813->this_arg;
      add_var (buf, jit, D.31814, D.31812, D.31782, D.31741, 1);
      <D.31811>:
      goto <D.31815>;
      <D.31804>:
      D.31805 = BIT_FIELD_REF <*sig, 8, 112>;
      D.31806 = D.31805 & 64;
      if (D.31806 == 0) goto <D.31816>; else goto <D.31817>;
      <D.31816>:
      {
        struct MonoObject * p;

        try
          {
            p = 0B;
            D.31741 = frame->domain;
            D.31761 = frame->actual_method;
            D.31813 = D.31761->klass;
            D.31818 = &D.31813->byval_arg;
            buffer_add_value (buf, D.31818, &p, D.31741);
          }
        finally
          {
            p = {CLOBBER};
          }
      }
      goto <D.31819>;
      <D.31817>:
      D.31741 = frame->domain;
      D.31782 = &frame->ctx;
      D.31812 = jit->this_var;
      D.31742 = frame->api_method;
      D.31800 = D.31742->klass;
      D.31820 = &D.31800->byval_arg;
      add_var (buf, jit, D.31820, D.31812, D.31782, D.31741, 1);
      <D.31819>:
      <D.31815>:
      goto <D.27695>;
      <D.27699>:
      {
        guint8 * val_buf;
        struct MonoType * t;
        struct MonoDebugVarInfo * var;

        p.311 = p;
        len = decode_int (p.311, &p, end);
        D.31761 = frame->actual_method;
        header = mono_method_get_header (D.31761);
        i = 0;
        goto <D.27704>;
        <D.27703>:
        p.311 = p;
        pos = decode_int (p.311, &p, end);
        if (pos < 0) goto <D.31821>; else goto <D.31822>;
        <D.31821>:
        pos = ~pos;
        if (pos < 0) goto <D.31824>; else goto <D.31827>;
        <D.31827>:
        pos.317 = (unsigned int) pos;
        D.31773 = jit->num_params;
        if (pos.317 >= D.31773) goto <D.31824>; else goto <D.31825>;
        <D.31824>:
        iftmp.319 = 1;
        goto <D.31826>;
        <D.31825>:
        iftmp.319 = 0;
        <D.31826>:
        D.31828 = iftmp.319 != 0;
        D.31829 = (long int) D.31828;
        D.31830 = __builtin_expect (D.31829, 0);
        if (D.31830 != 0) goto <D.31831>; else goto <D.31832>;
        <D.31831>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 8593, "pos >= 0 && pos < jit->num_params");
        <D.31832>:
        t = sig->params[pos];
        D.31779 = jit->params;
        D.31780 = (long unsigned int) pos;
        D.31781 = D.31780 * 32;
        var = D.31779 + D.31781;
        goto <D.31833>;
        <D.31822>:
        if (pos < 0) goto <D.31835>; else goto <D.31838>;
        <D.31838>:
        pos.317 = (unsigned int) pos;
        D.31791 = jit->num_locals;
        if (pos.317 >= D.31791) goto <D.31835>; else goto <D.31836>;
        <D.31835>:
        iftmp.320 = 1;
        goto <D.31837>;
        <D.31836>:
        iftmp.320 = 0;
        <D.31837>:
        D.31839 = iftmp.320 != 0;
        D.31840 = (long int) D.31839;
        D.31841 = __builtin_expect (D.31840, 0);
        if (D.31841 != 0) goto <D.31842>; else goto <D.31843>;
        <D.31842>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 8598, "pos >= 0 && pos < jit->num_locals");
        <D.31843>:
        t = header->locals[pos];
        D.31797 = jit->locals;
        D.31780 = (long unsigned int) pos;
        D.31781 = D.31780 * 32;
        var = D.31797 + D.31781;
        <D.31833>:
        D.31844 = mono_type_is_reference (t);
        if (D.31844 != 0) goto <D.31845>; else goto <D.31846>;
        <D.31845>:
        val_buf = __builtin_alloca (8);
        goto <D.31847>;
        <D.31846>:
        D.31848 = mono_class_from_mono_type (t);
        D.31849 = mono_class_instance_size (D.31848);
        D.31850 = (long unsigned int) D.31849;
        val_buf = __builtin_alloca (D.31850);
        <D.31847>:
        p.311 = p;
        D.31741 = frame->domain;
        D.31851 = decode_value (t, D.31741, val_buf, p.311, &p, end);
        err = (int) D.31851;
        if (err != 0) goto <D.31852>; else goto <D.31853>;
        <D.31852>:
        D.31712 = (ErrorCode) err;
        return D.31712;
        <D.31853>:
        D.31854 = &tls->restore_ctx;
        D.31855 = &frame->reg_locations;
        D.31741 = frame->domain;
        D.31782 = &frame->ctx;
        set_var (t, var, D.31782, D.31741, val_buf, D.31855, D.31854);
        i = i + 1;
        <D.27704>:
        if (i < len) goto <D.27703>; else goto <D.27705>;
        <D.27705>:
        mono_metadata_free_mh (header);
        goto <D.27695>;
      }
      <D.27706>:
      D.31712 = 100;
      return D.31712;
      <D.27695>:
      D.31712 = 0;
      return D.31712;
    }
  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.31858;
  int D.31859;
  long int reg_val.321;
  long int D.31861;
  unsigned int D.31862;
  int D.31863;
  sizetype D.31864;
  long int D.31865;
  _Bool D.31866;
  long int D.31867;
  long int D.31868;
  _Bool D.31871;
  long int D.31872;
  long int D.31873;
  _Bool D.31876;
  long int D.31877;
  long int D.31878;
  unsigned int D.31881;
  int D.31882;
  long int D.31885;
  unsigned int D.31886;
  int D.31887;
  sizetype D.31888;
  long int D.31892;
  _Bool D.31894;
  long int D.31895;
  long int D.31896;
  unsigned int D.31899;
  int D.31900;
  long int D.31903;
  unsigned int D.31904;
  int D.31905;
  sizetype D.31906;
  long int D.31910;
  _Bool D.31912;
  long int D.31913;
  long int D.31914;
  void * D.31917;
  long int D.31918;
  int D.31919;
  sizetype D.31920;
  guint32 flags;
  int reg;
  guint8 * addr;
  guint8 * gaddr;
  mgreg_t reg_val;

  try
    {
      D.31858 = var->index;
      flags = D.31858 & 4026531840;
      D.31858 = var->index;
      D.31859 = (int) D.31858;
      reg = D.31859 & 268435455;
      switch (flags) <default: <D.26850>, case 0: <D.26838>, case 268435456: <D.26840>, case 805306368: <D.26841>, case 1073741824: <D.26842>, case 1342177280: <D.26844>, case 1610612736: <D.26843>>
      <D.26838>:
      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.26839>;
      <D.26840>:
      D.31861 = mono_arch_context_get_int_reg (ctx, reg);
      addr = (guint8 *) D.31861;
      D.31862 = var->offset;
      D.31863 = (int) D.31862;
      D.31864 = (sizetype) D.31863;
      addr = addr + D.31864;
      buffer_add_value_full (buf, t, addr, domain, as_vtype);
      goto <D.26839>;
      <D.26841>:
      monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "debugger-agent.c", 5939);
      <D.26842>:
      <D.26843>:
      D.31865 = mono_arch_context_get_int_reg (ctx, reg);
      addr = (guint8 *) D.31865;
      D.31862 = var->offset;
      D.31863 = (int) D.31862;
      D.31864 = (sizetype) D.31863;
      addr = addr + D.31864;
      gaddr = MEM[(void * *)addr];
      D.31866 = gaddr == 0B;
      D.31867 = (long int) D.31866;
      D.31868 = __builtin_expect (D.31867, 0);
      if (D.31868 != 0) goto <D.31869>; else goto <D.31870>;
      <D.31869>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 5948, "gaddr");
      <D.31870>:
      buffer_add_value_full (buf, t, gaddr, domain, as_vtype);
      goto <D.26839>;
      <D.26844>:
      {
        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.31871 = info_var == 0B;
        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", 5960, "info_var");
        <D.31875>:
        D.31876 = locals_var == 0B;
        D.31877 = (long int) D.31876;
        D.31878 = __builtin_expect (D.31877, 0);
        if (D.31878 != 0) goto <D.31879>; else goto <D.31880>;
        <D.31879>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 5961, "locals_var");
        <D.31880>:
        D.31881 = info_var->index;
        flags = D.31881 & 4026531840;
        D.31881 = info_var->index;
        D.31882 = (int) D.31881;
        reg = D.31882 & 268435455;
        if (flags == 268435456) goto <D.31883>; else goto <D.31884>;
        <D.31883>:
        D.31885 = mono_arch_context_get_int_reg (ctx, reg);
        addr = (guint8 *) D.31885;
        D.31886 = info_var->offset;
        D.31887 = (int) D.31886;
        D.31888 = (sizetype) D.31887;
        addr = addr + D.31888;
        info = MEM[(void * *)addr];
        goto <D.31889>;
        <D.31884>:
        if (flags == 0) goto <D.31890>; else goto <D.31891>;
        <D.31890>:
        D.31892 = mono_arch_context_get_int_reg (ctx, reg);
        info = (struct MonoGSharedVtMethodRuntimeInfo *) D.31892;
        goto <D.31893>;
        <D.31891>:
        monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "debugger-agent.c", 5972);
        <D.31893>:
        <D.31889>:
        D.31894 = info == 0B;
        D.31895 = (long int) D.31894;
        D.31896 = __builtin_expect (D.31895, 0);
        if (D.31896 != 0) goto <D.31897>; else goto <D.31898>;
        <D.31897>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 5974, "info");
        <D.31898>:
        D.31899 = locals_var->index;
        flags = D.31899 & 4026531840;
        D.31899 = locals_var->index;
        D.31900 = (int) D.31899;
        reg = D.31900 & 268435455;
        if (flags == 268435456) goto <D.31901>; else goto <D.31902>;
        <D.31901>:
        D.31903 = mono_arch_context_get_int_reg (ctx, reg);
        addr = (guint8 *) D.31903;
        D.31904 = locals_var->offset;
        D.31905 = (int) D.31904;
        D.31906 = (sizetype) D.31905;
        addr = addr + D.31906;
        locals = MEM[(void * *)addr];
        goto <D.31907>;
        <D.31902>:
        if (flags == 0) goto <D.31908>; else goto <D.31909>;
        <D.31908>:
        D.31910 = mono_arch_context_get_int_reg (ctx, reg);
        locals = (guint8 *) D.31910;
        goto <D.31911>;
        <D.31909>:
        monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "debugger-agent.c", 5985);
        <D.31911>:
        <D.31907>:
        D.31912 = locals == 0B;
        D.31913 = (long int) D.31912;
        D.31914 = __builtin_expect (D.31913, 0);
        if (D.31914 != 0) goto <D.31915>; else goto <D.31916>;
        <D.31915>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 5987, "locals");
        <D.31916>:
        D.31917 = info->entries[idx];
        D.31918 = (long int) D.31917;
        D.31919 = (int) D.31918;
        D.31920 = (sizetype) D.31919;
        addr = locals + D.31920;
        buffer_add_value_full (buf, t, addr, domain, as_vtype);
        goto <D.26839>;
      }
      <D.26850>:
      monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "debugger-agent.c", 5996);
      <D.26839>:
    }
  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.31921;
  int D.31922;
  int D.31923;
  struct MonoClass * D.31927;
  unsigned char D.31928;
  unsigned char D.31929;
  long int D.31932;
  long unsigned int D.31935;
  unsigned char D.31940;
  _Bool D.31941;
  _Bool D.31942;
  _Bool D.31943;
  unsigned char D.31945;
  mgreg_t iftmp.322;
  signed char D.31950;
  unsigned char D.31952;
  mgreg_t iftmp.323;
  short int D.31956;
  short unsigned int D.31958;
  int D.31959;
  unsigned int D.31960;
  long unsigned int D.31961;
  long unsigned int D.31962;
  mgreg_t * * D.31963;
  mgreg_t * D.31964;
  int log_level.324;
  _Bool D.31968;
  long int D.31969;
  long int D.31970;
  void * v.325;
  struct FILE * log_file.326;
  long int D.31978;
  unsigned int D.31979;
  int D.31980;
  sizetype D.31981;
  long int D.31985;
  _Bool D.31986;
  long int D.31987;
  long int D.31988;
  guint32 flags;
  int reg;
  int size;
  guint8 * addr;
  guint8 * gaddr;

  D.31921 = var->index;
  flags = D.31921 & 4026531840;
  D.31921 = var->index;
  D.31922 = (int) D.31921;
  reg = D.31922 & 268435455;
  D.31923 = mono_type_is_reference (t);
  if (D.31923 != 0) goto <D.31924>; else goto <D.31925>;
  <D.31924>:
  size = 8;
  goto <D.31926>;
  <D.31925>:
  D.31927 = mono_class_from_mono_type (t);
  size = mono_class_value_size (D.31927, 0B);
  <D.31926>:
  switch (flags) <default: <D.26878>, case 0: <D.26865>, case 268435456: <D.26875>, case 805306368: <D.26877>, case 1073741824: <D.26876>>
  <D.26865>:
  {
    mgreg_t v;
    gboolean is_signed;

    is_signed = 0;
    D.31928 = BIT_FIELD_REF <*t, 8, 88>;
    D.31929 = D.31928 & 64;
    if (D.31929 != 0) goto <D.31930>; else goto <D.31931>;
    <D.31930>:
    D.31932 = mono_arch_context_get_int_reg (ctx, reg);
    addr = (guint8 *) D.31932;
    if (addr != 0B) goto <D.31933>; else goto <D.31934>;
    <D.31933>:
    D.31935 = (long unsigned int) size;
    mono_gc_memmove_atomic (addr, val, D.31935);
    <D.31934>:
    goto <D.26868>;
    <D.31931>:
    D.31928 = BIT_FIELD_REF <*t, 8, 88>;
    D.31929 = D.31928 & 64;
    if (D.31929 == 0) goto <D.31938>; else goto <D.31939>;
    <D.31938>:
    D.31940 = t->type;
    D.31941 = D.31940 == 4;
    D.31942 = D.31940 == 6;
    D.31943 = D.31941 | D.31942;
    if (D.31943 != 0) goto <D.31936>; else goto <D.31944>;
    <D.31944>:
    D.31945 = t->type;
    if (D.31945 == 8) goto <D.31936>; else goto <D.31946>;
    <D.31946>:
    D.31945 = t->type;
    if (D.31945 == 10) goto <D.31936>; else goto <D.31937>;
    <D.31936>:
    is_signed = 1;
    <D.31937>:
    <D.31939>:
    switch (size) <default: <D.26874>, case 1: <D.26869>, case 2: <D.26871>, case 4: <D.26872>, case 8: <D.26873>>
    <D.26869>:
    if (is_signed != 0) goto <D.31948>; else goto <D.31949>;
    <D.31948>:
    D.31950 = MEM[(gint8 *)val];
    iftmp.322 = (mgreg_t) D.31950;
    goto <D.31951>;
    <D.31949>:
    D.31952 = *val;
    iftmp.322 = (mgreg_t) D.31952;
    <D.31951>:
    v = iftmp.322;
    goto <D.26870>;
    <D.26871>:
    if (is_signed != 0) goto <D.31954>; else goto <D.31955>;
    <D.31954>:
    D.31956 = MEM[(gint16 *)val];
    iftmp.323 = (mgreg_t) D.31956;
    goto <D.31957>;
    <D.31955>:
    D.31958 = MEM[(guint16 *)val];
    iftmp.323 = (mgreg_t) D.31958;
    <D.31957>:
    v = iftmp.323;
    goto <D.26870>;
    <D.26872>:
    D.31959 = MEM[(gint32 *)val];
    D.31960 = (unsigned int) D.31959;
    v = (mgreg_t) D.31960;
    goto <D.26870>;
    <D.26873>:
    v = MEM[(gint64 *)val];
    goto <D.26870>;
    <D.26874>:
    monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "debugger-agent.c", 6048);
    <D.26870>:
    D.31961 = (long unsigned int) reg;
    D.31962 = D.31961 * 8;
    D.31963 = reg_locations + D.31962;
    D.31964 = *D.31963;
    if (D.31964 != 0B) goto <D.31965>; else goto <D.31966>;
    <D.31965>:
    log_level.324 = log_level;
    D.31968 = log_level.324 > 0;
    D.31969 = (long int) D.31968;
    D.31970 = __builtin_expect (D.31969, 0);
    if (D.31970 != 0) goto <D.31971>; else goto <D.31972>;
    <D.31971>:
    v.325 = (void *) v;
    D.31961 = (long unsigned int) reg;
    D.31962 = D.31961 * 8;
    D.31963 = reg_locations + D.31962;
    D.31964 = *D.31963;
    log_file.326 = log_file;
    fprintf (log_file.326, "[dbg] Setting stack location %p for reg %x to %p.\n", D.31964, reg, v.325);
    log_file.326 = log_file;
    fflush (log_file.326);
    <D.31972>:
    D.31961 = (long unsigned int) reg;
    D.31962 = D.31961 * 8;
    D.31963 = reg_locations + D.31962;
    D.31964 = *D.31963;
    *D.31964 = v;
    goto <D.31975>;
    <D.31966>:
    log_level.324 = log_level;
    D.31968 = log_level.324 > 0;
    D.31969 = (long int) D.31968;
    D.31970 = __builtin_expect (D.31969, 0);
    if (D.31970 != 0) goto <D.31976>; else goto <D.31977>;
    <D.31976>:
    v.325 = (void *) v;
    log_file.326 = log_file;
    fprintf (log_file.326, "[dbg] Setting context location for reg %x to %p.\n", reg, v.325);
    log_file.326 = log_file;
    fflush (log_file.326);
    <D.31977>:
    mono_arch_context_set_int_reg (restore_ctx, reg, v);
    <D.31975>:
    mono_arch_context_set_int_reg (ctx, reg, v);
    goto <D.26868>;
  }
  <D.26875>:
  D.31978 = mono_arch_context_get_int_reg (ctx, reg);
  addr = (guint8 *) D.31978;
  D.31979 = var->offset;
  D.31980 = (int) D.31979;
  D.31981 = (sizetype) D.31980;
  addr = addr + D.31981;
  D.31928 = BIT_FIELD_REF <*t, 8, 88>;
  D.31929 = D.31928 & 64;
  if (D.31929 != 0) goto <D.31982>; else goto <D.31983>;
  <D.31982>:
  addr = MEM[(guint8 * *)addr];
  if (addr == 0B) goto <D.26868>; else goto <D.31984>;
  <D.31984>:
  <D.31983>:
  D.31935 = (long unsigned int) size;
  mono_gc_memmove_atomic (addr, val, D.31935);
  goto <D.26868>;
  <D.26876>:
  D.31985 = mono_arch_context_get_int_reg (ctx, reg);
  addr = (guint8 *) D.31985;
  D.31979 = var->offset;
  D.31980 = (int) D.31979;
  D.31981 = (sizetype) D.31980;
  addr = addr + D.31981;
  gaddr = MEM[(void * *)addr];
  D.31986 = gaddr == 0B;
  D.31987 = (long int) D.31986;
  D.31988 = __builtin_expect (D.31987, 0);
  if (D.31988 != 0) goto <D.31989>; else goto <D.31990>;
  <D.31989>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 6092, "gaddr");
  <D.31990>:
  D.31935 = (long unsigned int) size;
  mono_gc_memmove_atomic (gaddr, val, D.31935);
  goto <D.26868>;
  <D.26877>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "debugger-agent.c", 6097);
  <D.26878>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "debugger-agent.c", 6100);
  <D.26868>:
}


array_commands (int command, guint8 * p, guint8 * end, struct Buffer * buf)
{
  guint8 * p.327;
  <unnamed type> D.31992;
  ErrorCode D.31995;
  struct MonoArray * arr.328;
  struct MonoVTable * D.31997;
  struct MonoClass * D.31998;
  unsigned char D.31999;
  unsigned int D.32000;
  struct MonoArrayBounds * D.32001;
  unsigned int D.32004;
  long unsigned int D.32006;
  long unsigned int D.32007;
  struct MonoArrayBounds * D.32008;
  unsigned int D.32009;
  int D.32010;
  unsigned int D.32011;
  int D.32012;
  _Bool D.32013;
  _Bool D.32014;
  _Bool D.32015;
  int D.32016;
  _Bool D.32017;
  long int D.32018;
  long int D.32019;
  unsigned int index.329;
  unsigned int len.330;
  unsigned int D.32024;
  _Bool D.32025;
  long int D.32026;
  long int D.32027;
  double[0:] * D.32030;
  int D.32031;
  sizetype D.32032;
  struct MonoDomain * D.32033;
  struct MonoClass * D.32034;
  struct MonoType * D.32035;
  int D.32036;
  struct MonoArray * arr;
  int objid;
  int err;
  int index;
  int len;
  int i;
  int esize;
  void * elem;

  try
    {
      p.327 = p;
      objid = decode_objid (p.327, &p, end);
      D.31992 = get_object (objid, &arr);
      err = (int) D.31992;
      if (err != 0) goto <D.31993>; else goto <D.31994>;
      <D.31993>:
      D.31995 = (ErrorCode) err;
      return D.31995;
      <D.31994>:
      switch (command) <default: <D.27734>, case 1: <D.27721>, case 2: <D.27726>, case 3: <D.27730>>
      <D.27721>:
      arr.328 = arr;
      D.31997 = arr.328->obj.vtable;
      D.31998 = D.31997->klass;
      D.31999 = D.31998->rank;
      D.32000 = (unsigned int) D.31999;
      buffer_add_int (buf, D.32000);
      arr.328 = arr;
      D.32001 = arr.328->bounds;
      if (D.32001 == 0B) goto <D.32002>; else goto <D.32003>;
      <D.32002>:
      arr.328 = arr;
      D.32004 = arr.328->max_length;
      buffer_add_int (buf, D.32004);
      buffer_add_int (buf, 0);
      goto <D.32005>;
      <D.32003>:
      i = 0;
      goto <D.27723>;
      <D.27722>:
      arr.328 = arr;
      D.32001 = arr.328->bounds;
      D.32006 = (long unsigned int) i;
      D.32007 = D.32006 * 8;
      D.32008 = D.32001 + D.32007;
      D.32009 = D.32008->length;
      buffer_add_int (buf, D.32009);
      arr.328 = arr;
      D.32001 = arr.328->bounds;
      D.32006 = (long unsigned int) i;
      D.32007 = D.32006 * 8;
      D.32008 = D.32001 + D.32007;
      D.32010 = D.32008->lower_bound;
      D.32011 = (unsigned int) D.32010;
      buffer_add_int (buf, D.32011);
      i = i + 1;
      <D.27723>:
      arr.328 = arr;
      D.31997 = arr.328->obj.vtable;
      D.31998 = D.31997->klass;
      D.31999 = D.31998->rank;
      D.32012 = (int) D.31999;
      if (D.32012 > i) goto <D.27722>; else goto <D.27724>;
      <D.27724>:
      <D.32005>:
      goto <D.27725>;
      <D.27726>:
      p.327 = p;
      index = decode_int (p.327, &p, end);
      p.327 = p;
      len = decode_int (p.327, &p, end);
      D.32013 = index < 0;
      D.32014 = len < 0;
      D.32015 = D.32013 | D.32014;
      D.32016 = (int) D.32015;
      D.32017 = D.32016 != 0;
      D.32018 = (long int) D.32017;
      D.32019 = __builtin_expect (D.32018, 0);
      if (D.32019 != 0) goto <D.32020>; else goto <D.32021>;
      <D.32020>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 8653, "index >= 0 && len >= 0");
      <D.32021>:
      index.329 = (unsigned int) index;
      arr.328 = arr;
      D.32004 = arr.328->max_length;
      len.330 = (unsigned int) len;
      D.32024 = D.32004 - len.330;
      D.32025 = index.329 > D.32024;
      D.32026 = (long int) D.32025;
      D.32027 = __builtin_expect (D.32026, 0);
      if (D.32027 != 0) goto <D.32028>; else goto <D.32029>;
      <D.32028>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 8655, "!(index > arr->max_length - len)");
      <D.32029>:
      arr.328 = arr;
      D.31997 = arr.328->obj.vtable;
      D.31998 = D.31997->klass;
      esize = mono_array_element_size (D.31998);
      i = index;
      goto <D.27728>;
      <D.27727>:
      arr.328 = arr;
      D.32030 = &arr.328->vector;
      D.32031 = i * esize;
      D.32032 = (sizetype) D.32031;
      elem = D.32030 + D.32032;
      arr.328 = arr;
      D.31997 = arr.328->obj.vtable;
      D.32033 = D.31997->domain;
      arr.328 = arr;
      D.31997 = arr.328->obj.vtable;
      D.31998 = D.31997->klass;
      D.32034 = D.31998->element_class;
      D.32035 = &D.32034->byval_arg;
      buffer_add_value (buf, D.32035, elem, D.32033);
      i = i + 1;
      <D.27728>:
      D.32036 = index + len;
      if (D.32036 > i) goto <D.27727>; else goto <D.27729>;
      <D.27729>:
      goto <D.27725>;
      <D.27730>:
      p.327 = p;
      index = decode_int (p.327, &p, end);
      p.327 = p;
      len = decode_int (p.327, &p, end);
      D.32013 = index < 0;
      D.32014 = len < 0;
      D.32015 = D.32013 | D.32014;
      D.32016 = (int) D.32015;
      D.32017 = D.32016 != 0;
      D.32018 = (long int) D.32017;
      D.32019 = __builtin_expect (D.32018, 0);
      if (D.32019 != 0) goto <D.32037>; else goto <D.32038>;
      <D.32037>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 8667, "index >= 0 && len >= 0");
      <D.32038>:
      index.329 = (unsigned int) index;
      arr.328 = arr;
      D.32004 = arr.328->max_length;
      len.330 = (unsigned int) len;
      D.32024 = D.32004 - len.330;
      D.32025 = index.329 > D.32024;
      D.32026 = (long int) D.32025;
      D.32027 = __builtin_expect (D.32026, 0);
      if (D.32027 != 0) goto <D.32039>; else goto <D.32040>;
      <D.32039>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 8669, "!(index > arr->max_length - len)");
      <D.32040>:
      arr.328 = arr;
      D.31997 = arr.328->obj.vtable;
      D.31998 = D.31997->klass;
      esize = mono_array_element_size (D.31998);
      i = index;
      goto <D.27732>;
      <D.27731>:
      arr.328 = arr;
      D.32030 = &arr.328->vector;
      D.32031 = i * esize;
      D.32032 = (sizetype) D.32031;
      elem = D.32030 + D.32032;
      p.327 = p;
      arr.328 = arr;
      D.31997 = arr.328->obj.vtable;
      D.32033 = D.31997->domain;
      arr.328 = arr;
      D.31997 = arr.328->obj.vtable;
      D.31998 = D.31997->klass;
      D.32034 = D.31998->element_class;
      D.32035 = &D.32034->byval_arg;
      decode_value (D.32035, D.32033, elem, p.327, &p, end);
      i = i + 1;
      <D.27732>:
      D.32036 = index + len;
      if (D.32036 > i) goto <D.27731>; else goto <D.27733>;
      <D.27733>:
      goto <D.27725>;
      <D.27734>:
      D.31995 = 100;
      return D.31995;
      <D.27725>:
      D.31995 = 0;
      return D.31995;
    }
  finally
    {
      arr = {CLOBBER};
    }
}


string_commands (int command, guint8 * p, guint8 * end, struct Buffer * buf)
{
  guint8 * p.331;
  <unnamed type> D.32044;
  ErrorCode D.32047;
  struct MonoString * str.332;
  int D.32049;
  long unsigned int D.32050;
  long int D.32051;
  long int D.32052;
  int D.32053;
  int D.32054;
  mono_unichar2 * D.32057;
  long unsigned int D.32058;
  long unsigned int D.32059;
  long unsigned int D.32060;
  long unsigned int D.32061;
  gunichar2 * D.32062;
  short unsigned int D.32063;
  unsigned int D.32064;
  int objid;
  int err;
  struct MonoString * str;
  char * s;
  int i;
  int index;
  int length;
  gunichar2 * c;

  try
    {
      p.331 = p;
      objid = decode_objid (p.331, &p, end);
      D.32044 = get_object (objid, &str);
      err = (int) D.32044;
      if (err != 0) goto <D.32045>; else goto <D.32046>;
      <D.32045>:
      D.32047 = (ErrorCode) err;
      return D.32047;
      <D.32046>:
      switch (command) <default: <D.27756>, case 1: <D.27749>, case 2: <D.27751>, case 3: <D.27752>>
      <D.27749>:
      str.332 = str;
      s = mono_string_to_utf8 (str.332);
      buffer_add_string (buf, s);
      monoeg_g_free (s);
      goto <D.27750>;
      <D.27751>:
      str.332 = str;
      D.32049 = mono_string_length (str.332);
      D.32050 = (long unsigned int) D.32049;
      buffer_add_long (buf, D.32050);
      goto <D.27750>;
      <D.27752>:
      p.331 = p;
      D.32051 = decode_long (p.331, &p, end);
      index = (int) D.32051;
      p.331 = p;
      D.32052 = decode_long (p.331, &p, end);
      length = (int) D.32052;
      str.332 = str;
      D.32053 = mono_string_length (str.332);
      D.32054 = D.32053 - length;
      if (D.32054 < index) goto <D.32055>; else goto <D.32056>;
      <D.32055>:
      D.32047 = 102;
      return D.32047;
      <D.32056>:
      str.332 = str;
      D.32057 = mono_string_chars (str.332);
      D.32058 = (long unsigned int) index;
      D.32059 = D.32058 * 2;
      c = D.32057 + D.32059;
      i = 0;
      goto <D.27754>;
      <D.27753>:
      D.32060 = (long unsigned int) i;
      D.32061 = D.32060 * 2;
      D.32062 = c + D.32061;
      D.32063 = *D.32062;
      D.32064 = (unsigned int) D.32063;
      buffer_add_short (buf, D.32064);
      i = i + 1;
      <D.27754>:
      if (i < length) goto <D.27753>; else goto <D.27755>;
      <D.27755>:
      goto <D.27750>;
      <D.27756>:
      D.32047 = 100;
      return D.32047;
      <D.27750>:
      D.32047 = 0;
      return D.32047;
    }
  finally
    {
      str = {CLOBBER};
    }
}


buffer_add_short (struct Buffer * buf, guint32 val)
{
  guint8 * D.32067;
  unsigned int D.32068;
  unsigned char D.32069;
  guint8 * D.32070;
  unsigned char D.32071;
  guint8 * D.32072;

  buffer_make_room (buf, 2);
  D.32067 = buf->p;
  D.32068 = val >> 8;
  D.32069 = (unsigned char) D.32068;
  *D.32067 = D.32069;
  D.32067 = buf->p;
  D.32070 = D.32067 + 1;
  D.32071 = (unsigned char) val;
  *D.32070 = D.32071;
  D.32067 = buf->p;
  D.32072 = D.32067 + 2;
  buf->p = D.32072;
}


object_commands (int command, guint8 * p, guint8 * end, struct Buffer * buf)
{
  guint8 * p.333;
  <unnamed type> D.32076;
  int err.334;
  int err.335;
  ErrorCode D.32082;
  <unnamed type> D.32083;
  int err.336;
  struct MonoObject * obj.337;
  struct MonoVTable * D.32088;
  void * D.32089;
  struct MonoType * D.32090;
  struct MonoClass * D.32091;
  struct MonoDomain * D.32092;
  struct MonoClass * D.32095;
  struct MonoType * D.32100;
  short unsigned int D.32101;
  int D.32102;
  int D.32103;
  int D.32106;
  _Bool D.32109;
  long int D.32110;
  long int D.32111;
  struct MonoClass * D.32114;
  int D.32115;
  long unsigned int D.32116;
  int D.32118;
  sizetype D.32119;
  void * D.32120;
  struct MonoClass * D.32123;
  struct MonoType * D.32128;
  short unsigned int D.32129;
  int D.32130;
  int D.32131;
  int D.32134;
  _Bool D.32137;
  long int D.32138;
  long int D.32139;
  struct MonoClass * D.32142;
  int D.32143;
  long unsigned int D.32144;
  <unnamed type> D.32145;
  int err.338;
  int D.32150;
  sizetype D.32151;
  guint8 * D.32152;
  <unnamed type> D.32153;
  int err.339;
  long unsigned int obj.340;
  struct MonoClass * D.32158;
  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.32073>; else goto <D.32074>;
      <D.32073>:
      p.333 = p;
      objid = decode_objid (p.333, &p, end);
      D.32076 = get_object (objid, &obj);
      err.334 = (int) D.32076;
      err = err.334;
      err.335 = err;
      if (err.335 != 0) goto <D.32079>; else goto <D.32080>;
      <D.32079>:
      buffer_add_int (buf, 1);
      goto <D.32081>;
      <D.32080>:
      buffer_add_int (buf, 0);
      <D.32081>:
      D.32082 = 0;
      return D.32082;
      <D.32074>:
      p.333 = p;
      objid = decode_objid (p.333, &p, end);
      D.32083 = get_object (objid, &obj);
      err.336 = (int) D.32083;
      err = err.336;
      err.335 = err;
      if (err.335 != 0) goto <D.32085>; else goto <D.32086>;
      <D.32085>:
      err.335 = err;
      D.32082 = (ErrorCode) err.335;
      return D.32082;
      <D.32086>:
      switch (command) <default: <D.27795>, case 1: <D.27771>, case 2: <D.27773>, case 4: <D.27792>, case 5: <D.27793>, case 6: <D.27783>, case 7: <D.27794>>
      <D.27771>:
      obj.337 = obj;
      D.32088 = obj.337->vtable;
      D.32089 = D.32088->type;
      D.32090 = MEM[(struct MonoReflectionType *)D.32089].type;
      D.32091 = mono_class_from_mono_type (D.32090);
      obj.337 = obj;
      D.32088 = obj.337->vtable;
      D.32092 = D.32088->domain;
      buffer_add_typeid (buf, D.32092, D.32091);
      goto <D.27772>;
      <D.27773>:
      p.333 = p;
      len = decode_int (p.333, &p, end);
      i = 0;
      goto <D.27781>;
      <D.27780>:
      {
        struct MonoClassField * f;

        p.333 = p;
        f = decode_fieldid (p.333, &p, end, 0B, &err);
        err.335 = err;
        if (err.335 != 0) goto <D.32093>; else goto <D.32094>;
        <D.32093>:
        err.335 = err;
        D.32082 = (ErrorCode) err.335;
        return D.32082;
        <D.32094>:
        found = 0;
        obj.337 = obj;
        D.32088 = obj.337->vtable;
        k = D.32088->klass;
        goto <D.27777>;
        <D.27776>:
        D.32095 = f->parent;
        if (D.32095 == k) goto <D.32096>; else goto <D.32097>;
        <D.32096>:
        found = 1;
        goto <D.27775>;
        <D.32097>:
        k = k->parent;
        <D.27777>:
        if (k != 0B) goto <D.27776>; else goto <D.27775>;
        <D.27775>:
        if (found == 0) goto <D.32098>; else goto <D.32099>;
        <D.32098>:
        D.32082 = 25;
        return D.32082;
        <D.32099>:
        D.32100 = f->type;
        D.32101 = D.32100->attrs;
        D.32102 = (int) D.32101;
        D.32103 = D.32102 & 16;
        if (D.32103 != 0) goto <D.32104>; else goto <D.32105>;
        <D.32104>:
        {
          guint8 * val;
          struct MonoVTable * vtable;

          D.32106 = mono_class_field_is_special_static (f);
          if (D.32106 != 0) goto <D.32107>; else goto <D.32108>;
          <D.32107>:
          D.32082 = 25;
          return D.32082;
          <D.32108>:
          D.32100 = f->type;
          D.32101 = D.32100->attrs;
          D.32102 = (int) D.32101;
          D.32103 = D.32102 & 16;
          D.32109 = D.32103 == 0;
          D.32110 = (long int) D.32109;
          D.32111 = __builtin_expect (D.32110, 0);
          if (D.32111 != 0) goto <D.32112>; else goto <D.32113>;
          <D.32112>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 8780, "f->type->attrs & FIELD_ATTRIBUTE_STATIC");
          <D.32113>:
          D.32095 = f->parent;
          obj.337 = obj;
          D.32088 = obj.337->vtable;
          D.32092 = D.32088->domain;
          vtable = mono_class_vtable (D.32092, D.32095);
          D.32100 = f->type;
          D.32114 = mono_class_from_mono_type (D.32100);
          D.32115 = mono_class_instance_size (D.32114);
          D.32116 = (long unsigned int) D.32115;
          val = monoeg_malloc (D.32116);
          mono_field_static_get_value (vtable, f, val);
          obj.337 = obj;
          D.32088 = obj.337->vtable;
          D.32092 = D.32088->domain;
          D.32100 = f->type;
          buffer_add_value (buf, D.32100, val, D.32092);
          monoeg_g_free (val);
        }
        goto <D.32117>;
        <D.32105>:
        obj.337 = obj;
        D.32088 = obj.337->vtable;
        D.32092 = D.32088->domain;
        obj.337 = obj;
        D.32118 = f->offset;
        D.32119 = (sizetype) D.32118;
        D.32120 = obj.337 + D.32119;
        D.32100 = f->type;
        buffer_add_value (buf, D.32100, D.32120, D.32092);
        <D.32117>:
      }
      i = i + 1;
      <D.27781>:
      if (i < len) goto <D.27780>; else goto <D.27782>;
      <D.27782>:
      goto <D.27772>;
      <D.27783>:
      p.333 = p;
      len = decode_int (p.333, &p, end);
      i = 0;
      goto <D.27790>;
      <D.27789>:
      p.333 = p;
      f = decode_fieldid (p.333, &p, end, 0B, &err);
      err.335 = err;
      if (err.335 != 0) goto <D.32121>; else goto <D.32122>;
      <D.32121>:
      err.335 = err;
      D.32082 = (ErrorCode) err.335;
      return D.32082;
      <D.32122>:
      found = 0;
      obj.337 = obj;
      D.32088 = obj.337->vtable;
      k = D.32088->klass;
      goto <D.27786>;
      <D.27785>:
      D.32123 = f->parent;
      if (D.32123 == k) goto <D.32124>; else goto <D.32125>;
      <D.32124>:
      found = 1;
      goto <D.27784>;
      <D.32125>:
      k = k->parent;
      <D.27786>:
      if (k != 0B) goto <D.27785>; else goto <D.27784>;
      <D.27784>:
      if (found == 0) goto <D.32126>; else goto <D.32127>;
      <D.32126>:
      D.32082 = 25;
      return D.32082;
      <D.32127>:
      D.32128 = f->type;
      D.32129 = D.32128->attrs;
      D.32130 = (int) D.32129;
      D.32131 = D.32130 & 16;
      if (D.32131 != 0) goto <D.32132>; else goto <D.32133>;
      <D.32132>:
      {
        guint8 * val;
        struct MonoVTable * vtable;

        D.32134 = mono_class_field_is_special_static (f);
        if (D.32134 != 0) goto <D.32135>; else goto <D.32136>;
        <D.32135>:
        D.32082 = 25;
        return D.32082;
        <D.32136>:
        D.32128 = f->type;
        D.32129 = D.32128->attrs;
        D.32130 = (int) D.32129;
        D.32131 = D.32130 & 16;
        D.32137 = D.32131 == 0;
        D.32138 = (long int) D.32137;
        D.32139 = __builtin_expect (D.32138, 0);
        if (D.32139 != 0) goto <D.32140>; else goto <D.32141>;
        <D.32140>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 8817, "f->type->attrs & FIELD_ATTRIBUTE_STATIC");
        <D.32141>:
        D.32123 = f->parent;
        obj.337 = obj;
        D.32088 = obj.337->vtable;
        D.32092 = D.32088->domain;
        vtable = mono_class_vtable (D.32092, D.32123);
        D.32128 = f->type;
        D.32142 = mono_class_from_mono_type (D.32128);
        D.32143 = mono_class_instance_size (D.32142);
        D.32144 = (long unsigned int) D.32143;
        val = monoeg_malloc (D.32144);
        p.333 = p;
        obj.337 = obj;
        D.32088 = obj.337->vtable;
        D.32092 = D.32088->domain;
        D.32128 = f->type;
        D.32145 = decode_value (D.32128, D.32092, val, p.333, &p, end);
        err.338 = (int) D.32145;
        err = err.338;
        err.335 = err;
        if (err.335 != 0) goto <D.32147>; else goto <D.32148>;
        <D.32147>:
        monoeg_g_free (val);
        err.335 = err;
        D.32082 = (ErrorCode) err.335;
        return D.32082;
        <D.32148>:
        mono_field_static_set_value (vtable, f, val);
        monoeg_g_free (val);
      }
      goto <D.32149>;
      <D.32133>:
      p.333 = p;
      obj.337 = obj;
      D.32150 = f->offset;
      D.32151 = (sizetype) D.32150;
      D.32152 = obj.337 + D.32151;
      obj.337 = obj;
      D.32088 = obj.337->vtable;
      D.32092 = D.32088->domain;
      D.32128 = f->type;
      D.32153 = decode_value (D.32128, D.32092, D.32152, p.333, &p, end);
      err.339 = (int) D.32153;
      err = err.339;
      err.335 = err;
      if (err.335 != 0) goto <D.32155>; else goto <D.32156>;
      <D.32155>:
      err.335 = err;
      D.32082 = (ErrorCode) err.335;
      return D.32082;
      <D.32156>:
      <D.32149>:
      i = i + 1;
      <D.27790>:
      if (i < len) goto <D.27789>; else goto <D.27791>;
      <D.27791>:
      goto <D.27772>;
      <D.27792>:
      obj.337 = obj;
      obj.340 = (long unsigned int) obj.337;
      buffer_add_long (buf, obj.340);
      goto <D.27772>;
      <D.27793>:
      obj.337 = obj;
      D.32088 = obj.337->vtable;
      D.32092 = D.32088->domain;
      buffer_add_domainid (buf, D.32092);
      goto <D.27772>;
      <D.27794>:
      obj.337 = obj;
      D.32088 = obj.337->vtable;
      D.32089 = D.32088->type;
      D.32090 = MEM[(struct MonoReflectionType *)D.32089].type;
      D.32158 = mono_class_from_mono_type (D.32090);
      obj.337 = obj;
      D.32088 = obj.337->vtable;
      D.32092 = D.32088->domain;
      buffer_add_typeid (buf, D.32092, D.32158);
      obj.337 = obj;
      D.32088 = obj.337->vtable;
      D.32092 = D.32088->domain;
      buffer_add_domainid (buf, D.32092);
      goto <D.27772>;
      <D.27795>:
      D.32082 = 100;
      return D.32082;
      <D.27772>:
      D.32082 = 0;
      return D.32082;
    }
  finally
    {
      err = {CLOBBER};
      obj = {CLOBBER};
    }
}


send_reply_packet (int id, int error, struct Buffer * data)
{
  guint8 * D.32161;
  long int D.32162;
  guint8 * D.32163;
  long int D.32164;
  long int D.32165;
  unsigned int D.32166;
  unsigned int D.32167;
  unsigned int len.341;
  unsigned int id.342;
  int D.32170;
  unsigned char D.32171;
  int D.32172;
  unsigned char D.32173;
  int D.32174;
  long unsigned int D.32175;
  guint8 * D.32176;
  guint8 * D.32177;
  gboolean D.32178;
  struct Buffer buf;
  int len;
  gboolean res;

  try
    {
      D.32161 = data->p;
      D.32162 = (long int) D.32161;
      D.32163 = data->buf;
      D.32164 = (long int) D.32163;
      D.32165 = D.32162 - D.32164;
      D.32166 = (unsigned int) D.32165;
      D.32167 = D.32166 + 11;
      len = (int) D.32167;
      buffer_init (&buf, len);
      len.341 = (unsigned int) len;
      buffer_add_int (&buf, len.341);
      id.342 = (unsigned int) id;
      buffer_add_int (&buf, id.342);
      buffer_add_byte (&buf, 128);
      D.32170 = error >> 8;
      D.32171 = (unsigned char) D.32170;
      D.32172 = (int) D.32171;
      buffer_add_byte (&buf, D.32172);
      D.32173 = (unsigned char) error;
      D.32174 = (int) D.32173;
      buffer_add_byte (&buf, D.32174);
      D.32161 = data->p;
      D.32162 = (long int) D.32161;
      D.32163 = data->buf;
      D.32164 = (long int) D.32163;
      D.32165 = D.32162 - D.32164;
      D.32175 = (long unsigned int) D.32165;
      D.32163 = data->buf;
      D.32176 = buf.buf;
      D.32177 = D.32176 + 11;
      memcpy (D.32177, D.32163, D.32175);
      D.32176 = buf.buf;
      res = transport_send (D.32176, len);
      buffer_free (&buf);
      D.32178 = res;
      return D.32178;
    }
  finally
    {
      buf = {CLOBBER};
    }
}


save_thread_context (struct MonoContext * ctx)
{
  unsigned int debugger_tls_id.343;
  _Bool D.32182;
  long int D.32183;
  long int D.32184;
  struct MonoThreadUnwindState * D.32189;
  struct DebuggerTlsData * tls;

  debugger_tls_id.343 = debugger_tls_id;
  tls = pthread_getspecific (debugger_tls_id.343);
  D.32182 = tls == 0B;
  D.32183 = (long int) D.32182;
  D.32184 = __builtin_expect (D.32183, 0);
  if (D.32184 != 0) goto <D.32185>; else goto <D.32186>;
  <D.32185>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 2357, "tls");
  <D.32186>:
  if (ctx != 0B) goto <D.32187>; else goto <D.32188>;
  <D.32187>:
  D.32189 = &tls->context;
  mono_thread_state_init_from_monoctx (D.32189, ctx);
  goto <D.32190>;
  <D.32188>:
  D.32189 = &tls->context;
  mono_thread_state_init_from_current (D.32189);
  <D.32190>:
}


suspend_vm ()
{
  int suspend_count.344;
  int suspend_count.345;
  int log_level.346;
  _Bool D.32194;
  long int D.32195;
  long int D.32196;
  long unsigned int D.32199;
  void * D.32200;
  struct FILE * log_file.347;
  struct MonoGHashTable * thread_to_tls.348;

  mono_loader_lock ();
  pthread_mutex_lock (&suspend_mutex);
  suspend_count.344 = suspend_count;
  suspend_count.345 = suspend_count.344 + 1;
  suspend_count = suspend_count.345;
  log_level.346 = log_level;
  D.32194 = log_level.346 > 0;
  D.32195 = (long int) D.32194;
  D.32196 = __builtin_expect (D.32195, 0);
  if (D.32196 != 0) goto <D.32197>; else goto <D.32198>;
  <D.32197>:
  D.32199 = GetCurrentThreadId ();
  D.32200 = (void *) D.32199;
  log_file.347 = log_file;
  fprintf (log_file.347, "[%p] Suspending vm...\n", D.32200);
  log_file.347 = log_file;
  fflush (log_file.347);
  <D.32198>:
  suspend_count.344 = suspend_count;
  if (suspend_count.344 == 1) goto <D.32202>; else goto <D.32203>;
  <D.32202>:
  start_single_stepping ();
  thread_to_tls.348 = thread_to_tls;
  mono_g_hash_table_foreach (thread_to_tls.348, notify_thread, 0B);
  <D.32203>:
  pthread_mutex_unlock (&suspend_mutex);
  suspend_count.344 = suspend_count;
  if (suspend_count.344 == 1) goto <D.32205>; else goto <D.32206>;
  <D.32205>:
  mono_thread_pool_suspend ();
  <D.32206>:
  mono_loader_unlock ();
}


notify_thread (void * key, void * value, void * user_data)
{
  long unsigned int D.32209;
  int D.32211;
  int log_level.349;
  _Bool D.32213;
  long int D.32214;
  long int D.32215;
  void * tid.350;
  long unsigned int D.32219;
  void * D.32220;
  struct FILE * log_file.351;
  gint32 * D.32222;
  int D.32223;
  long unsigned int D.32226;
  long unsigned int D.32231;
  void * D.32232;
  long int D.32234;
  char * D.32235;
  void * D.32236;
  long unsigned int D.32237;
  int D.32239;
  long unsigned int D.32244;
  void * D.32245;
  struct MonoInternalThread * thread;
  struct DebuggerTlsData * tls;
  gsize tid;
  int res;

  thread = key;
  tls = value;
  tid = thread->tid;
  D.32209 = GetCurrentThreadId ();
  if (D.32209 == tid) goto <D.32207>; else goto <D.32210>;
  <D.32210>:
  D.32211 = tls->terminated;
  if (D.32211 != 0) goto <D.32207>; else goto <D.32208>;
  <D.32207>:
  return;
  <D.32208>:
  log_level.349 = log_level;
  D.32213 = log_level.349 > 0;
  D.32214 = (long int) D.32213;
  D.32215 = __builtin_expect (D.32214, 0);
  if (D.32215 != 0) goto <D.32216>; else goto <D.32217>;
  <D.32216>:
  tid.350 = (void *) tid;
  D.32219 = GetCurrentThreadId ();
  D.32220 = (void *) D.32219;
  log_file.351 = log_file;
  fprintf (log_file.351, "[%p] Interrupting %p...\n", D.32220, tid.350);
  log_file.351 = log_file;
  fflush (log_file.351);
  <D.32217>:
  D.32222 = &tls->interrupt_count;
  InterlockedIncrement (D.32222);
  D.32223 = mono_thread_info_new_interrupt_enabled ();
  if (D.32223 != 0) goto <D.32224>; else goto <D.32225>;
  <D.32224>:
  {
    struct MonoThreadInfo * info;
    struct MonoJitInfo * ji;

    D.32226 = thread->tid;
    info = mono_thread_info_safe_suspend_sync (D.32226, 0);
    if (info == 0B) goto <D.32227>; else goto <D.32228>;
    <D.32227>:
    log_level.349 = log_level;
    D.32213 = log_level.349 > 0;
    D.32214 = (long int) D.32213;
    D.32215 = __builtin_expect (D.32214, 0);
    if (D.32215 != 0) goto <D.32229>; else goto <D.32230>;
    <D.32229>:
    tid.350 = (void *) tid;
    D.32231 = GetCurrentThreadId ();
    D.32232 = (void *) D.32231;
    log_file.351 = log_file;
    fprintf (log_file.351, "[%p] mono_thread_info_suspend_sync () failed for %p...\n", D.32232, tid.350);
    log_file.351 = log_file;
    fflush (log_file.351);
    <D.32230>:
    tls->terminated = 1;
    goto <D.32233>;
    <D.32228>:
    D.32234 = info->suspend_state.ctx.rip;
    D.32235 = (char *) D.32234;
    D.32236 = info->suspend_state.unwind_data[0];
    ji = mono_jit_info_table_find (D.32236, D.32235);
    thread_interrupt (tls, info, 0B, ji);
    D.32237 = info->node.key;
    mono_thread_info_resume (D.32237);
    <D.32233>:
  }
  goto <D.32238>;
  <D.32225>:
  D.32239 = mono_thread_get_abort_signal ();
  res = mono_thread_kill (thread, D.32239);
  if (res != 0) goto <D.32240>; else goto <D.32241>;
  <D.32240>:
  log_level.349 = log_level;
  D.32213 = log_level.349 > 0;
  D.32214 = (long int) D.32213;
  D.32215 = __builtin_expect (D.32214, 0);
  if (D.32215 != 0) goto <D.32242>; else goto <D.32243>;
  <D.32242>:
  tid.350 = (void *) tid;
  D.32244 = GetCurrentThreadId ();
  D.32245 = (void *) D.32244;
  log_file.351 = log_file;
  fprintf (log_file.351, "[%p] mono_thread_kill () failed for %p: %d...\n", D.32245, tid.350, res);
  log_file.351 = log_file;
  fflush (log_file.351);
  <D.32243>:
  tls->terminated = 1;
  <D.32241>:
  <D.32238>:
}


thread_interrupt (struct DebuggerTlsData * tls, struct MonoThreadInfo * info, void * sigctx, struct MonoJitInfo * ji)
{
  int D.32247;
  gboolean D.32250;
  gint32 * D.32251;
  long int D.32257;
  int log_level.352;
  _Bool D.32265;
  long int D.32266;
  long int D.32267;
  struct MonoMethod * D.32270;
  const char * D.32271;
  void * tid.353;
  struct FILE * log_file.354;
  signed long D.32274;
  long unsigned int D.32275;
  long unsigned int D.32276;
  struct MonoInternalThread * D.32283;
  struct MonoRuntimeExceptionHandlingCallbacks * D.32291;
  void (*<T2836>) (gboolean (*MonoInternalStackWalk) (struct MonoStackFrameInfo *, struct MonoContext *, void *), struct MonoThreadUnwindState *, MonoUnwindOptions, void *) D.32292;
  struct MonoThreadUnwindState * D.32293;
  int D.32294;
  struct StackFrameInfo * D.32297;
  struct MonoThreadUnwindState * D.32298;
  _Bool D.32299;
  long int D.32300;
  long int D.32301;
  struct MonoThreadUnwindState * D.32304;
  struct MonoContext * D.32307;
  void * D.32308;
  void * D.32309;
  gboolean res;
  void * ip;
  MonoNativeThreadId tid;

  D.32247 = tls->interrupt_count;
  if (D.32247 == 0) goto <D.32248>; else goto <D.32249>;
  <D.32248>:
  D.32250 = 0;
  return D.32250;
  <D.32249>:
  D.32251 = &tls->interrupt_count;
  InterlockedDecrement (D.32251);
  if (sigctx != 0B) goto <D.32252>; else goto <D.32253>;
  <D.32252>:
  ip = mono_arch_ip_from_context (sigctx);
  goto <D.32254>;
  <D.32253>:
  if (info != 0B) goto <D.32255>; else goto <D.32256>;
  <D.32255>:
  D.32257 = info->suspend_state.ctx.rip;
  ip = (void *) D.32257;
  goto <D.32258>;
  <D.32256>:
  ip = 0B;
  <D.32258>:
  <D.32254>:
  if (info != 0B) goto <D.32259>; else goto <D.32260>;
  <D.32259>:
  tid = info->node.key;
  goto <D.32261>;
  <D.32260>:
  tid = GetCurrentThreadId ();
  <D.32261>:
  if (ji != 0B) goto <D.32262>; else goto <D.32263>;
  <D.32262>:
  log_level.352 = log_level;
  D.32265 = log_level.352 > 0;
  D.32266 = (long int) D.32265;
  D.32267 = __builtin_expect (D.32266, 0);
  if (D.32267 != 0) goto <D.32268>; else goto <D.32269>;
  <D.32268>:
  D.32270 = jinfo_get_method (ji);
  D.32271 = D.32270->name;
  tid.353 = (void *) tid;
  log_file.354 = log_file;
  fprintf (log_file.354, "[%p] Received interrupt while at %s(%p), continuing.\n", tid.353, D.32271, ip);
  log_file.354 = log_file;
  fflush (log_file.354);
  <D.32269>:
  D.32250 = 1;
  return D.32250;
  <D.32263>:
  D.32274 = BIT_FIELD_REF <*tls, 64, 1600>;
  D.32275 = (long unsigned int) D.32274;
  D.32276 = D.32275;
  if (D.32276 == 0) goto <D.32277>; else goto <D.32278>;
  <D.32277>:
  {
    struct MonoContext ctx;
    struct GetLastFrameUserData data;

    try
      {
        if (ip != 0B) goto <D.32279>; else goto <D.32280>;
        <D.32279>:
        log_level.352 = log_level;
        D.32265 = log_level.352 > 0;
        D.32266 = (long int) D.32265;
        D.32267 = __builtin_expect (D.32266, 0);
        if (D.32267 != 0) goto <D.32281>; else goto <D.32282>;
        <D.32281>:
        tid.353 = (void *) tid;
        log_file.354 = log_file;
        fprintf (log_file.354, "[%p] Received interrupt while at %p, treating as suspended.\n", tid.353, ip);
        log_file.354 = log_file;
        fflush (log_file.354);
        <D.32282>:
        <D.32280>:
        D.32283 = tls->thread;
        if (D.32283 == 0B) goto <D.32284>; else goto <D.32285>;
        <D.32284>:
        D.32250 = 1;
        return D.32250;
        <D.32285>:
        data.last_frame_set = 0;
        if (sigctx != 0B) goto <D.32286>; else goto <D.32287>;
        <D.32286>:
        mono_arch_sigctx_to_monoctx (sigctx, &ctx);
        mono_walk_stack_with_ctx (get_last_frame, &ctx, 0, &data);
        goto <D.32288>;
        <D.32287>:
        if (info != 0B) goto <D.32289>; else goto <D.32290>;
        <D.32289>:
        D.32291 = mono_get_eh_callbacks ();
        D.32292 = D.32291->mono_walk_stack_with_state;
        D.32293 = &info->suspend_state;
        D.32292 (get_last_frame, D.32293, 0, &data);
        <D.32290>:
        <D.32288>:
        D.32294 = data.last_frame_set;
        if (D.32294 != 0) goto <D.32295>; else goto <D.32296>;
        <D.32295>:
        D.32297 = &tls->async_last_frame;
        memcpy (D.32297, &data.last_frame, 88);
        D.32298 = &tls->async_state;
        res = mono_thread_state_init_from_monoctx (D.32298, &ctx);
        D.32299 = res == 0;
        D.32300 = (long int) D.32299;
        D.32301 = __builtin_expect (D.32300, 0);
        if (D.32301 != 0) goto <D.32302>; else goto <D.32303>;
        <D.32302>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 2519, "res");
        <D.32303>:
        D.32304 = &tls->context;
        mono_thread_state_init_from_monoctx (D.32304, &ctx);
        D.32299 = res == 0;
        D.32300 = (long int) D.32299;
        D.32301 = __builtin_expect (D.32300, 0);
        if (D.32301 != 0) goto <D.32305>; else goto <D.32306>;
        <D.32305>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 2521, "res");
        <D.32306>:
        D.32307 = &tls->async_state.ctx;
        memcpy (D.32307, &data.ctx, 136);
        D.32308 = data.lmf;
        tls->async_state.unwind_data[1] = D.32308;
        D.32283 = tls->thread;
        D.32309 = D.32283->jit_data;
        tls->async_state.unwind_data[2] = D.32309;
        goto <D.32310>;
        <D.32296>:
        tls->async_state.valid = 0;
        <D.32310>:
        mono_memory_barrier ();
        tls->suspended = 1;
        mono_sem_post (&suspend_sem);
      }
    finally
      {
        ctx = {CLOBBER};
        data = {CLOBBER};
      }
  }
  <D.32278>:
  D.32250 = 1;
  return D.32250;
}


get_last_frame (struct StackFrameInfo * info, struct MonoContext * ctx, void * user_data)
{
  <unnamed type> D.32314;
  gboolean D.32317;
  int D.32318;
  struct StackFrameInfo * D.32321;
  struct MonoContext * D.32322;
  void * D.32323;
  struct GetLastFrameUserData * data;

  data = user_data;
  D.32314 = info->type;
  if (D.32314 == 2) goto <D.32315>; else goto <D.32316>;
  <D.32315>:
  D.32317 = 0;
  return D.32317;
  <D.32316>:
  D.32318 = data->last_frame_set;
  if (D.32318 == 0) goto <D.32319>; else goto <D.32320>;
  <D.32319>:
  D.32321 = &data->last_frame;
  memcpy (D.32321, info, 88);
  data->last_frame_set = 1;
  D.32317 = 0;
  return D.32317;
  <D.32320>:
  D.32322 = &data->ctx;
  memcpy (D.32322, ctx, 136);
  D.32323 = info->lmf;
  data->lmf = D.32323;
  D.32317 = 1;
  return D.32317;
}


mono_memory_barrier ()
{
  __sync_synchronize ();
}


get_objref (struct MonoObject * obj)
{
  struct ObjRef * D.32327;
  struct GHashTable * obj_to_objref.355;
  struct GHashTable * obj_to_objref.356;
  struct MonoGHashTable * suspended_objs.357;
  int D.32333;
  int suspend_count.358;
  struct MonoGHashTable * suspended_objs.359;
  int D.32340;
  long int D.32343;
  const void * D.32344;
  unsigned int D.32347;
  struct MonoObject * D.32348;
  long unsigned int obj.360;
  long unsigned int D.32353;
  const void * D.32354;
  struct MonoObject * D.32357;
  int D.32360;
  unsigned int D.32361;
  int D.32362;
  long int D.32363;
  void * D.32364;
  struct GHashTable * objrefs.361;
  int D.32366;
  void * D.32369;
  void * D.32371;
  struct ObjRef * ref;
  struct GSList * reflist;
  struct GSList * l;
  int hash;

  reflist = 0B;
  hash = 0;
  if (obj == 0B) goto <D.32325>; else goto <D.32326>;
  <D.32325>:
  D.32327 = 0B;
  return D.32327;
  <D.32326>:
  mono_loader_lock ();
  obj_to_objref.355 = obj_to_objref;
  if (obj_to_objref.355 == 0B) goto <D.32329>; else goto <D.32330>;
  <D.32329>:
  obj_to_objref.356 = monoeg_g_hash_table_new (0B, 0B);
  obj_to_objref = obj_to_objref.356;
  suspended_objs.357 = mono_g_hash_table_new_type (0B, 0B, 1);
  suspended_objs = suspended_objs.357;
  D.32333 = mono_gc_is_moving ();
  if (D.32333 == 0) goto <D.32334>; else goto <D.32335>;
  <D.32334>:
  mono_gc_register_root (&suspended_objs, 8, 0B);
  <D.32335>:
  <D.32330>:
  suspend_count.358 = suspend_count;
  if (suspend_count.358 != 0) goto <D.32337>; else goto <D.32338>;
  <D.32337>:
  suspended_objs.359 = suspended_objs;
  mono_g_hash_table_insert (suspended_objs.359, obj, 0B);
  <D.32338>:
  D.32340 = mono_gc_is_moving ();
  if (D.32340 != 0) goto <D.32341>; else goto <D.32342>;
  <D.32341>:
  hash = mono_object_hash (obj);
  D.32343 = (long int) hash;
  D.32344 = (const void *) D.32343;
  obj_to_objref.355 = obj_to_objref;
  reflist = monoeg_g_hash_table_lookup (obj_to_objref.355, D.32344);
  l = reflist;
  goto <D.25530>;
  <D.25529>:
  ref = l->data;
  if (ref != 0B) goto <D.32345>; else goto <D.32346>;
  <D.32345>:
  D.32347 = ref->handle;
  D.32348 = mono_gchandle_get_target (D.32347);
  if (D.32348 == obj) goto <D.32349>; else goto <D.32350>;
  <D.32349>:
  mono_loader_unlock ();
  D.32327 = ref;
  return D.32327;
  <D.32350>:
  <D.32346>:
  l = l->next;
  <D.25530>:
  if (l != 0B) goto <D.25529>; else goto <D.25531>;
  <D.25531>:
  goto <D.32351>;
  <D.32342>:
  obj.360 = (long unsigned int) obj;
  D.32353 = ~obj.360;
  D.32354 = (const void *) D.32353;
  obj_to_objref.355 = obj_to_objref;
  ref = monoeg_g_hash_table_lookup (obj_to_objref.355, D.32354);
  if (ref != 0B) goto <D.32355>; else goto <D.32356>;
  <D.32355>:
  D.32347 = ref->handle;
  D.32357 = mono_gchandle_get_target (D.32347);
  if (D.32357 == obj) goto <D.32358>; else goto <D.32359>;
  <D.32358>:
  mono_loader_unlock ();
  D.32327 = ref;
  return D.32327;
  <D.32359>:
  <D.32356>:
  <D.32351>:
  ref = monoeg_malloc0 (8);
  D.32360 = InterlockedIncrement (&objref_id);
  ref->id = D.32360;
  D.32361 = mono_gchandle_new_weakref (obj, 0);
  ref->handle = D.32361;
  D.32362 = ref->id;
  D.32363 = (long int) D.32362;
  D.32364 = (void *) D.32363;
  objrefs.361 = objrefs;
  monoeg_g_hash_table_insert_replace (objrefs.361, D.32364, ref, 0);
  D.32366 = mono_gc_is_moving ();
  if (D.32366 != 0) goto <D.32367>; else goto <D.32368>;
  <D.32367>:
  reflist = monoeg_g_slist_append (reflist, ref);
  D.32343 = (long int) hash;
  D.32369 = (void *) D.32343;
  obj_to_objref.355 = obj_to_objref;
  monoeg_g_hash_table_insert_replace (obj_to_objref.355, D.32369, reflist, 0);
  goto <D.32370>;
  <D.32368>:
  obj.360 = (long unsigned int) obj;
  D.32353 = ~obj.360;
  D.32371 = (void *) D.32353;
  obj_to_objref.355 = obj_to_objref;
  monoeg_g_hash_table_insert_replace (obj_to_objref.355, D.32371, ref, 0);
  <D.32370>:
  mono_loader_unlock ();
  D.32327 = ref;
  return D.32327;
}


send_packet (int command_set, int command, struct Buffer * data)
{
  guint8 * D.32373;
  long int D.32374;
  guint8 * D.32375;
  long int D.32376;
  long int D.32377;
  unsigned int D.32378;
  unsigned int D.32379;
  unsigned int len.362;
  unsigned int id.363;
  unsigned char D.32382;
  int D.32383;
  unsigned char D.32384;
  int D.32385;
  long unsigned int D.32386;
  guint8 * D.32387;
  guint8 * D.32388;
  gboolean D.32389;
  struct Buffer buf;
  int len;
  int id;
  gboolean res;

  try
    {
      id = InterlockedIncrement (&packet_id);
      D.32373 = data->p;
      D.32374 = (long int) D.32373;
      D.32375 = data->buf;
      D.32376 = (long int) D.32375;
      D.32377 = D.32374 - D.32376;
      D.32378 = (unsigned int) D.32377;
      D.32379 = D.32378 + 11;
      len = (int) D.32379;
      buffer_init (&buf, len);
      len.362 = (unsigned int) len;
      buffer_add_int (&buf, len.362);
      id.363 = (unsigned int) id;
      buffer_add_int (&buf, id.363);
      buffer_add_byte (&buf, 0);
      D.32382 = (unsigned char) command_set;
      D.32383 = (int) D.32382;
      buffer_add_byte (&buf, D.32383);
      D.32384 = (unsigned char) command;
      D.32385 = (int) D.32384;
      buffer_add_byte (&buf, D.32385);
      D.32373 = data->p;
      D.32374 = (long int) D.32373;
      D.32375 = data->buf;
      D.32376 = (long int) D.32375;
      D.32377 = D.32374 - D.32376;
      D.32386 = (long unsigned int) D.32377;
      D.32375 = data->buf;
      D.32387 = buf.buf;
      D.32388 = D.32387 + 11;
      memcpy (D.32388, D.32375, D.32386);
      D.32387 = buf.buf;
      res = transport_send (D.32387, len);
      buffer_free (&buf);
      D.32389 = res;
      return D.32389;
    }
  finally
    {
      buf = {CLOBBER};
    }
}


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

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


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

  switch (event) <default: <D.26077>, case 0: <D.26060>, case 1: <D.26061>, case 2: <D.26062>, case 3: <D.26063>, case 4: <D.26064>, case 5: <D.26065>, case 6: <D.26066>, case 7: <D.26067>, case 8: <D.26068>, case 9: <D.26069>, case 10: <D.26070>, case 11: <D.26071>, case 12: <D.26072>, case 13: <D.26073>, case 14: <D.26074>, case 15: <D.26075>, case 16: <D.26076>>
  <D.26060>:
  D.32393 = "VM_START";
  return D.32393;
  <D.26061>:
  D.32393 = "VM_DEATH";
  return D.32393;
  <D.26062>:
  D.32393 = "THREAD_START";
  return D.32393;
  <D.26063>:
  D.32393 = "THREAD_DEATH";
  return D.32393;
  <D.26064>:
  D.32393 = "APPDOMAIN_CREATE";
  return D.32393;
  <D.26065>:
  D.32393 = "APPDOMAIN_UNLOAD";
  return D.32393;
  <D.26066>:
  D.32393 = "METHOD_ENTRY";
  return D.32393;
  <D.26067>:
  D.32393 = "METHOD_EXIT";
  return D.32393;
  <D.26068>:
  D.32393 = "ASSEMBLY_LOAD";
  return D.32393;
  <D.26069>:
  D.32393 = "ASSEMBLY_UNLOAD";
  return D.32393;
  <D.26070>:
  D.32393 = "BREAKPOINT";
  return D.32393;
  <D.26071>:
  D.32393 = "STEP";
  return D.32393;
  <D.26072>:
  D.32393 = "TYPE_LOAD";
  return D.32393;
  <D.26073>:
  D.32393 = "EXCEPTION";
  return D.32393;
  <D.26074>:
  D.32393 = "KEEPALIVE";
  return D.32393;
  <D.26075>:
  D.32393 = "USER_BREAK";
  return D.32393;
  <D.26076>:
  D.32393 = "USER_LOG";
  return D.32393;
  <D.26077>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "debugger-agent.c", 3535);
  D.32393 = "";
  return D.32393;
}


suspend_current ()
{
  long unsigned int D.32395;
  long unsigned int debugger_thread_id.364;
  _Bool D.32397;
  long int D.32398;
  long int D.32399;
  int D.32402;
  unsigned int debugger_tls_id.365;
  _Bool D.32406;
  long int D.32407;
  long int D.32408;
  int D.32411;
  int log_level.366;
  _Bool D.32415;
  long int D.32416;
  long int D.32417;
  long unsigned int D.32420;
  void * D.32421;
  struct FILE * log_file.367;
  _Bool D.32423;
  long int D.32424;
  long int D.32425;
  int suspend_count.368;
  unsigned int suspend_count.369;
  unsigned int D.32430;
  int threads_suspend_count.370;
  int threads_suspend_count.371;
  long unsigned int D.32435;
  void * D.32436;
  struct InvokeData * D.32437;
  int err;
  struct DebuggerTlsData * tls;

  D.32395 = GetCurrentThreadId ();
  debugger_thread_id.364 = debugger_thread_id;
  D.32397 = D.32395 == debugger_thread_id.364;
  D.32398 = (long int) D.32397;
  D.32399 = __builtin_expect (D.32398, 0);
  if (D.32399 != 0) goto <D.32400>; else goto <D.32401>;
  <D.32400>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 2855, "debugger_thread_id != GetCurrentThreadId ()");
  <D.32401>:
  D.32402 = mono_loader_lock_is_owned_by_self ();
  if (D.32402 != 0) goto <D.32403>; else goto <D.32404>;
  <D.32403>:
  return;
  <D.32404>:
  debugger_tls_id.365 = debugger_tls_id;
  tls = pthread_getspecific (debugger_tls_id.365);
  D.32406 = tls == 0B;
  D.32407 = (long int) D.32406;
  D.32408 = __builtin_expect (D.32407, 0);
  if (D.32408 != 0) goto <D.32409>; else goto <D.32410>;
  <D.32409>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 2866, "tls");
  <D.32410>:
  pthread_mutex_lock (&suspend_mutex);
  tls->suspending = 0;
  tls->really_suspended = 1;
  D.32411 = tls->suspended;
  if (D.32411 == 0) goto <D.32412>; else goto <D.32413>;
  <D.32412>:
  tls->suspended = 1;
  mono_sem_post (&suspend_sem);
  <D.32413>:
  log_level.366 = log_level;
  D.32415 = log_level.366 > 0;
  D.32416 = (long int) D.32415;
  D.32417 = __builtin_expect (D.32416, 0);
  if (D.32417 != 0) goto <D.32418>; else goto <D.32419>;
  <D.32418>:
  D.32420 = GetCurrentThreadId ();
  D.32421 = (void *) D.32420;
  log_file.367 = log_file;
  fprintf (log_file.367, "[%p] Suspended.\n", D.32421);
  log_file.367 = log_file;
  fflush (log_file.367);
  <D.32419>:
  goto <D.25864>;
  <D.25863>:
  err = pthread_cond_wait (&suspend_cond, &suspend_mutex);
  D.32423 = err != 0;
  D.32424 = (long int) D.32423;
  D.32425 = __builtin_expect (D.32424, 0);
  if (D.32425 != 0) goto <D.32426>; else goto <D.32427>;
  <D.32426>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 2893, "err == 0");
  <D.32427>:
  <D.25864>:
  suspend_count.368 = suspend_count;
  suspend_count.369 = (unsigned int) suspend_count.368;
  D.32430 = tls->resume_count;
  if (suspend_count.369 != D.32430) goto <D.25863>; else goto <D.25865>;
  <D.25865>:
  tls->suspended = 0;
  tls->really_suspended = 0;
  threads_suspend_count.370 = threads_suspend_count;
  threads_suspend_count.371 = threads_suspend_count.370 + -1;
  threads_suspend_count = threads_suspend_count.371;
  pthread_mutex_unlock (&suspend_mutex);
  log_level.366 = log_level;
  D.32415 = log_level.366 > 0;
  D.32416 = (long int) D.32415;
  D.32417 = __builtin_expect (D.32416, 0);
  if (D.32417 != 0) goto <D.32433>; else goto <D.32434>;
  <D.32433>:
  D.32435 = GetCurrentThreadId ();
  D.32436 = (void *) D.32435;
  log_file.367 = log_file;
  fprintf (log_file.367, "[%p] Resumed.\n", D.32436);
  log_file.367 = log_file;
  fflush (log_file.367);
  <D.32434>:
  D.32437 = tls->pending_invoke;
  if (D.32437 != 0B) goto <D.32438>; else goto <D.32439>;
  <D.32438>:
  D.32437 = tls->pending_invoke;
  D.32437->has_ctx = 1;
  D.32437 = tls->pending_invoke;
  D.32437->ctx = tls->context.ctx;
  invoke_method ();
  <D.32439>:
  tls->context.valid = 0;
  tls->async_state.valid = 0;
  invalidate_frames (tls);
}


invoke_method ()
{
  unsigned int debugger_tls_id.372;
  _Bool D.32442;
  long int D.32443;
  long int D.32444;
  _Bool D.32447;
  long int D.32448;
  long int D.32449;
  struct InvokeData * D.32452;
  guint8 * p.373;
  guint8 * p.374;
  <unnamed type> D.32458;
  int D.32459;
  int D.32460;
  int D.32463;
  int D.32464;
  unsigned int i.375;
  unsigned int D.32468;
  struct MonoContext * D.32469;
  int D.32470;
  unsigned int D.32475;
  _Bool D.32476;
  long int D.32477;
  long int D.32478;
  unsigned int D.32481;
  int log_level.376;
  _Bool D.32483;
  long int D.32484;
  long int D.32485;
  long unsigned int D.32488;
  void * D.32489;
  struct FILE * log_file.377;
  int D.32491;
  struct MonoInternalThread * D.32494;
  struct InvokeData * D.32495;
  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.372 = debugger_tls_id;
      tls = pthread_getspecific (debugger_tls_id.372);
      D.32442 = tls == 0B;
      D.32443 = (long int) D.32442;
      D.32444 = __builtin_expect (D.32443, 0);
      if (D.32444 != 0) goto <D.32445>; else goto <D.32446>;
      <D.32445>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 6421, "tls");
      <D.32446>:
      mono_loader_lock ();
      invoke = tls->pending_invoke;
      D.32447 = invoke == 0B;
      D.32448 = (long int) D.32447;
      D.32449 = __builtin_expect (D.32448, 0);
      if (D.32449 != 0) goto <D.32450>; else goto <D.32451>;
      <D.32450>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 6431, "invoke");
      <D.32451>:
      tls->pending_invoke = 0B;
      D.32452 = tls->invoke;
      invoke->last_invoke = D.32452;
      tls->invoke = invoke;
      mono_loader_unlock ();
      tls->frames_up_to_date = 0;
      id = invoke->id;
      p.373 = invoke->p;
      p = p.373;
      err = 0;
      mindex = 0;
      goto <D.26993>;
      <D.26992>:
      buffer_init (&buf, 128);
      if (err != 0) goto <D.32454>; else goto <D.32455>;
      <D.32454>:
      goto <D.32456>;
      <D.32455>:
      p.374 = p;
      D.32458 = do_invoke_method (tls, &buf, invoke, p.374, &p);
      err = (int) D.32458;
      <D.32456>:
      D.32459 = invoke->nmethods;
      D.32460 = D.32459 + -1;
      if (D.32460 == mindex) goto <D.32461>; else goto <D.32462>;
      <D.32461>:
      D.32463 = invoke->flags;
      D.32464 = D.32463 & 2;
      if (D.32464 == 0) goto <D.32465>; else goto <D.32466>;
      <D.32465>:
      i = 0;
      goto <D.26990>;
      <D.26989>:
      suspend_vm ();
      i = i + 1;
      <D.26990>:
      i.375 = (unsigned int) i;
      D.32468 = invoke->suspend_count;
      if (i.375 < D.32468) goto <D.26989>; else goto <D.26991>;
      <D.26991>:
      <D.32466>:
      <D.32462>:
      send_reply_packet (id, err, &buf);
      buffer_free (&buf);
      mindex = mindex + 1;
      <D.26993>:
      D.32459 = invoke->nmethods;
      if (D.32459 > mindex) goto <D.26992>; else goto <D.26994>;
      <D.26994>:
      D.32469 = &invoke->ctx;
      memcpy (&restore_ctx, D.32469, 136);
      D.32470 = invoke->has_ctx;
      if (D.32470 != 0) goto <D.32471>; else goto <D.32472>;
      <D.32471>:
      save_thread_context (&restore_ctx);
      <D.32472>:
      D.32463 = invoke->flags;
      D.32464 = D.32463 & 2;
      if (D.32464 != 0) goto <D.32473>; else goto <D.32474>;
      <D.32473>:
      D.32475 = tls->resume_count;
      D.32476 = D.32475 == 0;
      D.32477 = (long int) D.32476;
      D.32478 = __builtin_expect (D.32477, 0);
      if (D.32478 != 0) goto <D.32479>; else goto <D.32480>;
      <D.32479>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 6473, "tls->resume_count");
      <D.32480>:
      D.32475 = tls->resume_count;
      D.32468 = invoke->suspend_count;
      D.32481 = D.32475 - D.32468;
      tls->resume_count = D.32481;
      <D.32474>:
      log_level.376 = log_level;
      D.32483 = log_level.376 > 0;
      D.32484 = (long int) D.32483;
      D.32485 = __builtin_expect (D.32484, 0);
      if (D.32485 != 0) goto <D.32486>; else goto <D.32487>;
      <D.32486>:
      D.32475 = tls->resume_count;
      D.32488 = GetCurrentThreadId ();
      D.32489 = (void *) D.32488;
      log_file.377 = log_file;
      fprintf (log_file.377, "[%p] Invoke finished (%d), resume_count = %d.\n", D.32489, err, D.32475);
      log_file.377 = log_file;
      fflush (log_file.377);
      <D.32487>:
      mono_loader_lock ();
      D.32491 = tls->abort_requested;
      if (D.32491 != 0) goto <D.32492>; else goto <D.32493>;
      <D.32492>:
      D.32494 = tls->thread;
      mono_thread_internal_reset_abort (D.32494);
      <D.32493>:
      D.32452 = tls->invoke;
      D.32495 = D.32452->last_invoke;
      tls->invoke = D.32495;
      tls->abort_requested = 0;
      mono_loader_unlock ();
      p.373 = invoke->p;
      monoeg_g_free (p.373);
      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.32496;
  int log_level.378;
  _Bool D.32500;
  long int D.32501;
  long int D.32502;
  const char * iftmp.379;
  struct MonoObject * this.380;
  struct MonoVTable * D.32509;
  struct MonoClass * D.32510;
  char * D.32512;
  long unsigned int D.32513;
  void * D.32514;
  struct FILE * log_file.381;
  void * * D.32516;
  guint8 * p.382;
  int err.383;
  ErrorCode D.32521;
  struct MonoClass * D.32522;
  unsigned char D.32523;
  unsigned char D.32524;
  int D.32527;
  long unsigned int D.32528;
  short unsigned int D.32533;
  int D.32534;
  int D.32535;
  long unsigned int D.32541;
  void * D.32542;
  int D.32543;
  long unsigned int D.32544;
  struct MonoDomain * domain.384;
  struct MonoType * D.32546;
  <unnamed type> D.32547;
  int err.385;
  struct MonoObject * this.386;
  unsigned int D.32557;
  unsigned int D.32558;
  unsigned char D.32560;
  long unsigned int D.32566;
  void * D.32567;
  const char * iftmp.387;
  char * D.32574;
  long unsigned int D.32575;
  void * D.32576;
  struct MonoDomain * D.32579;
  int D.26961;
  int iftmp.388;
  int D.26960;
  const char[6] * D.32591;
  unsigned char D.32592;
  int D.32593;
  unsigned char D.32594;
  int D.32595;
  _Bool D.32596;
  _Bool D.32597;
  _Bool D.32598;
  const unsigned char * D.32601;
  unsigned char D.32602;
  int D.32603;
  const unsigned char * D.32604;
  unsigned char D.32605;
  int D.32606;
  _Bool D.32607;
  _Bool D.32608;
  const unsigned char * D.32611;
  unsigned char D.32612;
  int D.32613;
  const unsigned char * D.32614;
  unsigned char D.32615;
  int D.32616;
  _Bool D.32617;
  _Bool D.32618;
  const unsigned char * D.32621;
  unsigned char D.32622;
  int D.32623;
  const unsigned char * D.32624;
  unsigned char D.32625;
  int D.32626;
  const char * D.32628;
  unsigned int D.32631;
  struct MonoObject * this.389;
  int D.32638;
  short unsigned int D.32641;
  int D.32642;
  long unsigned int D.32645;
  long unsigned int D.32646;
  struct MonoType * D.32647;
  int D.32648;
  long unsigned int D.32651;
  long unsigned int D.32652;
  guint8 * D.32653;
  <unnamed type> D.32654;
  int err.390;
  void * * D.32657;
  void * D.32658;
  struct MonoVTable * D.32661;
  struct MonoDomain * D.32662;
  guint8 * * D.32666;
  struct MonoClass * D.32667;
  int D.32668;
  long unsigned int D.32669;
  void * D.32670;
  guint8 * D.32671;
  <unnamed type> D.32672;
  int err.391;
  int D.32677;
  int D.32678;
  int D.32682;
  struct MonoLMF * D.32685;
  struct MonoContext * D.32686;
  struct MonoObject * res.392;
  struct MonoObject * res.393;
  long unsigned int D.32694;
  long int D.32695;
  const char * iftmp.394;
  struct MonoObject * exc.395;
  struct MonoVTable * D.32700;
  struct MonoClass * D.32701;
  struct MonoObject * res.396;
  long unsigned int D.32704;
  void * D.32705;
  struct MonoClass * D.32708;
  struct MonoType * D.32709;
  struct MonoType * D.32711;
  unsigned char D.32712;
  int D.26974;
  int iftmp.397;
  int D.26973;
  unsigned char D.32720;
  int D.32721;
  _Bool D.32722;
  _Bool D.32723;
  _Bool D.32724;
  const unsigned char * D.32727;
  unsigned char D.32728;
  int D.32729;
  _Bool D.32730;
  _Bool D.32731;
  const unsigned char * D.32734;
  unsigned char D.32735;
  int D.32736;
  _Bool D.32737;
  _Bool D.32738;
  const unsigned char * D.32741;
  unsigned char D.32742;
  int D.32743;
  struct MonoClass * D.32747;
  struct MonoType * D.32748;
  int D.32750;
  struct MonoClass * D.32757;
  unsigned char D.32758;
  unsigned char D.32759;
  struct MonoClass * D.32762;
  int D.32763;
  int D.32766;
  long unsigned int D.32767;
  _Bool D.32768;
  long int D.32769;
  long int D.32770;
  _Bool D.32774;
  long int D.32775;
  long int D.32776;
  void * D.32779;
  void * D.32782;
  long int D.32783;
  long int D.32784;
  struct MonoLMF * D.32785;
  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.32496 = invoke->method;
      if (D.32496 != 0B) goto <D.32497>; else goto <D.32498>;
      <D.32497>:
      this = 0B;
      log_level.378 = log_level;
      D.32500 = log_level.378 > 0;
      D.32501 = (long int) D.32500;
      D.32502 = __builtin_expect (D.32501, 0);
      if (D.32502 != 0) goto <D.32503>; else goto <D.32504>;
      <D.32503>:
      this.380 = this;
      if (this.380 != 0B) goto <D.32507>; else goto <D.32508>;
      <D.32507>:
      this.380 = this;
      D.32509 = this.380->vtable;
      D.32510 = D.32509->klass;
      iftmp.379 = D.32510->name;
      goto <D.32511>;
      <D.32508>:
      iftmp.379 = "<null>";
      <D.32511>:
      D.32496 = invoke->method;
      D.32512 = mono_method_full_name (D.32496, 1);
      D.32513 = GetCurrentThreadId ();
      D.32514 = (void *) D.32513;
      log_file.381 = log_file;
      fprintf (log_file.381, "[%p] Invoking method \'%s\' on receiver \'%s\'.\n", D.32514, D.32512, iftmp.379);
      log_file.381 = log_file;
      fflush (log_file.381);
      <D.32504>:
      D.32516 = invoke->args;
      D.32496 = invoke->method;
      mono_runtime_invoke (D.32496, 0B, D.32516, &exc);
      monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "debugger-agent.c", 6243);
      <D.32498>:
      p.382 = p;
      m = decode_methodid (p.382, &p, end, &domain, &err);
      err.383 = err;
      if (err.383 != 0) goto <D.32519>; else goto <D.32520>;
      <D.32519>:
      err.383 = err;
      D.32521 = (ErrorCode) err.383;
      return D.32521;
      <D.32520>:
      sig = mono_method_signature (m);
      D.32522 = m->klass;
      D.32523 = BIT_FIELD_REF <*D.32522, 8, 256>;
      D.32524 = D.32523 & 8;
      if (D.32524 != 0) goto <D.32525>; else goto <D.32526>;
      <D.32525>:
      D.32522 = m->klass;
      D.32527 = mono_class_instance_size (D.32522);
      D.32528 = (long unsigned int) D.32527;
      this_buf = __builtin_alloca (D.32528);
      goto <D.32529>;
      <D.32526>:
      this_buf = __builtin_alloca (8);
      <D.32529>:
      D.32522 = m->klass;
      D.32523 = BIT_FIELD_REF <*D.32522, 8, 256>;
      D.32524 = D.32523 & 8;
      if (D.32524 != 0) goto <D.32532>; else goto <D.32530>;
      <D.32532>:
      D.32533 = m->flags;
      D.32534 = (int) D.32533;
      D.32535 = D.32534 & 16;
      if (D.32535 != 0) goto <D.32536>; else goto <D.32530>;
      <D.32536>:
      {
        int type;

        p.382 = p;
        type = decode_byte (p.382, &p, end);
        if (type != 240) goto <D.32537>; else goto <D.32538>;
        <D.32537>:
        log_level.378 = log_level;
        D.32500 = log_level.378 > 0;
        D.32501 = (long int) D.32500;
        D.32502 = __builtin_expect (D.32501, 0);
        if (D.32502 != 0) goto <D.32539>; else goto <D.32540>;
        <D.32539>:
        D.32541 = GetCurrentThreadId ();
        D.32542 = (void *) D.32541;
        log_file.381 = log_file;
        fprintf (log_file.381, "[%p] Error: Static vtype method invoked with this argument.\n", D.32542);
        log_file.381 = log_file;
        fflush (log_file.381);
        <D.32540>:
        D.32521 = 102;
        return D.32521;
        <D.32538>:
        D.32522 = m->klass;
        D.32543 = mono_class_instance_size (D.32522);
        D.32544 = (long unsigned int) D.32543;
        memset (this_buf, 0, D.32544);
      }
      goto <D.32531>;
      <D.32530>:
      p.382 = p;
      domain.384 = domain;
      D.32522 = m->klass;
      D.32546 = &D.32522->byval_arg;
      D.32547 = decode_value (D.32546, domain.384, this_buf, p.382, &p, end);
      err.385 = (int) D.32547;
      err = err.385;
      err.383 = err;
      if (err.383 != 0) goto <D.32549>; else goto <D.32550>;
      <D.32549>:
      err.383 = err;
      D.32521 = (ErrorCode) err.383;
      return D.32521;
      <D.32550>:
      <D.32531>:
      D.32522 = m->klass;
      D.32523 = BIT_FIELD_REF <*D.32522, 8, 256>;
      D.32524 = D.32523 & 8;
      if (D.32524 == 0) goto <D.32551>; else goto <D.32552>;
      <D.32551>:
      this.386 = MEM[(struct MonoObject * *)this_buf];
      this = this.386;
      goto <D.32554>;
      <D.32552>:
      this = 0B;
      <D.32554>:
      D.32522 = m->klass;
      D.32557 = D.32522->flags;
      D.32558 = D.32557 & 32;
      if (D.32558 != 0) goto <D.32555>; else goto <D.32559>;
      <D.32559>:
      D.32522 = m->klass;
      D.32560 = D.32522->byval_arg.type;
      if (D.32560 == 19) goto <D.32555>; else goto <D.32561>;
      <D.32561>:
      D.32522 = m->klass;
      D.32560 = D.32522->byval_arg.type;
      if (D.32560 == 30) goto <D.32555>; else goto <D.32556>;
      <D.32555>:
      this.380 = this;
      if (this.380 == 0B) goto <D.32562>; else goto <D.32563>;
      <D.32562>:
      log_level.378 = log_level;
      D.32500 = log_level.378 > 0;
      D.32501 = (long int) D.32500;
      D.32502 = __builtin_expect (D.32501, 0);
      if (D.32502 != 0) goto <D.32564>; else goto <D.32565>;
      <D.32564>:
      D.32566 = GetCurrentThreadId ();
      D.32567 = (void *) D.32566;
      log_file.381 = log_file;
      fprintf (log_file.381, "[%p] Error: Interface method invoked without this argument.\n", D.32567);
      log_file.381 = log_file;
      fflush (log_file.381);
      <D.32565>:
      D.32521 = 102;
      return D.32521;
      <D.32563>:
      this.380 = this;
      m = mono_object_get_virtual_method (this.380, m);
      <D.32556>:
      log_level.378 = log_level;
      D.32500 = log_level.378 > 0;
      D.32501 = (long int) D.32500;
      D.32502 = __builtin_expect (D.32501, 0);
      if (D.32502 != 0) goto <D.32568>; else goto <D.32569>;
      <D.32568>:
      this.380 = this;
      if (this.380 != 0B) goto <D.32571>; else goto <D.32572>;
      <D.32571>:
      this.380 = this;
      D.32509 = this.380->vtable;
      D.32510 = D.32509->klass;
      iftmp.387 = D.32510->name;
      goto <D.32573>;
      <D.32572>:
      iftmp.387 = "<null>";
      <D.32573>:
      D.32574 = mono_method_full_name (m, 1);
      D.32575 = GetCurrentThreadId ();
      D.32576 = (void *) D.32575;
      log_file.381 = log_file;
      fprintf (log_file.381, "[%p] Invoking method \'%s\' on receiver \'%s\'.\n", D.32576, D.32574, iftmp.387);
      log_file.381 = log_file;
      fflush (log_file.381);
      <D.32569>:
      this.380 = this;
      if (this.380 != 0B) goto <D.32577>; else goto <D.32578>;
      <D.32577>:
      this.380 = this;
      D.32509 = this.380->vtable;
      D.32579 = D.32509->domain;
      domain.384 = domain;
      if (D.32579 != domain.384) goto <D.32580>; else goto <D.32581>;
      <D.32580>:
      monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "debugger-agent.c", 6285);
      <D.32581>:
      <D.32578>:
      D.32522 = m->klass;
      D.32523 = BIT_FIELD_REF <*D.32522, 8, 256>;
      D.32524 = D.32523 & 8;
      if (D.32524 == 0) goto <D.32582>; else goto <D.32583>;
      <D.32582>:
      D.32533 = m->flags;
      D.32534 = (int) D.32533;
      D.32535 = D.32534 & 16;
      if (D.32535 == 0) goto <D.32584>; else goto <D.32585>;
      <D.32584>:
      this.380 = this;
      if (this.380 == 0B) goto <D.32586>; else goto <D.32587>;
      <D.32586>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          __s2 = m->name;
          D.32591 = ".ctor";
          D.32592 = MEM[(const unsigned char *)D.32591];
          D.32593 = (int) D.32592;
          D.32594 = *__s2;
          D.32595 = (int) D.32594;
          __result = D.32593 - D.32595;
          {
            D.32596 = __s2_len != 0;
            D.32597 = __result == 0;
            D.32598 = D.32596 & D.32597;
            if (D.32598 != 0) goto <D.32599>; else goto <D.32600>;
            <D.32599>:
            D.32601 = &MEM[(void *)".ctor" + 1B];
            D.32602 = *D.32601;
            D.32603 = (int) D.32602;
            D.32604 = __s2 + 1;
            D.32605 = *D.32604;
            D.32606 = (int) D.32605;
            __result = D.32603 - D.32606;
            D.32607 = __s2_len > 1;
            D.32597 = __result == 0;
            D.32608 = D.32607 & D.32597;
            if (D.32608 != 0) goto <D.32609>; else goto <D.32610>;
            <D.32609>:
            D.32611 = &MEM[(void *)".ctor" + 2B];
            D.32612 = *D.32611;
            D.32613 = (int) D.32612;
            D.32614 = __s2 + 2;
            D.32615 = *D.32614;
            D.32616 = (int) D.32615;
            __result = D.32613 - D.32616;
            D.32617 = __s2_len > 2;
            D.32597 = __result == 0;
            D.32618 = D.32617 & D.32597;
            if (D.32618 != 0) goto <D.32619>; else goto <D.32620>;
            <D.32619>:
            D.32621 = &MEM[(void *)".ctor" + 3B];
            D.32622 = *D.32621;
            D.32623 = (int) D.32622;
            D.32624 = __s2 + 3;
            D.32625 = *D.32624;
            D.32626 = (int) D.32625;
            __result = D.32623 - D.32626;
            <D.32620>:
            <D.32610>:
            <D.32600>:
          }
          D.26960 = __result;
        }
        iftmp.388 = -D.26960;
        goto <D.32627>;
        <D.32590>:
        D.32628 = m->name;
        iftmp.388 = __builtin_strcmp (D.32628, ".ctor");
        <D.32627>:
        D.26961 = iftmp.388;
      }
      if (D.26961 == 0) goto <D.32629>; else goto <D.32630>;
      <D.32629>:
      D.32522 = m->klass;
      D.32557 = D.32522->flags;
      D.32631 = D.32557 & 128;
      if (D.32631 != 0) goto <D.32632>; else goto <D.32633>;
      <D.32632>:
      D.32521 = 102;
      return D.32521;
      <D.32633>:
      D.32522 = m->klass;
      domain.384 = domain;
      this.389 = mono_object_new (domain.384, D.32522);
      this = this.389;
      goto <D.32635>;
      <D.32630>:
      D.32521 = 102;
      return D.32521;
      <D.32635>:
      <D.32587>:
      <D.32585>:
      <D.32583>:
      this.380 = this;
      if (this.380 != 0B) goto <D.32636>; else goto <D.32637>;
      <D.32636>:
      D.32522 = m->klass;
      D.32546 = &D.32522->byval_arg;
      this.380 = this;
      D.32638 = obj_is_of_type (this.380, D.32546);
      if (D.32638 == 0) goto <D.32639>; else goto <D.32640>;
      <D.32639>:
      D.32521 = 102;
      return D.32521;
      <D.32640>:
      <D.32637>:
      p.382 = p;
      nargs = decode_int (p.382, &p, end);
      D.32641 = sig->param_count;
      D.32642 = (int) D.32641;
      if (D.32642 != nargs) goto <D.32643>; else goto <D.32644>;
      <D.32643>:
      D.32521 = 102;
      return D.32521;
      <D.32644>:
      D.32645 = (long unsigned int) nargs;
      D.32646 = D.32645 * 8;
      arg_buf = __builtin_alloca (D.32646);
      D.32645 = (long unsigned int) nargs;
      D.32646 = D.32645 * 8;
      memset (arg_buf, 0, D.32646);
      D.32645 = (long unsigned int) nargs;
      D.32646 = D.32645 * 8;
      args = __builtin_alloca (D.32646);
      i = 0;
      goto <D.26964>;
      <D.26963>:
      D.32647 = sig->params[i];
      D.32648 = mono_type_is_reference (D.32647);
      if (D.32648 != 0) goto <D.32649>; else goto <D.32650>;
      <D.32649>:
      p.382 = p;
      D.32651 = (long unsigned int) i;
      D.32652 = D.32651 * 8;
      D.32653 = args + D.32652;
      domain.384 = domain;
      D.32647 = sig->params[i];
      D.32654 = decode_value (D.32647, domain.384, D.32653, p.382, &p, end);
      err.390 = (int) D.32654;
      err = err.390;
      err.383 = err;
      if (err.383 != 0) goto <D.26962>; else goto <D.32656>;
      <D.32656>:
      D.32651 = (long unsigned int) i;
      D.32652 = D.32651 * 8;
      D.32657 = args + D.32652;
      D.32658 = *D.32657;
      if (D.32658 != 0B) goto <D.32659>; else goto <D.32660>;
      <D.32659>:
      D.32651 = (long unsigned int) i;
      D.32652 = D.32651 * 8;
      D.32657 = args + D.32652;
      D.32658 = *D.32657;
      D.32661 = MEM[(struct MonoObject *)D.32658].vtable;
      D.32662 = D.32661->domain;
      domain.384 = domain;
      if (D.32662 != domain.384) goto <D.32663>; else goto <D.32664>;
      <D.32663>:
      monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "debugger-agent.c", 6315);
      <D.32664>:
      <D.32660>:
      goto <D.32665>;
      <D.32650>:
      D.32651 = (long unsigned int) i;
      D.32652 = D.32651 * 8;
      D.32666 = arg_buf + D.32652;
      D.32647 = sig->params[i];
      D.32667 = mono_class_from_mono_type (D.32647);
      D.32668 = mono_class_instance_size (D.32667);
      D.32669 = (long unsigned int) D.32668;
      D.32670 = __builtin_alloca (D.32669);
      *D.32666 = D.32670;
      p.382 = p;
      D.32651 = (long unsigned int) i;
      D.32652 = D.32651 * 8;
      D.32666 = arg_buf + D.32652;
      D.32671 = *D.32666;
      domain.384 = domain;
      D.32647 = sig->params[i];
      D.32672 = decode_value (D.32647, domain.384, D.32671, p.382, &p, end);
      err.391 = (int) D.32672;
      err = err.391;
      err.383 = err;
      if (err.383 != 0) goto <D.26962>; else goto <D.32674>;
      <D.32674>:
      D.32651 = (long unsigned int) i;
      D.32652 = D.32651 * 8;
      D.32657 = args + D.32652;
      D.32651 = (long unsigned int) i;
      D.32652 = D.32651 * 8;
      D.32666 = arg_buf + D.32652;
      D.32671 = *D.32666;
      *D.32657 = D.32671;
      <D.32665>:
      i = i + 1;
      <D.26964>:
      if (i < nargs) goto <D.26963>; else goto <D.26962>;
      <D.26962>:
      if (i < nargs) goto <D.32675>; else goto <D.32676>;
      <D.32675>:
      err.383 = err;
      D.32521 = (ErrorCode) err.383;
      return D.32521;
      <D.32676>:
      D.32677 = invoke->flags;
      D.32678 = D.32677 & 1;
      if (D.32678 != 0) goto <D.32679>; else goto <D.32680>;
      <D.32679>:
      tls->disable_breakpoints = 1;
      goto <D.32681>;
      <D.32680>:
      tls->disable_breakpoints = 0;
      <D.32681>:
      D.32682 = invoke->has_ctx;
      if (D.32682 != 0) goto <D.32683>; else goto <D.32684>;
      <D.32683>:
      {
        struct MonoLMF * * lmf_addr;

        lmf_addr = mono_get_lmf_addr ();
        memset (&ext, 0, 216);
        D.32685 = *lmf_addr;
        mono_arch_init_lmf_ext (&ext, D.32685);
        ext.debugger_invoke = 1;
        D.32686 = &invoke->ctx;
        memcpy (&ext.ctx, D.32686, 136);
        mono_set_lmf (&ext);
      }
      <D.32684>:
      mono_stopwatch_start (&watch);
      D.32522 = m->klass;
      D.32523 = BIT_FIELD_REF <*D.32522, 8, 256>;
      D.32524 = D.32523 & 8;
      if (D.32524 != 0) goto <D.32687>; else goto <D.32688>;
      <D.32687>:
      res.392 = mono_runtime_invoke (m, this_buf, args, &exc);
      res = res.392;
      goto <D.32690>;
      <D.32688>:
      this.380 = this;
      res.393 = mono_runtime_invoke (m, this.380, args, &exc);
      res = res.393;
      <D.32690>:
      mono_stopwatch_stop (&watch);
      log_level.378 = log_level;
      D.32500 = log_level.378 > 0;
      D.32501 = (long int) D.32500;
      D.32502 = __builtin_expect (D.32501, 0);
      if (D.32502 != 0) goto <D.32692>; else goto <D.32693>;
      <D.32692>:
      D.32694 = mono_stopwatch_elapsed_ms (&watch);
      D.32695 = (long int) D.32694;
      exc.395 = exc;
      if (exc.395 != 0B) goto <D.32698>; else goto <D.32699>;
      <D.32698>:
      exc.395 = exc;
      D.32700 = exc.395->vtable;
      D.32701 = D.32700->klass;
      iftmp.394 = D.32701->name;
      goto <D.32702>;
      <D.32699>:
      iftmp.394 = 0B;
      <D.32702>:
      res.396 = res;
      D.32704 = GetCurrentThreadId ();
      D.32705 = (void *) D.32704;
      log_file.381 = log_file;
      fprintf (log_file.381, "[%p] Invoke result: %p, exc: %s, time: %ld ms.\n", D.32705, res.396, iftmp.394, D.32695);
      log_file.381 = log_file;
      fflush (log_file.381);
      <D.32693>:
      exc.395 = exc;
      if (exc.395 != 0B) goto <D.32706>; else goto <D.32707>;
      <D.32706>:
      buffer_add_byte (buf, 0);
      domain.384 = domain;
      D.32708 = mono_defaults.object_class;
      D.32709 = &D.32708->byval_arg;
      buffer_add_value (buf, D.32709, &exc, domain.384);
      goto <D.32710>;
      <D.32707>:
      buffer_add_byte (buf, 1);
      D.32711 = sig->ret;
      D.32712 = D.32711->type;
      if (D.32712 == 1) goto <D.32713>; else goto <D.32714>;
      <D.32713>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          __s2 = m->name;
          D.32591 = ".ctor";
          D.32592 = MEM[(const unsigned char *)D.32591];
          D.32593 = (int) D.32592;
          D.32720 = *__s2;
          D.32721 = (int) D.32720;
          __result = D.32593 - D.32721;
          {
            D.32722 = __s2_len != 0;
            D.32723 = __result == 0;
            D.32724 = D.32722 & D.32723;
            if (D.32724 != 0) goto <D.32725>; else goto <D.32726>;
            <D.32725>:
            D.32601 = &MEM[(void *)".ctor" + 1B];
            D.32602 = *D.32601;
            D.32603 = (int) D.32602;
            D.32727 = __s2 + 1;
            D.32728 = *D.32727;
            D.32729 = (int) D.32728;
            __result = D.32603 - D.32729;
            D.32730 = __s2_len > 1;
            D.32723 = __result == 0;
            D.32731 = D.32730 & D.32723;
            if (D.32731 != 0) goto <D.32732>; else goto <D.32733>;
            <D.32732>:
            D.32611 = &MEM[(void *)".ctor" + 2B];
            D.32612 = *D.32611;
            D.32613 = (int) D.32612;
            D.32734 = __s2 + 2;
            D.32735 = *D.32734;
            D.32736 = (int) D.32735;
            __result = D.32613 - D.32736;
            D.32737 = __s2_len > 2;
            D.32723 = __result == 0;
            D.32738 = D.32737 & D.32723;
            if (D.32738 != 0) goto <D.32739>; else goto <D.32740>;
            <D.32739>:
            D.32621 = &MEM[(void *)".ctor" + 3B];
            D.32622 = *D.32621;
            D.32623 = (int) D.32622;
            D.32741 = __s2 + 3;
            D.32742 = *D.32741;
            D.32743 = (int) D.32742;
            __result = D.32623 - D.32743;
            <D.32740>:
            <D.32733>:
            <D.32726>:
          }
          D.26973 = __result;
        }
        iftmp.397 = -D.26973;
        goto <D.32744>;
        <D.32719>:
        D.32628 = m->name;
        iftmp.397 = __builtin_strcmp (D.32628, ".ctor");
        <D.32744>:
        D.26974 = iftmp.397;
      }
      if (D.26974 == 0) goto <D.32745>; else goto <D.32715>;
      <D.32745>:
      D.32522 = m->klass;
      D.32523 = BIT_FIELD_REF <*D.32522, 8, 256>;
      D.32524 = D.32523 & 8;
      if (D.32524 == 0) goto <D.32746>; else goto <D.32715>;
      <D.32746>:
      domain.384 = domain;
      D.32708 = mono_defaults.object_class;
      D.32709 = &D.32708->byval_arg;
      buffer_add_value (buf, D.32709, &this, domain.384);
      goto <D.32716>;
      <D.32715>:
      domain.384 = domain;
      D.32747 = mono_defaults.void_class;
      D.32748 = &D.32747->byval_arg;
      buffer_add_value (buf, D.32748, 0B, domain.384);
      <D.32716>:
      goto <D.32749>;
      <D.32714>:
      D.32711 = sig->ret;
      D.32750 = mono_type_is_reference (D.32711);
      if (D.32750 != 0) goto <D.32751>; else goto <D.32752>;
      <D.32751>:
      domain.384 = domain;
      D.32711 = sig->ret;
      buffer_add_value (buf, D.32711, &res, domain.384);
      goto <D.32753>;
      <D.32752>:
      D.32711 = sig->ret;
      D.32757 = mono_class_from_mono_type (D.32711);
      D.32758 = BIT_FIELD_REF <*D.32757, 8, 256>;
      D.32759 = D.32758 & 8;
      if (D.32759 != 0) goto <D.32754>; else goto <D.32760>;
      <D.32760>:
      D.32711 = sig->ret;
      D.32712 = D.32711->type;
      if (D.32712 == 15) goto <D.32754>; else goto <D.32761>;
      <D.32761>:
      D.32711 = sig->ret;
      D.32712 = D.32711->type;
      if (D.32712 == 27) goto <D.32754>; else goto <D.32755>;
      <D.32754>:
      D.32711 = sig->ret;
      D.32762 = mono_class_from_mono_type (D.32711);
      D.32763 = mono_class_is_nullable (D.32762);
      if (D.32763 != 0) goto <D.32764>; else goto <D.32765>;
      <D.32764>:
      {
        struct MonoClass * k;
        guint8 * nullable_buf;

        D.32711 = sig->ret;
        k = mono_class_from_mono_type (D.32711);
        D.32766 = mono_class_value_size (k, 0B);
        D.32767 = (long unsigned int) D.32766;
        nullable_buf = __builtin_alloca (D.32767);
        D.32768 = nullable_buf == 0B;
        D.32769 = (long int) D.32768;
        D.32770 = __builtin_expect (D.32769, 0);
        if (D.32770 != 0) goto <D.32771>; else goto <D.32772>;
        <D.32771>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 6379, "nullable_buf");
        <D.32772>:
        res.396 = res;
        mono_nullable_init (nullable_buf, res.396, k);
        domain.384 = domain;
        D.32711 = sig->ret;
        buffer_add_value (buf, D.32711, nullable_buf, domain.384);
      }
      goto <D.32773>;
      <D.32765>:
      res.396 = res;
      D.32774 = res.396 == 0B;
      D.32775 = (long int) D.32774;
      D.32776 = __builtin_expect (D.32775, 0);
      if (D.32776 != 0) goto <D.32777>; else goto <D.32778>;
      <D.32777>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 6383, "res");
      <D.32778>:
      domain.384 = domain;
      res.396 = res;
      D.32779 = mono_object_unbox (res.396);
      D.32711 = sig->ret;
      buffer_add_value (buf, D.32711, D.32779, domain.384);
      <D.32773>:
      goto <D.32756>;
      <D.32755>:
      monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "debugger-agent.c", 6387);
      <D.32756>:
      <D.32753>:
      <D.32749>:
      <D.32710>:
      tls->disable_breakpoints = 0;
      D.32682 = invoke->has_ctx;
      if (D.32682 != 0) goto <D.32780>; else goto <D.32781>;
      <D.32780>:
      D.32782 = ext.lmf.previous_lmf;
      D.32783 = (long int) D.32782;
      D.32784 = D.32783 & -4;
      D.32785 = (struct MonoLMF *) D.32784;
      mono_set_lmf (D.32785);
      <D.32781>:
      p.382 = p;
      *endp = p.382;
      D.32521 = 0;
      return D.32521;
    }
  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.32790;
  int D.32795;
  void * D.32797;
  long unsigned int D.32798;

  D.32790 = __builtin_constant_p (__len);
  if (D.32790 != 0) goto <D.32791>; else goto <D.32792>;
  <D.32791>:
  if (__len == 0) goto <D.32793>; else goto <D.32794>;
  <D.32793>:
  D.32795 = __builtin_constant_p (__ch);
  if (D.32795 == 0) goto <D.32788>; else goto <D.32796>;
  <D.32796>:
  if (__ch != 0) goto <D.32788>; else goto <D.32789>;
  <D.32788>:
  __warn_memset_zero_len ();
  D.32797 = __dest;
  return D.32797;
  <D.32789>:
  <D.32794>:
  <D.32792>:
  D.32798 = __builtin_object_size (__dest, 0);
  D.32797 = __builtin___memset_chk (__dest, __ch, __len, D.32798);
  return D.32797;
}


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

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


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

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


mono_stopwatch_elapsed_ms (struct MonoStopwatch * w)
{
  guint64 D.32802;
  long unsigned int D.32803;
  long unsigned int D.32804;

  D.32803 = mono_stopwatch_elapsed (w);
  D.32804 = D.32803 + 500;
  D.32802 = D.32804 / 1000;
  return D.32802;
}


mono_stopwatch_elapsed (struct MonoStopwatch * w)
{
  guint64 D.32806;
  long int D.32807;
  long int D.32808;
  long int D.32809;
  long int D.32810;

  D.32807 = w->stop;
  D.32808 = w->start;
  D.32809 = D.32807 - D.32808;
  D.32810 = D.32809 / 10;
  D.32806 = (guint64) D.32810;
  return D.32806;
}


send_type_load (struct MonoClass * klass)
{
  union mono_mutex_t * D.32812;
  _Bool D.32815;
  long int D.32816;
  long int D.32817;
  struct GHashTable * D.32820;
  void * D.32821;
  _Bool D.32826;
  long int D.32827;
  long int D.32828;
  gboolean type_load;
  struct MonoDomain * domain;
  struct AgentDomainInfo * info;

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

    D.32812 = &domain->lock.mutex;
    ret = pthread_mutex_lock (D.32812);
    if (ret != 0) goto <D.32813>; else goto <D.32814>;
    <D.32813>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.32814>:
    D.32815 = ret != 0;
    D.32816 = (long int) D.32815;
    D.32817 = __builtin_expect (D.32816, 0);
    if (D.32817 != 0) goto <D.32818>; else goto <D.32819>;
    <D.32818>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 3983, "ret == 0");
    <D.32819>:
  }
  info = get_agent_domain_info (domain);
  D.32820 = info->loaded_classes;
  D.32821 = monoeg_g_hash_table_lookup (D.32820, klass);
  if (D.32821 == 0B) goto <D.32822>; else goto <D.32823>;
  <D.32822>:
  type_load = 1;
  D.32820 = info->loaded_classes;
  monoeg_g_hash_table_insert_replace (D.32820, klass, klass, 0);
  <D.32823>:
  {
    int ret;

    D.32812 = &domain->lock.mutex;
    ret = pthread_mutex_unlock (D.32812);
    if (ret != 0) goto <D.32824>; else goto <D.32825>;
    <D.32824>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.32825>:
    D.32826 = ret != 0;
    D.32827 = (long int) D.32826;
    D.32828 = __builtin_expect (D.32827, 0);
    if (D.32828 != 0) goto <D.32829>; else goto <D.32830>;
    <D.32829>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 3992, "ret == 0");
    <D.32830>:
  }
  mono_loader_unlock ();
  if (type_load != 0) goto <D.32831>; else goto <D.32832>;
  <D.32831>:
  emit_type_load (klass, klass, 0B);
  <D.32832>:
}


add_pending_breakpoints (struct MonoMethod * method, struct MonoJitInfo * ji)
{
  struct GPtrArray * breakpoints.398;
  void * * D.32836;
  long unsigned int D.32837;
  long unsigned int D.32838;
  void * * D.32839;
  int D.32840;
  struct GPtrArray * D.32843;
  void * * D.32844;
  long unsigned int D.32845;
  long unsigned int D.32846;
  void * * D.32847;
  struct MonoJitInfo * D.32848;
  unsigned int j.399;
  unsigned int D.32852;
  union mono_mutex_t * D.32855;
  _Bool D.32858;
  long int D.32859;
  long int D.32860;
  void * D.32863;
  struct GHashTable * D.32864;
  unsigned char D.32867;
  unsigned char D.32868;
  struct MonoMethod * D.32871;
  _Bool D.32874;
  long int D.32875;
  long int D.32876;
  _Bool D.32881;
  long int D.32882;
  long int D.32883;
  unsigned int i.400;
  unsigned int D.32887;
  int i;
  int j;
  struct MonoSeqPointInfo * seq_points;
  struct MonoDomain * domain;
  struct MonoMethod * jmethod;

  breakpoints.398 = breakpoints;
  if (breakpoints.398 == 0B) goto <D.32834>; else goto <D.32835>;
  <D.32834>:
  return;
  <D.32835>:
  domain = mono_domain_get ();
  mono_loader_lock ();
  i = 0;
  goto <D.26290>;
  <D.26289>:
  {
    struct MonoBreakpoint * bp;
    gboolean found;

    breakpoints.398 = breakpoints;
    D.32836 = breakpoints.398->pdata;
    D.32837 = (long unsigned int) i;
    D.32838 = D.32837 * 8;
    D.32839 = D.32836 + D.32838;
    bp = *D.32839;
    found = 0;
    D.32840 = bp_matches_method (bp, method);
    if (D.32840 == 0) goto <D.32841>; else goto <D.32842>;
    <D.32841>:
    // predicted unlikely by continue predictor.
    goto <D.26282>;
    <D.32842>:
    j = 0;
    goto <D.26285>;
    <D.26284>:
    {
      struct BreakpointInstance * inst;

      D.32843 = bp->children;
      D.32844 = D.32843->pdata;
      D.32845 = (long unsigned int) j;
      D.32846 = D.32845 * 8;
      D.32847 = D.32844 + D.32846;
      inst = *D.32847;
      D.32848 = inst->ji;
      if (D.32848 == ji) goto <D.32849>; else goto <D.32850>;
      <D.32849>:
      found = 1;
      <D.32850>:
    }
    j = j + 1;
    <D.26285>:
    j.399 = (unsigned int) j;
    D.32843 = bp->children;
    D.32852 = D.32843->len;
    if (j.399 < D.32852) goto <D.26284>; else goto <D.26286>;
    <D.26286>:
    if (found == 0) goto <D.32853>; else goto <D.32854>;
    <D.32853>:
    jmethod = jinfo_get_method (ji);
    {
      int ret;

      D.32855 = &domain->lock.mutex;
      ret = pthread_mutex_lock (D.32855);
      if (ret != 0) goto <D.32856>; else goto <D.32857>;
      <D.32856>:
      monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
      <D.32857>:
      D.32858 = ret != 0;
      D.32859 = (long int) D.32858;
      D.32860 = __builtin_expect (D.32859, 0);
      if (D.32860 != 0) goto <D.32861>; else goto <D.32862>;
      <D.32861>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 4271, "ret == 0");
      <D.32862>:
    }
    D.32863 = domain->runtime_info;
    D.32864 = MEM[(struct MonoJitDomainInfo *)D.32863].seq_points;
    seq_points = monoeg_g_hash_table_lookup (D.32864, jmethod);
    if (seq_points == 0B) goto <D.32865>; else goto <D.32866>;
    <D.32865>:
    D.32867 = BIT_FIELD_REF <*jmethod, 8, 264>;
    D.32868 = D.32867 & 16;
    if (D.32868 != 0) goto <D.32869>; else goto <D.32870>;
    <D.32869>:
    D.32871 = mono_method_get_declaring_generic_method (jmethod);
    D.32863 = domain->runtime_info;
    D.32864 = MEM[(struct MonoJitDomainInfo *)D.32863].seq_points;
    seq_points = monoeg_g_hash_table_lookup (D.32864, D.32871);
    <D.32870>:
    <D.32866>:
    {
      int ret;

      D.32855 = &domain->lock.mutex;
      ret = pthread_mutex_unlock (D.32855);
      if (ret != 0) goto <D.32872>; else goto <D.32873>;
      <D.32872>:
      monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
      <D.32873>:
      D.32874 = ret != 0;
      D.32875 = (long int) D.32874;
      D.32876 = __builtin_expect (D.32875, 0);
      if (D.32876 != 0) goto <D.32877>; else goto <D.32878>;
      <D.32877>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 4275, "ret == 0");
      <D.32878>:
    }
    if (seq_points == 0B) goto <D.32879>; else goto <D.32880>;
    <D.32879>:
    // predicted unlikely by continue predictor.
    goto <D.26282>;
    <D.32880>:
    D.32881 = seq_points == 0B;
    D.32882 = (long int) D.32881;
    D.32883 = __builtin_expect (D.32882, 0);
    if (D.32883 != 0) goto <D.32884>; else goto <D.32885>;
    <D.32884>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 4279, "seq_points");
    <D.32885>:
    insert_breakpoint (seq_points, domain, ji, bp, 0B);
    <D.32854>:
  }
  <D.26282>:
  i = i + 1;
  <D.26290>:
  i.400 = (unsigned int) i;
  breakpoints.398 = breakpoints;
  D.32887 = breakpoints.398->len;
  if (i.400 < D.32887) goto <D.26289>; else goto <D.26291>;
  <D.26291>:
  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.401;
  void * * D.32890;
  long unsigned int D.32891;
  long unsigned int D.32892;
  void * * D.32893;
  int D.32894;
  int D.32897;
  int D.32898;
  unsigned int i.402;
  unsigned int D.32900;
  int i;
  gboolean found;

  mono_loader_lock ();
  found = 1;
  goto <D.26911>;
  <D.26910>:
  found = 0;
  i = 0;
  goto <D.26909>;
  <D.26908>:
  {
    struct EventRequest * req;

    event_requests.401 = event_requests;
    D.32890 = event_requests.401->pdata;
    D.32891 = (long unsigned int) i;
    D.32892 = D.32891 * 8;
    D.32893 = D.32890 + D.32892;
    req = *D.32893;
    D.32894 = event_req_matches_assembly (req, assembly);
    if (D.32894 != 0) goto <D.32895>; else goto <D.32896>;
    <D.32895>:
    D.32897 = req->event_kind;
    D.32898 = req->id;
    clear_event_request (D.32898, D.32897);
    found = 1;
    goto <D.26907>;
    <D.32896>:
  }
  i = i + 1;
  <D.26909>:
  i.402 = (unsigned int) i;
  event_requests.401 = event_requests;
  D.32900 = event_requests.401->len;
  if (i.402 < D.32900) goto <D.26908>; else goto <D.26907>;
  <D.26907>:
  <D.26911>:
  if (found != 0) goto <D.26910>; else goto <D.26912>;
  <D.26912>:
  mono_loader_unlock ();
}


event_req_matches_assembly (struct EventRequest * req, struct MonoAssembly * assembly)
{
  int D.32901;
  gboolean D.32904;
  void * D.32905;
  <unnamed type> D.32906;
  struct MonoClass * D.32909;
  struct MonoImage * D.32912;
  struct MonoAssembly * D.32913;
  struct MonoAssembly * * D.32918;
  long unsigned int D.32921;
  long unsigned int D.32922;
  struct MonoAssembly * * D.32923;
  struct MonoAssembly * D.32924;
  int D.32927;

  D.32901 = req->event_kind;
  if (D.32901 == 10) goto <D.32902>; else goto <D.32903>;
  <D.32902>:
  D.32905 = req->info;
  D.32904 = breakpoint_matches_assembly (D.32905, assembly);
  return D.32904;
  <D.32903>:
  {
    int i;
    int j;

    i = 0;
    goto <D.26899>;
    <D.26898>:
    {
      struct Modifier * m;

      m = &req->modifiers[i];
      D.32906 = m->kind;
      if (D.32906 == 8) goto <D.32907>; else goto <D.32908>;
      <D.32907>:
      D.32909 = m->data.exc_class;
      if (D.32909 != 0B) goto <D.32910>; else goto <D.32911>;
      <D.32910>:
      D.32909 = m->data.exc_class;
      D.32912 = D.32909->image;
      D.32913 = D.32912->assembly;
      if (D.32913 == assembly) goto <D.32914>; else goto <D.32915>;
      <D.32914>:
      D.32904 = 1;
      return D.32904;
      <D.32915>:
      <D.32911>:
      <D.32908>:
      D.32906 = m->kind;
      if (D.32906 == 11) goto <D.32916>; else goto <D.32917>;
      <D.32916>:
      D.32918 = m->data.assemblies;
      if (D.32918 != 0B) goto <D.32919>; else goto <D.32920>;
      <D.32919>:
      j = 0;
      goto <D.26896>;
      <D.26895>:
      D.32918 = m->data.assemblies;
      D.32921 = (long unsigned int) j;
      D.32922 = D.32921 * 8;
      D.32923 = D.32918 + D.32922;
      D.32924 = *D.32923;
      if (D.32924 == assembly) goto <D.32925>; else goto <D.32926>;
      <D.32925>:
      D.32904 = 1;
      return D.32904;
      <D.32926>:
      j = j + 1;
      <D.26896>:
      D.32918 = m->data.assemblies;
      D.32921 = (long unsigned int) j;
      D.32922 = D.32921 * 8;
      D.32923 = D.32918 + D.32922;
      D.32924 = *D.32923;
      if (D.32924 != 0B) goto <D.26895>; else goto <D.26897>;
      <D.26897>:
      <D.32920>:
      <D.32917>:
    }
    i = i + 1;
    <D.26899>:
    D.32927 = req->nmodifiers;
    if (D.32927 > i) goto <D.26898>; else goto <D.26900>;
    <D.26900>:
  }
  D.32904 = 0;
  return D.32904;
}


breakpoint_matches_assembly (struct MonoBreakpoint * bp, struct MonoAssembly * assembly)
{
  gboolean D.32929;
  int iftmp.403;
  struct MonoMethod * D.32933;
  struct MonoClass * D.32935;
  struct MonoImage * D.32936;
  struct MonoAssembly * D.32937;

  D.32933 = bp->method;
  if (D.32933 != 0B) goto <D.32934>; else goto <D.32931>;
  <D.32934>:
  D.32933 = bp->method;
  D.32935 = D.32933->klass;
  D.32936 = D.32935->image;
  D.32937 = D.32936->assembly;
  if (D.32937 == assembly) goto <D.32938>; else goto <D.32931>;
  <D.32938>:
  iftmp.403 = 1;
  goto <D.32932>;
  <D.32931>:
  iftmp.403 = 0;
  <D.32932>:
  D.32929 = iftmp.403;
  return D.32929;
}


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

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


type_comes_from_assembly (void * klass, void * also_klass, void * assembly)
{
  gboolean D.32941;
  struct MonoImage * D.32942;
  struct MonoImage * D.32943;
  _Bool D.32944;

  D.32942 = mono_class_get_image (klass);
  D.32943 = mono_assembly_get_image (assembly);
  D.32944 = D.32942 == D.32943;
  D.32941 = (gboolean) D.32944;
  return D.32941;
}


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

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


thread_end (struct MonoProfiler * prof, uintptr_t tid)
{
  const void * tid.405;
  struct MonoGHashTable * tid_to_thread.406;
  struct MonoGHashTable * tid_to_thread_obj.407;
  struct MonoGHashTable * thread_to_tls.408;
  struct MonoInternalThread * * D.32955;
  int log_level.409;
  _Bool D.32959;
  long int D.32960;
  long int D.32961;
  void * tid.410;
  struct FILE * log_file.411;
  struct MonoInternalThread * thread;
  struct DebuggerTlsData * tls;

  tls = 0B;
  mono_loader_lock ();
  tid.405 = (const void *) tid;
  tid_to_thread.406 = tid_to_thread;
  thread = mono_g_hash_table_lookup (tid_to_thread.406, tid.405);
  if (thread != 0B) goto <D.32949>; else goto <D.32950>;
  <D.32949>:
  tid.405 = (const void *) tid;
  tid_to_thread_obj.407 = tid_to_thread_obj;
  mono_g_hash_table_remove (tid_to_thread_obj.407, tid.405);
  thread_to_tls.408 = thread_to_tls;
  tls = mono_g_hash_table_lookup (thread_to_tls.408, thread);
  if (tls != 0B) goto <D.32953>; else goto <D.32954>;
  <D.32953>:
  tls->terminated = 1;
  D.32955 = &tls->thread;
  mono_gc_deregister_root (D.32955);
  tls->thread = 0B;
  <D.32954>:
  <D.32950>:
  mono_loader_unlock ();
  if (thread != 0B) goto <D.32956>; else goto <D.32957>;
  <D.32956>:
  log_level.409 = log_level;
  D.32959 = log_level.409 > 0;
  D.32960 = (long int) D.32959;
  D.32961 = __builtin_expect (D.32960, 0);
  if (D.32961 != 0) goto <D.32962>; else goto <D.32963>;
  <D.32962>:
  tid.410 = (void *) tid;
  log_file.411 = log_file;
  fprintf (log_file.411, "[%p] Thread terminated, obj=%p, tls=%p.\n", tid.410, thread, tls);
  log_file.411 = log_file;
  fflush (log_file.411);
  <D.32963>:
  process_profiler_event (3, thread);
  <D.32957>:
}


thread_startup (struct MonoProfiler * prof, uintptr_t tid)
{
  long unsigned int debugger_thread_id.412;
  long unsigned int D.32969;
  _Bool D.32970;
  long int D.32971;
  long int D.32972;
  const void * tid.413;
  struct MonoGHashTable * tid_to_thread.414;
  int log_level.415;
  _Bool D.32982;
  long int D.32983;
  long int D.32984;
  void * tid.416;
  struct FILE * log_file.417;
  struct MonoGHashTable * thread_to_tls.418;
  struct MonoGHashTable * tid_to_thread_obj.419;
  unsigned int debugger_tls_id.420;
  _Bool D.32994;
  long int D.32995;
  long int D.32996;
  void * D.33001;
  struct MonoInternalThread * * D.33002;
  struct MonoThread * D.33005;
  struct MonoInternalThread * thread;
  struct MonoInternalThread * old_thread;
  struct DebuggerTlsData * tls;

  thread = mono_thread_internal_current ();
  debugger_thread_id.412 = debugger_thread_id;
  if (tid == debugger_thread_id.412) goto <D.32967>; else goto <D.32968>;
  <D.32967>:
  return;
  <D.32968>:
  D.32969 = thread->tid;
  D.32970 = D.32969 != tid;
  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>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 3789, "thread->tid == tid");
  <D.32974>:
  mono_loader_lock ();
  tid.413 = (const void *) tid;
  tid_to_thread.414 = tid_to_thread;
  old_thread = mono_g_hash_table_lookup (tid_to_thread.414, tid.413);
  mono_loader_unlock ();
  if (old_thread != 0B) goto <D.32977>; else goto <D.32978>;
  <D.32977>:
  if (thread == old_thread) goto <D.32979>; else goto <D.32980>;
  <D.32979>:
  log_level.415 = log_level;
  D.32982 = log_level.415 > 0;
  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>:
  tid.416 = (void *) tid;
  tid.416 = (void *) tid;
  log_file.417 = log_file;
  fprintf (log_file.417, "[%p] thread_start () called multiple times for %p, ignored.\n", tid.416, tid.416);
  log_file.417 = log_file;
  fflush (log_file.417);
  <D.32986>:
  return;
  <D.32980>:
  log_level.415 = log_level;
  D.32982 = log_level.415 > 0;
  D.32983 = (long int) D.32982;
  D.32984 = __builtin_expect (D.32983, 0);
  if (D.32984 != 0) goto <D.32989>; else goto <D.32990>;
  <D.32989>:
  tid.416 = (void *) tid;
  tid.416 = (void *) tid;
  log_file.417 = log_file;
  fprintf (log_file.417, "[%p] Removing stale data for tid %p.\n", tid.416, tid.416);
  log_file.417 = log_file;
  fflush (log_file.417);
  <D.32990>:
  mono_loader_lock ();
  thread_to_tls.418 = thread_to_tls;
  mono_g_hash_table_remove (thread_to_tls.418, old_thread);
  tid.413 = (const void *) tid;
  tid_to_thread.414 = tid_to_thread;
  mono_g_hash_table_remove (tid_to_thread.414, tid.413);
  tid.413 = (const void *) tid;
  tid_to_thread_obj.419 = tid_to_thread_obj;
  mono_g_hash_table_remove (tid_to_thread_obj.419, tid.413);
  mono_loader_unlock ();
  <D.32978>:
  debugger_tls_id.420 = debugger_tls_id;
  tls = pthread_getspecific (debugger_tls_id.420);
  D.32994 = tls != 0B;
  D.32995 = (long int) D.32994;
  D.32996 = __builtin_expect (D.32995, 0);
  if (D.32996 != 0) goto <D.32997>; else goto <D.32998>;
  <D.32997>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 3817, "!tls");
  <D.32998>:
  tls = monoeg_malloc0 (1128);
  if (0 != 0) goto <D.32999>; else goto <D.33000>;
  <D.32999>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 3820, "sizeof (tls->thread) == sizeof (MonoObject*)");
  <D.33000>:
  D.33001 = mono_gc_make_root_descr_all_refs (1);
  D.33002 = &tls->thread;
  mono_gc_register_root (D.33002, 8, D.33001);
  tls->thread = thread;
  debugger_tls_id.420 = debugger_tls_id;
  mono_native_tls_set_value (debugger_tls_id.420, tls);
  log_level.415 = log_level;
  D.32982 = log_level.415 > 0;
  D.32983 = (long int) D.32982;
  D.32984 = __builtin_expect (D.32983, 0);
  if (D.32984 != 0) goto <D.33003>; else goto <D.33004>;
  <D.33003>:
  tid.416 = (void *) tid;
  log_file.417 = log_file;
  fprintf (log_file.417, "[%p] Thread started, obj=%p, tls=%p.\n", tid.416, thread, tls);
  log_file.417 = log_file;
  fflush (log_file.417);
  <D.33004>:
  mono_loader_lock ();
  thread_to_tls.418 = thread_to_tls;
  mono_g_hash_table_insert (thread_to_tls.418, thread, tls);
  tid.416 = (void *) tid;
  tid_to_thread.414 = tid_to_thread;
  mono_g_hash_table_insert (tid_to_thread.414, tid.416, thread);
  D.33005 = mono_thread_current ();
  tid.416 = (void *) tid;
  tid_to_thread_obj.419 = tid_to_thread_obj;
  mono_g_hash_table_insert (tid_to_thread_obj.419, tid.416, D.33005);
  mono_loader_unlock ();
  process_profiler_event (2, thread);
  suspend_current ();
}


mono_native_tls_set_value (pthread_key_t key, void * value)
{
  int D.33007;
  int D.33008;
  _Bool D.33009;

  D.33008 = pthread_setspecific (key, value);
  D.33009 = D.33008 == 0;
  D.33007 = (int) D.33009;
  return D.33007;
}


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

  clear_breakpoints_for_domain (domain);
  mono_loader_lock ();
  thread_to_tls.421 = thread_to_tls;
  mono_g_hash_table_foreach (thread_to_tls.421, 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.422;
  void * * D.33015;
  long unsigned int D.33016;
  long unsigned int D.33017;
  void * * D.33018;
  struct GPtrArray * D.33019;
  void * * D.33020;
  long unsigned int D.33021;
  long unsigned int D.33022;
  void * * D.33023;
  struct MonoDomain * D.33024;
  unsigned int j.423;
  unsigned int D.33029;
  unsigned int i.424;
  unsigned int D.33031;
  int i;
  int j;

  breakpoints.422 = breakpoints;
  if (breakpoints.422 == 0B) goto <D.33013>; else goto <D.33014>;
  <D.33013>:
  return;
  <D.33014>:
  mono_loader_lock ();
  i = 0;
  goto <D.26353>;
  <D.26352>:
  {
    struct MonoBreakpoint * bp;

    breakpoints.422 = breakpoints;
    D.33015 = breakpoints.422->pdata;
    D.33016 = (long unsigned int) i;
    D.33017 = D.33016 * 8;
    D.33018 = D.33015 + D.33017;
    bp = *D.33018;
    j = 0;
    goto <D.26350>;
    <D.26349>:
    {
      struct BreakpointInstance * inst;

      D.33019 = bp->children;
      D.33020 = D.33019->pdata;
      D.33021 = (long unsigned int) j;
      D.33022 = D.33021 * 8;
      D.33023 = D.33020 + D.33022;
      inst = *D.33023;
      D.33024 = inst->domain;
      if (D.33024 == domain) goto <D.33025>; else goto <D.33026>;
      <D.33025>:
      remove_breakpoint (inst);
      monoeg_g_free (inst);
      j.423 = (unsigned int) j;
      D.33019 = bp->children;
      monoeg_g_ptr_array_remove_index_fast (D.33019, j.423);
      goto <D.33028>;
      <D.33026>:
      j = j + 1;
      <D.33028>:
    }
    <D.26350>:
    j.423 = (unsigned int) j;
    D.33019 = bp->children;
    D.33029 = D.33019->len;
    if (j.423 < D.33029) goto <D.26349>; else goto <D.26351>;
    <D.26351>:
  }
  i = i + 1;
  <D.26353>:
  i.424 = (unsigned int) i;
  breakpoints.422 = breakpoints;
  D.33031 = breakpoints.422->len;
  if (i.424 < D.33031) goto <D.26352>; else goto <D.26354>;
  <D.26354>:
  mono_loader_unlock ();
}


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

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


runtime_initialized (struct MonoProfiler * prof)
{
  struct MonoThread * D.33034;
  int D.33035;

  D.33034 = mono_thread_current ();
  process_profiler_event (0, D.33034);
  D.33035 = agent_config.defer;
  if (D.33035 != 0) goto <D.33036>; else goto <D.33037>;
  <D.33036>:
  start_debugger_thread ();
  <D.33037>:
}


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

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


mono_debugger_agent_cleanup ()
{
  int inited.426;

  inited.426 = inited;
  if (inited.426 == 0) goto <D.33040>; else goto <D.33041>;
  <D.33040>:
  return;
  <D.33041>:
  stop_debugger_thread ();
  breakpoints_cleanup ();
  objrefs_cleanup ();
  ids_cleanup ();
  pthread_mutex_destroy (&debugger_thread_exited_mutex);
}


stop_debugger_thread ()
{
  int inited.427;
  long unsigned int D.33046;
  long unsigned int debugger_thread_id.428;
  int debugger_thread_exited.429;

  inited.427 = inited;
  if (inited.427 == 0) goto <D.33044>; else goto <D.33045>;
  <D.33044>:
  return;
  <D.33045>:
  transport_close1 ();
  D.33046 = GetCurrentThreadId ();
  debugger_thread_id.428 = debugger_thread_id;
  if (D.33046 != debugger_thread_id.428) goto <D.33048>; else goto <D.33049>;
  <D.33048>:
  <D.25406>:
  pthread_mutex_lock (&debugger_thread_exited_mutex);
  debugger_thread_exited.429 = debugger_thread_exited;
  if (debugger_thread_exited.429 == 0) goto <D.33051>; else goto <D.33052>;
  <D.33051>:
  pthread_cond_wait (&debugger_thread_exited_cond, &debugger_thread_exited_mutex);
  <D.33052>:
  pthread_mutex_unlock (&debugger_thread_exited_mutex);
  debugger_thread_exited.429 = debugger_thread_exited;
  if (debugger_thread_exited.429 == 0) goto <D.25406>; else goto <D.25407>;
  <D.25407>:
  <D.33049>:
  transport_close2 ();
}


transport_close1 ()
{
  struct DebuggerTransport * transport.430;
  void (*<T86e>) (void) D.33055;

  transport.430 = transport;
  D.33055 = transport.430->close1;
  D.33055 ();
}


breakpoints_cleanup ()
{
  struct GPtrArray * event_requests.431;
  void * * D.33057;
  long unsigned int D.33058;
  long unsigned int D.33059;
  void * * D.33060;
  int D.33061;
  void * D.33064;
  unsigned int i.432;
  unsigned int D.33067;
  struct GPtrArray * breakpoints.433;
  void * * D.33069;
  void * * D.33070;
  void * D.33071;
  unsigned int D.33072;
  struct GHashTable * bp_locs.434;
  int i;

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

    event_requests.431 = event_requests;
    D.33057 = event_requests.431->pdata;
    D.33058 = (long unsigned int) i;
    D.33059 = D.33058 * 8;
    D.33060 = D.33057 + D.33059;
    req = *D.33060;
    D.33061 = req->event_kind;
    if (D.33061 == 10) goto <D.33062>; else goto <D.33063>;
    <D.33062>:
    D.33064 = req->info;
    clear_breakpoint (D.33064);
    i.432 = (unsigned int) i;
    event_requests.431 = event_requests;
    monoeg_g_ptr_array_remove_index_fast (event_requests.431, i.432);
    monoeg_g_free (req);
    goto <D.33066>;
    <D.33063>:
    i = i + 1;
    <D.33066>:
  }
  <D.26337>:
  i.432 = (unsigned int) i;
  event_requests.431 = event_requests;
  D.33067 = event_requests.431->len;
  if (i.432 < D.33067) goto <D.26336>; else goto <D.26338>;
  <D.26338>:
  i = 0;
  goto <D.26340>;
  <D.26339>:
  breakpoints.433 = breakpoints;
  D.33069 = breakpoints.433->pdata;
  D.33058 = (long unsigned int) i;
  D.33059 = D.33058 * 8;
  D.33070 = D.33069 + D.33059;
  D.33071 = *D.33070;
  monoeg_g_free (D.33071);
  i = i + 1;
  <D.26340>:
  i.432 = (unsigned int) i;
  breakpoints.433 = breakpoints;
  D.33072 = breakpoints.433->len;
  if (i.432 < D.33072) goto <D.26339>; else goto <D.26341>;
  <D.26341>:
  breakpoints.433 = breakpoints;
  monoeg_g_ptr_array_free (breakpoints.433, 1);
  bp_locs.434 = bp_locs;
  monoeg_g_hash_table_destroy (bp_locs.434);
  breakpoints = 0B;
  bp_locs = 0B;
  mono_loader_unlock ();
}


objrefs_cleanup ()
{
  struct GHashTable * objrefs.435;

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


ids_cleanup ()
{
  struct GPtrArray * D.33075;
  void * * D.33078;
  long unsigned int D.33079;
  long unsigned int D.33080;
  void * * D.33081;
  void * D.33082;
  unsigned int j.436;
  unsigned int D.33084;
  int i;
  int j;

  i = 0;
  goto <D.25610>;
  <D.25609>:
  D.33075 = ids[i];
  if (D.33075 != 0B) goto <D.33076>; else goto <D.33077>;
  <D.33076>:
  j = 0;
  goto <D.25607>;
  <D.25606>:
  D.33075 = ids[i];
  D.33078 = D.33075->pdata;
  D.33079 = (long unsigned int) j;
  D.33080 = D.33079 * 8;
  D.33081 = D.33078 + D.33080;
  D.33082 = *D.33081;
  monoeg_g_free (D.33082);
  j = j + 1;
  <D.25607>:
  j.436 = (unsigned int) j;
  D.33075 = ids[i];
  D.33084 = D.33075->len;
  if (j.436 < D.33084) goto <D.25606>; else goto <D.25608>;
  <D.25608>:
  D.33075 = ids[i];
  monoeg_g_ptr_array_free (D.33075, 1);
  <D.33077>:
  ids[i] = 0B;
  i = i + 1;
  <D.25610>:
  if (i <= 6) goto <D.25609>; else goto <D.25611>;
  <D.25611>:
}


transport_init ()
{
  int D.25366;
  const char * D.33085;
  char * D.33086;
  int ntransports.437;
  struct _IO_FILE * stderr.438;
  const char * iftmp.439;
  struct DebuggerTransport * transport.440;
  int i;

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

    D.33085 = transports[i].name;
    D.33086 = agent_config.transport;
    D.25366 = __builtin_strcmp (D.33086, D.33085);
  }
  if (D.25366 == 0) goto <D.25367>; else goto <D.33087>;
  <D.33087>:
  i = i + 1;
  <D.25369>:
  ntransports.437 = ntransports;
  if (i < ntransports.437) goto <D.25368>; else goto <D.25367>;
  <D.25367>:
  ntransports.437 = ntransports;
  if (i == ntransports.437) goto <D.33089>; else goto <D.33090>;
  <D.33089>:
  stderr.438 = stderr;
  fprintf (stderr.438, "debugger-agent: The supported values for the \'transport\' option are: ");
  i = 0;
  goto <D.25371>;
  <D.25370>:
  D.33085 = transports[i].name;
  if (i > 0) goto <D.33093>; else goto <D.33094>;
  <D.33093>:
  iftmp.439 = ", ";
  goto <D.33095>;
  <D.33094>:
  iftmp.439 = "";
  <D.33095>:
  stderr.438 = stderr;
  fprintf (stderr.438, "%s\'%s\'", iftmp.439, D.33085);
  i = i + 1;
  <D.25371>:
  ntransports.437 = ntransports;
  if (i < ntransports.437) goto <D.25370>; else goto <D.25372>;
  <D.25372>:
  stderr.438 = stderr;
  fprintf (stderr.438, "\n");
  exit (1);
  <D.33090>:
  transport.440 = &transports[i];
  transport = transport.440;
}


register_socket_transport ()
{
  struct DebuggerTransport trans;

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


socket_transport_recv (void * buf, int len)
{
  int D.33097;
  long unsigned int D.33098;
  sizetype D.33099;
  void * D.33100;
  long int D.33101;
  int D.33104;
  int * D.33110;
  int D.33111;
  unsigned int D.33115;
  int last_keepalive.441;
  int D.33117;
  _Bool D.33122;
  _Bool D.33123;
  _Bool D.33124;
  int D.33127;
  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.25284>:
  again:
  D.33097 = len - total;
  D.33098 = (long unsigned int) D.33097;
  D.33099 = (sizetype) total;
  D.33100 = buf + D.33099;
  D.33101 = recv (fd, D.33100, D.33098, flags);
  res = (int) D.33101;
  if (res > 0) goto <D.33102>; else goto <D.33103>;
  <D.33102>:
  total = total + res;
  <D.33103>:
  D.33104 = agent_config.keepalive;
  if (D.33104 != 0) goto <D.33105>; else goto <D.33106>;
  <D.33105>:
  {
    gboolean need_keepalive;

    need_keepalive = 0;
    if (res == -1) goto <D.33109>; else goto <D.33107>;
    <D.33109>:
    D.33110 = __errno_location ();
    D.33111 = *D.33110;
    if (D.33111 == 11) goto <D.33112>; else goto <D.33107>;
    <D.33112>:
    need_keepalive = 1;
    goto <D.33108>;
    <D.33107>:
    if (res == -1) goto <D.33113>; else goto <D.33114>;
    <D.33113>:
    D.33115 = mono_msec_ticks ();
    msecs = (gint32) D.33115;
    last_keepalive.441 = last_keepalive;
    D.33117 = msecs - last_keepalive.441;
    D.33104 = agent_config.keepalive;
    if (D.33117 >= D.33104) goto <D.33118>; else goto <D.33119>;
    <D.33118>:
    need_keepalive = 1;
    last_keepalive = msecs;
    <D.33119>:
    <D.33114>:
    <D.33108>:
    if (need_keepalive != 0) goto <D.33120>; else goto <D.33121>;
    <D.33120>:
    process_profiler_event (14, 0B);
    goto again;
    <D.33121>:
  }
  <D.33106>:
  D.33122 = res > 0;
  D.33123 = total < len;
  D.33124 = D.33122 & D.33123;
  if (D.33124 != 0) goto <D.25284>; else goto <D.33125>;
  <D.33125>:
  if (res == -1) goto <D.33126>; else goto <D.25285>;
  <D.33126>:
  D.33110 = __errno_location ();
  D.33111 = *D.33110;
  if (D.33111 == 4) goto <D.25284>; else goto <D.25285>;
  <D.25285>:
  D.33127 = total;
  return D.33127;
}


recv (int __fd, void * __buf, size_t __n, int __flags)
{
  long unsigned int D.33129;
  int D.33132;
  ssize_t D.33135;
  long unsigned int D.33136;
  long unsigned int D.33137;
  long unsigned int D.33140;

  D.33129 = __builtin_object_size (__buf, 0);
  if (D.33129 != 18446744073709551615) goto <D.33130>; else goto <D.33131>;
  <D.33130>:
  D.33132 = __builtin_constant_p (__n);
  if (D.33132 == 0) goto <D.33133>; else goto <D.33134>;
  <D.33133>:
  D.33136 = __builtin_object_size (__buf, 0);
  D.33135 = __recv_chk (__fd, __buf, __n, D.33136, __flags);
  return D.33135;
  <D.33134>:
  D.33137 = __builtin_object_size (__buf, 0);
  if (D.33137 < __n) goto <D.33138>; else goto <D.33139>;
  <D.33138>:
  D.33140 = __builtin_object_size (__buf, 0);
  D.33135 = __recv_chk_warn (__fd, __buf, __n, D.33140, __flags);
  return D.33135;
  <D.33139>:
  <D.33131>:
  D.33135 = __recv_alias (__fd, __buf, __n, __flags);
  return D.33135;
}


socket_transport_send (void * data, int len)
{
  long unsigned int D.33142;
  int conn_fd.442;
  long int D.33144;
  int * D.33146;
  int D.33147;
  gboolean D.33150;
  int res;

  <D.25299>:
  D.33142 = (long unsigned int) len;
  conn_fd.442 = conn_fd;
  D.33144 = send (conn_fd.442, data, D.33142, 0);
  res = (int) D.33144;
  if (res == -1) goto <D.33145>; else goto <D.25300>;
  <D.33145>:
  D.33146 = __errno_location ();
  D.33147 = *D.33146;
  if (D.33147 == 4) goto <D.25299>; else goto <D.25300>;
  <D.25300>:
  if (res != len) goto <D.33148>; else goto <D.33149>;
  <D.33148>:
  D.33150 = 0;
  return D.33150;
  <D.33149>:
  D.33150 = 1;
  return D.33150;
}


socket_transport_close2 ()
{
  int conn_fd.443;

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


socket_transport_close1 ()
{
  int conn_fd.444;
  int listen_fd.445;

  conn_fd.444 = conn_fd;
  shutdown (conn_fd.444, 0);
  listen_fd.445 = listen_fd;
  shutdown (listen_fd.445, 2);
  listen_fd.445 = listen_fd;
  close (listen_fd.445);
}


socket_transport_connect (const char * address)
{
  char * D.33155;
  _Bool D.33158;
  long int D.33159;
  long int D.33160;
  char * host.446;
  int port.447;
  const char * D.33170;
  struct _IO_FILE * stderr.448;
  int D.33172;
  _Bool D.33177;
  long int D.33178;
  long int D.33179;
  int * D.33184;
  int D.33185;
  char * D.33186;
  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.33187;
  short unsigned int D.25317;
  int D.33190;
  int D.33191;
  short unsigned int D.33194;
  signed short D.33195;
  int D.33196;
  signed short D.33197;
  signed short D.33198;
  int port.449;
  int D.33202;
  int D.33203;
  int D.33204;
  int D.33207;
  unsigned int D.33210;
  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.33211;
  struct sockaddr * D.33212;
  struct addrinfo * result.450;
  int D.33218;
  int log_level.451;
  _Bool D.33222;
  long int D.33223;
  long int D.33224;
  int D.33227;
  struct FILE * log_file.452;
  int D.33231;
  long int D.33232;
  long int D.25328;
  long int iftmp.453;
  int D.33234;
  long int iftmp.454;
  unsigned long __d.455;
  long int D.33243;
  long int D.33244;
  int D.33245;
  long int D.33246;
  long int D.33247;
  int D.33248;
  int conn_fd.456;
  int conn_fd.457;
  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.33260;
  int D.33261;
  int D.33265;
  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.33155 = agent_config.address;
      if (D.33155 != 0B) goto <D.33156>; else goto <D.33157>;
      <D.33156>:
      D.33155 = agent_config.address;
      res = parse_address (D.33155, &host, &port);
      D.33158 = res != 0;
      D.33159 = (long int) D.33158;
      D.33160 = __builtin_expect (D.33159, 0);
      if (D.33160 != 0) goto <D.33161>; else goto <D.33162>;
      <D.33161>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 1177, "res == 0");
      <D.33162>:
      goto <D.33163>;
      <D.33157>:
      host = 0B;
      port = 0;
      <D.33163>:
      conn_fd = -1;
      listen_fd = -1;
      host.446 = host;
      if (host.446 != 0B) goto <D.33165>; else goto <D.33166>;
      <D.33165>:
      port.447 = port;
      sprintf (&port_string, "%d", port.447);
      mono_network_init ();
      memset (&hints, 0, 48);
      hints.ai_family = 0;
      hints.ai_socktype = 1;
      hints.ai_flags = 0;
      hints.ai_protocol = 0;
      host.446 = host;
      s = getaddrinfo (host.446, &port_string, &hints, &result);
      if (s != 0) goto <D.33168>; else goto <D.33169>;
      <D.33168>:
      D.33170 = gai_strerror (s);
      port.447 = port;
      host.446 = host;
      stderr.448 = stderr;
      fprintf (stderr.448, "debugger-agent: Unable to resolve %s:%d: %s\n", host.446, port.447, D.33170);
      exit (1);
      <D.33169>:
      <D.33166>:
      D.33172 = agent_config.server;
      if (D.33172 != 0) goto <D.33173>; else goto <D.33174>;
      <D.33173>:
      host.446 = host;
      if (host.446 == 0B) goto <D.33175>; else goto <D.33176>;
      <D.33175>:
      {
        struct sockaddr_in addr;
        socklen_t addrlen;

        try
          {
            sfd = socket (2, 1, 0);
            D.33177 = sfd == 0;
            D.33178 = (long int) D.33177;
            D.33179 = __builtin_expect (D.33178, 0);
            if (D.33179 != 0) goto <D.33180>; else goto <D.33181>;
            <D.33180>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 1222, "sfd");
            <D.33181>:
            res = listen (sfd, 16);
            if (res == -1) goto <D.33182>; else goto <D.33183>;
            <D.33182>:
            D.33184 = __errno_location ();
            D.33185 = *D.33184;
            D.33186 = strerror (D.33185);
            stderr.448 = stderr;
            fprintf (stderr.448, "debugger-agent: Unable to setup listening socket: %s\n", D.33186);
            exit (1);
            <D.33183>:
            listen_fd = sfd;
            addrlen = 16;
            memset (&addr, 0, 16);
            D.33187.__sockaddr__ = &addr;
            res = getsockname (sfd, D.33187, &addrlen);
            D.33158 = res != 0;
            D.33159 = (long int) D.33158;
            D.33160 = __builtin_expect (D.33159, 0);
            if (D.33160 != 0) goto <D.33188>; else goto <D.33189>;
            <D.33188>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 1235, "res == 0");
            <D.33189>:
            host = "127.0.0.1";
            {
              short unsigned int __v;
              short unsigned int __x;

              __x = addr.sin_port;
              {
                D.33190 = (int) __x;
                D.33191 = __builtin_constant_p (D.33190);
                if (D.33191 != 0) goto <D.33192>; else goto <D.33193>;
                <D.33192>:
                D.33194 = __x >> 8;
                D.33195 = (signed short) D.33194;
                D.33190 = (int) __x;
                D.33196 = D.33190 << 8;
                D.33197 = (signed short) D.33196;
                D.33198 = D.33195 | D.33197;
                __v = (short unsigned int) D.33198;
                goto <D.33199>;
                <D.33193>:
                __asm__("rorw $8, %w0" : "=r" __v : "0" __x : "cc");
                <D.33199>:
              }
              D.25317 = __v;
            }
            port.449 = (int) D.25317;
            port = port.449;
            port.447 = port;
            host.446 = host;
            printf ("%s:%d\n", host.446, port.447);
          }
        finally
          {
            addr = {CLOBBER};
            addrlen = {CLOBBER};
          }
      }
      goto <D.33201>;
      <D.33176>:
      rp = result;
      goto <D.25322>;
      <D.25321>:
      {
        int n;

        try
          {
            n = 1;
            D.33202 = rp->ai_protocol;
            D.33203 = rp->ai_socktype;
            D.33204 = rp->ai_family;
            sfd = socket (D.33204, D.33203, D.33202);
            if (sfd == -1) goto <D.33205>; else goto <D.33206>;
            <D.33205>:
            // predicted unlikely by continue predictor.
            goto <D.25319>;
            <D.33206>:
            D.33207 = setsockopt (sfd, 1, 2, &n, 4);
            if (D.33207 == -1) goto <D.33208>; else goto <D.33209>;
            <D.33208>:
            // predicted unlikely by continue predictor.
            goto <D.25319>;
            <D.33209>:
            D.33210 = rp->ai_addrlen;
            D.33212 = rp->ai_addr;
            D.33211.__sockaddr__ = D.33212;
            res = bind (sfd, D.33211, D.33210);
            if (res == -1) goto <D.33213>; else goto <D.33214>;
            <D.33213>:
            // predicted unlikely by continue predictor.
            goto <D.25319>;
            <D.33214>:
            res = listen (sfd, 16);
            if (res == -1) goto <D.33215>; else goto <D.33216>;
            <D.33215>:
            // predicted unlikely by continue predictor.
            goto <D.25319>;
            <D.33216>:
            listen_fd = sfd;
            goto <D.25320>;
          }
        finally
          {
            n = {CLOBBER};
          }
      }
      <D.25319>:
      rp = rp->ai_next;
      <D.25322>:
      if (rp != 0B) goto <D.25321>; else goto <D.25320>;
      <D.25320>:
      result.450 = result;
      freeaddrinfo (result.450);
      <D.33201>:
      D.33218 = agent_config.defer;
      if (D.33218 != 0) goto <D.33219>; else goto <D.33220>;
      <D.33219>:
      return;
      <D.33220>:
      log_level.451 = log_level;
      D.33222 = log_level.451 > 0;
      D.33223 = (long int) D.33222;
      D.33224 = __builtin_expect (D.33223, 0);
      if (D.33224 != 0) goto <D.33225>; else goto <D.33226>;
      <D.33225>:
      D.33227 = agent_config.timeout;
      port.447 = port;
      host.446 = host;
      log_file.452 = log_file;
      fprintf (log_file.452, "Listening on %s:%d (timeout=%d ms)...\n", host.446, port.447, D.33227);
      log_file.452 = log_file;
      fflush (log_file.452);
      <D.33226>:
      D.33227 = agent_config.timeout;
      if (D.33227 != 0) goto <D.33229>; else goto <D.33230>;
      <D.33229>:
      {
        struct fd_set readfds;
        struct timeval tv;

        try
          {
            tv.tv_sec = 0;
            D.33227 = agent_config.timeout;
            D.33231 = D.33227 * 1000;
            D.33232 = (long int) D.33231;
            tv.tv_usec = D.33232;
            {
              int __d0;
              int __d1;

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

              __d = (long int) sfd;
              D.33234 = __builtin_constant_p (__d);
              if (D.33234 != 0) goto <D.33235>; else goto <D.33236>;
              <D.33235>:
              __d.455 = (unsigned long) __d;
              if (__d.455 <= 1023) goto <D.33239>; else goto <D.33240>;
              <D.33239>:
              iftmp.454 = __d / 64;
              goto <D.33241>;
              <D.33240>:
              iftmp.454 = __fdelt_warn (__d);
              <D.33241>:
              iftmp.453 = iftmp.454;
              goto <D.33242>;
              <D.33236>:
              iftmp.453 = __fdelt_chk (__d);
              <D.33242>:
              D.25328 = iftmp.453;
            }
            D.33243 = D.25328;
            D.33244 = readfds.fds_bits[D.33243];
            D.33245 = sfd % 64;
            D.33246 = 1 << D.33245;
            D.33247 = D.33244 | D.33246;
            readfds.fds_bits[D.33243] = D.33247;
            D.33248 = sfd + 1;
            res = select (D.33248, &readfds, 0B, 0B, &tv);
            if (res == 0) goto <D.33249>; else goto <D.33250>;
            <D.33249>:
            stderr.448 = stderr;
            fprintf (stderr.448, "debugger-agent: Timed out waiting to connect.\n");
            exit (1);
            <D.33250>:
          }
        finally
          {
            readfds = {CLOBBER};
            tv = {CLOBBER};
          }
      }
      <D.33230>:
      conn_fd.456 = socket_transport_accept (sfd);
      conn_fd = conn_fd.456;
      conn_fd.457 = conn_fd;
      if (conn_fd.457 == -1) goto <D.33253>; else goto <D.33254>;
      <D.33253>:
      exit (1);
      <D.33254>:
      log_level.451 = log_level;
      D.33222 = log_level.451 > 0;
      D.33223 = (long int) D.33222;
      D.33224 = __builtin_expect (D.33223, 0);
      if (D.33224 != 0) goto <D.33255>; else goto <D.33256>;
      <D.33255>:
      conn_fd.457 = conn_fd;
      log_file.452 = log_file;
      fprintf (log_file.452, "Accepted connection from client, socket fd=%d.\n", conn_fd.457);
      log_file.452 = log_file;
      fflush (log_file.452);
      <D.33256>:
      goto <D.33257>;
      <D.33174>:
      rp = result;
      goto <D.25332>;
      <D.25331>:
      D.33202 = rp->ai_protocol;
      D.33203 = rp->ai_socktype;
      D.33204 = rp->ai_family;
      sfd = socket (D.33204, D.33203, D.33202);
      if (sfd == -1) goto <D.33258>; else goto <D.33259>;
      <D.33258>:
      // predicted unlikely by continue predictor.
      goto <D.25329>;
      <D.33259>:
      D.33210 = rp->ai_addrlen;
      D.33212 = rp->ai_addr;
      D.33260.__sockaddr__ = D.33212;
      D.33261 = connect (sfd, D.33260, D.33210);
      if (D.33261 != -1) goto <D.25330>; else goto <D.33262>;
      <D.33262>:
      close (sfd);
      <D.25329>:
      rp = rp->ai_next;
      <D.25332>:
      if (rp != 0B) goto <D.25331>; else goto <D.25330>;
      <D.25330>:
      if (rp == 0B) goto <D.33263>; else goto <D.33264>;
      <D.33263>:
      port.447 = port;
      host.446 = host;
      stderr.448 = stderr;
      fprintf (stderr.448, "debugger-agent: Unable to connect to %s:%d\n", host.446, port.447);
      exit (1);
      <D.33264>:
      conn_fd = sfd;
      result.450 = result;
      freeaddrinfo (result.450);
      <D.33257>:
      D.33265 = transport_handshake ();
      if (D.33265 == 0) goto <D.33266>; else goto <D.33267>;
      <D.33266>:
      exit (1);
      <D.33267>:
    }
  finally
    {
      hints = {CLOBBER};
      result = {CLOBBER};
      port_string = {CLOBBER};
      host = {CLOBBER};
      port = {CLOBBER};
    }
}


register_transport (struct DebuggerTransport * trans)
{
  int ntransports.458;
  _Bool D.33274;
  long int D.33275;
  long int D.33276;
  struct DebuggerTransport * D.33279;
  int ntransports.459;

  ntransports.458 = ntransports;
  D.33274 = ntransports.458 > 15;
  D.33275 = (long int) D.33274;
  D.33276 = __builtin_expect (D.33275, 0);
  if (D.33276 != 0) goto <D.33277>; else goto <D.33278>;
  <D.33277>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 1419, "ntransports < MAX_TRANSPORTS");
  <D.33278>:
  ntransports.458 = ntransports;
  D.33279 = &transports[ntransports.458];
  memcpy (D.33279, trans, 48);
  ntransports.458 = ntransports;
  ntransports.459 = ntransports.458 + 1;
  ntransports = ntransports.459;
}


mono_native_tls_alloc (pthread_key_t * key, void * destructor)
{
  int D.33281;
  void (*<Tc2>) (void *) destructor.460;
  int D.33283;
  _Bool D.33284;

  destructor.460 = (void (*<Tc2>) (void *)) destructor;
  D.33283 = pthread_key_create (key, destructor.460);
  D.33284 = D.33283 == 0;
  D.33281 = (int) D.33284;
  return D.33281;
}


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

  i = 0;
  goto <D.25599>;
  <D.25598>:
  D.33286 = monoeg_g_ptr_array_new ();
  ids[i] = D.33286;
  i = i + 1;
  <D.25599>:
  if (i <= 6) goto <D.25598>; else goto <D.25600>;
  <D.25600>:
}


objrefs_init ()
{
  struct GHashTable * objrefs.461;

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


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

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


breakpoints_init ()
{
  struct GPtrArray * breakpoints.462;
  struct GHashTable * bp_locs.463;

  breakpoints.462 = monoeg_g_ptr_array_new ();
  breakpoints = breakpoints.462;
  bp_locs.463 = monoeg_g_hash_table_new (0B, 0B);
  bp_locs = bp_locs.463;
}


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.33291;
  char * D.33294;
  char * D.33297;
  char * D.33298;
  struct _IO_FILE * stderr.464;
  int res;

  D.33291 = InterlockedCompareExchange (&inited, 1, 0);
  if (D.33291 == 1) goto <D.33292>; else goto <D.33293>;
  <D.33292>:
  return;
  <D.33293>:
  D.33294 = agent_config.launch;
  if (D.33294 != 0B) goto <D.33295>; else goto <D.33296>;
  <D.33295>:
  {
    char * argv[16];

    try
      {
        D.33294 = agent_config.launch;
        argv[0] = D.33294;
        D.33297 = agent_config.transport;
        argv[1] = D.33297;
        D.33298 = agent_config.address;
        argv[2] = D.33298;
        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.33299>; else goto <D.33300>;
        <D.33299>:
        D.33294 = agent_config.launch;
        stderr.464 = stderr;
        fprintf (stderr.464, "Failed to execute \'%s\'.\n", D.33294);
        exit (1);
        <D.33300>:
      }
    finally
      {
        argv = {CLOBBER};
      }
  }
  <D.33296>:
  D.33298 = agent_config.address;
  transport_connect (D.33298);
  if (on_startup == 0) goto <D.33302>; else goto <D.33303>;
  <D.33302>:
  vm_start_event_sent = 1;
  start_debugger_thread ();
  <D.33303>:
}


InterlockedCompareExchange (volatile gint32 * dest, gint32 exch, gint32 comp)
{
  gint32 D.33305;
  unsigned int exch.465;
  unsigned int comp.466;
  unsigned int D.33308;

  exch.465 = (unsigned int) exch;
  comp.466 = (unsigned int) comp;
  D.33308 = __sync_val_compare_and_swap_4 (dest, comp.466, exch.465);
  D.33305 = (gint32) D.33308;
  return D.33305;
}


transport_connect (const char * address)
{
  struct DebuggerTransport * transport.467;
  void (*<T3f59>) (const char *) D.33311;

  transport.467 = transport;
  D.33311 = transport.467->connect;
  D.33311 (address);
}


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


mono_debugger_agent_transport_handshake ()
{
  gboolean D.33312;

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


mono_debugger_agent_free_domain_info (struct MonoDomain * domain)
{
  void * D.33314;
  struct GHashTable * D.33317;
  struct GHashTable * D.33320;
  struct GHashTable * D.33321;
  struct GPtrArray * file_names.468;
  void * * D.33323;
  long unsigned int D.33324;
  long unsigned int D.33325;
  void * * D.33326;
  void * D.33327;
  unsigned int i.469;
  unsigned int D.33329;
  int D.33330;
  struct GHashTable * D.33331;
  char * basename.470;
  struct GSList * l.471;
  int D.33334;
  struct GHashTable * D.33335;
  int D.33336;
  struct GPtrArray * D.33337;
  void * * D.33340;
  long unsigned int D.33341;
  long unsigned int D.33342;
  void * * D.33343;
  struct MonoDomain * D.33344;
  unsigned int j.472;
  unsigned int D.33348;
  struct GHashTable * domains.473;
  struct AgentDomainInfo * info;
  int i;
  int j;
  struct GHashTableIter iter;
  struct GPtrArray * file_names;
  char * basename;
  struct GSList * l;

  try
    {
      D.33314 = domain->runtime_info;
      info = MEM[(struct MonoJitDomainInfo *)D.33314].agent_info;
      if (info != 0B) goto <D.33315>; else goto <D.33316>;
      <D.33315>:
      i = 0;
      goto <D.25623>;
      <D.25622>:
      D.33317 = info->val_to_id[i];
      if (D.33317 != 0B) goto <D.33318>; else goto <D.33319>;
      <D.33318>:
      D.33317 = info->val_to_id[i];
      monoeg_g_hash_table_destroy (D.33317);
      <D.33319>:
      i = i + 1;
      <D.25623>:
      if (i <= 6) goto <D.25622>; else goto <D.25624>;
      <D.25624>:
      D.33320 = info->loaded_classes;
      monoeg_g_hash_table_destroy (D.33320);
      D.33321 = info->source_files;
      monoeg_g_hash_table_iter_init (&iter, D.33321);
      goto <D.25629>;
      <D.25628>:
      i = 0;
      goto <D.25626>;
      <D.25625>:
      file_names.468 = file_names;
      D.33323 = file_names.468->pdata;
      D.33324 = (long unsigned int) i;
      D.33325 = D.33324 * 8;
      D.33326 = D.33323 + D.33325;
      D.33327 = *D.33326;
      monoeg_g_free (D.33327);
      i = i + 1;
      <D.25626>:
      i.469 = (unsigned int) i;
      file_names.468 = file_names;
      D.33329 = file_names.468->len;
      if (i.469 < D.33329) goto <D.25625>; else goto <D.25627>;
      <D.25627>:
      file_names.468 = file_names;
      monoeg_g_ptr_array_free (file_names.468, 1);
      <D.25629>:
      D.33330 = monoeg_g_hash_table_iter_next (&iter, 0B, &file_names);
      if (D.33330 != 0) goto <D.25628>; else goto <D.25630>;
      <D.25630>:
      D.33331 = info->source_file_to_class;
      monoeg_g_hash_table_iter_init (&iter, D.33331);
      goto <D.25632>;
      <D.25631>:
      basename.470 = basename;
      monoeg_g_free (basename.470);
      l.471 = l;
      monoeg_g_slist_free (l.471);
      <D.25632>:
      D.33334 = monoeg_g_hash_table_iter_next (&iter, &basename, &l);
      if (D.33334 != 0) goto <D.25631>; else goto <D.25633>;
      <D.25633>:
      D.33335 = info->source_file_to_class_ignorecase;
      monoeg_g_hash_table_iter_init (&iter, D.33335);
      goto <D.25635>;
      <D.25634>:
      basename.470 = basename;
      monoeg_g_free (basename.470);
      l.471 = l;
      monoeg_g_slist_free (l.471);
      <D.25635>:
      D.33336 = monoeg_g_hash_table_iter_next (&iter, &basename, &l);
      if (D.33336 != 0) goto <D.25634>; else goto <D.25636>;
      <D.25636>:
      monoeg_g_free (info);
      <D.33316>:
      D.33314 = domain->runtime_info;
      MEM[(struct MonoJitDomainInfo *)D.33314].agent_info = 0B;
      i = 0;
      goto <D.25642>;
      <D.25641>:
      D.33337 = ids[i];
      if (D.33337 != 0B) goto <D.33338>; else goto <D.33339>;
      <D.33338>:
      j = 0;
      goto <D.25639>;
      <D.25638>:
      {
        struct Id * id;

        D.33337 = ids[i];
        D.33340 = D.33337->pdata;
        D.33341 = (long unsigned int) j;
        D.33342 = D.33341 * 8;
        D.33343 = D.33340 + D.33342;
        id = *D.33343;
        D.33344 = id->domain;
        if (D.33344 == domain) goto <D.33345>; else goto <D.33346>;
        <D.33345>:
        id->domain = 0B;
        <D.33346>:
      }
      j = j + 1;
      <D.25639>:
      j.472 = (unsigned int) j;
      D.33337 = ids[i];
      D.33348 = D.33337->len;
      if (j.472 < D.33348) goto <D.25638>; else goto <D.25640>;
      <D.25640>:
      <D.33339>:
      i = i + 1;
      <D.25642>:
      if (i <= 6) goto <D.25641>; else goto <D.25643>;
      <D.25643>:
      mono_loader_lock ();
      domains.473 = domains;
      monoeg_g_hash_table_remove (domains.473, 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.474;
  gboolean D.33353;
  unsigned int debugger_tls_id.475;
  int log_level.476;
  _Bool D.33358;
  long int D.33359;
  long int D.33360;
  long unsigned int D.33363;
  void * D.33364;
  struct FILE * log_file.477;
  struct DebuggerTlsData * tls;

  inited.474 = inited;
  if (inited.474 == 0) goto <D.33351>; else goto <D.33352>;
  <D.33351>:
  D.33353 = 0;
  return D.33353;
  <D.33352>:
  debugger_tls_id.475 = debugger_tls_id;
  tls = pthread_getspecific (debugger_tls_id.475);
  if (tls == 0B) goto <D.33355>; else goto <D.33356>;
  <D.33355>:
  log_level.476 = log_level;
  D.33358 = log_level.476 > 0;
  D.33359 = (long int) D.33358;
  D.33360 = __builtin_expect (D.33359, 0);
  if (D.33360 != 0) goto <D.33361>; else goto <D.33362>;
  <D.33361>:
  D.33363 = GetCurrentThreadId ();
  D.33364 = (void *) D.33363;
  log_file.477 = log_file;
  fprintf (log_file.477, "[%p] Received interrupt with no TLS, continuing.\n", D.33364);
  log_file.477 = log_file;
  fflush (log_file.477);
  <D.33362>:
  D.33353 = 0;
  return D.33353;
  <D.33356>:
  D.33353 = thread_interrupt (tls, 0B, sigctx, ji);
  return D.33353;
}


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 int D.33367;
  struct MonoDomain * D.33368;
  _Bool D.33369;
  long int D.33370;
  long int D.33371;
  long int ip.478;
  void * D.33375;
  long int D.33376;
  long int D.33377;
  unsigned char D.33380;
  unsigned char D.33381;
  int D.33383;
  int native_offset.479;
  struct MonoDomain * D.33385;
  _Bool D.33388;
  long int D.33389;
  long int D.33390;
  int log_level.480;
  _Bool D.33394;
  long int D.33395;
  long int D.33396;
  int iftmp.481;
  const char * D.33403;
  long unsigned int D.33404;
  void * D.33405;
  struct FILE * log_file.482;
  struct GPtrArray * breakpoints.483;
  void * * D.33408;
  long unsigned int D.33409;
  long unsigned int D.33410;
  void * * D.33411;
  struct MonoMethod * D.33412;
  struct GPtrArray * D.33415;
  void * * D.33416;
  long unsigned int D.33417;
  long unsigned int D.33418;
  void * * D.33419;
  struct MonoJitInfo * D.33420;
  struct SeqPoint * D.33423;
  struct EventRequest * D.33426;
  int D.33427;
  unsigned int j.484;
  unsigned int D.33432;
  unsigned int i.485;
  unsigned int D.33434;
  unsigned int D.33435;
  unsigned int D.33438;
  int D.33441;
  void * * D.33447;
  void * * D.33448;
  struct MonoInternalThread * D.33449;
  struct MonoInternalThread * D.33450;
  struct MonoSeqPointInfo * info.486;
  unsigned int D.33456;
  int suspend_policy.487;
  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.33367 = ctx->rip;
      ip = (guint8 *) D.33367;
      D.33368 = mono_domain_get ();
      ji = mini_jit_info_table_find (D.33368, ip, 0B);
      D.33369 = ji == 0B;
      D.33370 = (long int) D.33369;
      D.33371 = __builtin_expect (D.33370, 0);
      if (D.33371 != 0) goto <D.33372>; else goto <D.33373>;
      <D.33372>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 4554, "ji");
      <D.33373>:
      method = jinfo_get_method (ji);
      ip.478 = (long int) ip;
      D.33375 = ji->code_start;
      D.33376 = (long int) D.33375;
      D.33377 = ip.478 - D.33376;
      native_offset = (guint32) D.33377;
      mono_arch_skip_breakpoint (ctx, ji);
      D.33380 = BIT_FIELD_REF <*method, 8, 256>;
      D.33381 = D.33380 & 124;
      if (D.33381 != 0) goto <D.33378>; else goto <D.33382>;
      <D.33382>:
      D.33383 = tls->disable_breakpoints;
      if (D.33383 != 0) goto <D.33378>; else goto <D.33379>;
      <D.33378>:
      return;
      <D.33379>:
      bp_reqs = monoeg_g_ptr_array_new ();
      ss_reqs = monoeg_g_ptr_array_new ();
      ss_reqs_orig = monoeg_g_ptr_array_new ();
      mono_loader_lock ();
      native_offset.479 = (int) native_offset;
      D.33385 = mono_domain_get ();
      sp = find_prev_seq_point_for_native_offset (D.33385, method, native_offset.479, &info);
      if (sp == 0B) goto <D.33386>; else goto <D.33387>;
      <D.33386>:
      no_seq_points_found (method);
      <D.33387>:
      D.33388 = sp == 0B;
      D.33389 = (long int) D.33388;
      D.33390 = __builtin_expect (D.33389, 0);
      if (D.33390 != 0) goto <D.33391>; else goto <D.33392>;
      <D.33391>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 4581, "sp");
      <D.33392>:
      log_level.480 = log_level;
      D.33394 = log_level.480 > 0;
      D.33395 = (long int) D.33394;
      D.33396 = __builtin_expect (D.33395, 0);
      if (D.33396 != 0) goto <D.33397>; else goto <D.33398>;
      <D.33397>:
      if (sp != 0B) goto <D.33400>; else goto <D.33401>;
      <D.33400>:
      iftmp.481 = sp->il_offset;
      goto <D.33402>;
      <D.33401>:
      iftmp.481 = -1;
      <D.33402>:
      D.33403 = method->name;
      D.33404 = GetCurrentThreadId ();
      D.33405 = (void *) D.33404;
      log_file.482 = log_file;
      fprintf (log_file.482, "[%p] Breakpoint hit, method=%s, ip=%p, offset=0x%x, sp il offset=0x%x.\n", D.33405, D.33403, ip, native_offset, iftmp.481);
      log_file.482 = log_file;
      fflush (log_file.482);
      <D.33398>:
      bp = 0B;
      i = 0;
      goto <D.26397>;
      <D.26396>:
      breakpoints.483 = breakpoints;
      D.33408 = breakpoints.483->pdata;
      D.33409 = (long unsigned int) i;
      D.33410 = D.33409 * 8;
      D.33411 = D.33408 + D.33410;
      bp = *D.33411;
      D.33412 = bp->method;
      if (D.33412 == 0B) goto <D.33413>; else goto <D.33414>;
      <D.33413>:
      // predicted unlikely by continue predictor.
      goto <D.26392>;
      <D.33414>:
      j = 0;
      goto <D.26394>;
      <D.26393>:
      D.33415 = bp->children;
      D.33416 = D.33415->pdata;
      D.33417 = (long unsigned int) j;
      D.33418 = D.33417 * 8;
      D.33419 = D.33416 + D.33418;
      inst = *D.33419;
      D.33420 = inst->ji;
      if (D.33420 == ji) goto <D.33421>; else goto <D.33422>;
      <D.33421>:
      D.33423 = inst->sp;
      if (D.33423 == sp) goto <D.33424>; else goto <D.33425>;
      <D.33424>:
      D.33426 = bp->req;
      D.33427 = D.33426->event_kind;
      if (D.33427 == 11) goto <D.33428>; else goto <D.33429>;
      <D.33428>:
      D.33426 = bp->req;
      monoeg_g_ptr_array_add (ss_reqs_orig, D.33426);
      goto <D.33430>;
      <D.33429>:
      D.33426 = bp->req;
      monoeg_g_ptr_array_add (bp_reqs, D.33426);
      <D.33430>:
      <D.33425>:
      <D.33422>:
      j = j + 1;
      <D.26394>:
      j.484 = (unsigned int) j;
      D.33415 = bp->children;
      D.33432 = D.33415->len;
      if (j.484 < D.33432) goto <D.26393>; else goto <D.26395>;
      <D.26395>:
      <D.26392>:
      i = i + 1;
      <D.26397>:
      i.485 = (unsigned int) i;
      breakpoints.483 = breakpoints;
      D.33434 = breakpoints.483->len;
      if (i.485 < D.33434) goto <D.26396>; else goto <D.26398>;
      <D.26398>:
      D.33435 = bp_reqs->len;
      if (D.33435 == 0) goto <D.33436>; else goto <D.33437>;
      <D.33436>:
      D.33438 = ss_reqs_orig->len;
      if (D.33438 == 0) goto <D.33439>; else goto <D.33440>;
      <D.33439>:
      D.33441 = sp->il_offset;
      if (D.33441 == -1) goto <D.33442>; else goto <D.33443>;
      <D.33442>:
      kind = 6;
      goto <D.33444>;
      <D.33443>:
      D.33441 = sp->il_offset;
      if (D.33441 == 16777215) goto <D.33445>; else goto <D.33446>;
      <D.33445>:
      kind = 7;
      <D.33446>:
      <D.33444>:
      <D.33440>:
      <D.33437>:
      i = 0;
      goto <D.26404>;
      <D.26403>:
      {
        struct EventRequest * req;
        struct SingleStepReq * ss_req;
        gboolean hit;

        D.33447 = ss_reqs_orig->pdata;
        D.33409 = (long unsigned int) i;
        D.33410 = D.33409 * 8;
        D.33448 = D.33447 + D.33410;
        req = *D.33448;
        ss_req = req->info;
        D.33449 = mono_thread_internal_current ();
        D.33450 = ss_req->thread;
        if (D.33449 != D.33450) goto <D.33451>; else goto <D.33452>;
        <D.33451>:
        // predicted unlikely by continue predictor.
        goto <D.26402>;
        <D.33452>:
        hit = ss_update (ss_req, ji, sp, tls, ctx);
        if (hit != 0) goto <D.33453>; else goto <D.33454>;
        <D.33453>:
        monoeg_g_ptr_array_add (ss_reqs, req);
        <D.33454>:
        info.486 = info;
        ss_start (ss_req, method, sp, info.486, ctx, tls, 0);
      }
      <D.26402>:
      i = i + 1;
      <D.26404>:
      i.485 = (unsigned int) i;
      D.33438 = ss_reqs_orig->len;
      if (i.485 < D.33438) goto <D.26403>; else goto <D.26405>;
      <D.26405>:
      D.33456 = ss_reqs->len;
      if (D.33456 != 0) goto <D.33457>; else goto <D.33458>;
      <D.33457>:
      ss_events = create_event_list (11, ss_reqs, ji, 0B, &suspend_policy);
      <D.33458>:
      D.33435 = bp_reqs->len;
      if (D.33435 != 0) goto <D.33459>; else goto <D.33460>;
      <D.33459>:
      bp_events = create_event_list (10, bp_reqs, ji, 0B, &suspend_policy);
      <D.33460>:
      if (kind != 10) goto <D.33461>; else goto <D.33462>;
      <D.33461>:
      enter_leave_events = create_event_list (kind, 0B, ji, 0B, &suspend_policy);
      <D.33462>:
      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.33463>; else goto <D.33464>;
      <D.33463>:
      suspend_policy.487 = suspend_policy;
      process_event (11, method, 0, ctx, ss_events, suspend_policy.487);
      <D.33464>:
      if (bp_events != 0B) goto <D.33466>; else goto <D.33467>;
      <D.33466>:
      suspend_policy.487 = suspend_policy;
      process_event (kind, method, 0, ctx, bp_events, suspend_policy.487);
      <D.33467>:
      if (enter_leave_events != 0B) goto <D.33468>; else goto <D.33469>;
      <D.33468>:
      suspend_policy.487 = suspend_policy;
      process_event (kind, method, 0, ctx, enter_leave_events, suspend_policy.487);
      <D.33469>:
    }
  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.33473;
  int D.33476;
  int D.33477;
  int log_level.488;
  _Bool D.33481;
  long int D.33482;
  long int D.33483;
  int D.33486;
  long unsigned int D.33487;
  void * D.33488;
  struct FILE * log_file.489;
  gboolean D.33490;
  int D.33495;
  struct MonoThreadUnwindState * D.33498;
  struct MonoInternalThread * D.33499;
  int D.33500;
  int D.33503;
  long unsigned int D.33510;
  void * D.33511;
  <unnamed type> D.33512;
  unsigned int D.33517;
  struct SingleStepReq * ss_req.490;
  struct MonoMethod * D.33522;
  unsigned int D.33524;
  int D.33525;
  unsigned int D.33526;
  long unsigned int D.33531;
  void * D.33532;
  long unsigned int D.33536;
  void * D.33537;
  int D.33540;
  struct MonoDebugMethodInfo * minfo;
  struct MonoDebugSourceLocation * loc;
  gboolean hit;
  struct MonoMethod * method;

  loc = 0B;
  hit = 1;
  D.33473 = req->depth;
  if (D.33473 == 1) goto <D.33474>; else goto <D.33475>;
  <D.33474>:
  D.33476 = sp->flags;
  D.33477 = D.33476 & 1;
  if (D.33477 != 0) goto <D.33478>; else goto <D.33479>;
  <D.33478>:
  log_level.488 = log_level;
  D.33481 = log_level.488 > 0;
  D.33482 = (long int) D.33481;
  D.33483 = __builtin_expect (D.33482, 0);
  if (D.33483 != 0) goto <D.33484>; else goto <D.33485>;
  <D.33484>:
  D.33486 = sp->il_offset;
  D.33487 = GetCurrentThreadId ();
  D.33488 = (void *) D.33487;
  log_file.489 = log_file;
  fprintf (log_file.489, "[%p] Seq point at nonempty stack %x while stepping over, continuing single stepping.\n", D.33488, D.33486);
  log_file.489 = log_file;
  fflush (log_file.489);
  <D.33485>:
  D.33490 = 0;
  return D.33490;
  <D.33479>:
  <D.33475>:
  D.33473 = req->depth;
  if (D.33473 == 1) goto <D.33491>; else goto <D.33492>;
  <D.33491>:
  if (hit != 0) goto <D.33493>; else goto <D.33494>;
  <D.33493>:
  D.33495 = tls->context.valid;
  if (D.33495 == 0) goto <D.33496>; else goto <D.33497>;
  <D.33496>:
  D.33498 = &tls->context;
  mono_thread_state_init_from_monoctx (D.33498, ctx);
  <D.33497>:
  D.33499 = tls->thread;
  compute_frame_info (D.33499, tls);
  D.33500 = req->nframes;
  if (D.33500 != 0) goto <D.33501>; else goto <D.33502>;
  <D.33501>:
  D.33503 = tls->frame_count;
  if (D.33503 != 0) goto <D.33504>; else goto <D.33505>;
  <D.33504>:
  D.33503 = tls->frame_count;
  D.33500 = req->nframes;
  if (D.33503 > D.33500) goto <D.33506>; else goto <D.33507>;
  <D.33506>:
  log_level.488 = log_level;
  D.33481 = log_level.488 > 0;
  D.33482 = (long int) D.33481;
  D.33483 = __builtin_expect (D.33482, 0);
  if (D.33483 != 0) goto <D.33508>; else goto <D.33509>;
  <D.33508>:
  D.33510 = GetCurrentThreadId ();
  D.33511 = (void *) D.33510;
  log_file.489 = log_file;
  fprintf (log_file.489, "[%p] Breakpoint at lower frame while stepping over, continuing single stepping.\n", D.33511);
  log_file.489 = log_file;
  fflush (log_file.489);
  <D.33509>:
  D.33490 = 0;
  return D.33490;
  <D.33507>:
  <D.33505>:
  <D.33502>:
  <D.33494>:
  <D.33492>:
  D.33512 = req->size;
  if (D.33512 != 1) goto <D.33513>; else goto <D.33514>;
  <D.33513>:
  D.33490 = 1;
  return D.33490;
  <D.33514>:
  method = jinfo_get_method (ji);
  minfo = mono_debug_lookup_method (method);
  if (minfo != 0B) goto <D.33515>; else goto <D.33516>;
  <D.33515>:
  D.33486 = sp->il_offset;
  D.33517 = (unsigned int) D.33486;
  loc = mono_debug_symfile_lookup_location (minfo, D.33517);
  <D.33516>:
  if (loc == 0B) goto <D.33518>; else goto <D.33520>;
  <D.33520>:
  ss_req.490 = ss_req;
  D.33522 = ss_req.490->last_method;
  if (D.33522 == method) goto <D.33523>; else goto <D.33519>;
  <D.33523>:
  D.33524 = loc->row;
  ss_req.490 = ss_req;
  D.33525 = ss_req.490->last_line;
  D.33526 = (unsigned int) D.33525;
  if (D.33524 == D.33526) goto <D.33518>; else goto <D.33519>;
  <D.33518>:
  if (loc == 0B) goto <D.33527>; else goto <D.33528>;
  <D.33527>:
  log_level.488 = log_level;
  D.33481 = log_level.488 > 0;
  D.33482 = (long int) D.33481;
  D.33483 = __builtin_expect (D.33482, 0);
  if (D.33483 != 0) goto <D.33529>; else goto <D.33530>;
  <D.33529>:
  D.33486 = sp->il_offset;
  D.33531 = GetCurrentThreadId ();
  D.33532 = (void *) D.33531;
  log_file.489 = log_file;
  fprintf (log_file.489, "[%p] No line number info for il offset %x, continuing single stepping.\n", D.33532, D.33486);
  log_file.489 = log_file;
  fflush (log_file.489);
  <D.33530>:
  goto <D.33533>;
  <D.33528>:
  log_level.488 = log_level;
  D.33481 = log_level.488 > 0;
  D.33482 = (long int) D.33481;
  D.33483 = __builtin_expect (D.33482, 0);
  if (D.33483 != 0) goto <D.33534>; else goto <D.33535>;
  <D.33534>:
  D.33524 = loc->row;
  D.33536 = GetCurrentThreadId ();
  D.33537 = (void *) D.33536;
  log_file.489 = log_file;
  fprintf (log_file.489, "[%p] Same source line (%d), continuing single stepping.\n", D.33537, D.33524);
  log_file.489 = log_file;
  fflush (log_file.489);
  <D.33535>:
  <D.33533>:
  hit = 0;
  <D.33519>:
  if (loc != 0B) goto <D.33538>; else goto <D.33539>;
  <D.33538>:
  ss_req.490 = ss_req;
  ss_req.490->last_method = method;
  ss_req.490 = ss_req;
  D.33524 = loc->row;
  D.33540 = (int) D.33524;
  ss_req.490->last_line = D.33540;
  mono_debug_free_source_location (loc);
  <D.33539>:
  D.33490 = hit;
  return D.33490;
}


process_signal_event (void (*<T45ea>) (struct DebuggerTlsData *) func)
{
  unsigned int debugger_tls_id.491;
  struct MonoContext * D.33543;
  struct MonoContext * D.33544;
  struct DebuggerTlsData * tls;
  struct MonoContext orig_restore_ctx;
  struct MonoContext ctx;

  try
    {
      debugger_tls_id.491 = debugger_tls_id;
      tls = pthread_getspecific (debugger_tls_id.491);
      D.33543 = &tls->restore_ctx;
      memcpy (&orig_restore_ctx, D.33543, 136);
      D.33544 = &tls->handler_ctx;
      D.33543 = &tls->restore_ctx;
      memcpy (D.33543, D.33544, 136);
      func (tls);
      D.33543 = &tls->restore_ctx;
      memcpy (&ctx, D.33543, 136);
      D.33543 = &tls->restore_ctx;
      memcpy (D.33543, &orig_restore_ctx, 136);
      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.492;
  long unsigned int D.33548;
  void * D.33549;
  struct _IO_FILE * stderr.493;
  _Bool D.33551;
  long int D.33552;
  long int D.33553;
  struct MonoContext * D.33556;
  struct DebuggerTlsData * tls;
  struct MonoContext ctx;

  try
    {
      debugger_tls_id.492 = debugger_tls_id;
      tls = pthread_getspecific (debugger_tls_id.492);
      if (tls == 0B) goto <D.33546>; else goto <D.33547>;
      <D.33546>:
      D.33548 = GetCurrentThreadId ();
      D.33549 = (void *) D.33548;
      stderr.493 = stderr;
      fprintf (stderr.493, "Thread %p is not attached to the JIT.\n", D.33549);
      <D.33547>:
      D.33551 = tls == 0B;
      D.33552 = (long int) D.33551;
      D.33553 = __builtin_expect (D.33552, 0);
      if (D.33553 != 0) goto <D.33554>; else goto <D.33555>;
      <D.33554>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 4690, "tls");
      <D.33555>:
      mono_arch_sigctx_to_monoctx (sigctx, &ctx);
      D.33556 = &tls->handler_ctx;
      memcpy (D.33556, &ctx, 136);
      mono_arch_setup_resume_sighandler_ctx (&ctx, func);
      mono_arch_monoctx_to_sigctx (&ctx, sigctx);
    }
  finally
    {
      ctx = {CLOBBER};
    }
}


mono_debugger_agent_user_break ()
{
  int D.33557;
  long int D.33560;
  void * D.33561;
  _Bool D.33562;
  long int D.33563;
  long int D.33564;
  int suspend_policy.494;

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

    try
      {
        ctx.rip = 0;
        mono_walk_stack_with_ctx (user_break_cb, 0B, 0, &ctx);
        D.33560 = ctx.rip;
        D.33561 = (void *) D.33560;
        D.33562 = D.33561 == 0B;
        D.33563 = (long int) D.33562;
        D.33564 = __builtin_expect (D.33563, 0);
        if (D.33564 != 0) goto <D.33565>; else goto <D.33566>;
        <D.33565>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 4747, "MONO_CONTEXT_GET_IP (&ctx) != NULL");
        <D.33566>:
        mono_loader_lock ();
        events = create_event_list (15, 0B, 0B, 0B, &suspend_policy);
        mono_loader_unlock ();
        suspend_policy.494 = suspend_policy;
        process_event (15, 0B, 0, &ctx, events, suspend_policy.494);
      }
    finally
      {
        ctx = {CLOBBER};
        suspend_policy = {CLOBBER};
      }
  }
  goto <D.33568>;
  <D.33559>:
  __asm__ __volatile__("int $03");
  <D.33568>:
}


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

  D.33569 = frame->managed;
  if (D.33569 != 0) goto <D.33570>; else goto <D.33571>;
  <D.33570>:
  MEM[(struct MonoContext *)data] = *ctx;
  D.33572 = 1;
  return D.33572;
  <D.33571>:
  D.33572 = 0;
  return D.33572;
}


mono_debugger_agent_single_step_event (void * sigctx)
{
  long unsigned int D.33574;
  long unsigned int debugger_thread_id.495;

  D.33574 = GetCurrentThreadId ();
  debugger_thread_id.495 = debugger_thread_id;
  if (D.33574 == debugger_thread_id.495) goto <D.33576>; else goto <D.33577>;
  <D.33576>:
  {
    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.33577>:
  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 int D.33580;
  int suspend_count.496;
  struct SingleStepReq * ss_req.497;
  struct MonoInternalThread * D.33587;
  struct MonoInternalThread * D.33588;
  int log_level.498;
  struct MonoDomain * D.33594;
  _Bool D.33595;
  long int D.33596;
  long int D.33597;
  void * D.33600;
  long int D.33601;
  void * D.33602;
  void * D.33603;
  struct MonoMethod * D.33604;
  char * D.33605;
  <unnamed type> D.33606;
  const char * D.33607;
  long unsigned int D.33608;
  void * D.33609;
  struct FILE * log_file.499;
  struct MonoDomain * D.33611;
  _Bool D.33612;
  long int D.33613;
  long int D.33614;
  _Bool D.33617;
  long int D.33618;
  long int D.33619;
  unsigned char D.33622;
  unsigned char D.33623;
  _Bool D.33624;
  _Bool D.33625;
  _Bool D.33626;
  struct MonoClass * D.33631;
  struct MonoClass * D.33632;
  int D.26465;
  int iftmp.500;
  int D.26464;
  const char[7] * D.33638;
  unsigned char D.33639;
  int D.33640;
  unsigned char D.33641;
  int D.33642;
  _Bool D.33643;
  _Bool D.33644;
  _Bool D.33645;
  const unsigned char * D.33648;
  unsigned char D.33649;
  int D.33650;
  const unsigned char * D.33651;
  unsigned char D.33652;
  int D.33653;
  _Bool D.33654;
  _Bool D.33655;
  const unsigned char * D.33658;
  unsigned char D.33659;
  int D.33660;
  const unsigned char * D.33661;
  unsigned char D.33662;
  int D.33663;
  _Bool D.33664;
  _Bool D.33665;
  const unsigned char * D.33668;
  unsigned char D.33669;
  int D.33670;
  const unsigned char * D.33671;
  unsigned char D.33672;
  int D.33673;
  const char * D.33675;
  char * D.33677;
  long int ip.501;
  void * D.33679;
  long int D.33680;
  long int D.33681;
  int D.33682;
  struct MonoDomain * domain.502;
  int D.33686;
  struct MonoSeqPointInfo * info.503;
  <unnamed type> D.33690;
  unsigned int D.33691;
  short unsigned int D.33694;
  int D.33695;
  int D.33696;
  int D.26474;
  int iftmp.504;
  int D.26473;
  const char[7] * D.33702;
  unsigned char D.33703;
  int D.33704;
  unsigned char D.33705;
  int D.33706;
  _Bool D.33707;
  _Bool D.33708;
  _Bool D.33709;
  const unsigned char * D.33712;
  unsigned char D.33713;
  int D.33714;
  const unsigned char * D.33715;
  unsigned char D.33716;
  int D.33717;
  _Bool D.33718;
  _Bool D.33719;
  const unsigned char * D.33722;
  unsigned char D.33723;
  int D.33724;
  const unsigned char * D.33725;
  unsigned char D.33726;
  int D.33727;
  _Bool D.33728;
  _Bool D.33729;
  const unsigned char * D.33732;
  unsigned char D.33733;
  int D.33734;
  const unsigned char * D.33735;
  unsigned char D.33736;
  int D.33737;
  struct EventRequest * D.33741;
  int suspend_policy.505;
  struct MonoMethod * D.33743;
  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.33580 = ctx->rip;
      ip = (guint8 *) D.33580;
      mono_arch_skip_single_step (ctx);
      suspend_count.496 = suspend_count;
      if (suspend_count.496 > 0) goto <D.33582>; else goto <D.33583>;
      <D.33582>:
      process_suspend (tls, ctx);
      return;
      <D.33583>:
      ss_req.497 = ss_req;
      if (ss_req.497 == 0B) goto <D.33585>; else goto <D.33586>;
      <D.33585>:
      return;
      <D.33586>:
      D.33587 = mono_thread_internal_current ();
      ss_req.497 = ss_req;
      D.33588 = ss_req.497->thread;
      if (D.33587 != D.33588) goto <D.33589>; else goto <D.33590>;
      <D.33589>:
      return;
      <D.33590>:
      log_level.498 = log_level;
      if (log_level.498 > 0) goto <D.33592>; else goto <D.33593>;
      <D.33592>:
      D.33594 = mono_domain_get ();
      ji = mini_jit_info_table_find (D.33594, ip, &domain);
      log_level.498 = log_level;
      D.33595 = log_level.498 > 0;
      D.33596 = (long int) D.33595;
      D.33597 = __builtin_expect (D.33596, 0);
      if (D.33597 != 0) goto <D.33598>; else goto <D.33599>;
      <D.33598>:
      ss_req.497 = ss_req;
      D.33600 = ss_req.497->last_sp;
      D.33601 = ctx->rsp;
      D.33602 = (void *) D.33601;
      D.33580 = ctx->rip;
      D.33603 = (void *) D.33580;
      D.33604 = jinfo_get_method (ji);
      D.33605 = mono_method_full_name (D.33604, 1);
      ss_req.497 = ss_req;
      D.33606 = ss_req.497->depth;
      D.33607 = ss_depth_to_string (D.33606);
      D.33608 = GetCurrentThreadId ();
      D.33609 = (void *) D.33608;
      log_file.499 = log_file;
      fprintf (log_file.499, "[%p] Single step event (depth=%s) at %s (%p), sp %p, last sp %p\n", D.33609, D.33607, D.33605, D.33603, D.33602, D.33600);
      log_file.499 = log_file;
      fflush (log_file.499);
      <D.33599>:
      <D.33593>:
      D.33611 = mono_domain_get ();
      ji = mini_jit_info_table_find (D.33611, ip, &domain);
      D.33612 = ji == 0B;
      D.33613 = (long int) D.33612;
      D.33614 = __builtin_expect (D.33613, 0);
      if (D.33614 != 0) goto <D.33615>; else goto <D.33616>;
      <D.33615>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 4813, "ji");
      <D.33616>:
      method = jinfo_get_method (ji);
      D.33617 = method == 0B;
      D.33618 = (long int) D.33617;
      D.33619 = __builtin_expect (D.33618, 0);
      if (D.33619 != 0) goto <D.33620>; else goto <D.33621>;
      <D.33620>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 4815, "method");
      <D.33621>:
      D.33622 = BIT_FIELD_REF <*method, 8, 256>;
      D.33623 = D.33622 & 124;
      D.33624 = D.33623 != 0;
      D.33625 = D.33623 != 68;
      D.33626 = D.33624 & D.33625;
      if (D.33626 != 0) goto <D.33627>; else goto <D.33628>;
      <D.33627>:
      return;
      <D.33628>:
      D.33631 = method->klass;
      D.33632 = mono_defaults.string_class;
      if (D.33631 == D.33632) goto <D.33633>; else goto <D.33634>;
      <D.33633>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          __s2 = method->name;
          D.33638 = "memset";
          D.33639 = MEM[(const unsigned char *)D.33638];
          D.33640 = (int) D.33639;
          D.33641 = *__s2;
          D.33642 = (int) D.33641;
          __result = D.33640 - D.33642;
          {
            D.33643 = __s2_len != 0;
            D.33644 = __result == 0;
            D.33645 = D.33643 & D.33644;
            if (D.33645 != 0) goto <D.33646>; else goto <D.33647>;
            <D.33646>:
            D.33648 = &MEM[(void *)"memset" + 1B];
            D.33649 = *D.33648;
            D.33650 = (int) D.33649;
            D.33651 = __s2 + 1;
            D.33652 = *D.33651;
            D.33653 = (int) D.33652;
            __result = D.33650 - D.33653;
            D.33654 = __s2_len > 1;
            D.33644 = __result == 0;
            D.33655 = D.33654 & D.33644;
            if (D.33655 != 0) goto <D.33656>; else goto <D.33657>;
            <D.33656>:
            D.33658 = &MEM[(void *)"memset" + 2B];
            D.33659 = *D.33658;
            D.33660 = (int) D.33659;
            D.33661 = __s2 + 2;
            D.33662 = *D.33661;
            D.33663 = (int) D.33662;
            __result = D.33660 - D.33663;
            D.33664 = __s2_len > 2;
            D.33644 = __result == 0;
            D.33665 = D.33664 & D.33644;
            if (D.33665 != 0) goto <D.33666>; else goto <D.33667>;
            <D.33666>:
            D.33668 = &MEM[(void *)"memset" + 3B];
            D.33669 = *D.33668;
            D.33670 = (int) D.33669;
            D.33671 = __s2 + 3;
            D.33672 = *D.33671;
            D.33673 = (int) D.33672;
            __result = D.33670 - D.33673;
            <D.33667>:
            <D.33657>:
            <D.33647>:
          }
          D.26464 = __result;
        }
        iftmp.500 = -D.26464;
        goto <D.33674>;
        <D.33637>:
        D.33675 = method->name;
        iftmp.500 = __builtin_strcmp (D.33675, "memset");
        <D.33674>:
        D.26465 = iftmp.500;
      }
      if (D.26465 == 0) goto <D.33629>; else goto <D.33676>;
      <D.33676>:
      D.33675 = method->name;
      D.33677 = strstr (D.33675, "memcpy");
      if (D.33677 != 0B) goto <D.33629>; else goto <D.33630>;
      <D.33629>:
      return;
      <D.33630>:
      <D.33634>:
      ip.501 = (long int) ip;
      D.33679 = ji->code_start;
      D.33680 = (long int) D.33679;
      D.33681 = ip.501 - D.33680;
      D.33682 = (int) D.33681;
      domain.502 = domain;
      sp = find_next_seq_point_for_native_offset (domain.502, method, D.33682, &info);
      if (sp == 0B) goto <D.33684>; else goto <D.33685>;
      <D.33684>:
      return;
      <D.33685>:
      il_offset = sp->il_offset;
      ss_req.497 = ss_req;
      D.33686 = ss_update (ss_req.497, ji, sp, tls, ctx);
      if (D.33686 == 0) goto <D.33687>; else goto <D.33688>;
      <D.33687>:
      return;
      <D.33688>:
      info.503 = info;
      ss_req.497 = ss_req;
      ss_start (ss_req.497, method, sp, info.503, ctx, tls, 0);
      ss_req.497 = ss_req;
      D.33690 = ss_req.497->filter;
      D.33691 = D.33690 & 1;
      if (D.33691 != 0) goto <D.33692>; else goto <D.33693>;
      <D.33692>:
      D.33694 = method->flags;
      D.33695 = (int) D.33694;
      D.33696 = D.33695 & 2048;
      if (D.33696 != 0) goto <D.33697>; else goto <D.33698>;
      <D.33697>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          __s2 = method->name;
          D.33702 = ".cctor";
          D.33703 = MEM[(const unsigned char *)D.33702];
          D.33704 = (int) D.33703;
          D.33705 = *__s2;
          D.33706 = (int) D.33705;
          __result = D.33704 - D.33706;
          {
            D.33707 = __s2_len != 0;
            D.33708 = __result == 0;
            D.33709 = D.33707 & D.33708;
            if (D.33709 != 0) goto <D.33710>; else goto <D.33711>;
            <D.33710>:
            D.33712 = &MEM[(void *)".cctor" + 1B];
            D.33713 = *D.33712;
            D.33714 = (int) D.33713;
            D.33715 = __s2 + 1;
            D.33716 = *D.33715;
            D.33717 = (int) D.33716;
            __result = D.33714 - D.33717;
            D.33718 = __s2_len > 1;
            D.33708 = __result == 0;
            D.33719 = D.33718 & D.33708;
            if (D.33719 != 0) goto <D.33720>; else goto <D.33721>;
            <D.33720>:
            D.33722 = &MEM[(void *)".cctor" + 2B];
            D.33723 = *D.33722;
            D.33724 = (int) D.33723;
            D.33725 = __s2 + 2;
            D.33726 = *D.33725;
            D.33727 = (int) D.33726;
            __result = D.33724 - D.33727;
            D.33728 = __s2_len > 2;
            D.33708 = __result == 0;
            D.33729 = D.33728 & D.33708;
            if (D.33729 != 0) goto <D.33730>; else goto <D.33731>;
            <D.33730>:
            D.33732 = &MEM[(void *)".cctor" + 3B];
            D.33733 = *D.33732;
            D.33734 = (int) D.33733;
            D.33735 = __s2 + 3;
            D.33736 = *D.33735;
            D.33737 = (int) D.33736;
            __result = D.33734 - D.33737;
            <D.33731>:
            <D.33721>:
            <D.33711>:
          }
          D.26473 = __result;
        }
        iftmp.504 = -D.26473;
        goto <D.33738>;
        <D.33701>:
        D.33675 = method->name;
        iftmp.504 = __builtin_strcmp (D.33675, ".cctor");
        <D.33738>:
        D.26474 = iftmp.504;
      }
      if (D.26474 == 0) goto <D.33739>; else goto <D.33740>;
      <D.33739>:
      return;
      <D.33740>:
      <D.33698>:
      <D.33693>:
      reqs = monoeg_g_ptr_array_new ();
      mono_loader_lock ();
      ss_req.497 = ss_req;
      D.33741 = ss_req.497->req;
      monoeg_g_ptr_array_add (reqs, D.33741);
      events = create_event_list (11, reqs, ji, 0B, &suspend_policy);
      monoeg_g_ptr_array_free (reqs, 1);
      mono_loader_unlock ();
      suspend_policy.505 = suspend_policy;
      D.33743 = jinfo_get_method (ji);
      process_event (11, D.33743, il_offset, ctx, events, suspend_policy.505);
    }
  finally
    {
      suspend_policy = {CLOBBER};
      domain = {CLOBBER};
      info = {CLOBBER};
    }
}


process_suspend (struct DebuggerTlsData * tls, struct MonoContext * ctx)
{
  long int D.33747;
  int D.33748;
  long unsigned int D.33751;
  long unsigned int debugger_thread_id.506;
  int suspend_count.507;
  unsigned int suspend_count.508;
  unsigned int D.33757;
  int log_level.509;
  _Bool D.33761;
  long int D.33762;
  long int D.33763;
  long unsigned int D.33766;
  void * D.33767;
  struct FILE * log_file.510;
  long unsigned int D.33773;
  void * D.33774;
  struct MonoDomain * D.33775;
  struct MonoClass * D.33778;
  struct MonoClass * D.33779;
  int D.25838;
  int iftmp.511;
  int D.25837;
  const char[7] * D.33785;
  unsigned char D.33786;
  int D.33787;
  unsigned char D.33788;
  int D.33789;
  _Bool D.33790;
  _Bool D.33791;
  _Bool D.33792;
  const unsigned char * D.33795;
  unsigned char D.33796;
  int D.33797;
  const unsigned char * D.33798;
  unsigned char D.33799;
  int D.33800;
  _Bool D.33801;
  _Bool D.33802;
  const unsigned char * D.33805;
  unsigned char D.33806;
  int D.33807;
  const unsigned char * D.33808;
  unsigned char D.33809;
  int D.33810;
  _Bool D.33811;
  _Bool D.33812;
  const unsigned char * D.33815;
  unsigned char D.33816;
  int D.33817;
  const unsigned char * D.33818;
  unsigned char D.33819;
  int D.33820;
  const char * D.33822;
  char * D.33824;
  guint8 * ip;
  struct MonoJitInfo * ji;
  struct MonoMethod * method;

  D.33747 = ctx->rip;
  ip = (guint8 *) D.33747;
  D.33748 = mono_loader_lock_is_owned_by_self ();
  if (D.33748 != 0) goto <D.33749>; else goto <D.33750>;
  <D.33749>:
  return;
  <D.33750>:
  D.33751 = GetCurrentThreadId ();
  debugger_thread_id.506 = debugger_thread_id;
  if (D.33751 == debugger_thread_id.506) goto <D.33753>; else goto <D.33754>;
  <D.33753>:
  return;
  <D.33754>:
  suspend_count.507 = suspend_count;
  suspend_count.508 = (unsigned int) suspend_count.507;
  D.33757 = tls->resume_count;
  if (suspend_count.508 != D.33757) goto <D.33758>; else goto <D.33759>;
  <D.33758>:
  tls->suspending = 1;
  <D.33759>:
  log_level.509 = log_level;
  D.33761 = log_level.509 > 0;
  D.33762 = (long int) D.33761;
  D.33763 = __builtin_expect (D.33762, 0);
  if (D.33763 != 0) goto <D.33764>; else goto <D.33765>;
  <D.33764>:
  D.33766 = GetCurrentThreadId ();
  D.33767 = (void *) D.33766;
  log_file.510 = log_file;
  fprintf (log_file.510, "[%p] Received single step event for suspending.\n", D.33767);
  log_file.510 = log_file;
  fflush (log_file.510);
  <D.33765>:
  suspend_count.507 = suspend_count;
  suspend_count.508 = (unsigned int) suspend_count.507;
  D.33757 = tls->resume_count;
  if (suspend_count.508 == D.33757) goto <D.33769>; else goto <D.33770>;
  <D.33769>:
  log_level.509 = log_level;
  D.33761 = log_level.509 > 0;
  D.33762 = (long int) D.33761;
  D.33763 = __builtin_expect (D.33762, 0);
  if (D.33763 != 0) goto <D.33771>; else goto <D.33772>;
  <D.33771>:
  D.33773 = GetCurrentThreadId ();
  D.33774 = (void *) D.33773;
  log_file.510 = log_file;
  fprintf (log_file.510, "[%p] Ignored during single threaded invoke.\n", D.33774);
  log_file.510 = log_file;
  fflush (log_file.510);
  <D.33772>:
  return;
  <D.33770>:
  D.33775 = mono_domain_get ();
  ji = mini_jit_info_table_find (D.33775, ip, 0B);
  method = jinfo_get_method (ji);
  D.33778 = method->klass;
  D.33779 = mono_defaults.string_class;
  if (D.33778 == D.33779) goto <D.33780>; else goto <D.33781>;
  <D.33780>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = method->name;
      D.33785 = "memset";
      D.33786 = MEM[(const unsigned char *)D.33785];
      D.33787 = (int) D.33786;
      D.33788 = *__s2;
      D.33789 = (int) D.33788;
      __result = D.33787 - D.33789;
      {
        D.33790 = __s2_len != 0;
        D.33791 = __result == 0;
        D.33792 = D.33790 & D.33791;
        if (D.33792 != 0) goto <D.33793>; else goto <D.33794>;
        <D.33793>:
        D.33795 = &MEM[(void *)"memset" + 1B];
        D.33796 = *D.33795;
        D.33797 = (int) D.33796;
        D.33798 = __s2 + 1;
        D.33799 = *D.33798;
        D.33800 = (int) D.33799;
        __result = D.33797 - D.33800;
        D.33801 = __s2_len > 1;
        D.33791 = __result == 0;
        D.33802 = D.33801 & D.33791;
        if (D.33802 != 0) goto <D.33803>; else goto <D.33804>;
        <D.33803>:
        D.33805 = &MEM[(void *)"memset" + 2B];
        D.33806 = *D.33805;
        D.33807 = (int) D.33806;
        D.33808 = __s2 + 2;
        D.33809 = *D.33808;
        D.33810 = (int) D.33809;
        __result = D.33807 - D.33810;
        D.33811 = __s2_len > 2;
        D.33791 = __result == 0;
        D.33812 = D.33811 & D.33791;
        if (D.33812 != 0) goto <D.33813>; else goto <D.33814>;
        <D.33813>:
        D.33815 = &MEM[(void *)"memset" + 3B];
        D.33816 = *D.33815;
        D.33817 = (int) D.33816;
        D.33818 = __s2 + 3;
        D.33819 = *D.33818;
        D.33820 = (int) D.33819;
        __result = D.33817 - D.33820;
        <D.33814>:
        <D.33804>:
        <D.33794>:
      }
      D.25837 = __result;
    }
    iftmp.511 = -D.25837;
    goto <D.33821>;
    <D.33784>:
    D.33822 = method->name;
    iftmp.511 = __builtin_strcmp (D.33822, "memset");
    <D.33821>:
    D.25838 = iftmp.511;
  }
  if (D.25838 == 0) goto <D.33776>; else goto <D.33823>;
  <D.33823>:
  D.33822 = method->name;
  D.33824 = strstr (D.33822, "memcpy");
  if (D.33824 != 0B) goto <D.33776>; else goto <D.33777>;
  <D.33776>:
  return;
  <D.33777>:
  <D.33781>:
  save_thread_context (ctx);
  suspend_current ();
}


debugger_agent_single_step_from_context (struct MonoContext * ctx)
{
  unsigned int debugger_tls_id.512;
  _Bool D.33827;
  long int D.33828;
  long int D.33829;
  struct MonoContext * D.33832;
  struct DebuggerTlsData * tls;
  struct MonoContext orig_restore_ctx;

  try
    {
      debugger_tls_id.512 = debugger_tls_id;
      tls = pthread_getspecific (debugger_tls_id.512);
      D.33827 = tls == 0B;
      D.33828 = (long int) D.33827;
      D.33829 = __builtin_expect (D.33828, 0);
      if (D.33829 != 0) goto <D.33830>; else goto <D.33831>;
      <D.33830>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 4909, "tls");
      <D.33831>:
      D.33832 = &tls->restore_ctx;
      memcpy (&orig_restore_ctx, D.33832, 136);
      D.33832 = &tls->restore_ctx;
      memcpy (D.33832, ctx, 136);
      process_single_step_inner (tls);
      D.33832 = &tls->restore_ctx;
      memcpy (ctx, D.33832, 136);
      D.33832 = &tls->restore_ctx;
      memcpy (D.33832, &orig_restore_ctx, 136);
    }
  finally
    {
      orig_restore_ctx = {CLOBBER};
    }
}


debugger_agent_breakpoint_from_context (struct MonoContext * ctx)
{
  unsigned int debugger_tls_id.513;
  _Bool D.33834;
  long int D.33835;
  long int D.33836;
  struct MonoContext * D.33839;
  struct DebuggerTlsData * tls;
  struct MonoContext orig_restore_ctx;

  try
    {
      debugger_tls_id.513 = debugger_tls_id;
      tls = pthread_getspecific (debugger_tls_id.513);
      D.33834 = tls == 0B;
      D.33835 = (long int) D.33834;
      D.33836 = __builtin_expect (D.33835, 0);
      if (D.33836 != 0) goto <D.33837>; else goto <D.33838>;
      <D.33837>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debugger-agent.c", 4928, "tls");
      <D.33838>:
      D.33839 = &tls->restore_ctx;
      memcpy (&orig_restore_ctx, D.33839, 136);
      D.33839 = &tls->restore_ctx;
      memcpy (D.33839, ctx, 136);
      process_breakpoint_inner (tls);
      D.33839 = &tls->restore_ctx;
      memcpy (ctx, D.33839, 136);
      D.33839 = &tls->restore_ctx;
      memcpy (D.33839, &orig_restore_ctx, 136);
    }
  finally
    {
      orig_restore_ctx = {CLOBBER};
    }
}


mono_debugger_agent_debug_log (int level, struct MonoString * category, struct MonoString * message)
{
  int D.33840;
  char * iftmp.514;
  char * iftmp.515;
  int suspend_policy.516;
  char * D.33852;
  char * D.33853;
  int suspend_policy;
  struct GSList * events;
  struct EventInfo ei;

  try
    {
      D.33840 = agent_config.enabled;
      if (D.33840 == 0) goto <D.33841>; else goto <D.33842>;
      <D.33841>:
      return;
      <D.33842>:
      mono_loader_lock ();
      events = create_event_list (16, 0B, 0B, 0B, &suspend_policy);
      mono_loader_unlock ();
      ei.level = level;
      if (category != 0B) goto <D.33844>; else goto <D.33845>;
      <D.33844>:
      iftmp.514 = mono_string_to_utf8 (category);
      goto <D.33846>;
      <D.33845>:
      iftmp.514 = 0B;
      <D.33846>:
      ei.category = iftmp.514;
      if (message != 0B) goto <D.33848>; else goto <D.33849>;
      <D.33848>:
      iftmp.515 = mono_string_to_utf8 (message);
      goto <D.33850>;
      <D.33849>:
      iftmp.515 = 0B;
      <D.33850>:
      ei.message = iftmp.515;
      suspend_policy.516 = suspend_policy;
      process_event (16, &ei, 0, 0B, events, suspend_policy.516);
      D.33852 = ei.category;
      monoeg_g_free (D.33852);
      D.33853 = ei.message;
      monoeg_g_free (D.33853);
    }
  finally
    {
      suspend_policy = {CLOBBER};
      ei = {CLOBBER};
    }
}


mono_debugger_agent_debug_log_is_enabled ()
{
  gboolean D.33857;

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


mono_debugger_agent_handle_exception (struct MonoException * exc, struct MonoContext * throw_ctx, struct MonoContext * catch_ctx)
{
  struct MonoGHashTable * thread_to_tls.517;
  int D.33864;
  int D.33869;
  int D.33874;
  int inited.518;
  struct GSList * D.33881;
  struct MonoVTable * D.33886;
  struct MonoClass * D.33887;
  struct MonoType * D.33888;
  int D.26602;
  int iftmp.519;
  int D.26601;
  const char[1] * D.33894;
  unsigned char D.33895;
  int D.33896;
  unsigned char D.33897;
  int D.33898;
  _Bool D.33899;
  _Bool D.33900;
  _Bool D.33901;
  const unsigned char * D.33904;
  unsigned char D.33905;
  int D.33906;
  const unsigned char * D.33907;
  unsigned char D.33908;
  int D.33909;
  _Bool D.33910;
  _Bool D.33911;
  const unsigned char * D.33914;
  unsigned char D.33915;
  int D.33916;
  const unsigned char * D.33917;
  unsigned char D.33918;
  int D.33919;
  _Bool D.33920;
  _Bool D.33921;
  const unsigned char * D.33924;
  unsigned char D.33925;
  int D.33926;
  const unsigned char * D.33927;
  unsigned char D.33928;
  int D.33929;
  unsigned char D.33931;
  int D.26611;
  long int D.33937;
  char * D.33938;
  struct MonoDomain * D.33939;
  long int D.33942;
  char * D.33943;
  struct MonoDomain * D.33944;
  _Bool D.33946;
  int D.33947;
  struct GPtrArray * event_requests.520;
  void * * D.33949;
  long unsigned int D.33950;
  long unsigned int D.33951;
  void * * D.33952;
  int D.33953;
  <unnamed type> D.33956;
  long unsigned int D.33963;
  long unsigned int D.33964;
  struct MonoAssembly * * D.33965;
  struct MonoAssembly * D.33966;
  struct MonoMethod * D.33967;
  struct MonoClass * D.33968;
  struct MonoImage * D.33969;
  struct MonoAssembly * D.33970;
  int D.33975;
  unsigned int i.521;
  unsigned int D.33977;
  int D.33980;
  struct MonoThreadUnwindState * D.33985;
  struct MonoDomain * D.33986;
  int suspend_policy.522;
  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.517 = thread_to_tls;
      if (thread_to_tls.517 != 0B) goto <D.33860>; else goto <D.33861>;
      <D.33860>:
      {
        struct MonoInternalThread * thread;

        thread = mono_thread_internal_current ();
        mono_loader_lock ();
        thread_to_tls.517 = thread_to_tls;
        tls = mono_g_hash_table_lookup (thread_to_tls.517, thread);
        mono_loader_unlock ();
        if (tls != 0B) goto <D.33862>; else goto <D.33863>;
        <D.33862>:
        D.33864 = tls->abort_requested;
        if (D.33864 != 0) goto <D.33865>; else goto <D.33866>;
        <D.33865>:
        return;
        <D.33866>:
        <D.33863>:
        if (tls != 0B) goto <D.33867>; else goto <D.33868>;
        <D.33867>:
        D.33869 = tls->disable_breakpoints;
        if (D.33869 != 0) goto <D.33870>; else goto <D.33871>;
        <D.33870>:
        return;
        <D.33871>:
        <D.33868>:
      }
      <D.33861>:
      memset (&ei, 0, 176);
      if (catch_ctx == 0B) goto <D.33872>; else goto <D.33873>;
      <D.33872>:
      D.33874 = agent_config.onuncaught;
      if (D.33874 != 0) goto <D.33875>; else goto <D.33876>;
      <D.33875>:
      inited.518 = inited;
      if (inited.518 == 0) goto <D.33878>; else goto <D.33879>;
      <D.33878>:
      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.33879>:
      <D.33876>:
      goto <D.33880>;
      <D.33873>:
      D.33881 = agent_config.onthrow;
      if (D.33881 != 0B) goto <D.33882>; else goto <D.33883>;
      <D.33882>:
      inited.518 = inited;
      if (inited.518 == 0) goto <D.33884>; else goto <D.33885>;
      <D.33884>:
      {
        struct GSList * l;
        gboolean found;

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

          ex_type = l->data;
          D.33886 = exc->object.vtable;
          D.33887 = D.33886->klass;
          D.33888 = &D.33887->byval_arg;
          f = mono_type_full_name (D.33888);
          {
            size_t __s1_len;
            size_t __s2_len;

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

              __s2 = ex_type;
              D.33894 = "";
              D.33895 = MEM[(const unsigned char *)D.33894];
              D.33896 = (int) D.33895;
              D.33897 = *__s2;
              D.33898 = (int) D.33897;
              __result = D.33896 - D.33898;
              {
                D.33899 = __s2_len != 0;
                D.33900 = __result == 0;
                D.33901 = D.33899 & D.33900;
                if (D.33901 != 0) goto <D.33902>; else goto <D.33903>;
                <D.33902>:
                D.33904 = &MEM[(void *)"" + 1B];
                D.33905 = *D.33904;
                D.33906 = (int) D.33905;
                D.33907 = __s2 + 1;
                D.33908 = *D.33907;
                D.33909 = (int) D.33908;
                __result = D.33906 - D.33909;
                D.33910 = __s2_len > 1;
                D.33900 = __result == 0;
                D.33911 = D.33910 & D.33900;
                if (D.33911 != 0) goto <D.33912>; else goto <D.33913>;
                <D.33912>:
                D.33914 = &MEM[(void *)"" + 2B];
                D.33915 = *D.33914;
                D.33916 = (int) D.33915;
                D.33917 = __s2 + 2;
                D.33918 = *D.33917;
                D.33919 = (int) D.33918;
                __result = D.33916 - D.33919;
                D.33920 = __s2_len > 2;
                D.33900 = __result == 0;
                D.33921 = D.33920 & D.33900;
                if (D.33921 != 0) goto <D.33922>; else goto <D.33923>;
                <D.33922>:
                D.33924 = &MEM[(void *)"" + 3B];
                D.33925 = *D.33924;
                D.33926 = (int) D.33925;
                D.33927 = __s2 + 3;
                D.33928 = *D.33927;
                D.33929 = (int) D.33928;
                __result = D.33926 - D.33929;
                <D.33923>:
                <D.33913>:
                <D.33903>:
              }
              D.26601 = __result;
            }
            iftmp.519 = -D.26601;
            goto <D.33930>;
            <D.33893>:
            D.33931 = MEM[(const unsigned char * {ref-all})ex_type];
            iftmp.519 = (int) D.33931;
            <D.33930>:
            D.26602 = iftmp.519;
          }
          if (D.26602 == 0) goto <D.33889>; else goto <D.33932>;
          <D.33932>:
          {
            size_t __s1_len;
            size_t __s2_len;

            D.26611 = __builtin_strcmp (ex_type, f);
          }
          if (D.26611 == 0) goto <D.33889>; else goto <D.33890>;
          <D.33889>:
          found = 1;
          <D.33890>:
          monoeg_g_free (f);
        }
        l = l->next;
        <D.26613>:
        if (l != 0B) goto <D.26612>; else goto <D.26614>;
        <D.26614>:
        if (found != 0) goto <D.33933>; else goto <D.33934>;
        <D.33933>:
        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.33934>:
      }
      <D.33885>:
      <D.33883>:
      <D.33880>:
      inited.518 = inited;
      if (inited.518 == 0) goto <D.33935>; else goto <D.33936>;
      <D.33935>:
      return;
      <D.33936>:
      D.33937 = throw_ctx->rip;
      D.33938 = (char *) D.33937;
      D.33939 = mono_domain_get ();
      ji = mini_jit_info_table_find (D.33939, D.33938, 0B);
      if (catch_ctx != 0B) goto <D.33940>; else goto <D.33941>;
      <D.33940>:
      D.33942 = catch_ctx->rip;
      D.33943 = (char *) D.33942;
      D.33944 = mono_domain_get ();
      catch_ji = mini_jit_info_table_find (D.33944, D.33943, 0B);
      goto <D.33945>;
      <D.33941>:
      catch_ji = 0B;
      <D.33945>:
      ei.exc = exc;
      D.33946 = catch_ctx != 0B;
      D.33947 = (int) D.33946;
      ei.caught = D.33947;
      mono_loader_lock ();
      i = 0;
      goto <D.26628>;
      <D.26627>:
      {
        struct EventRequest * req;

        event_requests.520 = event_requests;
        D.33949 = event_requests.520->pdata;
        D.33950 = (long unsigned int) i;
        D.33951 = D.33950 * 8;
        D.33952 = D.33949 + D.33951;
        req = *D.33952;
        D.33953 = req->event_kind;
        if (D.33953 != 13) goto <D.33954>; else goto <D.33955>;
        <D.33954>:
        // predicted unlikely by continue predictor.
        goto <D.26616>;
        <D.33955>:
        j = 0;
        goto <D.26625>;
        <D.26624>:
        {
          struct Modifier * mod;

          mod = &req->modifiers[j];
          D.33956 = mod->kind;
          if (D.33956 == 11) goto <D.33957>; else goto <D.33958>;
          <D.33957>:
          if (catch_ji != 0B) goto <D.33959>; else goto <D.33960>;
          <D.33959>:
          {
            int k;
            gboolean found;
            struct MonoAssembly * * assemblies;

            found = 0;
            assemblies = mod->data.assemblies;
            if (assemblies != 0B) goto <D.33961>; else goto <D.33962>;
            <D.33961>:
            k = 0;
            goto <D.26622>;
            <D.26621>:
            D.33963 = (long unsigned int) k;
            D.33964 = D.33963 * 8;
            D.33965 = assemblies + D.33964;
            D.33966 = *D.33965;
            D.33967 = jinfo_get_method (catch_ji);
            D.33968 = D.33967->klass;
            D.33969 = D.33968->image;
            D.33970 = D.33969->assembly;
            if (D.33966 == D.33970) goto <D.33971>; else goto <D.33972>;
            <D.33971>:
            found = 1;
            <D.33972>:
            k = k + 1;
            <D.26622>:
            D.33963 = (long unsigned int) k;
            D.33964 = D.33963 * 8;
            D.33965 = assemblies + D.33964;
            D.33966 = *D.33965;
            if (D.33966 != 0B) goto <D.26621>; else goto <D.26623>;
            <D.26623>:
            <D.33962>:
            if (found == 0) goto <D.33973>; else goto <D.33974>;
            <D.33973>:
            ei.caught = 0;
            <D.33974>:
          }
          <D.33960>:
          <D.33958>:
        }
        j = j + 1;
        <D.26625>:
        D.33975 = req->nmodifiers;
        if (D.33975 > j) goto <D.26624>; else goto <D.26626>;
        <D.26626>:
      }
      <D.26616>:
      i = i + 1;
      <D.26628>:
      i.521 = (unsigned int) i;
      event_requests.520 = event_requests;
      D.33977 = event_requests.520->len;
      if (i.521 < D.33977) goto <D.26627>; else goto <D.26629>;
      <D.26629>:
      events = create_event_list (13, 0B, ji, &ei, &suspend_policy);
      mono_loader_unlock ();
      if (tls != 0B) goto <D.33978>; else goto <D.33979>;
      <D.33978>:
      D.33980 = ei.caught;
      if (D.33980 != 0) goto <D.33981>; else goto <D.33982>;
      <D.33981>:
      if (catch_ctx != 0B) goto <D.33983>; else goto <D.33984>;
      <D.33983>:
      D.33985 = &tls->catch_state;
      memset (D.33985, 0, 168);
      tls->catch_state.ctx = *catch_ctx;
      D.33986 = mono_domain_get ();
      tls->catch_state.unwind_data[0] = D.33986;
      tls->catch_state.valid = 1;
      <D.33984>:
      <D.33982>:
      <D.33979>:
      suspend_policy.522 = suspend_policy;
      process_event (13, &ei, 0, throw_ctx, events, suspend_policy.522);
      if (tls != 0B) goto <D.33988>; else goto <D.33989>;
      <D.33988>:
      tls->catch_state.valid = 0;
      <D.33989>:
    }
  finally
    {
      suspend_policy = {CLOBBER};
      ei = {CLOBBER};
    }
}


mono_debugger_agent_begin_exception_filter (struct MonoException * exc, struct MonoContext * ctx, struct MonoContext * orig_ctx)
{
  int inited.523;
  unsigned int debugger_tls_id.524;
  struct MonoThreadUnwindState * D.33999;
  int D.34000;
  _Bool D.34001;
  long int D.34002;
  long int D.34003;
  struct DebuggerTlsData * tls;

  inited.523 = inited;
  if (inited.523 == 0) goto <D.33994>; else goto <D.33995>;
  <D.33994>:
  return;
  <D.33995>:
  debugger_tls_id.524 = debugger_tls_id;
  tls = pthread_getspecific (debugger_tls_id.524);
  if (tls == 0B) goto <D.33997>; else goto <D.33998>;
  <D.33997>:
  return;
  <D.33998>:
  D.33999 = &tls->filter_state;
  D.34000 = mono_thread_state_init_from_monoctx (D.33999, orig_ctx);
  D.34001 = D.34000 == 0;
  D.34002 = (long int) D.34001;
  D.34003 = __builtin_expect (D.34002, 0);
  if (D.34003 != 0) goto <D.34004>; else goto <D.34005>;
  <D.34004>:
  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.34005>:
}


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

  inited.525 = inited;
  if (inited.525 == 0) goto <D.34008>; else goto <D.34009>;
  <D.34008>:
  return;
  <D.34009>:
  debugger_tls_id.526 = debugger_tls_id;
  tls = pthread_getspecific (debugger_tls_id.526);
  if (tls == 0B) goto <D.34011>; else goto <D.34012>;
  <D.34011>:
  return;
  <D.34012>:
  tls->filter_state.valid = 0;
}