get_typedef (struct MonoImage * m, int idx)
{
  char * D.18982;
  struct MonoTableInfo * D.18983;
  int D.18984;
  unsigned int D.18985;
  int D.18986;
  char * iftmp.0;
  int show_tokens.1;
  int token.2;
  int D.18995;
  unsigned int D.18996;
  const char * D.18997;
  const char * iftmp.3;
  const char * iftmp.4;
  char D.19003;
  const char * D.19007;
  const char * iftmp.5;
  guint32 cols[6];
  const char * ns;
  char * tstring;
  char * result;
  guint32 token;

  try
    {
      if (idx == 1) goto <D.18980>; else goto <D.18981>;
      <D.18980>:
      D.18982 = 0B;
      return D.18982;
      <D.18981>:
      D.18983 = &m->tables[2];
      D.18984 = idx + -1;
      mono_metadata_decode_row (D.18983, D.18984, &cols, 6);
      D.18985 = cols[2];
      ns = mono_metadata_string_heap (m, D.18985);
      D.18986 = idx | 33554432;
      token = (guint32) D.18986;
      token = mono_metadata_nested_in_typedef (m, token);
      show_tokens.1 = show_tokens;
      if (show_tokens.1 != 0) goto <D.18989>; else goto <D.18990>;
      <D.18989>:
      iftmp.0 = monoeg_g_strdup_printf ("/*%08x*/", token);
      goto <D.18991>;
      <D.18990>:
      iftmp.0 = 0B;
      <D.18991>:
      tstring = iftmp.0;
      if (token != 0) goto <D.18992>; else goto <D.18993>;
      <D.18992>:
      {
        char * outer;

        token.2 = (int) token;
        D.18995 = token.2 & 16777215;
        outer = get_typedef (m, D.18995);
        D.18996 = cols[1];
        D.18997 = mono_metadata_string_heap (m, D.18996);
        if (tstring != 0B) goto <D.18999>; else goto <D.19000>;
        <D.18999>:
        iftmp.3 = tstring;
        goto <D.19001>;
        <D.19000>:
        iftmp.3 = "";
        <D.19001>:
        result = monoeg_g_strdup_printf ("%s/%s%s", outer, D.18997, iftmp.3);
        monoeg_g_free (outer);
        monoeg_g_free (tstring);
        D.18982 = result;
        return D.18982;
      }
      <D.18993>:
      D.19003 = *ns;
      if (D.19003 != 0) goto <D.19004>; else goto <D.19005>;
      <D.19004>:
      iftmp.4 = ".";
      goto <D.19006>;
      <D.19005>:
      iftmp.4 = "";
      <D.19006>:
      D.18996 = cols[1];
      D.19007 = mono_metadata_string_heap (m, D.18996);
      if (tstring != 0B) goto <D.19009>; else goto <D.19010>;
      <D.19009>:
      iftmp.5 = tstring;
      goto <D.19011>;
      <D.19010>:
      iftmp.5 = "";
      <D.19011>:
      result = monoeg_g_strdup_printf ("%s%s%s%s", ns, iftmp.4, D.19007, iftmp.5);
      monoeg_g_free (tstring);
      D.18982 = result;
      return D.18982;
    }
  finally
    {
      cols = {CLOBBER};
    }
}


get_module (struct MonoImage * m, int idx)
{
  _Bool D.19014;
  long int D.19015;
  long int D.19016;
  struct MonoTableInfo * D.19019;
  int D.19020;
  char * D.19021;
  unsigned int D.19022;
  const char * D.19023;
  guint32 cols[5];

  try
    {
      D.19014 = idx != 1;
      D.19015 = (long int) D.19014;
      D.19016 = __builtin_expect (D.19015, 0);
      if (D.19016 != 0) goto <D.19017>; else goto <D.19018>;
      <D.19017>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "get.c", 92, "idx == 1");
      <D.19018>:
      D.19019 = &m->tables[0];
      D.19020 = idx + -1;
      mono_metadata_decode_row (D.19019, D.19020, &cols, 5);
      D.19022 = cols[1];
      D.19023 = mono_metadata_string_heap (m, D.19022);
      D.19021 = get_escaped_name (D.19023);
      return D.19021;
    }
  finally
    {
      cols = {CLOBBER};
    }
}


get_moduleref (struct MonoImage * m, int idx)
{
  struct MonoTableInfo * D.19026;
  int D.19027;
  char * D.19028;
  unsigned int D.19029;
  const char * D.19030;
  guint32 cols[1];

  try
    {
      D.19026 = &m->tables[26];
      D.19027 = idx + -1;
      mono_metadata_decode_row (D.19026, D.19027, &cols, 1);
      D.19029 = cols[0];
      D.19030 = mono_metadata_string_heap (m, D.19029);
      D.19028 = get_escaped_name (D.19030);
      return D.19028;
    }
  finally
    {
      cols = {CLOBBER};
    }
}


get_assemblyref (struct MonoImage * m, int idx)
{
  struct MonoTableInfo * D.19033;
  int D.19034;
  char * D.19035;
  unsigned int D.19036;
  const char * D.19037;
  guint32 cols[9];

  try
    {
      D.19033 = &m->tables[35];
      D.19034 = idx + -1;
      mono_metadata_decode_row (D.19033, D.19034, &cols, 9);
      D.19036 = cols[6];
      D.19037 = mono_metadata_string_heap (m, D.19036);
      D.19035 = get_escaped_name (D.19037);
      return D.19035;
    }
  finally
    {
      cols = {CLOBBER};
    }
}


get_typespec (struct MonoImage * m, guint32 idx, gboolean is_def, struct MonoGenericContainer * container)
{
  struct MonoTableInfo * D.19040;
  unsigned int D.19041;
  int D.19042;
  unsigned int D.19043;
  const char * ptr.6;
  const char * ptr.7;
  unsigned int D.19046;
  const char * ptr.8;
  const char * ptr.9;
  char D.19049;
  int D.19050;
  const char * ptr.10;
  char * s.11;
  char D.19055;
  const char * ptr.12;
  char * s.13;
  const char * ptr.14;
  const char * ptr.15;
  const char * ptr.16;
  const char * ptr.17;
  const char * D.19069;
  const char * ptr.18;
  int show_tokens.19;
  unsigned int D.19074;
  char * D.19075;
  char * D.19077;
  guint32 cols[1];
  const char * ptr;
  char * s;
  char * result;
  struct GString * res;
  int len;
  struct MonoMethodSignature * sig;

  try
    {
      res = monoeg_g_string_new ("");
      D.19040 = &m->tables[27];
      D.19041 = idx + 4294967295;
      D.19042 = (int) D.19041;
      mono_metadata_decode_row (D.19040, D.19042, &cols, 1);
      D.19043 = cols[0];
      ptr.6 = mono_metadata_blob_heap (m, D.19043);
      ptr = ptr.6;
      ptr.7 = ptr;
      D.19046 = mono_metadata_decode_value (ptr.7, &ptr);
      len = (int) D.19046;
      ptr.7 = ptr;
      ptr.8 = ptr.7;
      ptr.9 = ptr.8 + 1;
      ptr = ptr.9;
      D.19049 = *ptr.8;
      D.19050 = (int) D.19049;
      switch (D.19050) <default: <D.18101>, case 15: <D.18096>, case 20: <D.18099>, case 27: <D.18098>, case 29: <D.18100>>
      <D.18096>:
      ptr.7 = ptr;
      ptr.10 = get_custom_mod (m, ptr.7, &s);
      ptr = ptr.10;
      s.11 = s;
      if (s.11 != 0B) goto <D.19053>; else goto <D.19054>;
      <D.19053>:
      s.11 = s;
      monoeg_g_string_append (res, s.11);
      monoeg_g_string_append_c (res, 32);
      s.11 = s;
      monoeg_g_free (s.11);
      <D.19054>:
      ptr.7 = ptr;
      D.19055 = *ptr.7;
      if (D.19055 == 1) goto <D.19056>; else goto <D.19057>;
      <D.19056>:
      monoeg_g_string_append (res, "void");
      goto <D.19058>;
      <D.19057>:
      ptr.7 = ptr;
      ptr.12 = get_type (m, ptr.7, &s, is_def, container);
      ptr = ptr.12;
      s.11 = s;
      if (s.11 != 0B) goto <D.19060>; else goto <D.19061>;
      <D.19060>:
      s.11 = s;
      monoeg_g_string_append (res, s.11);
      <D.19061>:
      <D.19058>:
      monoeg_g_string_append (res, "*");
      goto <D.18097>;
      <D.18098>:
      ptr.7 = ptr;
      sig = mono_metadata_parse_method_signature_full (m, container, 0, ptr.7, &ptr);
      s.13 = dis_stringify_function_ptr (m, sig);
      s = s.13;
      monoeg_g_string_append (res, "method ");
      s.11 = s;
      monoeg_g_string_append (res, s.11);
      s.11 = s;
      monoeg_g_free (s.11);
      goto <D.18097>;
      <D.18099>:
      ptr.7 = ptr;
      ptr.14 = get_type (m, ptr.7, &s, is_def, container);
      ptr = ptr.14;
      s.11 = s;
      monoeg_g_string_append (res, s.11);
      s.11 = s;
      monoeg_g_free (s.11);
      monoeg_g_string_append_c (res, 32);
      ptr.7 = ptr;
      ptr.15 = get_array_shape (m, ptr.7, &s);
      ptr = ptr.15;
      s.11 = s;
      monoeg_g_string_append (res, s.11);
      s.11 = s;
      monoeg_g_free (s.11);
      goto <D.18097>;
      <D.18100>:
      ptr.7 = ptr;
      ptr.16 = get_custom_mod (m, ptr.7, &s);
      ptr = ptr.16;
      s.11 = s;
      if (s.11 != 0B) goto <D.19066>; else goto <D.19067>;
      <D.19066>:
      s.11 = s;
      monoeg_g_string_append (res, s.11);
      monoeg_g_string_append_c (res, 32);
      s.11 = s;
      monoeg_g_free (s.11);
      <D.19067>:
      ptr.7 = ptr;
      ptr.17 = get_type (m, ptr.7, &s, is_def, container);
      ptr = ptr.17;
      s.11 = s;
      monoeg_g_string_append (res, s.11);
      monoeg_g_string_append (res, "[]");
      s.11 = s;
      monoeg_g_free (s.11);
      goto <D.18097>;
      <D.18101>:
      ptr.7 = ptr;
      D.19069 = ptr.7 + 4294967295;
      ptr.18 = get_type (m, D.19069, &s, is_def, container);
      ptr = ptr.18;
      s.11 = s;
      monoeg_g_string_append (res, s.11);
      s.11 = s;
      monoeg_g_free (s.11);
      goto <D.18097>;
      <D.18097>:
      show_tokens.19 = show_tokens;
      if (show_tokens.19 != 0) goto <D.19072>; else goto <D.19073>;
      <D.19072>:
      {
        int token;

        D.19074 = idx | 452984832;
        token = (int) D.19074;
        D.19075 = res->str;
        result = monoeg_g_strdup_printf ("%s/*%08x*/", D.19075, token);
      }
      goto <D.19076>;
      <D.19073>:
      result = res->str;
      <D.19076>:
      monoeg_g_string_free (res, 0);
      D.19077 = result;
      return D.19077;
    }
  finally
    {
      cols = {CLOBBER};
      ptr = {CLOBBER};
      s = {CLOBBER};
    }
}


get_array_shape (struct MonoImage * m, const char * ptr, char * * result)
{
  const char * ptr.20;
  unsigned int D.19083;
  unsigned int i.21;
  unsigned int D.19085;
  gint32 * D.19086;
  unsigned int D.19087;
  int D.19088;
  unsigned int i.22;
  unsigned int D.19092;
  gint32 * D.19093;
  int D.19094;
  char * D.19095;
  const char * D.19096;
  guint32 rank;
  guint32 num_sizes;
  guint32 num_lo_bounds;
  gint32 * sizes;
  gint32 * lo_bounds;
  int i;

  sizes = 0B;
  lo_bounds = 0B;
  ptr.20 = ptr;
  rank = mono_metadata_decode_value (ptr.20, &ptr);
  ptr.20 = ptr;
  num_sizes = mono_metadata_decode_value (ptr.20, &ptr);
  if (num_sizes != 0) goto <D.19081>; else goto <D.19082>;
  <D.19081>:
  D.19083 = num_sizes * 4;
  sizes = monoeg_malloc (D.19083);
  <D.19082>:
  i = 0;
  goto <D.18078>;
  <D.18077>:
  i.21 = (unsigned int) i;
  D.19085 = i.21 * 4;
  D.19086 = sizes + D.19085;
  ptr.20 = ptr;
  D.19087 = mono_metadata_decode_value (ptr.20, &ptr);
  D.19088 = (int) D.19087;
  *D.19086 = D.19088;
  i = i + 1;
  <D.18078>:
  i.22 = (unsigned int) i;
  if (i.22 < num_sizes) goto <D.18077>; else goto <D.18079>;
  <D.18079>:
  ptr.20 = ptr;
  num_lo_bounds = mono_metadata_decode_value (ptr.20, &ptr);
  if (num_lo_bounds != 0) goto <D.19090>; else goto <D.19091>;
  <D.19090>:
  D.19092 = num_lo_bounds * 4;
  lo_bounds = monoeg_malloc (D.19092);
  <D.19091>:
  i = 0;
  goto <D.18081>;
  <D.18080>:
  i.21 = (unsigned int) i;
  D.19085 = i.21 * 4;
  D.19093 = lo_bounds + D.19085;
  ptr.20 = ptr;
  D.19094 = mono_metadata_decode_signed_value (ptr.20, &ptr);
  *D.19093 = D.19094;
  i = i + 1;
  <D.18081>:
  i.22 = (unsigned int) i;
  if (i.22 < num_lo_bounds) goto <D.18080>; else goto <D.18082>;
  <D.18082>:
  D.19095 = stringify_array (rank, num_sizes, num_lo_bounds, sizes, lo_bounds);
  *result = D.19095;
  monoeg_g_free (sizes);
  monoeg_g_free (lo_bounds);
  D.19096 = ptr;
  return D.19096;
}


stringify_array (guint32 rank, guint32 num_sizes, guint32 num_lo_bounds, gint32 * sizes, gint32 * lo_bounds)
{
  unsigned int i.23;
  unsigned int i.24;
  unsigned int D.19104;
  gint32 * D.19105;
  int D.19106;
  gint32 * D.19111;
  int D.19112;
  int D.19113;
  int D.19114;
  char * D.19116;
  struct GString * res;
  int i;

  res = monoeg_g_string_new ("[");
  i = 0;
  goto <D.18064>;
  <D.18063>:
  if (i != 0) goto <D.19098>; else goto <D.19099>;
  <D.19098>:
  monoeg_g_string_append_c (res, 44);
  <D.19099>:
  i.23 = (unsigned int) i;
  if (i.23 < num_lo_bounds) goto <D.19101>; else goto <D.19102>;
  <D.19101>:
  i.24 = (unsigned int) i;
  D.19104 = i.24 * 4;
  D.19105 = lo_bounds + D.19104;
  D.19106 = *D.19105;
  monoeg_g_string_append_printf (res, "%d...", D.19106);
  <D.19102>:
  i.23 = (unsigned int) i;
  if (i.23 < num_sizes) goto <D.19107>; else goto <D.19108>;
  <D.19107>:
  i.23 = (unsigned int) i;
  if (i.23 < num_lo_bounds) goto <D.19109>; else goto <D.19110>;
  <D.19109>:
  i.24 = (unsigned int) i;
  D.19104 = i.24 * 4;
  D.19105 = lo_bounds + D.19104;
  D.19106 = *D.19105;
  i.24 = (unsigned int) i;
  D.19104 = i.24 * 4;
  D.19111 = sizes + D.19104;
  D.19112 = *D.19111;
  D.19113 = D.19106 + D.19112;
  D.19114 = D.19113 + -1;
  monoeg_g_string_append_printf (res, "%d", D.19114);
  goto <D.19115>;
  <D.19110>:
  i.24 = (unsigned int) i;
  D.19104 = i.24 * 4;
  D.19111 = sizes + D.19104;
  D.19112 = *D.19111;
  monoeg_g_string_append_printf (res, "%d", D.19112);
  <D.19115>:
  <D.19108>:
  i = i + 1;
  <D.18064>:
  i.23 = (unsigned int) i;
  if (i.23 < rank) goto <D.18063>; else goto <D.18065>;
  <D.18065>:
  monoeg_g_string_append (res, "]");
  D.19116 = monoeg_g_string_free (res, 0);
  return D.19116;
}


get_typeref (struct MonoImage * m, int idx)
{
  struct MonoTableInfo * D.19118;
  int D.19119;
  unsigned int D.19120;
  unsigned int D.19121;
  unsigned int D.19122;
  int rs_idx.25;
  const char * iftmp.26;
  char D.19125;
  const char * iftmp.27;
  const char * iftmp.28;
  int show_tokens.29;
  char * D.19140;
  guint32 cols[3];
  const char * s;
  const char * t;
  char * x;
  char * ret;
  guint32 rs_idx;
  guint32 table;

  try
    {
      D.19118 = &m->tables[1];
      D.19119 = idx + -1;
      mono_metadata_decode_row (D.19118, D.19119, &cols, 3);
      D.19120 = cols[1];
      t = mono_metadata_string_heap (m, D.19120);
      D.19121 = cols[2];
      s = mono_metadata_string_heap (m, D.19121);
      D.19122 = cols[0];
      rs_idx = D.19122 >> 2;
      D.19122 = cols[0];
      table = D.19122 & 3;
      switch (table) <default: <D.18119>, case 0: <D.18114>, case 1: <D.18116>, case 2: <D.18117>, case 3: <D.18118>>
      <D.18114>:
      rs_idx.25 = (int) rs_idx;
      x = get_module (m, rs_idx.25);
      D.19125 = *s;
      if (D.19125 != 0) goto <D.19126>; else goto <D.19127>;
      <D.19126>:
      iftmp.26 = ".";
      goto <D.19128>;
      <D.19127>:
      iftmp.26 = "";
      <D.19128>:
      ret = monoeg_g_strdup_printf ("[%s] %s%s%s", x, s, iftmp.26, t);
      monoeg_g_free (x);
      goto <D.18115>;
      <D.18116>:
      rs_idx.25 = (int) rs_idx;
      x = get_moduleref (m, rs_idx.25);
      D.19125 = *s;
      if (D.19125 != 0) goto <D.19130>; else goto <D.19131>;
      <D.19130>:
      iftmp.27 = ".";
      goto <D.19132>;
      <D.19131>:
      iftmp.27 = "";
      <D.19132>:
      ret = monoeg_g_strdup_printf ("[.module %s]%s%s%s", x, s, iftmp.27, t);
      goto <D.18115>;
      <D.18117>:
      rs_idx.25 = (int) rs_idx;
      x = get_assemblyref (m, rs_idx.25);
      D.19125 = *s;
      if (D.19125 != 0) goto <D.19134>; else goto <D.19135>;
      <D.19134>:
      iftmp.28 = ".";
      goto <D.19136>;
      <D.19135>:
      iftmp.28 = "";
      <D.19136>:
      ret = monoeg_g_strdup_printf ("[%s]%s%s%s", x, s, iftmp.28, t);
      monoeg_g_free (x);
      goto <D.18115>;
      <D.18118>:
      rs_idx.25 = (int) rs_idx;
      x = get_typeref (m, rs_idx.25);
      ret = monoeg_g_strdup_printf ("%s/%s", x, t);
      monoeg_g_free (x);
      goto <D.18115>;
      <D.18119>:
      ret = monoeg_g_strdup_printf ("Unknown table in TypeRef %d", table);
      <D.18115>:
      show_tokens.29 = show_tokens;
      if (show_tokens.29 != 0) goto <D.19138>; else goto <D.19139>;
      <D.19138>:
      {
        int token;
        char * temp;

        token = idx | 16777216;
        temp = monoeg_g_strdup_printf ("%s/*%08x*/", ret, token);
        monoeg_g_free (ret);
        ret = temp;
      }
      <D.19139>:
      D.19140 = ret;
      return D.19140;
    }
  finally
    {
      cols = {CLOBBER};
    }
}


get_typedef_or_ref (struct MonoImage * m, guint32 dor_token, struct MonoGenericContainer * container)
{
  int dor_token.30;
  unsigned int D.19144;
  unsigned int idx.31;
  char * D.19148;
  char * temp;
  char * s;
  int table;
  int idx;

  temp = 0B;
  s = 0B;
  dor_token.30 = (int) dor_token;
  table = dor_token.30 & 3;
  D.19144 = dor_token >> 2;
  idx = (int) D.19144;
  switch (table) <default: <D.18135>, case 0: <D.18131>, case 1: <D.18133>, case 2: <D.18134>>
  <D.18131>:
  temp = get_typedef (m, idx);
  s = monoeg_g_strdup_printf ("%s", temp);
  goto <D.18132>;
  <D.18133>:
  temp = get_typeref (m, idx);
  s = monoeg_g_strdup_printf ("%s", temp);
  goto <D.18132>;
  <D.18134>:
  idx.31 = (unsigned int) idx;
  s = get_typespec (m, idx.31, 0, container);
  goto <D.18132>;
  <D.18135>:
  monoeg_g_log (0B, 4, "Unhandled encoding for typedef-or-ref coded index 0x%08x", dor_token);
  <D.18136>:
  goto <D.18136>;
  <D.18132>:
  if (temp != 0B) goto <D.19146>; else goto <D.19147>;
  <D.19146>:
  monoeg_g_free (temp);
  <D.19147>:
  D.19148 = s;
  return D.19148;
}


get_type_or_methdef (struct MonoImage * m, guint32 dor_token)
{
  unsigned int D.19150;
  char * D.19153;
  unsigned int D.19154;
  int D.19155;

  D.19150 = dor_token & 1;
  if (D.19150 != 0) goto <D.19151>; else goto <D.19152>;
  <D.19151>:
  D.19154 = dor_token >> 1;
  D.19153 = get_methoddef (m, D.19154);
  return D.19153;
  <D.19152>:
  D.19154 = dor_token >> 1;
  D.19155 = (int) D.19154;
  D.19153 = get_typedef (m, D.19155);
  return D.19153;
}


get_encoded_typedef_or_ref (struct MonoImage * m, const char * ptr, char * * result)
{
  const char * ptr.32;
  char * D.19158;
  const char * D.19159;
  guint32 token;

  ptr.32 = ptr;
  token = mono_metadata_decode_value (ptr.32, &ptr);
  D.19158 = get_typedef_or_ref (m, token, 0B);
  *result = D.19158;
  D.19159 = ptr;
  return D.19159;
}


get_custom_mod (struct MonoImage * m, const char * ptr, char * * return_value)
{
  const char * iftmp.33;
  char D.19162;
  char * D.19166;
  char * s.34;
  gchar * D.19170;
  gchar * D.19172;
  unsigned char D.19173;
  unsigned char D.19174;
  const char * D.19175;
  char * s;
  const char * mod;

  try
    {
      *return_value = 0B;
      goto <D.18155>;
      <D.18154>:
      D.19162 = *ptr;
      if (D.19162 == 31) goto <D.19163>; else goto <D.19164>;
      <D.19163>:
      iftmp.33 = "modreq";
      goto <D.19165>;
      <D.19164>:
      iftmp.33 = "modopt";
      <D.19165>:
      mod = iftmp.33;
      ptr = ptr + 1;
      ptr = get_encoded_typedef_or_ref (m, ptr, &s);
      D.19166 = *return_value;
      if (D.19166 == 0B) goto <D.19167>; else goto <D.19168>;
      <D.19167>:
      s.34 = s;
      D.19170 = monoeg_g_strconcat (" ", mod, " (", s.34, ")", 0B);
      *return_value = D.19170;
      goto <D.19171>;
      <D.19168>:
      D.19166 = *return_value;
      s.34 = s;
      D.19172 = monoeg_g_strconcat (D.19166, " ", mod, " (", s.34, ")", 0B);
      *return_value = D.19172;
      <D.19171>:
      s.34 = s;
      monoeg_g_free (s.34);
      <D.18155>:
      D.19162 = *ptr;
      D.19173 = (unsigned char) D.19162;
      D.19174 = D.19173 + 225;
      if (D.19174 <= 1) goto <D.18154>; else goto <D.18156>;
      <D.18156>:
      D.19175 = ptr;
      return D.19175;
    }
  finally
    {
      s = {CLOBBER};
    }
}


dis_stringify_token (struct MonoImage * m, guint32 token)
{
  unsigned int D.19178;
  char * D.19179;
  int idx.35;
  guint idx;

  idx = token & 16777215;
  D.19178 = token >> 24;
  switch (D.19178) <default: <D.18167>, case 1: <D.18165>, case 2: <D.18164>, case 27: <D.18166>>
  <D.18164>:
  idx.35 = (int) idx;
  D.19179 = get_typedef (m, idx.35);
  return D.19179;
  <D.18165>:
  idx.35 = (int) idx;
  D.19179 = get_typeref (m, idx.35);
  return D.19179;
  <D.18166>:
  D.19179 = get_typespec (m, idx, 0, 0B);
  return D.19179;
  <D.18167>:
  goto <D.18168>;
  <D.18168>:
  D.19179 = monoeg_g_strdup_printf ("0x%08x", token);
  return D.19179;
}


dis_stringify_array (struct MonoImage * m, struct MonoArrayType * array, gboolean is_def)
{
  struct MonoClass * D.19183;
  struct MonoType * D.19184;
  unsigned char D.19185;
  unsigned int D.19186;
  unsigned char D.19187;
  unsigned int D.19188;
  unsigned char D.19189;
  unsigned int D.19190;
  int * D.19191;
  int * D.19192;
  char * D.19193;
  char * type;
  char * arr_str;
  char * ret;

  D.19183 = array->eklass;
  D.19184 = &D.19183->byval_arg;
  type = dis_stringify_type (m, D.19184, is_def);
  D.19185 = array->rank;
  D.19186 = (unsigned int) D.19185;
  D.19187 = array->numsizes;
  D.19188 = (unsigned int) D.19187;
  D.19189 = array->numlobounds;
  D.19190 = (unsigned int) D.19189;
  D.19191 = array->sizes;
  D.19192 = array->lobounds;
  arr_str = stringify_array (D.19186, D.19188, D.19190, D.19191, D.19192);
  ret = monoeg_g_strconcat (type, arr_str, 0B);
  monoeg_g_free (arr_str);
  monoeg_g_free (type);
  D.19193 = ret;
  return D.19193;
}


dis_stringify_modifiers (struct MonoImage * m, int n, struct MonoCustomMod * mod)
{
  unsigned int i.36;
  unsigned int D.19196;
  struct MonoCustomMod * D.19197;
  <unnamed-unsigned:31> D.19198;
  unsigned int D.19199;
  const char * iftmp.37;
  unsigned int D.19203;
  unsigned int D.19204;
  char * D.19208;
  struct GString * s;
  char * result;
  int i;

  s = monoeg_g_string_new ("");
  i = 0;
  goto <D.18187>;
  <D.18186>:
  {
    char * tok;

    i.36 = (unsigned int) i;
    D.19196 = i.36 * 4;
    D.19197 = mod + D.19196;
    D.19198 = D.19197->token;
    D.19199 = (unsigned int) D.19198;
    tok = dis_stringify_token (m, D.19199);
    if (i > 0) goto <D.19200>; else goto <D.19201>;
    <D.19200>:
    monoeg_g_string_append_printf (s, " ");
    <D.19201>:
    i.36 = (unsigned int) i;
    D.19196 = i.36 * 4;
    D.19197 = mod + D.19196;
    D.19203 = BIT_FIELD_REF <*D.19197, 32, 0>;
    D.19204 = D.19203 & 1;
    if (D.19204 != 0) goto <D.19205>; else goto <D.19206>;
    <D.19205>:
    iftmp.37 = "modreq";
    goto <D.19207>;
    <D.19206>:
    iftmp.37 = "modopt";
    <D.19207>:
    monoeg_g_string_append_printf (s, " %s (%s)", iftmp.37, tok);
    monoeg_g_free (tok);
  }
  i = i + 1;
  <D.18187>:
  if (i < n) goto <D.18186>; else goto <D.18188>;
  <D.18188>:
  monoeg_g_string_append_c (s, 32);
  result = s->str;
  monoeg_g_string_free (s, 0);
  D.19208 = result;
  return D.19208;
}


dis_stringify_param (struct MonoImage * m, struct MonoType * param)
{
  const char * iftmp.38;
  short unsigned int D.19211;
  int D.19212;
  int D.19213;
  const char * iftmp.39;
  int D.19218;
  const char * iftmp.40;
  int D.19223;
  const gchar * iftmp.41;
  char D.19228;
  char * D.19232;
  char * t;
  char * result;
  char * attribs;
  const char * in;
  const char * out;
  const char * opt;

  D.19211 = param->attrs;
  D.19212 = (int) D.19211;
  D.19213 = D.19212 & 1;
  if (D.19213 != 0) goto <D.19214>; else goto <D.19215>;
  <D.19214>:
  iftmp.38 = "[in]";
  goto <D.19216>;
  <D.19215>:
  iftmp.38 = "";
  <D.19216>:
  in = iftmp.38;
  D.19211 = param->attrs;
  D.19212 = (int) D.19211;
  D.19218 = D.19212 & 2;
  if (D.19218 != 0) goto <D.19219>; else goto <D.19220>;
  <D.19219>:
  iftmp.39 = "[out]";
  goto <D.19221>;
  <D.19220>:
  iftmp.39 = "";
  <D.19221>:
  out = iftmp.39;
  D.19211 = param->attrs;
  D.19212 = (int) D.19211;
  D.19223 = D.19212 & 16;
  if (D.19223 != 0) goto <D.19224>; else goto <D.19225>;
  <D.19224>:
  iftmp.40 = "[opt]";
  goto <D.19226>;
  <D.19225>:
  iftmp.40 = "";
  <D.19226>:
  opt = iftmp.40;
  attribs = monoeg_g_strconcat (in, out, opt, 0B);
  t = dis_stringify_type (m, param, 1);
  D.19228 = *attribs;
  if (D.19228 != 0) goto <D.19229>; else goto <D.19230>;
  <D.19229>:
  iftmp.41 = " ";
  goto <D.19231>;
  <D.19230>:
  iftmp.41 = "";
  <D.19231>:
  result = monoeg_g_strjoin (iftmp.41, attribs, t, 0B);
  monoeg_g_free (t);
  monoeg_g_free (attribs);
  D.19232 = result;
  return D.19232;
}


dis_stringify_marshal_spec (struct MonoMarshalSpec * spec)
{
  <unnamed type> D.19234;
  char * D.19235;
  int D.19236;
  short int D.19237;
  <unnamed type> D.19238;
  short int D.19247;
  unsigned int D.19248;
  <unnamed type> D.19252;
  const char * iftmp.42;
  const char * iftmp.43;
  char * D.19260;
  const char * iftmp.44;
  char * D.19265;

  D.19234 = spec->native;
  switch (D.19234) <default: <D.18299>, case 23: <D.18287>, case 29: <D.18295>, case 30: <D.18288>, case 42: <D.18289>, case 44: <D.18298>>
  <D.18287>:
  D.19236 = spec->data.array_data.num_elem;
  D.19235 = monoeg_g_strdup_printf (" marshal (fixed sysstring [%d])", D.19236);
  return D.19235;
  <D.18288>:
  D.19236 = spec->data.array_data.num_elem;
  D.19235 = monoeg_g_strdup_printf (" marshal (fixed array [%d])", D.19236);
  return D.19235;
  <D.18289>:
  {
    char * elem_type;
    char * elems;
    char * ret;
    guint32 num_elem;
    guint32 param_num;

    D.19236 = spec->data.array_data.num_elem;
    num_elem = (guint32) D.19236;
    D.19237 = spec->data.array_data.param_num;
    param_num = (guint32) D.19237;
    D.19238 = spec->data.array_data.elem_type;
    elem_type = dis_stringify_native_type (D.19238);
    if (num_elem == 4294967295) goto <D.19241>; else goto <D.19239>;
    <D.19241>:
    if (param_num == 4294967295) goto <D.19242>; else goto <D.19239>;
    <D.19242>:
    elems = monoeg_strdup ("");
    goto <D.19240>;
    <D.19239>:
    if (param_num == 4294967295) goto <D.19243>; else goto <D.19246>;
    <D.19246>:
    D.19247 = spec->data.array_data.elem_mult;
    if (D.19247 == 0) goto <D.19243>; else goto <D.19244>;
    <D.19243>:
    elems = monoeg_g_strdup_printf ("%d", num_elem);
    goto <D.19245>;
    <D.19244>:
    D.19248 = num_elem + 4294967295;
    if (D.19248 > 4294967293) goto <D.19249>; else goto <D.19250>;
    <D.19249>:
    elems = monoeg_g_strdup_printf ("+ %d", param_num);
    goto <D.19251>;
    <D.19250>:
    elems = monoeg_g_strdup_printf ("%d + %d", num_elem, param_num);
    <D.19251>:
    <D.19245>:
    <D.19240>:
    ret = monoeg_g_strdup_printf (" marshal (%s[%s])", elem_type, elems);
    monoeg_g_free (elem_type);
    monoeg_g_free (elems);
    D.19235 = ret;
    return D.19235;
  }
  <D.18295>:
  {
    char * elem_type;
    char * ret;

    elem_type = 0B;
    D.19252 = spec->data.safearray_data.elem_type;
    if (D.19252 != 0) goto <D.19253>; else goto <D.19254>;
    <D.19253>:
    D.19252 = spec->data.safearray_data.elem_type;
    elem_type = dis_stringify_variant_type (D.19252);
    <D.19254>:
    if (elem_type != 0B) goto <D.19256>; else goto <D.19257>;
    <D.19256>:
    iftmp.42 = elem_type;
    goto <D.19258>;
    <D.19257>:
    iftmp.42 = "";
    <D.19258>:
    ret = monoeg_g_strdup_printf (" marshal (safearray %s)", iftmp.42);
    monoeg_g_free (elem_type);
    D.19235 = ret;
    return D.19235;
  }
  <D.18298>:
  D.19260 = spec->data.custom_data.custom_name;
  if (D.19260 != 0B) goto <D.19261>; else goto <D.19262>;
  <D.19261>:
  iftmp.43 = spec->data.custom_data.custom_name;
  goto <D.19263>;
  <D.19262>:
  iftmp.43 = "";
  <D.19263>:
  D.19265 = spec->data.custom_data.cookie;
  if (D.19265 != 0B) goto <D.19266>; else goto <D.19267>;
  <D.19266>:
  iftmp.44 = spec->data.custom_data.cookie;
  goto <D.19268>;
  <D.19267>:
  iftmp.44 = "";
  <D.19268>:
  D.19235 = monoeg_g_strdup_printf (" marshal (custom (\"%s\", \"%s\"))", iftmp.43, iftmp.44);
  return D.19235;
  <D.18299>:
  {
    char * native_type;
    char * ret;

    D.19234 = spec->native;
    native_type = dis_stringify_native_type (D.19234);
    ret = monoeg_g_strdup_printf (" marshal (%s)", native_type);
    monoeg_g_free (native_type);
    D.19235 = ret;
    return D.19235;
  }
}


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

  if (str != 0B) goto <D.19270>; else goto <D.19271>;
  <D.19270>:
  D.19272 = __strdup (str);
  return D.19272;
  <D.19271>:
  D.19272 = 0B;
  return D.19272;
}


dis_stringify_variant_type (MonoMarshalVariant variant)
{
  char * D.19274;

  switch (variant) <default: <D.18246>, case 0: <D.18202>, case 1: <D.18203>, case 2: <D.18204>, case 3: <D.18205>, case 4: <D.18206>, case 5: <D.18207>, case 6: <D.18208>, case 7: <D.18209>, case 8: <D.18210>, case 9: <D.18211>, case 10: <D.18212>, case 11: <D.18213>, case 12: <D.18214>, case 13: <D.18215>, case 14: <D.18216>, case 16: <D.18217>, case 17: <D.18218>, case 18: <D.18219>, case 19: <D.18220>, case 20: <D.18221>, case 21: <D.18222>, case 22: <D.18223>, case 23: <D.18224>, case 24: <D.18225>, case 25: <D.18226>, case 26: <D.18227>, case 27: <D.18228>, case 28: <D.18229>, case 29: <D.18230>, case 30: <D.18231>, case 31: <D.18232>, case 36: <D.18233>, case 64: <D.18234>, case 65: <D.18235>, case 66: <D.18236>, case 67: <D.18237>, case 68: <D.18238>, case 69: <D.18239>, case 70: <D.18240>, case 71: <D.18241>, case 72: <D.18242>, case 4096: <D.18243>, case 8192: <D.18244>, case 16384: <D.18245>>
  <D.18202>:
  D.19274 = monoeg_strdup ("");
  return D.19274;
  <D.18203>:
  D.19274 = monoeg_strdup ("null");
  return D.19274;
  <D.18204>:
  D.19274 = monoeg_strdup ("int16");
  return D.19274;
  <D.18205>:
  D.19274 = monoeg_strdup ("int32");
  return D.19274;
  <D.18206>:
  D.19274 = monoeg_strdup ("float32");
  return D.19274;
  <D.18207>:
  D.19274 = monoeg_strdup ("float64");
  return D.19274;
  <D.18208>:
  D.19274 = monoeg_strdup ("currency");
  return D.19274;
  <D.18209>:
  D.19274 = monoeg_strdup ("date");
  return D.19274;
  <D.18210>:
  D.19274 = monoeg_strdup ("bstr");
  return D.19274;
  <D.18211>:
  D.19274 = monoeg_strdup ("idispatch");
  return D.19274;
  <D.18212>:
  D.19274 = monoeg_strdup ("error");
  return D.19274;
  <D.18213>:
  D.19274 = monoeg_strdup ("bool");
  return D.19274;
  <D.18214>:
  D.19274 = monoeg_strdup ("variant");
  return D.19274;
  <D.18215>:
  D.19274 = monoeg_strdup ("iunknown");
  return D.19274;
  <D.18216>:
  D.19274 = monoeg_strdup ("decimal");
  return D.19274;
  <D.18217>:
  D.19274 = monoeg_strdup ("int8");
  return D.19274;
  <D.18218>:
  D.19274 = monoeg_strdup ("unsigned int8");
  return D.19274;
  <D.18219>:
  D.19274 = monoeg_strdup ("unsigned int16");
  return D.19274;
  <D.18220>:
  D.19274 = monoeg_strdup ("unsigned int32");
  return D.19274;
  <D.18221>:
  D.19274 = monoeg_strdup ("int64");
  return D.19274;
  <D.18222>:
  D.19274 = monoeg_strdup ("unsigned int64");
  return D.19274;
  <D.18223>:
  D.19274 = monoeg_strdup ("int");
  return D.19274;
  <D.18224>:
  D.19274 = monoeg_strdup ("unsigned int");
  return D.19274;
  <D.18225>:
  D.19274 = monoeg_strdup ("void");
  return D.19274;
  <D.18226>:
  D.19274 = monoeg_strdup ("hresult");
  return D.19274;
  <D.18227>:
  D.19274 = monoeg_strdup ("*");
  return D.19274;
  <D.18228>:
  D.19274 = monoeg_strdup ("safearray");
  return D.19274;
  <D.18229>:
  D.19274 = monoeg_strdup ("carray");
  return D.19274;
  <D.18230>:
  D.19274 = monoeg_strdup ("userdefined");
  return D.19274;
  <D.18231>:
  D.19274 = monoeg_strdup ("lpstr");
  return D.19274;
  <D.18232>:
  D.19274 = monoeg_strdup ("lpwstr");
  return D.19274;
  <D.18233>:
  D.19274 = monoeg_strdup ("record");
  return D.19274;
  <D.18234>:
  D.19274 = monoeg_strdup ("filetime");
  return D.19274;
  <D.18235>:
  D.19274 = monoeg_strdup ("blob");
  return D.19274;
  <D.18236>:
  D.19274 = monoeg_strdup ("stream");
  return D.19274;
  <D.18237>:
  D.19274 = monoeg_strdup ("storage");
  return D.19274;
  <D.18238>:
  D.19274 = monoeg_strdup ("streamed_object");
  return D.19274;
  <D.18239>:
  D.19274 = monoeg_strdup ("stored_object");
  return D.19274;
  <D.18240>:
  D.19274 = monoeg_strdup ("blob_object");
  return D.19274;
  <D.18241>:
  D.19274 = monoeg_strdup ("cf");
  return D.19274;
  <D.18242>:
  D.19274 = monoeg_strdup ("clsid");
  return D.19274;
  <D.18243>:
  D.19274 = monoeg_strdup ("vector");
  return D.19274;
  <D.18244>:
  D.19274 = monoeg_strdup ("[]");
  return D.19274;
  <D.18245>:
  D.19274 = monoeg_strdup ("&");
  return D.19274;
  <D.18246>:
  D.19274 = monoeg_strdup ("unknown");
  return D.19274;
}


dis_stringify_native_type (MonoMarshalNative native)
{
  char * D.19276;

  switch (native) <default: <D.18283>, case 2: <D.18250>, case 3: <D.18251>, case 4: <D.18252>, case 5: <D.18253>, case 6: <D.18254>, case 7: <D.18255>, case 8: <D.18256>, case 9: <D.18257>, case 10: <D.18258>, case 11: <D.18259>, case 12: <D.18260>, case 15: <D.18261>, case 19: <D.18262>, case 20: <D.18263>, case 21: <D.18264>, case 22: <D.18265>, case 25: <D.18266>, case 26: <D.18267>, case 27: <D.18268>, case 28: <D.18269>, case 29: <D.18270>, case 31: <D.18271>, case 32: <D.18272>, case 34: <D.18273>, case 35: <D.18274>, case 36: <D.18275>, case 37: <D.18276>, case 38: <D.18277>, case 40: <D.18278>, case 43: <D.18279>, case 44: <D.18280>, case 45: <D.18281>, case 80: <D.18282>>
  <D.18250>:
  D.19276 = monoeg_strdup ("bool");
  return D.19276;
  <D.18251>:
  D.19276 = monoeg_strdup ("int8");
  return D.19276;
  <D.18252>:
  D.19276 = monoeg_strdup ("unsigned int8");
  return D.19276;
  <D.18253>:
  D.19276 = monoeg_strdup ("int16");
  return D.19276;
  <D.18254>:
  D.19276 = monoeg_strdup ("unsigned int16");
  return D.19276;
  <D.18255>:
  D.19276 = monoeg_strdup ("int32");
  return D.19276;
  <D.18256>:
  D.19276 = monoeg_strdup ("unsigned int32");
  return D.19276;
  <D.18257>:
  D.19276 = monoeg_strdup ("int64");
  return D.19276;
  <D.18258>:
  D.19276 = monoeg_strdup ("unsigned int64");
  return D.19276;
  <D.18259>:
  D.19276 = monoeg_strdup ("float32");
  return D.19276;
  <D.18260>:
  D.19276 = monoeg_strdup ("float64");
  return D.19276;
  <D.18261>:
  D.19276 = monoeg_strdup ("currency");
  return D.19276;
  <D.18262>:
  D.19276 = monoeg_strdup ("bstr");
  return D.19276;
  <D.18263>:
  D.19276 = monoeg_strdup ("lpstr");
  return D.19276;
  <D.18264>:
  D.19276 = monoeg_strdup ("lpwstr");
  return D.19276;
  <D.18265>:
  D.19276 = monoeg_strdup ("lptstr");
  return D.19276;
  <D.18266>:
  D.19276 = monoeg_strdup ("iunknown");
  return D.19276;
  <D.18267>:
  D.19276 = monoeg_strdup ("idispatch");
  return D.19276;
  <D.18268>:
  D.19276 = monoeg_strdup ("struct");
  return D.19276;
  <D.18269>:
  D.19276 = monoeg_strdup ("interface");
  return D.19276;
  <D.18270>:
  D.19276 = monoeg_strdup ("safearray");
  return D.19276;
  <D.18271>:
  D.19276 = monoeg_strdup ("int");
  return D.19276;
  <D.18272>:
  D.19276 = monoeg_strdup ("unsigned int");
  return D.19276;
  <D.18273>:
  D.19276 = monoeg_strdup ("vbbyrefstr");
  return D.19276;
  <D.18274>:
  D.19276 = monoeg_strdup ("ansi bstr");
  return D.19276;
  <D.18275>:
  D.19276 = monoeg_strdup ("tbstr");
  return D.19276;
  <D.18276>:
  D.19276 = monoeg_strdup ("variant bool");
  return D.19276;
  <D.18277>:
  D.19276 = monoeg_strdup ("method");
  return D.19276;
  <D.18278>:
  D.19276 = monoeg_strdup ("as any");
  return D.19276;
  <D.18279>:
  D.19276 = monoeg_strdup ("lpstruct");
  return D.19276;
  <D.18280>:
  D.19276 = monoeg_strdup ("custom");
  return D.19276;
  <D.18281>:
  D.19276 = monoeg_strdup ("error");
  return D.19276;
  <D.18282>:
  D.19276 = monoeg_strdup ("");
  return D.19276;
  <D.18283>:
  D.19276 = monoeg_strdup ("unknown");
  return D.19276;
}


get_generic_param (struct MonoImage * m, struct MonoGenericContainer * container)
{
  char * D.19280;
  struct MonoGenericParamFull * D.19281;
  unsigned int i.45;
  unsigned int D.19283;
  struct MonoGenericParamInfo * iftmp.46;
  struct MonoGenericContainer * D.19285;
  short unsigned int D.19291;
  int D.19292;
  int D.19293;
  int D.19296;
  int D.19299;
  int D.19302;
  int D.19305;
  struct MonoClass * D.19311;
  struct MonoType * D.19312;
  struct MonoGenericParamInfo * iftmp.47;
  const char * D.19320;
  <unnamed-signed:31> D.19321;
  int D.19322;
  struct GString * result;
  char * retval;
  int i;

  if (container == 0B) goto <D.19278>; else goto <D.19279>;
  <D.19278>:
  D.19280 = 0B;
  return D.19280;
  <D.19279>:
  result = monoeg_g_string_new ("");
  monoeg_g_string_append_c (result, 60);
  i = 0;
  goto <D.18320>;
  <D.18319>:
  {
    struct MonoGenericParam * param;
    struct MonoGenericParamInfo * param_info;
    struct MonoClass * * constr;
    int first;
    guint16 flags;
    char * esname;

    D.19281 = container->type_params;
    i.45 = (unsigned int) i;
    D.19283 = i.45 * 32;
    param = D.19281 + D.19283;
    D.19285 = param->owner;
    if (D.19285 != 0B) goto <D.19286>; else goto <D.19287>;
    <D.19286>:
    iftmp.46 = &MEM[(struct MonoGenericParamFull *)param].info;
    goto <D.19288>;
    <D.19287>:
    iftmp.46 = 0B;
    <D.19288>:
    param_info = iftmp.46;
    first = 1;
    if (i > 0) goto <D.19289>; else goto <D.19290>;
    <D.19289>:
    monoeg_g_string_append (result, ",");
    <D.19290>:
    D.19291 = param_info->flags;
    flags = D.19291 & 3;
    D.19292 = (int) flags;
    D.19293 = D.19292 & 1;
    if (D.19293 != 0) goto <D.19294>; else goto <D.19295>;
    <D.19294>:
    monoeg_g_string_append (result, "+ ");
    <D.19295>:
    D.19292 = (int) flags;
    D.19296 = D.19292 & 2;
    if (D.19296 != 0) goto <D.19297>; else goto <D.19298>;
    <D.19297>:
    monoeg_g_string_append (result, "- ");
    <D.19298>:
    D.19291 = param_info->flags;
    flags = D.19291 & 28;
    D.19292 = (int) flags;
    D.19299 = D.19292 & 4;
    if (D.19299 != 0) goto <D.19300>; else goto <D.19301>;
    <D.19300>:
    monoeg_g_string_append (result, "class ");
    <D.19301>:
    D.19292 = (int) flags;
    D.19302 = D.19292 & 8;
    if (D.19302 != 0) goto <D.19303>; else goto <D.19304>;
    <D.19303>:
    monoeg_g_string_append (result, "valuetype ");
    <D.19304>:
    D.19292 = (int) flags;
    D.19305 = D.19292 & 16;
    if (D.19305 != 0) goto <D.19306>; else goto <D.19307>;
    <D.19306>:
    monoeg_g_string_append (result, ".ctor ");
    <D.19307>:
    constr = param_info->constraints;
    goto <D.18317>;
    <D.18316>:
    {
      char * sig;

      if (first != 0) goto <D.19308>; else goto <D.19309>;
      <D.19308>:
      monoeg_g_string_append_c (result, 40);
      first = 0;
      goto <D.19310>;
      <D.19309>:
      monoeg_g_string_append (result, ", ");
      <D.19310>:
      D.19311 = *constr;
      D.19312 = &D.19311->byval_arg;
      sig = dis_stringify_type (m, D.19312, 1);
      monoeg_g_string_append (result, sig);
      monoeg_g_free (sig);
    }
    constr = constr + 4;
    <D.18317>:
    if (constr != 0B) goto <D.19313>; else goto <D.18318>;
    <D.19313>:
    D.19311 = *constr;
    if (D.19311 != 0B) goto <D.18316>; else goto <D.18318>;
    <D.18318>:
    if (first == 0) goto <D.19314>; else goto <D.19315>;
    <D.19314>:
    monoeg_g_string_append (result, ") ");
    <D.19315>:
    D.19285 = param->owner;
    if (D.19285 != 0B) goto <D.19317>; else goto <D.19318>;
    <D.19317>:
    iftmp.47 = &MEM[(struct MonoGenericParamFull *)param].info;
    goto <D.19319>;
    <D.19318>:
    iftmp.47 = 0B;
    <D.19319>:
    D.19320 = iftmp.47->name;
    esname = get_escaped_name (D.19320);
    monoeg_g_string_append (result, esname);
    monoeg_g_free (esname);
  }
  i = i + 1;
  <D.18320>:
  D.19321 = container->type_argc;
  D.19322 = (int) D.19321;
  if (D.19322 > i) goto <D.18319>; else goto <D.18321>;
  <D.18321>:
  monoeg_g_string_append_c (result, 62);
  retval = result->str;
  monoeg_g_string_free (result, 0);
  D.19280 = retval;
  return D.19280;
}


dis_stringify_method_signature (struct MonoImage * m, struct MonoMethodSignature * method, int methoddef_row, struct MonoGenericContainer * container, gboolean fully_qualified)
{
  char * D.19324;

  D.19324 = dis_stringify_method_signature_full (m, method, methoddef_row, container, fully_qualified, 1);
  return D.19324;
}


dis_stringify_method_signature_full (struct MonoImage * m, struct MonoMethodSignature * method, int methoddef_row, struct MonoGenericContainer * container, gboolean fully_qualified, gboolean with_marshal_info)
{
  int iftmp.48;
  _Bool D.19331;
  long int D.19332;
  long int D.19333;
  struct MonoTableInfo * D.19338;
  int D.19339;
  unsigned int methoddef_row.49;
  int type_idx.50;
  unsigned int D.19347;
  unsigned int D.19350;
  const char * sig.51;
  int D.19352;
  unsigned int D.19353;
  const char * sig.52;
  unsigned int D.19359;
  unsigned int D.19360;
  <unnamed-unsigned:24> D.19363;
  int D.19364;
  <unnamed-unsigned:24> D.19368;
  int D.19369;
  int D.19370;
  unsigned int D.19371;
  unsigned int D.19372;
  _Bool D.19373;
  int iftmp.53;
  short unsigned int D.19379;
  struct MonoTableInfo * D.19386;
  unsigned int D.19387;
  int D.19388;
  unsigned int i.54;
  unsigned int D.19393;
  unsigned int D.19397;
  const char * D.19398;
  unsigned int D.19401;
  unsigned int D.19402;
  int D.19416;
  int D.19421;
  struct MonoType * D.19422;
  const char * iftmp.55;
  int D.19427;
  struct MonoType * D.19428;
  <unnamed-unsigned:6> D.19431;
  unsigned int D.19432;
  const char * D.19433;
  const char * iftmp.56;
  char * D.19442;
  int show_method_tokens.57;
  int D.19448;
  int D.19449;
  char * D.19452;
  guint32 cols[6];
  guint32 pcols[3];
  guint32 param_index;
  guint32 next_param_index;
  gboolean has_param_row;
  const char * method_name;
  int free_method;
  char * retval;
  char * esname;
  char * type;
  char * marshal_info;
  char * ret_marshal_info;
  char * gen_param;
  struct GString * result;
  struct GString * result_ret;
  int i;
  int start;

  try
    {
      param_index = 0;
      next_param_index = 0;
      method_name = "";
      free_method = 0;
      type = 0B;
      marshal_info = 0B;
      ret_marshal_info = 0B;
      gen_param = 0B;
      result = monoeg_g_string_new ("");
      result_ret = monoeg_g_string_new ("");
      if (method == 0B) goto <D.19329>; else goto <D.19327>;
      <D.19329>:
      if (methoddef_row == 0) goto <D.19330>; else goto <D.19327>;
      <D.19330>:
      iftmp.48 = 1;
      goto <D.19328>;
      <D.19327>:
      iftmp.48 = 0;
      <D.19328>:
      D.19331 = iftmp.48 != 0;
      D.19332 = (long int) D.19331;
      D.19333 = __builtin_expect (D.19332, 0);
      if (D.19333 != 0) goto <D.19334>; else goto <D.19335>;
      <D.19334>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "get.c", 878, "method || methoddef_row");
      <D.19335>:
      if (methoddef_row != 0) goto <D.19336>; else goto <D.19337>;
      <D.19336>:
      D.19338 = &m->tables[6];
      D.19339 = methoddef_row + -1;
      mono_metadata_decode_row (D.19338, D.19339, &cols, 6);
      if (fully_qualified != 0) goto <D.19340>; else goto <D.19341>;
      <D.19340>:
      {
        guint32 type_idx;

        methoddef_row.49 = (unsigned int) methoddef_row;
        type_idx = mono_metadata_typedef_from_method (m, methoddef_row.49);
        if (type_idx != 0) goto <D.19343>; else goto <D.19344>;
        <D.19343>:
        type_idx.50 = (int) type_idx;
        type = get_typedef (m, type_idx.50);
        goto <D.19346>;
        <D.19344>:
        type = monoeg_strdup ("<invalid>");
        <D.19346>:
      }
      <D.19341>:
      D.19347 = cols[3];
      method_name = mono_metadata_string_heap (m, D.19347);
      param_index = cols[5];
      if (method == 0B) goto <D.19348>; else goto <D.19349>;
      <D.19348>:
      {
        const char * sig;

        try
          {
            D.19350 = cols[4];
            sig.51 = mono_metadata_blob_heap (m, D.19350);
            sig = sig.51;
            D.19352 = methoddef_row | 100663296;
            D.19353 = (unsigned int) D.19352;
            container = mono_metadata_load_generic_params (m, D.19353, container);
            if (container != 0B) goto <D.19354>; else goto <D.19355>;
            <D.19354>:
            D.19352 = methoddef_row | 100663296;
            D.19353 = (unsigned int) D.19352;
            mono_metadata_load_generic_param_constraints (m, D.19353, container);
            <D.19355>:
            sig.52 = sig;
            mono_metadata_decode_blob_size (sig.52, &sig);
            sig.52 = sig;
            method = mono_metadata_parse_method_signature_full (m, container, methoddef_row, sig.52, &sig);
            free_method = 1;
          }
        finally
          {
            sig = {CLOBBER};
          }
      }
      <D.19349>:
      if (container != 0B) goto <D.19357>; else goto <D.19358>;
      <D.19357>:
      D.19359 = BIT_FIELD_REF <*container, 32, 128>;
      D.19360 = D.19359 & 2147483648;
      if (D.19360 != 0) goto <D.19361>; else goto <D.19362>;
      <D.19361>:
      gen_param = get_generic_param (m, container);
      <D.19362>:
      <D.19358>:
      D.19363 = m->tables[6].rows;
      D.19364 = (int) D.19363;
      if (D.19364 > methoddef_row) goto <D.19365>; else goto <D.19366>;
      <D.19365>:
      D.19338 = &m->tables[6];
      mono_metadata_decode_row (D.19338, methoddef_row, &cols, 6);
      next_param_index = cols[5];
      goto <D.19367>;
      <D.19366>:
      D.19368 = m->tables[8].rows;
      D.19369 = (int) D.19368;
      D.19370 = D.19369 + 1;
      next_param_index = (guint32) D.19370;
      <D.19367>:
      <D.19337>:
      D.19371 = BIT_FIELD_REF <*method, 32, 64>;
      D.19372 = D.19371 & 4194304;
      D.19373 = D.19372 == 0;
      start = (int) D.19373;
      i = 0;
      goto <D.18360>;
      <D.18359>:
      marshal_info = 0B;
      if (param_index != 0) goto <D.19377>; else goto <D.19375>;
      <D.19377>:
      if (param_index < next_param_index) goto <D.19378>; else goto <D.19375>;
      <D.19378>:
      iftmp.53 = 1;
      goto <D.19376>;
      <D.19375>:
      iftmp.53 = 0;
      <D.19376>:
      has_param_row = iftmp.53;
      esname = 0B;
      D.19379 = method->param_count;
      if (D.19379 == 0) goto <D.19380>; else goto <D.19381>;
      <D.19380>:
      if (has_param_row == 0) goto <D.19382>; else goto <D.19383>;
      <D.19382>:
      // predicted unlikely by continue predictor.
      goto <D.18356>;
      <D.19383>:
      <D.19381>:
      if (has_param_row != 0) goto <D.19384>; else goto <D.19385>;
      <D.19384>:
      D.19386 = &m->tables[8];
      D.19387 = param_index + 4294967295;
      D.19388 = (int) D.19387;
      mono_metadata_decode_row (D.19386, D.19388, &pcols, 3);
      <D.19385>:
      if (has_param_row != 0) goto <D.19391>; else goto <D.19389>;
      <D.19391>:
      i.54 = (unsigned int) i;
      D.19393 = pcols[1];
      if (i.54 == D.19393) goto <D.19394>; else goto <D.19389>;
      <D.19394>:
      if (i != 0) goto <D.19395>; else goto <D.19396>;
      <D.19395>:
      D.19397 = pcols[2];
      D.19398 = mono_metadata_string_heap (m, D.19397);
      esname = get_escaped_name (D.19398);
      <D.19396>:
      if (with_marshal_info != 0) goto <D.19399>; else goto <D.19400>;
      <D.19399>:
      D.19401 = pcols[0];
      D.19402 = D.19401 & 8192;
      if (D.19402 != 0) goto <D.19403>; else goto <D.19404>;
      <D.19403>:
      {
        const char * tp;
        struct MonoMarshalSpec * spec;

        D.19387 = param_index + 4294967295;
        tp = mono_metadata_get_marshal_info (m, D.19387, 0);
        if (tp != 0B) goto <D.19405>; else goto <D.19406>;
        <D.19405>:
        spec = mono_metadata_parse_marshal_spec (m, tp);
        if (i != 0) goto <D.19407>; else goto <D.19408>;
        <D.19407>:
        marshal_info = dis_stringify_marshal_spec (spec);
        goto <D.19409>;
        <D.19408>:
        ret_marshal_info = dis_stringify_marshal_spec (spec);
        <D.19409>:
        goto <D.19410>;
        <D.19406>:
        if (i != 0) goto <D.19411>; else goto <D.19412>;
        <D.19411>:
        marshal_info = monoeg_strdup ("(missing)");
        goto <D.19413>;
        <D.19412>:
        ret_marshal_info = monoeg_strdup ("(missing)");
        <D.19413>:
        <D.19410>:
      }
      <D.19404>:
      <D.19400>:
      param_index = param_index + 1;
      goto <D.19390>;
      <D.19389>:
      if (i != 0) goto <D.19414>; else goto <D.19415>;
      <D.19414>:
      D.19416 = i - start;
      esname = monoeg_g_strdup_printf ("A_%i", D.19416);
      <D.19415>:
      <D.19390>:
      if (i == 0) goto <D.19417>; else goto <D.19418>;
      <D.19417>:
      // predicted unlikely by continue predictor.
      goto <D.18356>;
      <D.19418>:
      if (i > 1) goto <D.19419>; else goto <D.19420>;
      <D.19419>:
      monoeg_g_string_append (result, ", ");
      <D.19420>:
      D.19421 = i + -1;
      D.19422 = method->params[D.19421];
      retval = dis_stringify_param (m, D.19422);
      if (marshal_info != 0B) goto <D.19424>; else goto <D.19425>;
      <D.19424>:
      iftmp.55 = marshal_info;
      goto <D.19426>;
      <D.19425>:
      iftmp.55 = "";
      <D.19426>:
      monoeg_g_string_append_printf (result, "%s%s %s", retval, iftmp.55, esname);
      monoeg_g_free (retval);
      monoeg_g_free (esname);
      monoeg_g_free (marshal_info);
      <D.18356>:
      i = i + 1;
      <D.18360>:
      D.19379 = method->param_count;
      D.19427 = (int) D.19379;
      if (D.19427 >= i) goto <D.18359>; else goto <D.18361>;
      <D.18361>:
      monoeg_g_string_append (result, ") ");
      D.19428 = method->ret;
      retval = dis_stringify_param (m, D.19428);
      D.19371 = BIT_FIELD_REF <*method, 32, 64>;
      D.19372 = D.19371 & 4194304;
      if (D.19372 != 0) goto <D.19429>; else goto <D.19430>;
      <D.19429>:
      monoeg_g_string_append (result_ret, "instance ");
      <D.19430>:
      D.19431 = method->call_convention;
      D.19432 = (unsigned int) D.19431;
      D.19433 = map (D.19432, &call_conv_type_map);
      monoeg_g_string_append (result_ret, D.19433);
      if (ret_marshal_info != 0B) goto <D.19435>; else goto <D.19436>;
      <D.19435>:
      iftmp.56 = ret_marshal_info;
      goto <D.19437>;
      <D.19436>:
      iftmp.56 = "";
      <D.19437>:
      monoeg_g_string_append_printf (result_ret, " %s%s ", retval, iftmp.56);
      monoeg_g_free (ret_marshal_info);
      if (type != 0B) goto <D.19438>; else goto <D.19439>;
      <D.19438>:
      {
        char * estype;

        estype = get_escaped_name (type);
        monoeg_g_string_append_printf (result_ret, "%s::", estype);
        monoeg_g_free (estype);
        monoeg_g_free (type);
      }
      <D.19439>:
      esname = get_escaped_name (method_name);
      monoeg_g_string_append (result_ret, esname);
      monoeg_g_free (esname);
      if (gen_param != 0B) goto <D.19440>; else goto <D.19441>;
      <D.19440>:
      monoeg_g_string_append (result_ret, gen_param);
      monoeg_g_free (gen_param);
      <D.19441>:
      monoeg_g_string_append (result_ret, " (");
      monoeg_g_free (retval);
      D.19442 = result_ret->str;
      monoeg_g_string_prepend (result, D.19442);
      monoeg_g_string_free (result_ret, 0);
      show_method_tokens.57 = show_method_tokens;
      if (show_method_tokens.57 != 0) goto <D.19444>; else goto <D.19445>;
      <D.19444>:
      if (methoddef_row != 0) goto <D.19446>; else goto <D.19447>;
      <D.19446>:
      D.19448 = methoddef_row >> 1;
      D.19449 = D.19448 | 100663296;
      monoeg_g_string_append_printf (result, " /* 0x%X */ ", D.19449);
      <D.19447>:
      <D.19445>:
      if (free_method != 0) goto <D.19450>; else goto <D.19451>;
      <D.19450>:
      mono_metadata_free_method_signature (method);
      <D.19451>:
      retval = result->str;
      monoeg_g_string_free (result, 0);
      D.19452 = retval;
      return D.19452;
    }
  finally
    {
      cols = {CLOBBER};
      pcols = {CLOBBER};
    }
}


dis_stringify_function_ptr (struct MonoImage * m, struct MonoMethodSignature * method)
{
  _Bool D.19455;
  long int D.19456;
  long int D.19457;
  <unnamed-unsigned:6> D.19460;
  unsigned int D.19461;
  const char * D.19462;
  struct MonoType * D.19463;
  struct MonoType * D.19466;
  short unsigned int D.19467;
  int D.19468;
  char * D.19469;
  char * retval;
  struct GString * result;
  int i;

  result = monoeg_g_string_new ("");
  D.19455 = method == 0B;
  D.19456 = (long int) D.19455;
  D.19457 = __builtin_expect (D.19456, 0);
  if (D.19457 != 0) goto <D.19458>; else goto <D.19459>;
  <D.19458>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "get.c", 1017, "method");
  <D.19459>:
  D.19460 = method->call_convention;
  D.19461 = (unsigned int) D.19460;
  D.19462 = map (D.19461, &call_conv_type_map);
  monoeg_g_string_append (result, D.19462);
  D.19463 = method->ret;
  retval = dis_stringify_param (m, D.19463);
  monoeg_g_string_append_printf (result, " %s ", retval);
  monoeg_g_free (retval);
  monoeg_g_string_append (result, " *(");
  i = 0;
  goto <D.18371>;
  <D.18370>:
  if (i != 0) goto <D.19464>; else goto <D.19465>;
  <D.19464>:
  monoeg_g_string_append (result, ", ");
  <D.19465>:
  D.19466 = method->params[i];
  retval = dis_stringify_param (m, D.19466);
  monoeg_g_string_append (result, retval);
  monoeg_g_free (retval);
  i = i + 1;
  <D.18371>:
  D.19467 = method->param_count;
  D.19468 = (int) D.19467;
  if (D.19468 > i) goto <D.18370>; else goto <D.18372>;
  <D.18372>:
  monoeg_g_string_append (result, ") ");
  retval = result->str;
  monoeg_g_string_free (result, 0);
  D.19469 = retval;
  return D.19469;
}


dis_stringify_object_with_class (struct MonoImage * m, struct MonoClass * c, gboolean prefix, gboolean is_def)
{
  const char * iftmp.58;
  unsigned char D.19472;
  unsigned int D.19476;
  char * D.19479;
  struct MonoImage * D.19480;
  const char * D.19483;
  int substitute_with_mscorlib_p.59;
  int D.18399;
  int iftmp.60;
  int D.18395;
  const char[7] * D.19493;
  unsigned char D.19494;
  int D.19495;
  unsigned char D.19496;
  int D.19497;
  const unsigned char * D.19502;
  unsigned char D.19503;
  int D.19504;
  const unsigned char * D.19505;
  unsigned char D.19506;
  int D.19507;
  const unsigned char * D.19512;
  unsigned char D.19513;
  int D.19514;
  const unsigned char * D.19515;
  unsigned char D.19516;
  int D.19517;
  const unsigned char * D.19522;
  unsigned char D.19523;
  int D.19524;
  const unsigned char * D.19525;
  unsigned char D.19526;
  int D.19527;
  struct MonoAssembly * D.19530;
  const char * D.19531;
  const char * D.19533;
  struct MonoGenericClass * D.19534;
  struct MonoType * D.19537;
  int D.19538;
  <unnamed-unsigned:22> D.19539;
  int D.19540;
  char * D.19543;
  const char * iftmp.61;
  const char * iftmp.62;
  const char * iftmp.63;
  struct MonoType * type;
  const char * otype;
  char * assemblyref;
  char * result;
  char * esname;
  char * generic;

  type = &c->byval_arg;
  D.19472 = type->type;
  if (D.19472 == 17) goto <D.19473>; else goto <D.19474>;
  <D.19473>:
  iftmp.58 = "valuetype ";
  goto <D.19475>;
  <D.19474>:
  iftmp.58 = "class ";
  <D.19475>:
  otype = iftmp.58;
  assemblyref = 0B;
  generic = 0B;
  D.19476 = c->type_token;
  if (D.19476 == 33554433) goto <D.19477>; else goto <D.19478>;
  <D.19477>:
  D.19479 = 0B;
  return D.19479;
  <D.19478>:
  D.19480 = c->image;
  if (D.19480 != m) goto <D.19481>; else goto <D.19482>;
  <D.19481>:
  D.19480 = c->image;
  D.19483 = D.19480->assembly_name;
  if (D.19483 != 0B) goto <D.19484>; else goto <D.19485>;
  <D.19484>:
  substitute_with_mscorlib_p.59 = substitute_with_mscorlib_p;
  if (substitute_with_mscorlib_p.59 != 0) goto <D.19489>; else goto <D.19486>;
  <D.19489>:
  {
    size_t __s1_len;
    size_t __s2_len;

    __s1_len = 6;
    if (__s1_len <= 3) goto <D.19491>; else goto <D.19492>;
    <D.19491>:
    {
      const unsigned char * __s2;
      int __result;

      D.19480 = c->image;
      __s2 = D.19480->assembly_name;
      D.19493 = "corlib";
      D.19494 = MEM[(const unsigned char *)D.19493];
      D.19495 = (int) D.19494;
      D.19496 = *__s2;
      D.19497 = (int) D.19496;
      __result = D.19495 - D.19497;
      {
        if (__s1_len != 0) goto <D.19498>; else goto <D.19499>;
        <D.19498>:
        if (__result == 0) goto <D.19500>; else goto <D.19501>;
        <D.19500>:
        D.19502 = &MEM[(void *)"corlib" + 1B];
        D.19503 = *D.19502;
        D.19504 = (int) D.19503;
        D.19505 = __s2 + 1;
        D.19506 = *D.19505;
        D.19507 = (int) D.19506;
        __result = D.19504 - D.19507;
        if (__s1_len > 1) goto <D.19508>; else goto <D.19509>;
        <D.19508>:
        if (__result == 0) goto <D.19510>; else goto <D.19511>;
        <D.19510>:
        D.19512 = &MEM[(void *)"corlib" + 2B];
        D.19513 = *D.19512;
        D.19514 = (int) D.19513;
        D.19515 = __s2 + 2;
        D.19516 = *D.19515;
        D.19517 = (int) D.19516;
        __result = D.19514 - D.19517;
        if (__s1_len > 2) goto <D.19518>; else goto <D.19519>;
        <D.19518>:
        if (__result == 0) goto <D.19520>; else goto <D.19521>;
        <D.19520>:
        D.19522 = &MEM[(void *)"corlib" + 3B];
        D.19523 = *D.19522;
        D.19524 = (int) D.19523;
        D.19525 = __s2 + 3;
        D.19526 = *D.19525;
        D.19527 = (int) D.19526;
        __result = D.19524 - D.19527;
        <D.19521>:
        <D.19519>:
        <D.19511>:
        <D.19509>:
        <D.19501>:
        <D.19499>:
      }
      D.18395 = __result;
    }
    iftmp.60 = D.18395;
    goto <D.19528>;
    <D.19492>:
    D.19480 = c->image;
    D.19483 = D.19480->assembly_name;
    iftmp.60 = __builtin_strcmp ("corlib", D.19483);
    <D.19528>:
    D.18399 = iftmp.60;
  }
  if (D.18399 == 0) goto <D.19529>; else goto <D.19486>;
  <D.19529>:
  assemblyref = monoeg_g_strdup_printf ("[%s]", "mscorlib");
  goto <D.19487>;
  <D.19486>:
  {
    char * esc;

    D.19480 = c->image;
    D.19530 = D.19480->assembly;
    D.19531 = D.19530->aname.name;
    esc = get_escaped_name (D.19531);
    assemblyref = monoeg_g_strdup_printf ("[%s]", esc);
    monoeg_g_free (esc);
  }
  <D.19487>:
  goto <D.19532>;
  <D.19485>:
  D.19480 = c->image;
  D.19533 = D.19480->module_name;
  assemblyref = monoeg_g_strdup_printf ("[.module %s]", D.19533);
  <D.19532>:
  <D.19482>:
  esname = get_escaped_class_name (c);
  D.19534 = c->generic_class;
  if (D.19534 != 0B) goto <D.19535>; else goto <D.19536>;
  <D.19535>:
  {
    struct MonoGenericClass * gclass;
    struct MonoGenericInst * inst;
    struct GString * str;
    int i;

    gclass = c->generic_class;
    inst = gclass->context.class_inst;
    str = monoeg_g_string_new ("");
    i = 0;
    goto <D.18407>;
    <D.18406>:
    {
      char * t;

      D.19537 = inst->type_argv[i];
      t = dis_stringify_type (m, D.19537, is_def);
      monoeg_g_string_append (str, t);
      D.19538 = i + 1;
      D.19539 = inst->type_argc;
      D.19540 = (int) D.19539;
      if (D.19538 != D.19540) goto <D.19541>; else goto <D.19542>;
      <D.19541>:
      monoeg_g_string_append (str, ", ");
      <D.19542>:
      monoeg_g_free (t);
    }
    i = i + 1;
    <D.18407>:
    D.19539 = inst->type_argc;
    D.19540 = (int) D.19539;
    if (D.19540 > i) goto <D.18406>; else goto <D.18408>;
    <D.18408>:
    D.19543 = str->str;
    generic = monoeg_g_strdup_printf ("<%s>", D.19543);
    monoeg_g_string_free (str, 1);
  }
  <D.19536>:
  if (prefix != 0) goto <D.19545>; else goto <D.19546>;
  <D.19545>:
  iftmp.61 = otype;
  goto <D.19547>;
  <D.19546>:
  iftmp.61 = "";
  <D.19547>:
  if (assemblyref != 0B) goto <D.19549>; else goto <D.19550>;
  <D.19549>:
  iftmp.62 = assemblyref;
  goto <D.19551>;
  <D.19550>:
  iftmp.62 = "";
  <D.19551>:
  if (generic != 0B) goto <D.19553>; else goto <D.19554>;
  <D.19553>:
  iftmp.63 = generic;
  goto <D.19555>;
  <D.19554>:
  iftmp.63 = "";
  <D.19555>:
  result = monoeg_g_strdup_printf ("%s%s%s%s", iftmp.61, iftmp.62, esname, iftmp.63);
  monoeg_g_free (generic);
  monoeg_g_free (assemblyref);
  monoeg_g_free (esname);
  D.19479 = result;
  return D.19479;
}


get_escaped_class_name (struct MonoClass * c)
{
  unsigned int D.19557;
  char * D.19560;
  unsigned char D.19563;
  unsigned char D.19565;
  const char * D.19568;
  struct MonoClass * D.19569;
  const char * D.19573;
  char D.19574;
  char * result;
  char * esname;

  D.19557 = c->type_token;
  if (D.19557 == 33554433) goto <D.19558>; else goto <D.19559>;
  <D.19558>:
  D.19560 = 0B;
  return D.19560;
  <D.19559>:
  D.19563 = c->rank;
  if (D.19563 != 0) goto <D.19561>; else goto <D.19564>;
  <D.19564>:
  D.19565 = c->byval_arg.type;
  if (D.19565 == 15) goto <D.19561>; else goto <D.19562>;
  <D.19561>:
  if (1 != 0) goto <D.19566>; else goto <D.19567>;
  <D.19566>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "get.c", 1051, "0");
  <D.19567>:
  <D.19562>:
  D.19568 = c->name;
  esname = get_escaped_name (D.19568);
  D.19569 = c->nested_in;
  if (D.19569 != 0B) goto <D.19570>; else goto <D.19571>;
  <D.19570>:
  {
    char * part_a;

    D.19569 = c->nested_in;
    part_a = get_escaped_class_name (D.19569);
    result = monoeg_g_strdup_printf ("%s/%s", part_a, esname);
    monoeg_g_free (part_a);
  }
  goto <D.19572>;
  <D.19571>:
  D.19573 = c->name_space;
  D.19574 = *D.19573;
  if (D.19574 != 0) goto <D.19575>; else goto <D.19576>;
  <D.19575>:
  D.19573 = c->name_space;
  result = monoeg_g_strdup_printf ("%s.%s", D.19573, esname);
  goto <D.19577>;
  <D.19576>:
  result = monoeg_strdup (esname);
  <D.19577>:
  <D.19572>:
  monoeg_g_free (esname);
  D.19560 = result;
  return D.19560;
}


dis_stringify_type (struct MonoImage * m, struct MonoType * type, gboolean is_def)
{
  unsigned int D.19579;
  unsigned int D.19580;
  <unnamed-unsigned:6> D.19583;
  int D.19584;
  struct MonoCustomMod[0:] * D.19585;
  unsigned char D.19586;
  int D.19587;
  unsigned int D.19588;
  const char * D.19589;
  struct MonoMethodSignature * D.19590;
  struct MonoType * D.19591;
  struct MonoClass * D.19592;
  struct MonoType * D.19593;
  struct MonoArrayType * D.19594;
  struct MonoGenericParam * D.19598;
  int D.19599;
  struct MonoGenericParamInfo * iftmp.64;
  struct MonoGenericContainer * D.19602;
  const char * D.19606;
  char * D.19607;
  short unsigned int D.19608;
  int D.19609;
  int D.19613;
  struct MonoGenericParamInfo * iftmp.65;
  const char * D.19619;
  char * D.19620;
  struct MonoGenericClass * D.19621;
  struct MonoClass * D.19622;
  struct MonoType * D.19623;
  struct MonoType * D.19624;
  int D.19625;
  <unnamed-unsigned:22> D.19626;
  int D.19627;
  char * D.19630;
  unsigned int D.19631;
  unsigned int D.19634;
  char * D.19639;
  const char * iftmp.66;
  const char * pinned;
  const char * byref;
  char * bare;
  char * mods;
  char * result;

  pinned = "";
  byref = "";
  bare = 0B;
  mods = 0B;
  D.19579 = BIT_FIELD_REF <*type, 32, 32>;
  D.19580 = D.19579 & 1056964608;
  if (D.19580 != 0) goto <D.19581>; else goto <D.19582>;
  <D.19581>:
  D.19583 = type->num_mods;
  D.19584 = (int) D.19583;
  D.19585 = &type->modifiers;
  mods = dis_stringify_modifiers (m, D.19584, D.19585);
  <D.19582>:
  D.19586 = type->type;
  D.19587 = (int) D.19586;
  switch (D.19587) <default: <D.18464>, case 1: <D.18452>, case 2: <D.18425>, case 3: <D.18426>, case 4: <D.18427>, case 5: <D.18428>, case 6: <D.18429>, case 7: <D.18430>, case 8: <D.18431>, case 9: <D.18432>, case 10: <D.18433>, case 11: <D.18434>, case 12: <D.18435>, case 13: <D.18436>, case 14: <D.18439>, case 15: <D.18447>, case 17: <D.18443>, case 18: <D.18444>, case 19: <D.18454>, case 20: <D.18451>, case 21: <D.18455>, case 22: <D.18441>, case 24: <D.18437>, case 25: <D.18438>, case 27: <D.18445>, case 28: <D.18440>, case 29: <D.18449>, case 30: <D.18453>>
  <D.18425>:
  <D.18426>:
  <D.18427>:
  <D.18428>:
  <D.18429>:
  <D.18430>:
  <D.18431>:
  <D.18432>:
  <D.18433>:
  <D.18434>:
  <D.18435>:
  <D.18436>:
  <D.18437>:
  <D.18438>:
  <D.18439>:
  <D.18440>:
  <D.18441>:
  D.19586 = type->type;
  D.19588 = (unsigned int) D.19586;
  D.19589 = map (D.19588, &element_type_map);
  bare = monoeg_strdup (D.19589);
  goto <D.18442>;
  <D.18443>:
  <D.18444>:
  bare = dis_stringify_object (m, type, is_def);
  goto <D.18442>;
  <D.18445>:
  {
    char * child_type;

    D.19590 = type->data.method;
    child_type = dis_stringify_function_ptr (m, D.19590);
    bare = monoeg_g_strdup_printf ("method %s", child_type);
    monoeg_g_free (child_type);
    goto <D.18442>;
  }
  <D.18447>:
  {
    char * child_type;

    D.19591 = type->data.type;
    child_type = dis_stringify_type (m, D.19591, is_def);
    bare = monoeg_g_strdup_printf ("%s*", child_type);
    monoeg_g_free (child_type);
    goto <D.18442>;
  }
  <D.18449>:
  {
    char * child_type;

    D.19592 = type->data.klass;
    D.19593 = &D.19592->byval_arg;
    child_type = dis_stringify_type (m, D.19593, is_def);
    bare = monoeg_g_strdup_printf ("%s[]", child_type);
    monoeg_g_free (child_type);
    goto <D.18442>;
  }
  <D.18451>:
  D.19594 = type->data.array;
  bare = dis_stringify_array (m, D.19594, is_def);
  goto <D.18442>;
  <D.18452>:
  bare = monoeg_strdup ("void");
  goto <D.18442>;
  <D.18453>:
  if (is_def != 0) goto <D.19597>; else goto <D.19595>;
  <D.19597>:
  D.19598 = type->data.generic_param;
  D.19599 = cant_print_generic_param_name (D.19598);
  if (D.19599 == 0) goto <D.19600>; else goto <D.19595>;
  <D.19600>:
  D.19598 = type->data.generic_param;
  D.19602 = D.19598->owner;
  if (D.19602 != 0B) goto <D.19603>; else goto <D.19604>;
  <D.19603>:
  D.19598 = type->data.generic_param;
  iftmp.64 = &MEM[(struct MonoGenericParamFull *)D.19598].info;
  goto <D.19605>;
  <D.19604>:
  iftmp.64 = 0B;
  <D.19605>:
  D.19606 = iftmp.64->name;
  D.19607 = get_escaped_name (D.19606);
  bare = monoeg_g_strdup_printf ("!!%s", D.19607);
  goto <D.19596>;
  <D.19595>:
  D.19598 = type->data.generic_param;
  D.19608 = D.19598->num;
  D.19609 = (int) D.19608;
  bare = monoeg_g_strdup_printf ("!!%d", D.19609);
  <D.19596>:
  goto <D.18442>;
  <D.18454>:
  if (is_def != 0) goto <D.19612>; else goto <D.19610>;
  <D.19612>:
  D.19598 = type->data.generic_param;
  D.19613 = cant_print_generic_param_name (D.19598);
  if (D.19613 == 0) goto <D.19614>; else goto <D.19610>;
  <D.19614>:
  D.19598 = type->data.generic_param;
  D.19602 = D.19598->owner;
  if (D.19602 != 0B) goto <D.19616>; else goto <D.19617>;
  <D.19616>:
  D.19598 = type->data.generic_param;
  iftmp.65 = &MEM[(struct MonoGenericParamFull *)D.19598].info;
  goto <D.19618>;
  <D.19617>:
  iftmp.65 = 0B;
  <D.19618>:
  D.19619 = iftmp.65->name;
  D.19620 = get_escaped_name (D.19619);
  bare = monoeg_g_strdup_printf ("!%s", D.19620);
  goto <D.19611>;
  <D.19610>:
  D.19598 = type->data.generic_param;
  D.19608 = D.19598->num;
  D.19609 = (int) D.19608;
  bare = monoeg_g_strdup_printf ("!%d", D.19609);
  <D.19611>:
  goto <D.18442>;
  <D.18455>:
  {
    struct GString * str;
    struct MonoGenericInst * inst;
    int i;
    char * generic_type;

    str = monoeg_g_string_new ("");
    D.19621 = type->data.generic_class;
    D.19622 = D.19621->container_class;
    D.19623 = &D.19622->byval_arg;
    generic_type = dis_stringify_type (m, D.19623, is_def);
    D.19621 = type->data.generic_class;
    inst = D.19621->context.class_inst;
    i = 0;
    goto <D.18462>;
    <D.18461>:
    {
      char * t;

      D.19624 = inst->type_argv[i];
      t = dis_stringify_type (m, D.19624, is_def);
      monoeg_g_string_append (str, t);
      D.19625 = i + 1;
      D.19626 = inst->type_argc;
      D.19627 = (int) D.19626;
      if (D.19625 != D.19627) goto <D.19628>; else goto <D.19629>;
      <D.19628>:
      monoeg_g_string_append (str, ", ");
      <D.19629>:
      monoeg_g_free (t);
    }
    i = i + 1;
    <D.18462>:
    D.19626 = inst->type_argc;
    D.19627 = (int) D.19626;
    if (D.19627 > i) goto <D.18461>; else goto <D.18463>;
    <D.18463>:
    D.19630 = str->str;
    bare = monoeg_g_strdup_printf ("%s<%s>", generic_type, D.19630);
    monoeg_g_string_free (str, 1);
    goto <D.18442>;
  }
  <D.18464>:
  D.19586 = type->type;
  D.19587 = (int) D.19586;
  monoeg_g_log (0B, 4, "Do not know how to stringify type 0x%x", D.19587);
  <D.18465>:
  goto <D.18465>;
  <D.18442>:
  D.19579 = BIT_FIELD_REF <*type, 32, 32>;
  D.19631 = D.19579 & 2147483648;
  if (D.19631 != 0) goto <D.19632>; else goto <D.19633>;
  <D.19632>:
  pinned = " pinned";
  <D.19633>:
  D.19579 = BIT_FIELD_REF <*type, 32, 32>;
  D.19634 = D.19579 & 1073741824;
  if (D.19634 != 0) goto <D.19635>; else goto <D.19636>;
  <D.19635>:
  byref = "&";
  <D.19636>:
  if (bare == 0B) goto <D.19637>; else goto <D.19638>;
  <D.19637>:
  D.19639 = bare;
  return D.19639;
  <D.19638>:
  if (mods != 0B) goto <D.19641>; else goto <D.19642>;
  <D.19641>:
  iftmp.66 = mods;
  goto <D.19643>;
  <D.19642>:
  iftmp.66 = "";
  <D.19643>:
  result = monoeg_g_strconcat (bare, byref, pinned, iftmp.66, 0B);
  monoeg_g_free (bare);
  D.19639 = result;
  return D.19639;
}


dis_stringify_object (struct MonoImage * m, struct MonoType * type, gboolean is_def)
{
  char * D.19645;
  struct MonoClass * c;

  c = mono_class_from_mono_type (type);
  D.19645 = dis_stringify_object_with_class (m, c, 1, is_def);
  return D.19645;
}


cant_print_generic_param_name (struct MonoGenericParam * gparam)
{
  _Bool D.19647;
  long int D.19648;
  long int D.19649;
  gboolean D.19652;
  int iftmp.67;
  struct GHashTable * mono_generic_params_with_ambiguous_names.68;
  void * D.19660;
  struct MonoGenericContainer * container;

  D.19647 = gparam == 0B;
  D.19648 = (long int) D.19647;
  D.19649 = __builtin_expect (D.19648, 0);
  if (D.19649 != 0) goto <D.19650>; else goto <D.19651>;
  <D.19650>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "get.c", 3166, "gparam");
  <D.19651>:
  container = gparam->owner;
  check_ambiguous_genparams (container);
  if (container == 0B) goto <D.19654>; else goto <D.19657>;
  <D.19657>:
  mono_generic_params_with_ambiguous_names.68 = mono_generic_params_with_ambiguous_names;
  if (mono_generic_params_with_ambiguous_names.68 != 0B) goto <D.19659>; else goto <D.19655>;
  <D.19659>:
  mono_generic_params_with_ambiguous_names.68 = mono_generic_params_with_ambiguous_names;
  D.19660 = monoeg_g_hash_table_lookup (mono_generic_params_with_ambiguous_names.68, gparam);
  if (D.19660 != 0B) goto <D.19654>; else goto <D.19655>;
  <D.19654>:
  iftmp.67 = 1;
  goto <D.19656>;
  <D.19655>:
  iftmp.67 = 0;
  <D.19656>:
  D.19652 = iftmp.67;
  return D.19652;
}


check_ambiguous_genparams (struct MonoGenericContainer * container)
{
  struct GHashTable * generic_containers.69;
  void * D.19667;
  struct MonoGenericParamFull * D.19670;
  unsigned int i.70;
  unsigned int D.19672;
  struct MonoGenericParamInfo * iftmp.71;
  struct MonoGenericContainer * D.19674;
  const char * D.19678;
  int D.19681;
  void * D.19682;
  struct GSList * D.19683;
  struct MonoGenericParamInfo * iftmp.72;
  const char * D.19689;
  <unnamed-signed:31> D.19690;
  int D.19691;
  struct GHashTable * mono_generic_params_with_ambiguous_names.73;
  struct GHashTable * mono_generic_params_with_ambiguous_names.74;
  void * D.19698;
  sizetype param.75;
  sizetype D.19700;
  sizetype D.19701;
  struct MonoGenericParamFull * D.19702;
  struct GHashTable * generic_containers.76;
  struct GSList * dup_list;
  struct GSList * l;
  struct GHashTable * table;
  void * * p;
  int i;

  dup_list = 0B;
  table = 0B;
  if (container == 0B) goto <D.19662>; else goto <D.19663>;
  <D.19662>:
  return;
  <D.19663>:
  generic_containers.69 = generic_containers;
  if (generic_containers.69 != 0B) goto <D.19665>; else goto <D.19666>;
  <D.19665>:
  generic_containers.69 = generic_containers;
  D.19667 = monoeg_g_hash_table_lookup (generic_containers.69, container);
  if (D.19667 != 0B) goto <D.19668>; else goto <D.19669>;
  <D.19668>:
  return;
  <D.19669>:
  <D.19666>:
  table = monoeg_g_hash_table_new (monoeg_g_str_hash, monoeg_g_str_equal);
  i = 0;
  goto <D.18958>;
  <D.18957>:
  {
    struct MonoGenericParam * param;

    D.19670 = container->type_params;
    i.70 = (unsigned int) i;
    D.19672 = i.70 * 32;
    param = D.19670 + D.19672;
    D.19674 = param->owner;
    if (D.19674 != 0B) goto <D.19675>; else goto <D.19676>;
    <D.19675>:
    iftmp.71 = &MEM[(struct MonoGenericParamFull *)param].info;
    goto <D.19677>;
    <D.19676>:
    iftmp.71 = 0B;
    <D.19677>:
    D.19678 = iftmp.71->name;
    p = monoeg_g_hash_table_lookup (table, D.19678);
    if (p != 0B) goto <D.19679>; else goto <D.19680>;
    <D.19679>:
    D.19681 = i + 1;
    D.19682 = (void *) D.19681;
    D.19683 = monoeg_g_slist_prepend (dup_list, D.19682);
    dup_list = monoeg_g_slist_prepend (D.19683, p);
    goto <D.19684>;
    <D.19680>:
    D.19674 = param->owner;
    if (D.19674 != 0B) goto <D.19686>; else goto <D.19687>;
    <D.19686>:
    iftmp.72 = &MEM[(struct MonoGenericParamFull *)param].info;
    goto <D.19688>;
    <D.19687>:
    iftmp.72 = 0B;
    <D.19688>:
    D.19689 = iftmp.72->name;
    D.19681 = i + 1;
    D.19682 = (void *) D.19681;
    monoeg_g_hash_table_insert_replace (table, D.19689, D.19682, 0);
    <D.19684>:
  }
  i = i + 1;
  <D.18958>:
  D.19690 = container->type_argc;
  D.19691 = (int) D.19690;
  if (D.19691 > i) goto <D.18957>; else goto <D.18959>;
  <D.18959>:
  if (dup_list != 0B) goto <D.19692>; else goto <D.19693>;
  <D.19692>:
  mono_generic_params_with_ambiguous_names.73 = mono_generic_params_with_ambiguous_names;
  if (mono_generic_params_with_ambiguous_names.73 == 0B) goto <D.19695>; else goto <D.19696>;
  <D.19695>:
  mono_generic_params_with_ambiguous_names.74 = monoeg_g_hash_table_new (0B, 0B);
  mono_generic_params_with_ambiguous_names = mono_generic_params_with_ambiguous_names.74;
  <D.19696>:
  l = dup_list;
  goto <D.18962>;
  <D.18961>:
  {
    int param;

    D.19698 = l->data;
    param = (int) D.19698;
    mono_generic_params_with_ambiguous_names.73 = mono_generic_params_with_ambiguous_names;
    D.19670 = container->type_params;
    param.75 = (sizetype) param;
    D.19700 = param.75 + 134217727;
    D.19701 = D.19700 * 32;
    D.19702 = D.19670 + D.19701;
    D.19670 = container->type_params;
    param.75 = (sizetype) param;
    D.19700 = param.75 + 134217727;
    D.19701 = D.19700 * 32;
    D.19702 = D.19670 + D.19701;
    monoeg_g_hash_table_insert_replace (mono_generic_params_with_ambiguous_names.73, D.19702, D.19702, 0);
  }
  l = l->next;
  <D.18962>:
  if (l != 0B) goto <D.18961>; else goto <D.18963>;
  <D.18963>:
  monoeg_g_slist_free (dup_list);
  <D.19693>:
  generic_containers.69 = generic_containers;
  if (generic_containers.69 == 0B) goto <D.19703>; else goto <D.19704>;
  <D.19703>:
  generic_containers.76 = monoeg_g_hash_table_new (0B, 0B);
  generic_containers = generic_containers.76;
  <D.19704>:
  generic_containers.69 = generic_containers;
  monoeg_g_hash_table_insert_replace (generic_containers.69, container, container, 0);
  monoeg_g_hash_table_destroy (table);
}


get_type (struct MonoImage * m, const char * ptr, char * * result, gboolean is_def, struct MonoGenericContainer * container)
{
  const char * ptr.77;
  char D.19708;
  const char * ptr.78;
  int show_tokens.79;
  gchar * D.19718;
  const char * ptr.80;
  char * temp.81;
  unsigned int D.19722;
  const char * ptr.82;
  char * D.19726;
  char * D.19729;
  gchar * D.19736;
  const char * D.19737;
  const char * start;
  guint32 type;
  struct MonoType * t;

  start = ptr;
  ptr.77 = ptr;
  D.19708 = *ptr.77;
  if (D.19708 == 16) goto <D.19709>; else goto <D.19710>;
  <D.19709>:
  ptr.77 = ptr;
  ptr.78 = ptr.77 + 1;
  ptr = ptr.78;
  <D.19710>:
  ptr.77 = ptr;
  type = mono_metadata_decode_value (ptr.77, &ptr);
  switch (type) <default: <D.18490>, case 17: <D.18476>, case 18: <D.18477>, case 21: <D.18482>>
  <D.18476>:
  <D.18477>:
  {
    guint32 token;
    struct MonoClass * klass;
    char * temp;

    ptr.77 = ptr;
    token = mono_metadata_parse_typedef_or_ref (m, ptr.77, &ptr);
    klass = mono_class_get (m, token);
    if (klass != 0B) goto <D.19712>; else goto <D.19713>;
    <D.19712>:
    temp = dis_stringify_object_with_class (m, klass, 1, 0);
    goto <D.19714>;
    <D.19713>:
    temp = monoeg_g_strdup_printf ("<BROKEN CLASS token_%8x>", token);
    <D.19714>:
    show_tokens.79 = show_tokens;
    if (show_tokens.79 != 0) goto <D.19716>; else goto <D.19717>;
    <D.19716>:
    D.19718 = monoeg_g_strdup_printf ("%s/*%08x*/", temp, token);
    *result = D.19718;
    monoeg_g_free (temp);
    goto <D.19719>;
    <D.19717>:
    *result = temp;
    <D.19719>:
    goto <D.18481>;
  }
  <D.18482>:
  {
    struct GString * str;
    int count;
    int i;
    char * temp;

    try
      {
        str = monoeg_g_string_new ("");
        ptr.77 = ptr;
        ptr.80 = get_type (m, ptr.77, &temp, is_def, container);
        ptr = ptr.80;
        temp.81 = temp;
        monoeg_g_string_append (str, temp.81);
        temp.81 = temp;
        monoeg_g_free (temp.81);
        ptr.77 = ptr;
        D.19722 = mono_metadata_decode_value (ptr.77, &ptr);
        count = (int) D.19722;
        monoeg_g_string_append (str, "<");
        i = 0;
        goto <D.18488>;
        <D.18487>:
        if (i != 0) goto <D.19723>; else goto <D.19724>;
        <D.19723>:
        monoeg_g_string_append (str, ",");
        <D.19724>:
        ptr.77 = ptr;
        ptr.82 = get_type (m, ptr.77, &temp, is_def, container);
        ptr = ptr.82;
        temp.81 = temp;
        monoeg_g_string_append (str, temp.81);
        i = i + 1;
        <D.18488>:
        if (i < count) goto <D.18487>; else goto <D.18489>;
        <D.18489>:
        monoeg_g_string_append (str, ">");
        D.19726 = str->str;
        *result = D.19726;
        monoeg_g_string_free (str, 0);
        goto <D.18481>;
      }
    finally
      {
        temp = {CLOBBER};
      }
  }
  <D.18490>:
  t = mono_metadata_parse_type_full (m, container, 0, 0, start, &ptr);
  if (t != 0B) goto <D.19727>; else goto <D.19728>;
  <D.19727>:
  D.19729 = dis_stringify_type (m, t, is_def);
  *result = D.19729;
  goto <D.19730>;
  <D.19728>:
  {
    struct GString * err;

    err = monoeg_g_string_new ("@!#$<InvalidType>$#!@");
    if (container != 0B) goto <D.19731>; else goto <D.19732>;
    <D.19731>:
    t = mono_metadata_parse_type_full (m, 0B, 0, 0, start, &ptr);
    <D.19732>:
    if (t != 0B) goto <D.19733>; else goto <D.19734>;
    <D.19733>:
    {
      char * name;

      name = dis_stringify_type (m, t, is_def);
      monoeg_g_log (0B, 16, "Encountered a generic type inappropriate for its context");
      monoeg_g_string_append (err, " // ");
      monoeg_g_string_append (err, name);
      monoeg_g_free (name);
    }
    goto <D.19735>;
    <D.19734>:
    monoeg_g_log (0B, 16, "Encountered an invalid type");
    <D.19735>:
    D.19736 = monoeg_g_string_free (err, 0);
    *result = D.19736;
  }
  <D.19730>:
  goto <D.18481>;
  <D.18481>:
  D.19737 = ptr;
  return D.19737;
}


get_field_signature (struct MonoImage * m, guint32 blob_signature, struct MonoGenericContainer * container)
{
  const char * ptr.83;
  const char * ptr.84;
  unsigned int D.19742;
  char D.19743;
  _Bool D.19744;
  long int D.19745;
  long int D.19746;
  const char * ptr.85;
  const char * ptr.86;
  const char * ptr.87;
  char * allocated_type_string.88;
  const char * iftmp.89;
  char * allocated_modifier_string.90;
  char * D.19762;
  char * allocated_modifier_string;
  char * allocated_type_string;
  const char * ptr;
  const char * base;
  char * res;
  int len;

  try
    {
      ptr.83 = mono_metadata_blob_heap (m, blob_signature);
      ptr = ptr.83;
      ptr.84 = ptr;
      D.19742 = mono_metadata_decode_value (ptr.84, &ptr);
      len = (int) D.19742;
      base = ptr;
      ptr.84 = ptr;
      D.19743 = *ptr.84;
      D.19744 = D.19743 != 6;
      D.19745 = (long int) D.19744;
      D.19746 = __builtin_expect (D.19745, 0);
      if (D.19746 != 0) goto <D.19747>; else goto <D.19748>;
      <D.19747>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "get.c", 1361, "*ptr == 0x06");
      <D.19748>:
      ptr.84 = ptr;
      ptr.85 = ptr.84 + 1;
      ptr = ptr.85;
      len = len + -1;
      ptr.84 = ptr;
      ptr.86 = get_custom_mod (m, ptr.84, &allocated_modifier_string);
      ptr = ptr.86;
      ptr.84 = ptr;
      ptr.87 = get_type (m, ptr.84, &allocated_type_string, 0, container);
      ptr = ptr.87;
      allocated_type_string.88 = allocated_type_string;
      allocated_modifier_string.90 = allocated_modifier_string;
      if (allocated_modifier_string.90 != 0B) goto <D.19755>; else goto <D.19756>;
      <D.19755>:
      iftmp.89 = allocated_modifier_string;
      goto <D.19757>;
      <D.19756>:
      iftmp.89 = "";
      <D.19757>:
      res = monoeg_g_strdup_printf ("%s%s", allocated_type_string.88, iftmp.89);
      allocated_modifier_string.90 = allocated_modifier_string;
      if (allocated_modifier_string.90 != 0B) goto <D.19758>; else goto <D.19759>;
      <D.19758>:
      allocated_modifier_string.90 = allocated_modifier_string;
      monoeg_g_free (allocated_modifier_string.90);
      <D.19759>:
      allocated_type_string.88 = allocated_type_string;
      if (allocated_type_string.88 != 0B) goto <D.19760>; else goto <D.19761>;
      <D.19760>:
      allocated_type_string.88 = allocated_type_string;
      monoeg_g_free (allocated_type_string.88);
      <D.19761>:
      D.19762 = res;
      return D.19762;
    }
  finally
    {
      allocated_modifier_string = {CLOBBER};
      allocated_type_string = {CLOBBER};
      ptr = {CLOBBER};
    }
}


get_field_literal_type (struct MonoImage * m, guint32 blob_signature)
{
  const char * ptr.91;
  const char * ptr.92;
  unsigned int D.19767;
  char D.19768;
  _Bool D.19769;
  long int D.19770;
  long int D.19771;
  const char * ptr.93;
  const char * ptr.94;
  char * allocated_modifier_string.95;
  MonoTypeEnum D.19779;
  const char * ptr;
  int len;
  char * allocated_modifier_string;

  try
    {
      ptr.91 = mono_metadata_blob_heap (m, blob_signature);
      ptr = ptr.91;
      ptr.92 = ptr;
      D.19767 = mono_metadata_decode_value (ptr.92, &ptr);
      len = (int) D.19767;
      ptr.92 = ptr;
      D.19768 = *ptr.92;
      D.19769 = D.19768 != 6;
      D.19770 = (long int) D.19769;
      D.19771 = __builtin_expect (D.19770, 0);
      if (D.19771 != 0) goto <D.19772>; else goto <D.19773>;
      <D.19772>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "get.c", 1391, "*ptr == 0x06");
      <D.19773>:
      ptr.92 = ptr;
      ptr.93 = ptr.92 + 1;
      ptr = ptr.93;
      len = len + -1;
      ptr.92 = ptr;
      ptr.94 = get_custom_mod (m, ptr.92, &allocated_modifier_string);
      ptr = ptr.94;
      allocated_modifier_string.95 = allocated_modifier_string;
      if (allocated_modifier_string.95 != 0B) goto <D.19777>; else goto <D.19778>;
      <D.19777>:
      allocated_modifier_string.95 = allocated_modifier_string;
      monoeg_g_free (allocated_modifier_string.95);
      <D.19778>:
      ptr.92 = ptr;
      D.19768 = *ptr.92;
      D.19779 = (MonoTypeEnum) D.19768;
      return D.19779;
    }
  finally
    {
      ptr = {CLOBBER};
      allocated_modifier_string = {CLOBBER};
    }
}


decode_literal (struct MonoImage * m, guint32 token)
{
  char * D.19782;

  D.19782 = monoeg_strdup ("LITERAL_VALUE");
  return D.19782;
}


get_ret_type (struct MonoImage * m, const char * ptr, char * * ret_type, struct MonoGenericContainer * container)
{
  char D.19784;
  char * allocated_type_string.96;
  char * mod.97;
  char * D.19799;
  const char * D.19800;
  struct GString * str;
  char * mod;
  char * allocated_type_string;
  int has_byref;

  try
    {
      str = monoeg_g_string_new ("");
      mod = 0B;
      has_byref = 0;
      ptr = get_custom_mod (m, ptr, &mod);
      D.19784 = *ptr;
      if (D.19784 == 22) goto <D.19785>; else goto <D.19786>;
      <D.19785>:
      monoeg_g_string_append (str, "typedref");
      ptr = ptr + 1;
      goto <D.19787>;
      <D.19786>:
      D.19784 = *ptr;
      if (D.19784 == 1) goto <D.19788>; else goto <D.19789>;
      <D.19788>:
      monoeg_g_string_append (str, "void");
      ptr = ptr + 1;
      goto <D.19790>;
      <D.19789>:
      D.19784 = *ptr;
      if (D.19784 == 16) goto <D.19791>; else goto <D.19792>;
      <D.19791>:
      has_byref = 1;
      ptr = ptr + 1;
      <D.19792>:
      ptr = get_type (m, ptr, &allocated_type_string, 0, container);
      allocated_type_string.96 = allocated_type_string;
      monoeg_g_string_append (str, allocated_type_string.96);
      if (has_byref != 0) goto <D.19794>; else goto <D.19795>;
      <D.19794>:
      monoeg_g_string_append (str, "& ");
      <D.19795>:
      allocated_type_string.96 = allocated_type_string;
      monoeg_g_free (allocated_type_string.96);
      <D.19790>:
      <D.19787>:
      mod.97 = mod;
      if (mod.97 != 0B) goto <D.19797>; else goto <D.19798>;
      <D.19797>:
      mod.97 = mod;
      monoeg_g_string_append (str, mod.97);
      monoeg_g_string_append_c (str, 32);
      mod.97 = mod;
      monoeg_g_free (mod.97);
      <D.19798>:
      D.19799 = str->str;
      *ret_type = D.19799;
      monoeg_g_string_free (str, 0);
      D.19800 = ptr;
      return D.19800;
    }
  finally
    {
      mod = {CLOBBER};
      allocated_type_string = {CLOBBER};
    }
}


get_param (struct MonoImage * m, const char * ptr, char * * retval, struct MonoGenericContainer * container)
{
  char D.19803;
  char * allocated_type_string.98;
  char * allocated_mod_string.99;
  char * D.19815;
  const char * D.19816;
  struct GString * str;
  char * allocated_mod_string;
  char * allocated_type_string;

  try
    {
      str = monoeg_g_string_new ("");
      ptr = get_custom_mod (m, ptr, &allocated_mod_string);
      D.19803 = *ptr;
      if (D.19803 == 22) goto <D.19804>; else goto <D.19805>;
      <D.19804>:
      monoeg_g_string_append (str, " typedref ");
      ptr = ptr + 1;
      goto <D.19806>;
      <D.19805>:
      {
        gboolean by_ref;

        by_ref = 0;
        D.19803 = *ptr;
        if (D.19803 == 16) goto <D.19807>; else goto <D.19808>;
        <D.19807>:
        monoeg_g_string_append (str, "[out] ");
        ptr = ptr + 1;
        by_ref = 1;
        <D.19808>:
        ptr = get_type (m, ptr, &allocated_type_string, 0, container);
        allocated_type_string.98 = allocated_type_string;
        monoeg_g_string_append (str, allocated_type_string.98);
        if (by_ref != 0) goto <D.19810>; else goto <D.19811>;
        <D.19810>:
        monoeg_g_string_append_c (str, 38);
        <D.19811>:
        allocated_type_string.98 = allocated_type_string;
        monoeg_g_free (allocated_type_string.98);
      }
      <D.19806>:
      allocated_mod_string.99 = allocated_mod_string;
      if (allocated_mod_string.99 != 0B) goto <D.19813>; else goto <D.19814>;
      <D.19813>:
      allocated_mod_string.99 = allocated_mod_string;
      monoeg_g_string_append (str, allocated_mod_string.99);
      monoeg_g_string_append_c (str, 32);
      allocated_mod_string.99 = allocated_mod_string;
      monoeg_g_free (allocated_mod_string.99);
      <D.19814>:
      D.19815 = str->str;
      *retval = D.19815;
      monoeg_g_string_free (str, 0);
      D.19816 = ptr;
      return D.19816;
    }
  finally
    {
      allocated_mod_string = {CLOBBER};
      allocated_type_string = {CLOBBER};
    }
}


get_escaped_name (const char * name)
{
  char * D.19821;
  struct GHashTable * key_table.100;
  _Bool D.19823;
  long int D.19824;
  long int D.19825;
  char D.19828;
  char D.19831;
  int s.101;
  int name.102;
  int D.19836;
  unsigned int D.19837;
  char * D.19838;
  const char * D.19839;
  char * D.19840;
  const short unsigned int * * D.19844;
  const short unsigned int * D.19845;
  unsigned int D.19846;
  unsigned int D.19847;
  const short unsigned int * D.19848;
  short unsigned int D.19849;
  int D.19850;
  int D.19851;
  void * D.19860;
  const char * s;
  char * ret;
  char * esc;

  if (name == 0B) goto <D.19819>; else goto <D.19820>;
  <D.19819>:
  D.19821 = 0B;
  return D.19821;
  <D.19820>:
  key_table.100 = key_table;
  D.19823 = key_table.100 == 0B;
  D.19824 = (long int) D.19823;
  D.19825 = __builtin_expect (D.19824, 0);
  if (D.19825 != 0) goto <D.19826>; else goto <D.19827>;
  <D.19826>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "get.c", 1557, "key_table");
  <D.19827>:
  D.19828 = *name;
  if (D.19828 == 0) goto <D.19829>; else goto <D.19830>;
  <D.19829>:
  D.19821 = monoeg_strdup (name);
  return D.19821;
  <D.19830>:
  s = name;
  goto <D.18556>;
  <D.18555>:
  {
    char * first;
    char * result;

    D.19831 = *s;
    if (D.19831 != 47) goto <D.19832>; else goto <D.19833>;
    <D.19832>:
    // predicted unlikely by continue predictor.
    goto <D.18554>;
    <D.19833>:
    s.101 = (int) s;
    name.102 = (int) name;
    D.19836 = s.101 - name.102;
    D.19837 = (unsigned int) D.19836;
    first = monoeg_g_strndup (name, D.19837);
    D.19838 = get_escaped_name (first);
    D.19839 = s + 1;
    D.19840 = get_escaped_name (D.19839);
    result = monoeg_g_strdup_printf ("%s/%s", D.19838, D.19840);
    monoeg_g_free (first);
    D.19821 = result;
    return D.19821;
  }
  <D.18554>:
  s = s + 1;
  <D.18556>:
  D.19831 = *s;
  if (D.19831 != 0) goto <D.18555>; else goto <D.18557>;
  <D.18557>:
  s = name;
  goto <D.18560>;
  <D.18559>:
  D.19844 = __ctype_b_loc ();
  D.19845 = *D.19844;
  D.19831 = *s;
  D.19846 = (unsigned int) D.19831;
  D.19847 = D.19846 * 2;
  D.19848 = D.19845 + D.19847;
  D.19849 = *D.19848;
  D.19850 = (int) D.19849;
  D.19851 = D.19850 & 8;
  if (D.19851 != 0) goto <D.19841>; else goto <D.19852>;
  <D.19852>:
  D.19831 = *s;
  if (D.19831 == 95) goto <D.19841>; else goto <D.19853>;
  <D.19853>:
  D.19831 = *s;
  if (D.19831 == 36) goto <D.19841>; else goto <D.19854>;
  <D.19854>:
  D.19831 = *s;
  if (D.19831 == 64) goto <D.19841>; else goto <D.19855>;
  <D.19855>:
  D.19831 = *s;
  if (D.19831 == 63) goto <D.19841>; else goto <D.19856>;
  <D.19856>:
  D.19831 = *s;
  if (D.19831 == 46) goto <D.19857>; else goto <D.19842>;
  <D.19857>:
  if (s != name) goto <D.19841>; else goto <D.19842>;
  <D.19842>:
  D.19831 = *s;
  if (D.19831 == 0) goto <D.19841>; else goto <D.19858>;
  <D.19858>:
  D.19831 = *s;
  if (D.19831 == 33) goto <D.19841>; else goto <D.19859>;
  <D.19859>:
  D.19831 = *s;
  if (D.19831 == 96) goto <D.19841>; else goto <D.19843>;
  <D.19841>:
  // predicted unlikely by continue predictor.
  goto <D.18558>;
  <D.19843>:
  esc = str_escape (name, "\'\\");
  ret = monoeg_g_strdup_printf ("\'%s\'", esc);
  monoeg_g_free (esc);
  D.19821 = ret;
  return D.19821;
  <D.18558>:
  s = s + 1;
  <D.18560>:
  D.19831 = *s;
  if (D.19831 != 0) goto <D.18559>; else goto <D.18561>;
  <D.18561>:
  key_table.100 = key_table;
  D.19860 = monoeg_g_hash_table_lookup (key_table.100, name);
  if (D.19860 != 0B) goto <D.19861>; else goto <D.19862>;
  <D.19861>:
  D.19821 = monoeg_g_strdup_printf ("\'%s\'", name);
  return D.19821;
  <D.19862>:
  D.19821 = str_escape (name, "\'\\");
  return D.19821;
}


str_escape (const char * str, const char * list)
{
  unsigned int D.19864;
  char D.19865;
  int D.19868;
  int D.19869;
  void * D.19872;
  char * D.19873;
  int p.103;
  int str.104;
  int D.19876;
  char * D.19878;
  const char * p;
  struct GString * res;

  p = str;
  D.19864 = strlen (str);
  res = monoeg_g_string_sized_new (D.19864);
  <D.18545>:
  goto <D.18542>;
  <D.18541>:
  p = p + 1;
  <D.18542>:
  D.19865 = *p;
  if (D.19865 != 0) goto <D.19866>; else goto <D.18543>;
  <D.19866>:
  D.19865 = *p;
  D.19868 = (int) D.19865;
  D.19869 = __builtin_constant_p (D.19868);
  if (D.19869 != 0) goto <D.19870>; else goto <D.19867>;
  <D.19870>:
  D.19865 = *p;
  if (D.19865 == 0) goto <D.19871>; else goto <D.19867>;
  <D.19871>:
  D.19865 = *p;
  D.19868 = (int) D.19865;
  D.19872 = __rawmemchr (list, D.19868);
  if (D.19872 == 0B) goto <D.18541>; else goto <D.18543>;
  <D.19867>:
  D.19865 = *p;
  D.19868 = (int) D.19865;
  D.19873 = __builtin_strchr (list, D.19868);
  if (D.19873 == 0B) goto <D.18541>; else goto <D.18543>;
  <D.18543>:
  p.103 = (int) p;
  str.104 = (int) str;
  D.19876 = p.103 - str.104;
  monoeg_g_string_append_len (res, str, D.19876);
  D.19865 = *p;
  if (D.19865 == 0) goto <D.18544>; else goto <D.19877>;
  <D.19877>:
  monoeg_g_string_append_c (res, 92);
  str = p;
  p = p + 1;
  goto <D.18545>;
  <D.18544>:
  D.19878 = monoeg_g_string_free (res, 0);
  return D.19878;
}


param_flags (guint32 f)
{
  char * D.19880;
  const char * D.19881;

  D.19881 = flags (f, &param_map);
  D.19880 = monoeg_strdup (D.19881);
  return D.19880;
}


field_flags (guint32 f)
{
  int f.105;
  int D.19884;
  unsigned int D.19885;
  unsigned int D.19886;
  unsigned int access.106;
  const char * D.19888;
  unsigned int rest.107;
  const char * D.19890;
  char * D.19891;
  char buffer[1024];
  int access;
  int rest;

  try
    {
      f.105 = (int) f;
      access = f.105 & 7;
      D.19884 = ~access;
      D.19885 = (unsigned int) D.19884;
      D.19886 = D.19885 & f;
      rest = (int) D.19886;
      buffer[0] = 0;
      access.106 = (unsigned int) access;
      D.19888 = map (access.106, &field_access_map);
      strcat (&buffer, D.19888);
      rest.107 = (unsigned int) rest;
      D.19890 = flags (rest.107, &field_flags_map);
      strcat (&buffer, D.19890);
      D.19891 = monoeg_strdup (&buffer);
      return D.19891;
    }
  finally
    {
      buffer = {CLOBBER};
    }
}


strcat (char * restrict __dest, const char * restrict __src)
{
  char * D.19894;
  unsigned int D.19895;

  D.19895 = __builtin_object_size (__dest, 1);
  D.19894 = __builtin___strcat_chk (__dest, __src, D.19895);
  return D.19894;
}


get_methodref_signature (struct MonoImage * m, guint32 blob_signature, const char * fancy_name)
{
  const char * ptr.108;
  const char * ptr.109;
  unsigned int D.19899;
  char D.19900;
  unsigned char D.19901;
  int D.19902;
  int D.19903;
  int D.19906;
  int D.19910;
  unsigned int cconv.110;
  int D.18598;
  int iftmp.111;
  int D.18597;
  const char[8] * D.19917;
  unsigned char D.19918;
  int D.19919;
  unsigned char D.19920;
  int D.19921;
  const unsigned char * D.19926;
  unsigned char D.19927;
  int D.19928;
  const unsigned char * D.19929;
  unsigned char D.19930;
  int D.19931;
  const unsigned char * D.19936;
  unsigned char D.19937;
  int D.19938;
  const unsigned char * D.19939;
  unsigned char D.19940;
  int D.19941;
  const unsigned char * D.19946;
  unsigned char D.19947;
  int D.19948;
  const unsigned char * D.19949;
  unsigned char D.19950;
  int D.19951;
  const char * ptr.112;
  unsigned int D.19958;
  unsigned int D.19959;
  const char * ptr.113;
  char * allocated_ret_type.114;
  const char * ptr.115;
  char * param.116;
  int D.19972;
  char * D.19975;
  struct GString * res;
  const char * ptr;
  char * allocated_ret_type;
  char * s;
  const char * cconv_str;
  gboolean seen_vararg;
  int param_count;
  int signature_len;
  int i;
  int gen_count;
  int cconv;

  try
    {
      res = monoeg_g_string_new ("");
      ptr.108 = mono_metadata_blob_heap (m, blob_signature);
      ptr = ptr.108;
      seen_vararg = 0;
      gen_count = 0;
      ptr.109 = ptr;
      D.19899 = mono_metadata_decode_value (ptr.109, &ptr);
      signature_len = (int) D.19899;
      ptr.109 = ptr;
      D.19900 = *ptr.109;
      D.19901 = (unsigned char) D.19900;
      D.19902 = (int) D.19901;
      D.19903 = D.19902 & 32;
      if (D.19903 != 0) goto <D.19904>; else goto <D.19905>;
      <D.19904>:
      ptr.109 = ptr;
      D.19900 = *ptr.109;
      D.19901 = (unsigned char) D.19900;
      D.19902 = (int) D.19901;
      D.19906 = D.19902 & 64;
      if (D.19906 != 0) goto <D.19907>; else goto <D.19908>;
      <D.19907>:
      monoeg_g_string_append (res, "explicit-this ");
      goto <D.19909>;
      <D.19908>:
      monoeg_g_string_append (res, "instance ");
      <D.19909>:
      <D.19905>:
      ptr.109 = ptr;
      D.19900 = *ptr.109;
      D.19901 = (unsigned char) D.19900;
      D.19902 = (int) D.19901;
      D.19910 = D.19902 & 16;
      if (D.19910 != 0) goto <D.19911>; else goto <D.19912>;
      <D.19911>:
      gen_count = 1;
      <D.19912>:
      ptr.109 = ptr;
      D.19900 = *ptr.109;
      D.19901 = (unsigned char) D.19900;
      D.19902 = (int) D.19901;
      cconv = D.19902 & 15;
      cconv.110 = (unsigned int) cconv;
      cconv_str = map (cconv.110, &call_conv_type_map);
      {
        size_t __s1_len;
        size_t __s2_len;

        __s2_len = 7;
        if (__s2_len <= 3) goto <D.19915>; else goto <D.19916>;
        <D.19915>:
        {
          const unsigned char * __s2;
          int __result;

          __s2 = cconv_str;
          D.19917 = "default";
          D.19918 = MEM[(const unsigned char *)D.19917];
          D.19919 = (int) D.19918;
          D.19920 = *__s2;
          D.19921 = (int) D.19920;
          __result = D.19919 - D.19921;
          {
            if (__s2_len != 0) goto <D.19922>; else goto <D.19923>;
            <D.19922>:
            if (__result == 0) goto <D.19924>; else goto <D.19925>;
            <D.19924>:
            D.19926 = &MEM[(void *)"default" + 1B];
            D.19927 = *D.19926;
            D.19928 = (int) D.19927;
            D.19929 = __s2 + 1;
            D.19930 = *D.19929;
            D.19931 = (int) D.19930;
            __result = D.19928 - D.19931;
            if (__s2_len > 1) goto <D.19932>; else goto <D.19933>;
            <D.19932>:
            if (__result == 0) goto <D.19934>; else goto <D.19935>;
            <D.19934>:
            D.19936 = &MEM[(void *)"default" + 2B];
            D.19937 = *D.19936;
            D.19938 = (int) D.19937;
            D.19939 = __s2 + 2;
            D.19940 = *D.19939;
            D.19941 = (int) D.19940;
            __result = D.19938 - D.19941;
            if (__s2_len > 2) goto <D.19942>; else goto <D.19943>;
            <D.19942>:
            if (__result == 0) goto <D.19944>; else goto <D.19945>;
            <D.19944>:
            D.19946 = &MEM[(void *)"default" + 3B];
            D.19947 = *D.19946;
            D.19948 = (int) D.19947;
            D.19949 = __s2 + 3;
            D.19950 = *D.19949;
            D.19951 = (int) D.19950;
            __result = D.19948 - D.19951;
            <D.19945>:
            <D.19943>:
            <D.19935>:
            <D.19933>:
            <D.19925>:
            <D.19923>:
          }
          D.18597 = __result;
        }
        iftmp.111 = -D.18597;
        goto <D.19952>;
        <D.19916>:
        iftmp.111 = __builtin_strcmp (cconv_str, "default");
        <D.19952>:
        D.18598 = iftmp.111;
      }
      if (D.18598 != 0) goto <D.19953>; else goto <D.19954>;
      <D.19953>:
      monoeg_g_string_append (res, cconv_str);
      monoeg_g_string_append (res, " ");
      <D.19954>:
      ptr.109 = ptr;
      ptr.112 = ptr.109 + 1;
      ptr = ptr.112;
      if (gen_count != 0) goto <D.19956>; else goto <D.19957>;
      <D.19956>:
      ptr.109 = ptr;
      D.19958 = mono_metadata_decode_value (ptr.109, &ptr);
      gen_count = (int) D.19958;
      <D.19957>:
      ptr.109 = ptr;
      D.19959 = mono_metadata_decode_value (ptr.109, &ptr);
      param_count = (int) D.19959;
      if (cconv != 10) goto <D.19960>; else goto <D.19961>;
      <D.19960>:
      ptr.109 = ptr;
      ptr.113 = get_ret_type (m, ptr.109, &allocated_ret_type, 0B);
      ptr = ptr.113;
      allocated_ret_type.114 = allocated_ret_type;
      monoeg_g_string_append (res, allocated_ret_type.114);
      allocated_ret_type.114 = allocated_ret_type;
      monoeg_g_free (allocated_ret_type.114);
      <D.19961>:
      if (fancy_name != 0B) goto <D.19964>; else goto <D.19965>;
      <D.19964>:
      monoeg_g_string_append_c (res, 32);
      monoeg_g_string_append (res, fancy_name);
      <D.19965>:
      monoeg_g_string_append (res, "(");
      i = 0;
      goto <D.18601>;
      <D.18600>:
      {
        char * param;

        try
          {
            param = 0B;
            ptr.109 = ptr;
            D.19900 = *ptr.109;
            if (D.19900 == 65) goto <D.19966>; else goto <D.19967>;
            <D.19966>:
            if (seen_vararg == 0) goto <D.19968>; else goto <D.19969>;
            <D.19968>:
            monoeg_g_string_append (res, "..., ");
            seen_vararg = 1;
            <D.19969>:
            ptr.109 = ptr;
            ptr.112 = ptr.109 + 1;
            ptr = ptr.112;
            <D.19967>:
            ptr.109 = ptr;
            ptr.115 = get_param (m, ptr.109, &param, 0B);
            ptr = ptr.115;
            param.116 = param;
            monoeg_g_string_append (res, param.116);
            D.19972 = i + 1;
            if (D.19972 != param_count) goto <D.19973>; else goto <D.19974>;
            <D.19973>:
            monoeg_g_string_append (res, ", ");
            <D.19974>:
            param.116 = param;
            monoeg_g_free (param.116);
          }
        finally
          {
            param = {CLOBBER};
          }
      }
      i = i + 1;
      <D.18601>:
      if (i < param_count) goto <D.18600>; else goto <D.18602>;
      <D.18602>:
      monoeg_g_string_append (res, ")");
      s = res->str;
      monoeg_g_string_free (res, 0);
      D.19975 = s;
      return D.19975;
    }
  finally
    {
      ptr = {CLOBBER};
      allocated_ret_type = {CLOBBER};
    }
}


get_fieldref_signature (struct MonoImage * m, int idx, struct MonoGenericContainer * container)
{
  struct MonoTableInfo * D.19978;
  int D.19979;
  unsigned int D.19980;
  unsigned int D.19981;
  unsigned int D.19982;
  const char * D.19983;
  const char * iftmp.117;
  const char * iftmp.118;
  char * D.19992;
  guint32 cols[3];
  struct MonoGenericContainer * new_container;
  char * type;
  char * esname;
  char * sig;
  char * full_sig;

  try
    {
      D.19978 = &m->tables[10];
      D.19979 = idx + -1;
      mono_metadata_decode_row (D.19978, D.19979, &cols, 3);
      D.19980 = cols[0];
      new_container = get_memberref_container (m, D.19980, container);
      D.19981 = cols[2];
      sig = get_field_signature (m, D.19981, new_container);
      D.19980 = cols[0];
      type = get_memberref_parent (m, D.19980, container);
      D.19982 = cols[1];
      D.19983 = mono_metadata_string_heap (m, D.19982);
      esname = get_escaped_name (D.19983);
      if (type != 0B) goto <D.19985>; else goto <D.19986>;
      <D.19985>:
      iftmp.117 = type;
      goto <D.19987>;
      <D.19986>:
      iftmp.117 = "";
      <D.19987>:
      if (type != 0B) goto <D.19989>; else goto <D.19990>;
      <D.19989>:
      iftmp.118 = "::";
      goto <D.19991>;
      <D.19990>:
      iftmp.118 = "";
      <D.19991>:
      full_sig = monoeg_g_strdup_printf ("%s %s%s%s", sig, iftmp.117, iftmp.118, esname);
      monoeg_g_free (sig);
      monoeg_g_free (type);
      monoeg_g_free (esname);
      D.19992 = full_sig;
      return D.19992;
    }
  finally
    {
      cols = {CLOBBER};
    }
}


get_memberref_container (struct MonoImage * m, guint32 mrp_token, struct MonoGenericContainer * container)
{
  struct MonoGenericContainer * D.19995;
  unsigned int D.19996;
  unsigned int D.19997;
  _Bool D.19998;
  long int D.19999;
  long int D.20000;
  struct MonoGenericContainer * iftmp.119;
  struct MonoGenericClass * D.20004;
  struct MonoClass * D.20007;
  struct MonoClass * klass;
  guint32 table;
  guint32 idx;

  table = mrp_token & 7;
  idx = mrp_token >> 3;
  switch (table) <default: <D.20009>, case 0: <D.18635>, case 1: <D.18636>, case 4: <D.18637>>
  <D.18635>:
  D.19996 = idx | 33554432;
  D.19995 = mono_metadata_load_generic_params (m, D.19996, 0B);
  return D.19995;
  <D.18636>:
  D.19995 = 0B;
  return D.19995;
  <D.18637>:
  D.19997 = idx | 452984832;
  klass = mono_class_get_full (m, D.19997, container);
  D.19998 = klass == 0B;
  D.19999 = (long int) D.19998;
  D.20000 = __builtin_expect (D.19999, 0);
  if (D.20000 != 0) goto <D.20001>; else goto <D.20002>;
  <D.20001>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "get.c", 1852, "klass");
  <D.20002>:
  D.20004 = klass->generic_class;
  if (D.20004 != 0B) goto <D.20005>; else goto <D.20006>;
  <D.20005>:
  D.20004 = klass->generic_class;
  D.20007 = D.20004->container_class;
  iftmp.119 = D.20007->generic_container;
  goto <D.20008>;
  <D.20006>:
  iftmp.119 = 0B;
  <D.20008>:
  D.19995 = iftmp.119;
  return D.19995;
  <D.20009>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "get.c", 1855);
  D.19995 = 0B;
  return D.19995;
}


get_memberref_parent (struct MonoImage * m, guint32 mrp_token, struct MonoGenericContainer * container)
{
  char * D.20011;
  int idx.120;
  guint32 table;
  guint32 idx;

  table = mrp_token & 7;
  idx = mrp_token >> 3;
  switch (table) <default: <D.20013>, case 0: <D.18645>, case 1: <D.18646>, case 2: <D.18647>, case 3: <D.18648>, case 4: <D.18649>>
  <D.18645>:
  idx.120 = (int) idx;
  D.20011 = get_typedef (m, idx.120);
  return D.20011;
  <D.18646>:
  idx.120 = (int) idx;
  D.20011 = get_typeref (m, idx.120);
  return D.20011;
  <D.18647>:
  D.20011 = monoeg_g_strdup_printf ("TODO:MemberRefParent-ModuleRef");
  return D.20011;
  <D.18648>:
  D.20011 = monoeg_strdup ("TODO:MethodDef");
  return D.20011;
  <D.18649>:
  D.20011 = get_typespec (m, idx, 0, container);
  return D.20011;
  <D.20013>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "get.c", 1884);
  D.20011 = 0B;
  return D.20011;
}


get_field (struct MonoImage * m, guint32 token, struct MonoGenericContainer * container)
{
  int token.121;
  unsigned int D.20016;
  char * D.20019;
  _Bool D.20020;
  long int D.20021;
  long int D.20022;
  struct MonoTableInfo * D.20025;
  int D.20026;
  unsigned int D.20027;
  unsigned int idx.122;
  int type_idx.123;
  unsigned int D.20032;
  const char * D.20033;
  const char * iftmp.124;
  const char * iftmp.125;
  int idx;
  guint32 cols[3];
  char * sig;
  char * res;
  char * type;
  char * estype;
  char * esname;
  guint32 type_idx;

  try
    {
      token.121 = (int) token;
      idx = token.121 & 16777215;
      D.20016 = token & 4278190080;
      if (D.20016 == 167772160) goto <D.20017>; else goto <D.20018>;
      <D.20017>:
      D.20019 = get_fieldref_signature (m, idx, container);
      return D.20019;
      <D.20018>:
      D.20016 = token & 4278190080;
      D.20020 = D.20016 != 67108864;
      D.20021 = (long int) D.20020;
      D.20022 = __builtin_expect (D.20021, 0);
      if (D.20022 != 0) goto <D.20023>; else goto <D.20024>;
      <D.20023>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "get.c", 1799, "mono_metadata_token_code (token) == MONO_TOKEN_FIELD_DEF");
      <D.20024>:
      D.20025 = &m->tables[4];
      D.20026 = idx + -1;
      mono_metadata_decode_row (D.20025, D.20026, &cols, 3);
      D.20027 = cols[2];
      sig = get_field_signature (m, D.20027, container);
      idx.122 = (unsigned int) idx;
      type_idx = mono_metadata_typedef_from_field (m, idx.122);
      if (type_idx == 0) goto <D.20029>; else goto <D.20030>;
      <D.20029>:
      res = monoeg_g_strdup_printf ("<invalid> %s", sig);
      monoeg_g_free (sig);
      D.20019 = res;
      return D.20019;
      <D.20030>:
      type_idx.123 = (int) type_idx;
      type = get_typedef (m, type_idx.123);
      estype = get_escaped_name (type);
      D.20032 = cols[1];
      D.20033 = mono_metadata_string_heap (m, D.20032);
      esname = get_escaped_name (D.20033);
      if (estype != 0B) goto <D.20035>; else goto <D.20036>;
      <D.20035>:
      iftmp.124 = estype;
      goto <D.20037>;
      <D.20036>:
      iftmp.124 = "";
      <D.20037>:
      if (estype != 0B) goto <D.20039>; else goto <D.20040>;
      <D.20039>:
      iftmp.125 = "::";
      goto <D.20041>;
      <D.20040>:
      iftmp.125 = "";
      <D.20041>:
      res = monoeg_g_strdup_printf ("%s %s%s%s", sig, iftmp.124, iftmp.125, esname);
      monoeg_g_free (type);
      monoeg_g_free (sig);
      monoeg_g_free (estype);
      monoeg_g_free (esname);
      D.20019 = res;
      return D.20019;
    }
  finally
    {
      cols = {CLOBBER};
    }
}


get_method (struct MonoImage * m, guint32 token, struct MonoGenericContainer * container)
{
  char * D.20044;

  D.20044 = get_method_core (m, token, 1, container);
  return D.20044;
}


get_method_core (struct MonoImage * m, guint32 token, gboolean fullsig, struct MonoGenericContainer * container)
{
  int token.126;
  struct MonoMethodSignature * D.20049;
  unsigned int D.20050;
  unsigned int D.20051;
  struct MonoMethod * D.20054;
  const char * D.20055;
  struct MonoClass * D.20056;
  struct MonoType * D.20057;
  int show_tokens.127;
  const char * iftmp.128;
  const char * iftmp.129;
  const char * iftmp.130;
  const char * iftmp.131;
  unsigned int D.20079;
  struct MonoTableInfo * D.20080;
  int D.20081;
  unsigned int D.20082;
  struct MonoTableInfo * D.20083;
  unsigned int D.20086;
  const char * iftmp.132;
  const char * iftmp.133;
  unsigned int D.20095;
  const char * D.20096;
  unsigned int D.20099;
  unsigned int D.20100;
  struct MonoGenericContainer * D.20103;
  <unnamed-signed:31> D.20104;
  unsigned int D.20106;
  unsigned int D.20109;
  unsigned int D.20110;
  struct MonoGenericContainer * D.20113;
  <unnamed-signed:31> D.20114;
  unsigned int D.20117;
  struct MonoTableInfo * D.20118;
  char * D.20122;
  int idx;
  guint32 member_cols[3];
  guint32 method_cols[6];
  char * sig;
  char * esname;
  char * name;
  struct MonoMethod * mh;
  struct MonoGenericContainer * type_container;

  try
    {
      token.126 = (int) token;
      idx = token.126 & 16777215;
      sig = 0B;
      type_container = container;
      mh = mono_get_method_full (m, token, 0B, container);
      if (mh != 0B) goto <D.20047>; else goto <D.20048>;
      <D.20047>:
      D.20049 = mono_method_signature (mh);
      D.20050 = BIT_FIELD_REF <*D.20049, 32, 64>;
      D.20051 = D.20050 & 33554432;
      if (D.20051 != 0) goto <D.20052>; else goto <D.20053>;
      <D.20052>:
      D.20054 = MEM[(struct MonoMethodInflated *)mh].declaring;
      container = mono_method_get_generic_container (D.20054);
      <D.20053>:
      D.20055 = mh->name;
      esname = get_escaped_name (D.20055);
      D.20056 = mh->klass;
      D.20057 = &D.20056->byval_arg;
      sig = dis_stringify_type (m, D.20057, 1);
      show_tokens.127 = show_tokens;
      if (show_tokens.127 != 0) goto <D.20059>; else goto <D.20060>;
      <D.20059>:
      if (sig != 0B) goto <D.20062>; else goto <D.20063>;
      <D.20062>:
      iftmp.128 = sig;
      goto <D.20064>;
      <D.20063>:
      iftmp.128 = "";
      <D.20064>:
      if (sig != 0B) goto <D.20066>; else goto <D.20067>;
      <D.20066>:
      iftmp.129 = "::";
      goto <D.20068>;
      <D.20067>:
      iftmp.129 = "";
      <D.20068>:
      name = monoeg_g_strdup_printf ("%s/*%08x*/%s%s", iftmp.128, token, iftmp.129, esname);
      goto <D.20069>;
      <D.20060>:
      if (sig != 0B) goto <D.20071>; else goto <D.20072>;
      <D.20071>:
      iftmp.130 = sig;
      goto <D.20073>;
      <D.20072>:
      iftmp.130 = "";
      <D.20073>:
      if (sig != 0B) goto <D.20075>; else goto <D.20076>;
      <D.20075>:
      iftmp.131 = "::";
      goto <D.20077>;
      <D.20076>:
      iftmp.131 = "";
      <D.20077>:
      name = monoeg_g_strdup_printf ("%s%s%s", iftmp.130, iftmp.131, esname);
      <D.20069>:
      monoeg_g_free (sig);
      monoeg_g_free (esname);
      goto <D.20078>;
      <D.20048>:
      name = 0B;
      <D.20078>:
      D.20079 = token & 4278190080;
      switch (D.20079) <default: <D.18671>, case 100663296: <D.18664>, case 167772160: <D.18666>, case 721420288: <D.18670>>
      <D.18664>:
      D.20080 = &m->tables[6];
      D.20081 = idx + -1;
      mono_metadata_decode_row (D.20080, D.20081, &method_cols, 6);
      D.20082 = method_cols[4];
      sig = get_methodref_signature (m, D.20082, name);
      goto <D.18665>;
      <D.18666>:
      D.20083 = &m->tables[10];
      D.20081 = idx + -1;
      mono_metadata_decode_row (D.20083, D.20081, &member_cols, 3);
      if (name == 0B) goto <D.20084>; else goto <D.20085>;
      <D.20084>:
      {
        char * parent;

        D.20086 = member_cols[0];
        parent = get_memberref_parent (m, D.20086, container);
        if (parent != 0B) goto <D.20088>; else goto <D.20089>;
        <D.20088>:
        iftmp.132 = parent;
        goto <D.20090>;
        <D.20089>:
        iftmp.132 = "";
        <D.20090>:
        if (parent != 0B) goto <D.20092>; else goto <D.20093>;
        <D.20092>:
        iftmp.133 = "::";
        goto <D.20094>;
        <D.20093>:
        iftmp.133 = "";
        <D.20094>:
        D.20095 = member_cols[1];
        D.20096 = mono_metadata_string_heap (m, D.20095);
        name = monoeg_g_strdup_printf ("%s%s%s", iftmp.132, iftmp.133, D.20096);
        monoeg_g_free (parent);
      }
      <D.20085>:
      if (mh != 0B) goto <D.20097>; else goto <D.20098>;
      <D.20097>:
      {
        int arity;

        arity = 0;
        D.20099 = BIT_FIELD_REF <*mh, 32, 160>;
        D.20100 = D.20099 & 2048;
        if (D.20100 != 0) goto <D.20101>; else goto <D.20102>;
        <D.20101>:
        D.20103 = mono_method_get_generic_container (mh);
        D.20104 = D.20103->type_argc;
        arity = (int) D.20104;
        goto <D.20105>;
        <D.20102>:
        D.20099 = BIT_FIELD_REF <*mh, 32, 160>;
        D.20106 = D.20099 & 4096;
        if (D.20106 != 0) goto <D.20107>; else goto <D.20108>;
        <D.20107>:
        D.20054 = MEM[(struct MonoMethodInflated *)mh].declaring;
        D.20109 = BIT_FIELD_REF <*D.20054, 32, 160>;
        D.20110 = D.20109 & 2048;
        if (D.20110 != 0) goto <D.20111>; else goto <D.20112>;
        <D.20111>:
        D.20054 = MEM[(struct MonoMethodInflated *)mh].declaring;
        D.20113 = mono_method_get_generic_container (D.20054);
        D.20114 = D.20113->type_argc;
        arity = (int) D.20114;
        <D.20112>:
        <D.20108>:
        <D.20105>:
        if (arity > 0) goto <D.20115>; else goto <D.20116>;
        <D.20115>:
        {
          char * str;

          str = monoeg_g_strdup_printf ("%s <[%d]>", name, arity);
          monoeg_g_free (name);
          name = str;
        }
        <D.20116>:
      }
      <D.20098>:
      D.20117 = member_cols[2];
      sig = get_methodref_signature (m, D.20117, name);
      goto <D.18665>;
      <D.18670>:
      D.20118 = &m->tables[43];
      D.20081 = idx + -1;
      mono_metadata_decode_row (D.20118, D.20081, &member_cols, 2);
      token = member_cols[0];
      sig = get_methodspec (m, idx, token, name, type_container);
      goto <D.18665>;
      <D.18671>:
      monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "get.c", 1971);
      <D.18665>:
      if (fullsig != 0) goto <D.20119>; else goto <D.20120>;
      <D.20119>:
      monoeg_g_free (name);
      goto <D.20121>;
      <D.20120>:
      monoeg_g_free (sig);
      D.20122 = name;
      return D.20122;
      <D.20121>:
      show_tokens.127 = show_tokens;
      if (show_tokens.127 != 0) goto <D.20123>; else goto <D.20124>;
      <D.20123>:
      {
        char * retval;

        retval = monoeg_g_strdup_printf ("%s /* %08x */", sig, token);
        monoeg_g_free (sig);
        D.20122 = retval;
        return D.20122;
      }
      <D.20124>:
      D.20122 = sig;
      return D.20122;
    }
  finally
    {
      member_cols = {CLOBBER};
      method_cols = {CLOBBER};
    }
}


get_methoddef (struct MonoImage * m, guint32 idx)
{
  unsigned int D.20127;
  struct MonoClass * D.20130;
  struct MonoType * D.20131;
  const char * iftmp.134;
  const char * iftmp.135;
  const char * D.20140;
  struct MonoTableInfo * D.20142;
  unsigned int D.20143;
  int D.20144;
  unsigned int D.20145;
  char * D.20146;
  guint32 cols[6];
  char * sig;
  const char * name;
  struct MonoMethod * mh;

  try
    {
      D.20127 = idx | 100663296;
      mh = mono_get_method (m, D.20127, 0B);
      if (mh != 0B) goto <D.20128>; else goto <D.20129>;
      <D.20128>:
      D.20130 = mh->klass;
      D.20131 = &D.20130->byval_arg;
      sig = dis_stringify_type (m, D.20131, 0);
      if (sig != 0B) goto <D.20133>; else goto <D.20134>;
      <D.20133>:
      iftmp.134 = sig;
      goto <D.20135>;
      <D.20134>:
      iftmp.134 = "";
      <D.20135>:
      if (sig != 0B) goto <D.20137>; else goto <D.20138>;
      <D.20137>:
      iftmp.135 = "::";
      goto <D.20139>;
      <D.20138>:
      iftmp.135 = "";
      <D.20139>:
      D.20140 = mh->name;
      name = monoeg_g_strdup_printf ("%s%s%s", iftmp.134, iftmp.135, D.20140);
      monoeg_g_free (sig);
      goto <D.20141>;
      <D.20129>:
      name = 0B;
      <D.20141>:
      D.20142 = &m->tables[6];
      D.20143 = idx + 4294967295;
      D.20144 = (int) D.20143;
      mono_metadata_decode_row (D.20142, D.20144, &cols, 6);
      D.20145 = cols[4];
      sig = get_methodref_signature (m, D.20145, name);
      D.20146 = sig;
      return D.20146;
    }
  finally
    {
      cols = {CLOBBER};
    }
}


get_method_type_param (struct MonoImage * m, guint32 blob_signature, struct MonoGenericContainer * container)
{
  const char * ptr.136;
  const char * ptr.137;
  const char * ptr.138;
  unsigned int D.20152;
  const char * ptr.139;
  char * param.140;
  int D.20155;
  char * D.20158;
  struct GString * res;
  const char * ptr;
  int param_count;
  int i;
  char * s;

  try
    {
      res = monoeg_g_string_new ("");
      ptr.136 = mono_metadata_blob_heap (m, blob_signature);
      ptr = ptr.136;
      i = 0;
      ptr.137 = ptr;
      mono_metadata_decode_value (ptr.137, &ptr);
      ptr.137 = ptr;
      ptr.138 = ptr.137 + 1;
      ptr = ptr.138;
      ptr.137 = ptr;
      D.20152 = mono_metadata_decode_value (ptr.137, &ptr);
      param_count = (int) D.20152;
      monoeg_g_string_append_c (res, 60);
      i = 0;
      goto <D.18698>;
      <D.18697>:
      {
        char * param;

        try
          {
            param = 0B;
            ptr.137 = ptr;
            ptr.139 = get_param (m, ptr.137, &param, container);
            ptr = ptr.139;
            param.140 = param;
            monoeg_g_string_append (res, param.140);
            D.20155 = i + 1;
            if (D.20155 != param_count) goto <D.20156>; else goto <D.20157>;
            <D.20156>:
            monoeg_g_string_append (res, ", ");
            <D.20157>:
            param.140 = param;
            monoeg_g_free (param.140);
          }
        finally
          {
            param = {CLOBBER};
          }
      }
      i = i + 1;
      <D.18698>:
      if (i < param_count) goto <D.18697>; else goto <D.18699>;
      <D.18699>:
      monoeg_g_string_append_c (res, 62);
      s = res->str;
      monoeg_g_string_free (res, 0);
      D.20158 = s;
      return D.20158;
    }
  finally
    {
      ptr = {CLOBBER};
    }
}


get_methodspec (struct MonoImage * m, int idx, guint32 token, const char * fancy_name, struct MonoGenericContainer * type_container)
{
  unsigned int D.20161;
  struct MonoTableInfo * D.20162;
  unsigned int D.20163;
  unsigned int D.20164;
  int D.20165;
  struct MonoTableInfo * D.20166;
  const char * ptr.141;
  const char * ptr.142;
  unsigned int D.20169;
  _Bool D.20170;
  long int D.20171;
  long int D.20172;
  char D.20177;
  unsigned char D.20178;
  int D.20179;
  int D.20180;
  int D.20183;
  int D.20187;
  const char * ptr.143;
  unsigned int D.20193;
  unsigned int D.20194;
  const char * ptr.144;
  char * allocated_ret_type.145;
  struct MonoTableInfo * D.20201;
  int D.20202;
  const char * ptr.146;
  char * param.147;
  int D.20205;
  char * D.20208;
  struct GString * res;
  guint32 member_cols[3];
  guint32 method_cols[6];
  char * s;
  char * type_param;
  const char * ptr;
  guint32 sig;
  int param_count;
  int cconv;
  int i;
  int gen_count;
  struct MonoGenericContainer * container;
  struct MonoMethod * mh;

  try
    {
      res = monoeg_g_string_new ("");
      sig = 0;
      gen_count = 0;
      mh = 0B;
      D.20161 = token & 1;
      switch (D.20161) <default: <D.18723>, case 0: <D.18720>, case 1: <D.18722>>
      <D.18720>:
      D.20162 = &m->tables[6];
      D.20163 = token >> 1;
      D.20164 = D.20163 + 4294967295;
      D.20165 = (int) D.20164;
      mono_metadata_decode_row (D.20162, D.20165, &method_cols, 6);
      sig = method_cols[4];
      goto <D.18721>;
      <D.18722>:
      D.20166 = &m->tables[10];
      D.20163 = token >> 1;
      D.20164 = D.20163 + 4294967295;
      D.20165 = (int) D.20164;
      mono_metadata_decode_row (D.20166, D.20165, &member_cols, 3);
      sig = member_cols[2];
      goto <D.18721>;
      <D.18723>:
      monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "get.c", 2091);
      <D.18721>:
      ptr.141 = mono_metadata_blob_heap (m, sig);
      ptr = ptr.141;
      ptr.142 = ptr;
      mono_metadata_decode_value (ptr.142, &ptr);
      D.20169 = method_dor_to_token (token);
      mh = mono_get_method_full (m, D.20169, 0B, type_container);
      D.20170 = mh == 0B;
      D.20171 = (long int) D.20170;
      D.20172 = __builtin_expect (D.20171, 0);
      if (D.20172 != 0) goto <D.20173>; else goto <D.20174>;
      <D.20173>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "get.c", 2098, "mh");
      <D.20174>:
      container = mono_method_get_generic_container (mh);
      if (container == 0B) goto <D.20175>; else goto <D.20176>;
      <D.20175>:
      container = type_container;
      <D.20176>:
      ptr.142 = ptr;
      D.20177 = *ptr.142;
      D.20178 = (unsigned char) D.20177;
      D.20179 = (int) D.20178;
      D.20180 = D.20179 & 32;
      if (D.20180 != 0) goto <D.20181>; else goto <D.20182>;
      <D.20181>:
      ptr.142 = ptr;
      D.20177 = *ptr.142;
      D.20178 = (unsigned char) D.20177;
      D.20179 = (int) D.20178;
      D.20183 = D.20179 & 64;
      if (D.20183 != 0) goto <D.20184>; else goto <D.20185>;
      <D.20184>:
      monoeg_g_string_append (res, "explicit-this ");
      goto <D.20186>;
      <D.20185>:
      monoeg_g_string_append (res, "instance ");
      <D.20186>:
      <D.20182>:
      ptr.142 = ptr;
      D.20177 = *ptr.142;
      D.20178 = (unsigned char) D.20177;
      D.20179 = (int) D.20178;
      D.20187 = D.20179 & 16;
      if (D.20187 != 0) goto <D.20188>; else goto <D.20189>;
      <D.20188>:
      gen_count = 1;
      <D.20189>:
      ptr.142 = ptr;
      D.20177 = *ptr.142;
      D.20178 = (unsigned char) D.20177;
      D.20179 = (int) D.20178;
      cconv = D.20179 & 15;
      ptr.142 = ptr;
      ptr.143 = ptr.142 + 1;
      ptr = ptr.143;
      if (gen_count != 0) goto <D.20191>; else goto <D.20192>;
      <D.20191>:
      ptr.142 = ptr;
      D.20193 = mono_metadata_decode_value (ptr.142, &ptr);
      gen_count = (int) D.20193;
      <D.20192>:
      ptr.142 = ptr;
      D.20194 = mono_metadata_decode_value (ptr.142, &ptr);
      param_count = (int) D.20194;
      if (cconv != 10) goto <D.20195>; else goto <D.20196>;
      <D.20195>:
      {
        char * allocated_ret_type;

        try
          {
            ptr.142 = ptr;
            ptr.144 = get_ret_type (m, ptr.142, &allocated_ret_type, container);
            ptr = ptr.144;
            allocated_ret_type.145 = allocated_ret_type;
            monoeg_g_string_append (res, allocated_ret_type.145);
            allocated_ret_type.145 = allocated_ret_type;
            monoeg_g_free (allocated_ret_type.145);
          }
        finally
          {
            allocated_ret_type = {CLOBBER};
          }
      }
      <D.20196>:
      if (fancy_name != 0B) goto <D.20199>; else goto <D.20200>;
      <D.20199>:
      monoeg_g_string_append_c (res, 32);
      monoeg_g_string_append (res, fancy_name);
      <D.20200>:
      D.20201 = &m->tables[43];
      D.20202 = idx + -1;
      mono_metadata_decode_row (D.20201, D.20202, &member_cols, 2);
      token = member_cols[1];
      type_param = get_method_type_param (m, token, type_container);
      monoeg_g_string_append (res, type_param);
      monoeg_g_string_append (res, " (");
      i = 0;
      goto <D.18727>;
      <D.18726>:
      {
        char * param;

        try
          {
            param = 0B;
            ptr.142 = ptr;
            ptr.146 = get_param (m, ptr.142, &param, container);
            ptr = ptr.146;
            param.147 = param;
            monoeg_g_string_append (res, param.147);
            D.20205 = i + 1;
            if (D.20205 != param_count) goto <D.20206>; else goto <D.20207>;
            <D.20206>:
            monoeg_g_string_append (res, ", ");
            <D.20207>:
            param.147 = param;
            monoeg_g_free (param.147);
          }
        finally
          {
            param = {CLOBBER};
          }
      }
      i = i + 1;
      <D.18727>:
      if (i < param_count) goto <D.18726>; else goto <D.18728>;
      <D.18728>:
      monoeg_g_string_append (res, ")");
      s = res->str;
      monoeg_g_string_free (res, 0);
      D.20208 = s;
      return D.20208;
    }
  finally
    {
      member_cols = {CLOBBER};
      method_cols = {CLOBBER};
      ptr = {CLOBBER};
    }
}


get_encoded_user_string_or_bytearray (const unsigned char * ptr, int len)
{
  int D.20211;
  int D.20212;
  unsigned int D.20213;
  sizetype i.148;
  sizetype D.20217;
  const unsigned char * D.20218;
  unsigned char D.20219;
  const short unsigned int * * D.20221;
  const short unsigned int * D.20222;
  const unsigned char * D.20223;
  unsigned char D.20224;
  unsigned int D.20225;
  unsigned int D.20226;
  const short unsigned int * D.20227;
  short unsigned int D.20228;
  int D.20229;
  int D.20230;
  char * D.20236;
  int D.20237;
  sizetype D.20238;
  char * D.20239;
  char D.20240;
  int D.20241;
  sizetype D.20242;
  char * D.20243;
  char * res;
  char * eres;
  char * result;
  int i;

  D.20211 = len >> 1;
  D.20212 = D.20211 + 1;
  D.20213 = (unsigned int) D.20212;
  res = monoeg_malloc (D.20213);
  i = 0;
  goto <D.18759>;
  <D.18758>:
  i.148 = (sizetype) i;
  D.20217 = i.148 + 1;
  D.20218 = ptr + D.20217;
  D.20219 = *D.20218;
  if (D.20219 != 0) goto <D.20214>; else goto <D.20220>;
  <D.20220>:
  D.20221 = __ctype_b_loc ();
  D.20222 = *D.20221;
  i.148 = (sizetype) i;
  D.20223 = ptr + i.148;
  D.20224 = *D.20223;
  D.20225 = (unsigned int) D.20224;
  D.20226 = D.20225 * 2;
  D.20227 = D.20222 + D.20226;
  D.20228 = *D.20227;
  D.20229 = (int) D.20228;
  D.20230 = D.20229 & 16384;
  if (D.20230 == 0) goto <D.20231>; else goto <D.20215>;
  <D.20231>:
  i.148 = (sizetype) i;
  D.20223 = ptr + i.148;
  D.20224 = *D.20223;
  if (D.20224 != 92) goto <D.20232>; else goto <D.20215>;
  <D.20232>:
  i.148 = (sizetype) i;
  D.20223 = ptr + i.148;
  D.20224 = *D.20223;
  if (D.20224 != 34) goto <D.20233>; else goto <D.20215>;
  <D.20233>:
  i.148 = (sizetype) i;
  D.20223 = ptr + i.148;
  D.20224 = *D.20223;
  if (D.20224 != 13) goto <D.20234>; else goto <D.20215>;
  <D.20234>:
  i.148 = (sizetype) i;
  D.20223 = ptr + i.148;
  D.20224 = *D.20223;
  if (D.20224 != 10) goto <D.20235>; else goto <D.20215>;
  <D.20235>:
  i.148 = (sizetype) i;
  D.20223 = ptr + i.148;
  D.20224 = *D.20223;
  if (D.20224 != 9) goto <D.20214>; else goto <D.20215>;
  <D.20214>:
  monoeg_g_free (res);
  D.20236 = get_encoded_user_string_bytearray (ptr, len);
  return D.20236;
  <D.20215>:
  D.20237 = i >> 1;
  D.20238 = (sizetype) D.20237;
  D.20239 = res + D.20238;
  i.148 = (sizetype) i;
  D.20223 = ptr + i.148;
  D.20224 = *D.20223;
  D.20240 = (char) D.20224;
  *D.20239 = D.20240;
  i = i + 2;
  <D.18759>:
  D.20241 = i + 1;
  if (D.20241 < len) goto <D.18758>; else goto <D.18760>;
  <D.18760>:
  D.20211 = len >> 1;
  D.20242 = (sizetype) D.20211;
  D.20243 = res + D.20242;
  *D.20243 = 0;
  eres = monoeg_g_strescape (res, 0B);
  result = monoeg_g_strdup_printf ("\"%s\"", eres);
  monoeg_g_free (res);
  monoeg_g_free (eres);
  D.20236 = result;
  return D.20236;
}


get_encoded_user_string_bytearray (const unsigned char * ptr, int len)
{
  char * D.20247;
  sizetype i.149;
  sizetype D.20249;
  const unsigned char * D.20250;
  unsigned char D.20251;
  int D.20252;
  unsigned int i.150;
  unsigned int D.20254;
  int iftmp.151;
  const short unsigned int * * D.20261;
  const short unsigned int * D.20262;
  sizetype j.152;
  const unsigned char * D.20264;
  unsigned char D.20265;
  unsigned int D.20266;
  unsigned int D.20267;
  const short unsigned int * D.20268;
  short unsigned int D.20269;
  int D.20270;
  int D.20271;
  int iftmp.153;
  const unsigned char * D.20278;
  unsigned char D.20279;
  unsigned int D.20280;
  unsigned int D.20281;
  const short unsigned int * D.20282;
  short unsigned int D.20283;
  int D.20284;
  int D.20285;
  gchar * str;
  int i;
  int j;
  int tspaces;
  struct GString * res;

  tspaces = len % 16;
  if (len == 0) goto <D.20245>; else goto <D.20246>;
  <D.20245>:
  D.20247 = monoeg_g_strdup_printf ("\"\"");
  return D.20247;
  <D.20246>:
  res = monoeg_g_string_new ("bytearray (\n\t");
  i = 1;
  goto <D.18742>;
  <D.18741>:
  i.149 = (sizetype) i;
  D.20249 = i.149 + 4294967295;
  D.20250 = ptr + D.20249;
  D.20251 = *D.20250;
  D.20252 = (int) D.20251;
  monoeg_g_string_append_printf (res, "%02x ", D.20252);
  i.150 = (unsigned int) i;
  D.20254 = i.150 & 15;
  if (D.20254 == 0) goto <D.20255>; else goto <D.20256>;
  <D.20255>:
  if (i == len) goto <D.20257>; else goto <D.20258>;
  <D.20257>:
  monoeg_g_string_append (res, ")// ");
  goto <D.20259>;
  <D.20258>:
  monoeg_g_string_append (res, " // ");
  <D.20259>:
  j = i + -16;
  goto <D.18739>;
  <D.18738>:
  D.20261 = __ctype_b_loc ();
  D.20262 = *D.20261;
  j.152 = (sizetype) j;
  D.20264 = ptr + j.152;
  D.20265 = *D.20264;
  D.20266 = (unsigned int) D.20265;
  D.20267 = D.20266 * 2;
  D.20268 = D.20262 + D.20267;
  D.20269 = *D.20268;
  D.20270 = (int) D.20269;
  D.20271 = D.20270 & 16384;
  if (D.20271 != 0) goto <D.20272>; else goto <D.20273>;
  <D.20272>:
  j.152 = (sizetype) j;
  D.20264 = ptr + j.152;
  D.20265 = *D.20264;
  iftmp.151 = (int) D.20265;
  goto <D.20274>;
  <D.20273>:
  iftmp.151 = 46;
  <D.20274>:
  monoeg_g_string_append_printf (res, "%c", iftmp.151);
  j = j + 1;
  <D.18739>:
  if (j < i) goto <D.18738>; else goto <D.18740>;
  <D.18740>:
  monoeg_g_string_append (res, "\n\t");
  <D.20256>:
  i = i + 1;
  <D.18742>:
  if (i <= len) goto <D.18741>; else goto <D.18743>;
  <D.18743>:
  if (tspaces != 0) goto <D.20275>; else goto <D.20276>;
  <D.20275>:
  monoeg_g_string_append (res, ")  ");
  i = tspaces + 1;
  goto <D.18745>;
  <D.18744>:
  monoeg_g_string_append_printf (res, "   ");
  i = i + 1;
  <D.18745>:
  if (i <= 15) goto <D.18744>; else goto <D.18746>;
  <D.18746>:
  monoeg_g_string_append (res, " // ");
  i = len - tspaces;
  goto <D.18748>;
  <D.18747>:
  D.20261 = __ctype_b_loc ();
  D.20262 = *D.20261;
  i.149 = (sizetype) i;
  D.20278 = ptr + i.149;
  D.20279 = *D.20278;
  D.20280 = (unsigned int) D.20279;
  D.20281 = D.20280 * 2;
  D.20282 = D.20262 + D.20281;
  D.20283 = *D.20282;
  D.20284 = (int) D.20283;
  D.20285 = D.20284 & 16384;
  if (D.20285 != 0) goto <D.20286>; else goto <D.20287>;
  <D.20286>:
  i.149 = (sizetype) i;
  D.20278 = ptr + i.149;
  D.20279 = *D.20278;
  iftmp.153 = (int) D.20279;
  goto <D.20288>;
  <D.20287>:
  iftmp.153 = 46;
  <D.20288>:
  monoeg_g_string_append_printf (res, "%c", iftmp.153);
  i = i + 1;
  <D.18748>:
  if (i < len) goto <D.18747>; else goto <D.18749>;
  <D.18749>:
  monoeg_g_string_append (res, "\n\t");
  <D.20276>:
  str = res->str;
  monoeg_g_string_free (res, 0);
  D.20247 = str;
  return D.20247;
}


stringify_double (double r)
{
  unsigned int D.20290;
  sizetype D.20291;
  char * D.18769;
  char * iftmp.154;
  char * iftmp.155;
  int D.20299;
  char * iftmp.156;
  int D.20304;
  char * iftmp.157;
  char D.20307;
  int D.20310;
  char * D.20314;
  char * ret;
  char * ptr;

  ret = monoeg_g_strdup_printf ("%.17g.", r);
  D.20290 = strlen (ret);
  D.20291 = D.20290 + 4294967295;
  ptr = ret + D.20291;
  {
    char __a0;
    char __a1;
    char __a2;

    __a0 = 46;
    if (__a0 == 0) goto <D.20293>; else goto <D.20294>;
    <D.20293>:
    iftmp.154 = 0B;
    goto <D.20295>;
    <D.20294>:
    __a1 = 101;
    if (__a1 == 0) goto <D.20297>; else goto <D.20298>;
    <D.20297>:
    D.20299 = (int) __a0;
    iftmp.155 = __builtin_strchr (ret, D.20299);
    goto <D.20300>;
    <D.20298>:
    __a2 = 69;
    if (__a2 == 0) goto <D.20302>; else goto <D.20303>;
    <D.20302>:
    D.20299 = (int) __a0;
    D.20304 = (int) __a1;
    iftmp.156 = __strpbrk_c2 (ret, D.20299, D.20304);
    goto <D.20305>;
    <D.20303>:
    D.20307 = 0;
    if (D.20307 == 0) goto <D.20308>; else goto <D.20309>;
    <D.20308>:
    D.20299 = (int) __a0;
    D.20304 = (int) __a1;
    D.20310 = (int) __a2;
    iftmp.157 = __strpbrk_c3 (ret, D.20299, D.20304, D.20310);
    goto <D.20311>;
    <D.20309>:
    iftmp.157 = __builtin_strpbrk (ret, ".eE");
    <D.20311>:
    iftmp.156 = iftmp.157;
    <D.20305>:
    iftmp.155 = iftmp.156;
    <D.20300>:
    iftmp.154 = iftmp.155;
    <D.20295>:
    D.18769 = iftmp.154;
  }
  if (D.18769 != ptr) goto <D.20312>; else goto <D.20313>;
  <D.20312>:
  *ptr = 0;
  <D.20313>:
  D.20314 = ret;
  return D.20314;
}


__strpbrk_c2 (const char * __s, int __accept1, int __accept2)
{
  char D.20316;
  int D.20318;
  char * D.20320;
  char * iftmp.158;

  goto <D.3218>;
  <D.3217>:
  __s = __s + 1;
  <D.3218>:
  D.20316 = *__s;
  if (D.20316 != 0) goto <D.20317>; else goto <D.3219>;
  <D.20317>:
  D.20316 = *__s;
  D.20318 = (int) D.20316;
  if (D.20318 != __accept1) goto <D.20319>; else goto <D.3219>;
  <D.20319>:
  D.20316 = *__s;
  D.20318 = (int) D.20316;
  if (D.20318 != __accept2) goto <D.3217>; else goto <D.3219>;
  <D.3219>:
  D.20316 = *__s;
  if (D.20316 != 0) goto <D.20322>; else goto <D.20323>;
  <D.20322>:
  iftmp.158 = __s;
  goto <D.20324>;
  <D.20323>:
  iftmp.158 = 0B;
  <D.20324>:
  D.20320 = iftmp.158;
  return D.20320;
}


__strpbrk_c3 (const char * __s, int __accept1, int __accept2, int __accept3)
{
  char D.20326;
  int D.20328;
  char * D.20331;
  char * iftmp.159;

  goto <D.3232>;
  <D.3231>:
  __s = __s + 1;
  <D.3232>:
  D.20326 = *__s;
  if (D.20326 != 0) goto <D.20327>; else goto <D.3233>;
  <D.20327>:
  D.20326 = *__s;
  D.20328 = (int) D.20326;
  if (D.20328 != __accept1) goto <D.20329>; else goto <D.3233>;
  <D.20329>:
  D.20326 = *__s;
  D.20328 = (int) D.20326;
  if (D.20328 != __accept2) goto <D.20330>; else goto <D.3233>;
  <D.20330>:
  D.20326 = *__s;
  D.20328 = (int) D.20326;
  if (D.20328 != __accept3) goto <D.3231>; else goto <D.3233>;
  <D.3233>:
  D.20326 = *__s;
  if (D.20326 != 0) goto <D.20333>; else goto <D.20334>;
  <D.20333>:
  iftmp.159 = __s;
  goto <D.20335>;
  <D.20334>:
  iftmp.159 = 0B;
  <D.20335>:
  D.20331 = iftmp.159;
  return D.20331;
}


get_constant (struct MonoImage * m, MonoTypeEnum t, guint32 blob_index)
{
  const char * ptr.160;
  const char * ptr.161;
  unsigned int D.20339;
  char * D.20340;
  const char * iftmp.162;
  char D.20342;
  short unsigned int D.20346;
  int D.20347;
  int D.20348;
  int D.20349;
  short unsigned int D.20350;
  int D.20351;
  unsigned int D.20352;
  const unsigned char * D.20353;
  unsigned int D.20354;
  float r.163;
  float r.164;
  unsigned int D.20359;
  double D.20360;
  long long unsigned int D.20361;
  double r.165;
  double r.166;
  const char * ptr;
  int len;

  try
    {
      ptr.160 = mono_metadata_blob_heap (m, blob_index);
      ptr = ptr.160;
      ptr.161 = ptr;
      D.20339 = mono_metadata_decode_value (ptr.161, &ptr);
      len = (int) D.20339;
      switch (t) <default: <D.18805>, case 2: <D.18777>, case 3: <D.18778>, case 4: <D.18780>, case 5: <D.18779>, case 6: <D.18782>, case 7: <D.18781>, case 8: <D.18784>, case 9: <D.18783>, case 10: <D.18786>, case 11: <D.18785>, case 12: <D.18789>, case 13: <D.18795>, case 14: <D.18803>, case 18: <D.18804>>
      <D.18777>:
      ptr.161 = ptr;
      D.20342 = *ptr.161;
      if (D.20342 != 0) goto <D.20343>; else goto <D.20344>;
      <D.20343>:
      iftmp.162 = "bool(true)";
      goto <D.20345>;
      <D.20344>:
      iftmp.162 = "bool(false)";
      <D.20345>:
      D.20340 = monoeg_g_strdup_printf ("%s", iftmp.162);
      return D.20340;
      <D.18778>:
      ptr.161 = ptr;
      D.20346 = mono_read16 (ptr.161);
      D.20347 = (int) D.20346;
      D.20340 = monoeg_g_strdup_printf ("char(0x%04x)", D.20347);
      return D.20340;
      <D.18779>:
      <D.18780>:
      ptr.161 = ptr;
      D.20342 = *ptr.161;
      D.20348 = (int) D.20342;
      D.20349 = D.20348 & 255;
      D.20340 = monoeg_g_strdup_printf ("int8(0x%02x)", D.20349);
      return D.20340;
      <D.18781>:
      <D.18782>:
      ptr.161 = ptr;
      D.20350 = mono_read16 (ptr.161);
      D.20351 = (int) D.20350;
      D.20340 = monoeg_g_strdup_printf ("int16(0x%08x)", D.20351);
      return D.20340;
      <D.18783>:
      <D.18784>:
      ptr.161 = ptr;
      D.20352 = mono_read32 (ptr.161);
      D.20340 = monoeg_g_strdup_printf ("int32(0x%08x)", D.20352);
      return D.20340;
      <D.18785>:
      <D.18786>:
      {
        guint32 low;
        guint32 high;

        ptr.161 = ptr;
        low = mono_read32 (ptr.161);
        ptr.161 = ptr;
        D.20353 = ptr.161 + 4;
        high = mono_read32 (D.20353);
        D.20340 = monoeg_g_strdup_printf ("int64(0x%08x%08x)", high, low);
        return D.20340;
      }
      <D.18789>:
      {
        gboolean normal;
        float r;

        try
          {
            {
              union mono_rfloat mf;

              try
                {
                  ptr.161 = ptr;
                  D.20354 = mono_read32 (ptr.161);
                  mf.ival = D.20354;
                  r.163 = mf.fval;
                  r = r.163;
                }
              finally
                {
                  mf = {CLOBBER};
                }
            }
            r.164 = r;
            normal = __finitef (r.164);
            if (normal == 0) goto <D.20357>; else goto <D.20358>;
            <D.20357>:
            ptr.161 = ptr;
            D.20359 = mono_read32 (ptr.161);
            D.20340 = monoeg_g_strdup_printf ("float32(0x%08x)", D.20359);
            return D.20340;
            <D.20358>:
            {
              char * str;
              char * ret;

              r.164 = r;
              D.20360 = (double) r.164;
              str = stringify_double (D.20360);
              ret = monoeg_g_strdup_printf ("float32(%s)", str);
              monoeg_g_free (str);
              D.20340 = ret;
              return D.20340;
            }
          }
        finally
          {
            r = {CLOBBER};
          }
      }
      <D.18795>:
      {
        gboolean normal;
        double r;

        try
          {
            {
              union mono_rdouble mf;

              try
                {
                  ptr.161 = ptr;
                  D.20361 = mono_read64 (ptr.161);
                  mf.ival = D.20361;
                  r.165 = mf.fval;
                  r = r.165;
                }
              finally
                {
                  mf = {CLOBBER};
                }
            }
            r.166 = r;
            normal = __finite (r.166);
            if (normal == 0) goto <D.20364>; else goto <D.20365>;
            <D.20364>:
            {
              guint32 low;
              guint32 high;

              ptr.161 = ptr;
              low = mono_read32 (ptr.161);
              ptr.161 = ptr;
              D.20353 = ptr.161 + 4;
              high = mono_read32 (D.20353);
              D.20340 = monoeg_g_strdup_printf ("float64(0x%08x%08x)", high, low);
              return D.20340;
            }
            <D.20365>:
            {
              char * str;
              char * ret;

              r.166 = r;
              str = stringify_double (r.166);
              ret = monoeg_g_strdup_printf ("float64(%s)", str);
              monoeg_g_free (str);
              D.20340 = ret;
              return D.20340;
            }
          }
        finally
          {
            r = {CLOBBER};
          }
      }
      <D.18803>:
      ptr.161 = ptr;
      D.20340 = get_encoded_user_string_or_bytearray (ptr.161, len);
      return D.20340;
      <D.18804>:
      D.20340 = monoeg_strdup ("nullref");
      return D.20340;
      <D.18805>:
      ptr.161 = ptr;
      D.20342 = *ptr.161;
      D.20348 = (int) D.20342;
      monoeg_g_log (0B, 4, "Unknown MONO_TYPE (%d) on constant at Blob index (0x%08x)\n", D.20348, blob_index);
      <D.18806>:
      goto <D.18806>;
      D.20340 = monoeg_g_strdup_printf ("Unknown");
      return D.20340;
    }
  finally
    {
      ptr = {CLOBBER};
    }
}


get_token (struct MonoImage * m, guint32 token, struct MonoGenericContainer * container)
{
  unsigned int D.20370;
  char * D.20371;
  int idx.167;
  struct MonoTableInfo * D.20373;
  unsigned int D.20374;
  unsigned int D.20375;
  int D.20376;
  unsigned int D.20377;
  const char * sig.168;
  const char * sig.169;
  char D.20380;
  char * temp;
  char * result;
  guint32 idx;

  idx = token & 16777215;
  D.20370 = token & 4278190080;
  switch (D.20370) <default: <D.18824>, case 16777216: <D.18819>, case 33554432: <D.18818>, case 67108864: <D.18815>, case 100663296: <D.18816>, case 167772160: <D.18821>, case 452984832: <D.18820>, case 721420288: <D.18817>>
  <D.18815>:
  temp = get_field (m, token, container);
  result = monoeg_g_strdup_printf ("field %s", temp);
  monoeg_g_free (temp);
  D.20371 = result;
  return D.20371;
  <D.18816>:
  <D.18817>:
  temp = get_method (m, token, container);
  result = monoeg_g_strdup_printf ("method %s", temp);
  monoeg_g_free (temp);
  D.20371 = result;
  return D.20371;
  <D.18818>:
  idx.167 = (int) idx;
  temp = get_typedef (m, idx.167);
  result = get_escaped_name (temp);
  monoeg_g_free (temp);
  D.20371 = result;
  return D.20371;
  <D.18819>:
  idx.167 = (int) idx;
  D.20371 = get_typeref (m, idx.167);
  return D.20371;
  <D.18820>:
  D.20371 = get_typespec (m, idx, 1, container);
  return D.20371;
  <D.18821>:
  {
    guint32 cols[3];
    const char * sig;

    try
      {
        D.20373 = &m->tables[10];
        D.20374 = token & 16777215;
        D.20375 = D.20374 + 4294967295;
        D.20376 = (int) D.20375;
        mono_metadata_decode_row (D.20373, D.20376, &cols, 3);
        D.20377 = cols[2];
        sig.168 = mono_metadata_blob_heap (m, D.20377);
        sig = sig.168;
        sig.169 = sig;
        mono_metadata_decode_blob_size (sig.169, &sig);
        sig.169 = sig;
        D.20380 = *sig.169;
        if (D.20380 == 6) goto <D.20381>; else goto <D.20382>;
        <D.20381>:
        temp = get_field (m, token, container);
        result = monoeg_g_strdup_printf ("field %s", temp);
        monoeg_g_free (temp);
        D.20371 = result;
        return D.20371;
        <D.20382>:
        temp = get_method (m, token, container);
        result = monoeg_g_strdup_printf ("method %s", temp);
        monoeg_g_free (temp);
        D.20371 = result;
        return D.20371;
      }
    finally
      {
        cols = {CLOBBER};
        sig = {CLOBBER};
      }
  }
  <D.18824>:
  monoeg_g_log (0B, 4, "Do not know how to decode tokens of type 0x%08x", token);
  <D.18825>:
  goto <D.18825>;
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "get.c", 2419);
  D.20371 = monoeg_strdup ("ERROR");
  return D.20371;
}


get_token_type (struct MonoImage * m, guint32 token, struct MonoGenericContainer * container)
{
  int token.170;
  unsigned int D.20386;
  unsigned int idx.171;
  char * D.20390;
  char * temp;
  char * s;
  int idx;

  temp = 0B;
  s = 0B;
  token.170 = (int) token;
  idx = token.170 & 16777215;
  D.20386 = token & 4278190080;
  switch (D.20386) <default: <D.18838>, case 16777216: <D.18836>, case 33554432: <D.18834>, case 452984832: <D.18837>>
  <D.18834>:
  temp = get_typedef (m, idx);
  s = monoeg_g_strdup_printf ("%s", temp);
  goto <D.18835>;
  <D.18836>:
  temp = get_typeref (m, idx);
  s = monoeg_g_strdup_printf ("%s", temp);
  goto <D.18835>;
  <D.18837>:
  idx.171 = (unsigned int) idx;
  s = get_typespec (m, idx.171, 0, container);
  goto <D.18835>;
  <D.18838>:
  monoeg_g_log (0B, 4, "Unhandled encoding for token 0x%08x", token);
  <D.18839>:
  goto <D.18839>;
  <D.18835>:
  if (temp != 0B) goto <D.20388>; else goto <D.20389>;
  <D.20388>:
  monoeg_g_free (temp);
  <D.20389>:
  D.20390 = s;
  return D.20390;
}


get_guid (struct MonoImage * m, guint32 guid_index)
{
  const unsigned char * D.20392;
  unsigned char D.20393;
  int D.20394;
  const unsigned char * D.20395;
  unsigned char D.20396;
  int D.20397;
  const unsigned char * D.20398;
  unsigned char D.20399;
  int D.20400;
  unsigned char D.20401;
  int D.20402;
  const unsigned char * D.20403;
  unsigned char D.20404;
  int D.20405;
  const unsigned char * D.20406;
  unsigned char D.20407;
  int D.20408;
  const unsigned char * D.20409;
  unsigned char D.20410;
  int D.20411;
  const unsigned char * D.20412;
  unsigned char D.20413;
  int D.20414;
  const unsigned char * D.20415;
  unsigned char D.20416;
  int D.20417;
  const unsigned char * D.20418;
  unsigned char D.20419;
  int D.20420;
  const unsigned char * D.20421;
  unsigned char D.20422;
  int D.20423;
  const unsigned char * D.20424;
  unsigned char D.20425;
  int D.20426;
  const unsigned char * D.20427;
  unsigned char D.20428;
  int D.20429;
  const unsigned char * D.20430;
  unsigned char D.20431;
  int D.20432;
  const unsigned char * D.20433;
  unsigned char D.20434;
  int D.20435;
  const unsigned char * D.20436;
  unsigned char D.20437;
  int D.20438;
  char * D.20439;
  const unsigned char * guid;
  char * result;

  guid = mono_metadata_guid_heap (m, guid_index);
  D.20392 = guid + 3;
  D.20393 = *D.20392;
  D.20394 = (int) D.20393;
  D.20395 = guid + 2;
  D.20396 = *D.20395;
  D.20397 = (int) D.20396;
  D.20398 = guid + 1;
  D.20399 = *D.20398;
  D.20400 = (int) D.20399;
  D.20401 = *guid;
  D.20402 = (int) D.20401;
  D.20403 = guid + 5;
  D.20404 = *D.20403;
  D.20405 = (int) D.20404;
  D.20406 = guid + 4;
  D.20407 = *D.20406;
  D.20408 = (int) D.20407;
  D.20409 = guid + 7;
  D.20410 = *D.20409;
  D.20411 = (int) D.20410;
  D.20412 = guid + 6;
  D.20413 = *D.20412;
  D.20414 = (int) D.20413;
  D.20415 = guid + 8;
  D.20416 = *D.20415;
  D.20417 = (int) D.20416;
  D.20418 = guid + 9;
  D.20419 = *D.20418;
  D.20420 = (int) D.20419;
  D.20421 = guid + 10;
  D.20422 = *D.20421;
  D.20423 = (int) D.20422;
  D.20424 = guid + 11;
  D.20425 = *D.20424;
  D.20426 = (int) D.20425;
  D.20427 = guid + 12;
  D.20428 = *D.20427;
  D.20429 = (int) D.20428;
  D.20430 = guid + 13;
  D.20431 = *D.20430;
  D.20432 = (int) D.20431;
  D.20433 = guid + 14;
  D.20434 = *D.20433;
  D.20435 = (int) D.20434;
  D.20436 = guid + 15;
  D.20437 = *D.20436;
  D.20438 = (int) D.20437;
  result = monoeg_g_strdup_printf ("{%02X%02X%02X%02X-%02X%02X-%02X%02X-%02X%02X-%02X%02X%02X%02X%02X%02X}", D.20394, D.20397, D.20400, D.20402, D.20405, D.20408, D.20411, D.20414, D.20417, D.20420, D.20423, D.20426, D.20429, D.20432, D.20435, D.20438);
  D.20439 = result;
  return D.20439;
}


dis_get_custom_attrs (struct MonoImage * m, guint32 token)
{
  unsigned int D.20441;
  struct GList * D.20442;
  int i.172;
  unsigned int D.20444;
  unsigned int D.20447;
  unsigned int D.20448;
  unsigned int D.20449;
  const char * val.173;
  const char * val.174;
  int len.175;
  char * D.20453;
  <unnamed-unsigned:24> D.20454;
  unsigned int D.20455;
  struct GList * list;
  guint32 idx;
  guint32 i;
  guint32 len;
  guint32 mtoken;
  guint32 cols[3];
  struct MonoTableInfo * ca;
  char * method;
  struct GString * attr;
  const char * val;

  try
    {
      list = 0B;
      idx = token & 16777215;
      idx = idx << 5;
      D.20441 = token >> 24;
      switch (D.20441) <default: <D.18871>, case 0: <D.18864>, case 2: <D.18860>, case 4: <D.18867>, case 6: <D.18868>, case 8: <D.18869>, case 20: <D.18866>, case 23: <D.18865>, case 32: <D.18862>, case 35: <D.18863>, case 42: <D.18870>>
      <D.18860>:
      idx = idx | 3;
      goto <D.18861>;
      <D.18862>:
      idx = idx | 14;
      goto <D.18861>;
      <D.18863>:
      idx = idx | 15;
      goto <D.18861>;
      <D.18864>:
      idx = idx | 7;
      goto <D.18861>;
      <D.18865>:
      idx = idx | 9;
      goto <D.18861>;
      <D.18866>:
      idx = idx | 10;
      goto <D.18861>;
      <D.18867>:
      idx = idx | 1;
      goto <D.18861>;
      <D.18868>:
      idx = idx;
      goto <D.18861>;
      <D.18869>:
      idx = idx | 4;
      goto <D.18861>;
      <D.18870>:
      idx = idx | 19;
      goto <D.18861>;
      <D.18871>:
      monoeg_g_print ("Missing custom attr get support for token 0x%08x\n", token);
      D.20442 = 0B;
      return D.20442;
      <D.18861>:
      ca = &m->tables[12];
      i = 0;
      goto <D.18880>;
      <D.18879>:
      {
        char * dump;

        i.172 = (int) i;
        mono_metadata_decode_row (ca, i.172, &cols, 3);
        D.20444 = cols[0];
        if (D.20444 != idx) goto <D.20445>; else goto <D.20446>;
        <D.20445>:
        // predicted unlikely by continue predictor.
        goto <D.18873>;
        <D.20446>:
        D.20447 = cols[1];
        mtoken = D.20447 >> 3;
        D.20447 = cols[1];
        D.20448 = D.20447 & 7;
        switch (D.20448) <default: <D.18877>, case 2: <D.18874>, case 3: <D.18876>>
        <D.18874>:
        mtoken = mtoken | 100663296;
        goto <D.18875>;
        <D.18876>:
        mtoken = mtoken | 167772160;
        goto <D.18875>;
        <D.18877>:
        D.20447 = cols[1];
        monoeg_g_log (0B, 4, "Unknown table for custom attr type %08x", D.20447);
        <D.18878>:
        goto <D.18878>;
        <D.18875>:
        method = get_method (m, mtoken, 0B);
        D.20449 = cols[2];
        val.173 = mono_metadata_blob_heap (m, D.20449);
        val = val.173;
        val.174 = val;
        len = mono_metadata_decode_value (val.174, &val);
        attr = monoeg_g_string_new (".custom ");
        val.174 = val;
        len.175 = (int) len;
        dump = data_dump (val.174, len.175, "\t\t");
        monoeg_g_string_append_printf (attr, "%s = %s", method, dump);
        monoeg_g_free (dump);
        D.20453 = attr->str;
        list = monoeg_g_list_append (list, D.20453);
        monoeg_g_string_free (attr, 0);
        monoeg_g_free (method);
      }
      <D.18873>:
      i = i + 1;
      <D.18880>:
      D.20454 = ca->rows;
      D.20455 = (unsigned int) D.20454;
      if (D.20455 > i) goto <D.18879>; else goto <D.18881>;
      <D.18881>:
      D.20442 = list;
      return D.20442;
    }
  finally
    {
      cols = {CLOBBER};
      val = {CLOBBER};
    }
}


get_marshal_info (struct MonoImage * m, const char * blob)
{
  const char * blob.176;
  unsigned int D.20459;
  char D.20460;
  int D.20461;
  char * D.20462;
  const char * D.20463;
  unsigned int D.20464;
  unsigned int D.20465;
  int len;
  int size;

  size = 0;
  blob.176 = blob;
  D.20459 = mono_metadata_decode_blob_size (blob.176, &blob);
  len = (int) D.20459;
  blob.176 = blob;
  D.20460 = *blob.176;
  D.20461 = (int) D.20460;
  switch (D.20461) <default: <D.18923>, case 2: <D.18888>, case 3: <D.18889>, case 4: <D.18890>, case 5: <D.18891>, case 6: <D.18892>, case 7: <D.18893>, case 8: <D.18894>, case 9: <D.18895>, case 10: <D.18896>, case 11: <D.18897>, case 12: <D.18898>, case 15: <D.18899>, case 19: <D.18900>, case 20: <D.18901>, case 21: <D.18902>, case 22: <D.18903>, case 23: <D.18904>, case 25: <D.18905>, case 26: <D.18906>, case 27: <D.18907>, case 28: <D.18908>, case 29: <D.18909>, case 30: <D.18910>, case 31: <D.18911>, case 32: <D.18912>, case 34: <D.18913>, case 35: <D.18914>, case 36: <D.18915>, case 37: <D.18916>, case 38: <D.18917>, case 40: <D.18918>, case 42: <D.18919>, case 43: <D.18920>, case 44: <D.18921>, case 45: <D.18922>>
  <D.18888>:
  D.20462 = monoeg_strdup ("bool");
  return D.20462;
  <D.18889>:
  D.20462 = monoeg_strdup ("int8");
  return D.20462;
  <D.18890>:
  D.20462 = monoeg_strdup ("unsigned int8");
  return D.20462;
  <D.18891>:
  D.20462 = monoeg_strdup ("int16");
  return D.20462;
  <D.18892>:
  D.20462 = monoeg_strdup ("unsigned int16");
  return D.20462;
  <D.18893>:
  D.20462 = monoeg_strdup ("int32");
  return D.20462;
  <D.18894>:
  D.20462 = monoeg_strdup ("unsigned int32");
  return D.20462;
  <D.18895>:
  D.20462 = monoeg_strdup ("int64");
  return D.20462;
  <D.18896>:
  D.20462 = monoeg_strdup ("unsigned int64");
  return D.20462;
  <D.18897>:
  D.20462 = monoeg_strdup ("float32");
  return D.20462;
  <D.18898>:
  D.20462 = monoeg_strdup ("float64");
  return D.20462;
  <D.18899>:
  D.20462 = monoeg_strdup ("currency");
  return D.20462;
  <D.18900>:
  D.20462 = monoeg_strdup ("bstr");
  return D.20462;
  <D.18901>:
  D.20462 = monoeg_strdup ("lpstr");
  return D.20462;
  <D.18902>:
  D.20462 = monoeg_strdup ("lpwstr");
  return D.20462;
  <D.18903>:
  D.20462 = monoeg_strdup ("lptstr");
  return D.20462;
  <D.18904>:
  blob.176 = blob;
  D.20463 = blob.176 + 1;
  D.20464 = mono_metadata_decode_value (D.20463, &blob);
  size = (int) D.20464;
  D.20462 = monoeg_g_strdup_printf ("fixed sysstring [%d]", size);
  return D.20462;
  <D.18905>:
  D.20462 = monoeg_strdup ("iunknown");
  return D.20462;
  <D.18906>:
  D.20462 = monoeg_strdup ("idispatch");
  return D.20462;
  <D.18907>:
  D.20462 = monoeg_strdup ("struct");
  return D.20462;
  <D.18908>:
  D.20462 = monoeg_strdup ("interface");
  return D.20462;
  <D.18909>:
  D.20462 = monoeg_strdup ("safearray");
  return D.20462;
  <D.18910>:
  blob.176 = blob;
  D.20463 = blob.176 + 1;
  D.20465 = mono_metadata_decode_value (D.20463, &blob);
  size = (int) D.20465;
  D.20462 = monoeg_g_strdup_printf ("fixed array [%d]", size);
  return D.20462;
  <D.18911>:
  D.20462 = monoeg_strdup ("int");
  return D.20462;
  <D.18912>:
  D.20462 = monoeg_strdup ("unsigned int");
  return D.20462;
  <D.18913>:
  D.20462 = monoeg_strdup ("vbbyrefstr");
  return D.20462;
  <D.18914>:
  D.20462 = monoeg_strdup ("ansi bstr");
  return D.20462;
  <D.18915>:
  D.20462 = monoeg_strdup ("tbstr");
  return D.20462;
  <D.18916>:
  D.20462 = monoeg_strdup ("variant bool");
  return D.20462;
  <D.18917>:
  D.20462 = monoeg_strdup ("method");
  return D.20462;
  <D.18918>:
  D.20462 = monoeg_strdup ("as any");
  return D.20462;
  <D.18919>:
  D.20462 = monoeg_strdup ("[]");
  return D.20462;
  <D.18920>:
  D.20462 = monoeg_strdup ("lpstruct");
  return D.20462;
  <D.18921>:
  D.20462 = monoeg_strdup ("custom");
  return D.20462;
  <D.18922>:
  D.20462 = monoeg_strdup ("error");
  return D.20462;
  <D.18923>:
  D.20462 = monoeg_strdup ("unknown");
  return D.20462;
}


init_key_table ()
{
  struct GHashTable * key_table.177;
  struct GHashTable * key_table.178;

  key_table.177 = monoeg_g_hash_table_new (monoeg_g_str_hash, monoeg_g_str_equal);
  key_table = key_table.177;
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "9", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "abstract", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "add", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "add.ovf", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "add.ovf.un", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "algorithm", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "alignment", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "and", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "ansi", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "any", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "arglist", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "array", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "as", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "assembly", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "assert", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "at", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "autochar", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "auto", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "beforefieldinit", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "bestfit", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "beq", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "beq.s", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "bge", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "bge.s", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "bge.un", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "bge.un.s", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "bgt", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "bgt.s", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "bgt.un", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "bgt.un.s", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "ble", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "ble.s", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "ble.un", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "ble.un.s", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "blob", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "blob_object", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "blt", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "blt.s", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "blt.un", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "blt.un.s", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "bne.un", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "bne.un.s", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "bool", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "box", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "break", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "brfalse", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "brfalse.s", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "br", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "brinst", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "brinst.s", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "brnull", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "brnull.s", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "br.s", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "brtrue", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "brtrue.s", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "brzero", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "brzero.s", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "bstr", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "bytearray", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "byvalstr", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "call", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "callconv", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "calli", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "callmostderived", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "callvirt", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "carray", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "castclass", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "catch", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "cdecl", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "ceq", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "cf", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "cgt", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "cgt.un", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "char", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "charmaperror", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "cil", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "ckfinite", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "class", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "clsid", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "clt", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "clt.un", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "Compilercontrolled", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "const", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "conv.i1", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "conv.i2", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "conv.i4", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "conv.i8", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "conv.i", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "conv.ovf.i1", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "conv.ovf.i1.un", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "conv.ovf.i2", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "conv.ovf.i2.un", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "conv.ovf.i4", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "conv.ovf.i4.un", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "conv.ovf.i8", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "conv.ovf.i8.un", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "conv.ovf.i", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "conv.ovf.i.un", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "conv.ovf.u1", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "conv.ovf.u1.un", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "conv.ovf.u2", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "conv.ovf.u2.un", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "conv.ovf.u4", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "conv.ovf.u4.un", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "conv.ovf.u8", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "conv.ovf.u8.un", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "conv.ovf.u", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "conv.ovf.u.un", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "conv.r4", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "conv.r8", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "conv.r.un", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "conv.u1", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "conv.u2", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "conv.u4", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "conv.u8", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "conv.u", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "cpblk", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "cpobj", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "currency", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "custom", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "date", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "decimal", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "default", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "demand", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "deny", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "div", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "div.un", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "dup", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "endfault", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "endfilter", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "endfinally", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "endmac", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "enum", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "error", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "explicit", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "extends", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "extern", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "false", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "famandassem", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "family", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "famorassem", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "fastcall", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "fault", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "field", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "filetime", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "filter", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "final", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "finally", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "fixed", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "flags", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "float32", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "float64", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "float", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "forwardref", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "fromunmanaged", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "handler", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "hidebysig", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "hresult", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "idispatch", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "il", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "illegal", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "implements", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "implicitcom", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "implicitres", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "import", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "in", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "inheritcheck", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "initblk", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "init", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "initobj", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "initonly", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "instance", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "int16", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "int32", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "int64", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "int8", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "interface", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "internalcall", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "int", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "isinst", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "iunknown", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "jmp", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "lasterr", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "lcid", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "ldarg.0", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "ldarg.1", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "ldarg.2", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "ldarg.3", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "ldarga", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "ldarga.s", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "ldarg", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "ldarg.s", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "ldc.i4.0", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "ldc.i4.1", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "ldc.i4.2", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "ldc.i4.3", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "ldc.i4.4", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "ldc.i4.5", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "ldc.i4.6", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "ldc.i4.7", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "ldc.i4.8", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "ldc.i4", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "ldc.i4.m1", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "ldc.i4.M1", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "ldc.i4.s", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "ldc.i8", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "ldc.r4", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "ldc.r8", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "ldelem", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "ldelema", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "ldelem.i1", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "ldelem.i2", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "ldelem.i4", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "ldelem.i8", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "ldelem.i", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "ldelem.r4", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "ldelem.r8", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "ldelem.ref", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "ldelem.u1", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "ldelem.u2", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "ldelem.u4", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "ldelem.u8", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "ldflda", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "ldfld", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "ldftn", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "ldind.i1", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "ldind.i2", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "ldind.i4", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "ldind.i8", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "ldind.i", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "ldind.r4", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "ldind.r8", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "ldind.ref", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "ldind.u1", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "ldind.u2", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "ldind.u4", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "ldind.u8", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "ldlen", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "ldloc.0", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "ldloc.1", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "ldloc.2", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "ldloc.3", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "ldloca", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "ldloca.s", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "ldloc", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "ldloc.s", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "ldnull", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "ldobj", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "ldsflda", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "ldsfld", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "ldstr", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "ldtoken", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "ldvirtftn", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "leave", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "leave.s", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "legacy", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "linkcheck", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "literal", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "localloc", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "lpstr", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "lpstruct", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "lptstr", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "lpvoid", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "lpwstr", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "managed", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "marshal", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "method", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "mkrefany", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "modopt", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "modreq", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "mul", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "mul.ovf", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "mul.ovf.un", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "native", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "neg", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "nested", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "newarr", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "newobj", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "newslot", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "noappdomain", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "noinlining", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "nomachine", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "nomangle", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "nometadata", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "noncasdemand", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "noncasinheritance", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "noncaslinkdemand", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "nop", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "noprocess", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "not", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "not_in_gc_heap", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "notremotable", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "notserialized", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "null", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "nullref", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "object", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "objectref", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "off", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "on", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "opt", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "optil", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "or", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "out", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "permitonly", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "pinned", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "pinvokeimpl", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "pop", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "prefix1", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "prefix2", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "prefix3", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "prefix4", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "prefix5", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "prefix6", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "prefix7", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "prefixref", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "prejitdeny", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "prejitgrant", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "preservesig", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "private", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "privatescope", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "property", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "protected", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "public", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "readonly", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "record", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "refany", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "refanytype", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "refanyval", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "rem", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "rem.un", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "reqmin", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "reqopt", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "reqrefuse", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "reqsecobj", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "request", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "ret", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "rethrow", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "retval", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "rtspecialname", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "runtime", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "safearray", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "sealed", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "sequential", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "serializable", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "shl", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "shr", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "shr.un", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "sizeof", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "special", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "specialname", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "starg", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "starg.s", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "static", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "stdcall", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "stelem", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "stelem.i1", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "stelem.i2", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "stelem.i4", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "stelem.i8", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "stelem.i", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "stelem.r4", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "stelem.r8", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "stelem.ref", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "stfld", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "stind.i1", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "stind.i2", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "stind.i4", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "stind.i8", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "stind.i", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "stind.r4", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "stind.r8", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "stloc", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "stobj", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "storage", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "stored_object", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "streamed_object", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "stream", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "strict", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "string", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "struct", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "stsfld", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "sub", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "sub.ovf", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "sub.ovf.un", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "switch", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "synchronized", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "syschar", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "sysstring", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "tbstr", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "thiscall", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "tls", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "to", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "true", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "type", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "typedref", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "uint", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "uint8", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "uint16", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "uint32", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "uint64", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "unbox", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "unicode", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "unmanagedexp", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "unmanaged", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "unsigned", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "userdefined", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "value", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "valuetype", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "vararg", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "variant", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "vector", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "virtual", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "void", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "wchar", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "winapi", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "with", 1B, 0);
  key_table.178 = key_table;
  monoeg_g_hash_table_insert_replace (key_table.178, "xor", 1B, 0);
}


method_dor_to_token (guint32 idx)
{
  unsigned int D.20469;
  guint32 D.20470;
  unsigned int D.20471;

  D.20469 = idx & 1;
  switch (D.20469) <default: <D.20472>, case 0: <D.18930>, case 1: <D.18931>>
  <D.18930>:
  D.20471 = idx >> 1;
  D.20470 = D.20471 | 100663296;
  return D.20470;
  <D.18931>:
  D.20471 = idx >> 1;
  D.20470 = D.20471 | 167772160;
  return D.20470;
  <D.20472>:
  D.20470 = 4294967295;
  return D.20470;
}


get_method_override (struct MonoImage * m, guint32 token, struct MonoGenericContainer * container)
{
  int D.20474;
  unsigned int D.20475;
  unsigned int D.20476;
  struct MonoClass * D.20482;
  struct MonoGenericClass * D.20484;
  struct MonoGenericContainer * D.20486;
  char * D.20487;
  <unnamed-unsigned:24> D.20488;
  int D.20489;
  struct MonoTableInfo * t;
  int i;

  t = &m->tables[25];
  i = 1;
  goto <D.18946>;
  <D.18945>:
  {
    guint32 cols[3];
    guint32 decl;
    guint32 impl;

    try
      {
        D.20474 = i + -1;
        mono_metadata_decode_row (t, D.20474, &cols, 3);
        D.20475 = cols[1];
        impl = method_dor_to_token (D.20475);
        D.20476 = cols[2];
        decl = method_dor_to_token (D.20476);
        if (token == impl) goto <D.20477>; else goto <D.20478>;
        <D.20477>:
        {
          struct MonoMethod * mh;

          mh = 0B;
          mh = mono_get_method_full (m, decl, 0B, container);
          if (mh != 0B) goto <D.20481>; else goto <D.20479>;
          <D.20481>:
          D.20482 = mh->klass;
          if (D.20482 != 0B) goto <D.20483>; else goto <D.20479>;
          <D.20483>:
          D.20482 = mh->klass;
          D.20484 = D.20482->generic_class;
          if (D.20484 != 0B) goto <D.20480>; else goto <D.20485>;
          <D.20485>:
          D.20482 = mh->klass;
          D.20486 = D.20482->generic_container;
          if (D.20486 != 0B) goto <D.20480>; else goto <D.20479>;
          <D.20480>:
          {
            char * meth_str;
            char * ret;

            meth_str = get_method_core (m, decl, 1, container);
            ret = monoeg_g_strdup_printf ("method %s", meth_str);
            monoeg_g_free (meth_str);
            D.20487 = ret;
            return D.20487;
          }
          <D.20479>:
          D.20487 = get_method_core (m, decl, 0, container);
          return D.20487;
        }
        <D.20478>:
      }
    finally
      {
        cols = {CLOBBER};
      }
  }
  i = i + 1;
  <D.18946>:
  D.20488 = t->rows;
  D.20489 = (int) D.20488;
  if (D.20489 >= i) goto <D.18945>; else goto <D.18947>;
  <D.18947>:
  D.20487 = 0B;
  return D.20487;
}


get_method_impl_flags (guint32 f)
{
  int f.179;
  int D.20494;
  int D.20495;
  unsigned int D.20496;
  unsigned int D.20497;
  unsigned int code_type.180;
  const char * D.20499;
  unsigned int managed_type.181;
  const char * D.20501;
  unsigned int rest.182;
  const char * D.20503;
  char * D.20504;
  struct GString * str;
  char * s;
  int code_type;
  int managed_type;
  int rest;

  str = monoeg_g_string_new ("");
  f.179 = (int) f;
  code_type = f.179 & 3;
  f.179 = (int) f;
  managed_type = f.179 & 4;
  D.20494 = code_type | managed_type;
  D.20495 = ~D.20494;
  D.20496 = (unsigned int) D.20495;
  D.20497 = D.20496 & f;
  rest = (int) D.20497;
  code_type.180 = (unsigned int) code_type;
  D.20499 = map (code_type.180, &method_impl_map);
  monoeg_g_string_append (str, D.20499);
  managed_type.181 = (unsigned int) managed_type;
  D.20501 = map (managed_type.181, &managed_type_map);
  monoeg_g_string_append (str, D.20501);
  rest.182 = (unsigned int) rest;
  D.20503 = flags (rest.182, &managed_impl_flags);
  monoeg_g_string_append (str, D.20503);
  s = str->str;
  monoeg_g_string_free (str, 0);
  D.20504 = s;
  return D.20504;
}