get_typedef (struct MonoImage * m, int idx)
{
  char * D.19129;
  int D.19130;
  struct MonoTableInfo * D.19131;
  unsigned int D.19132;
  int D.19133;
  char * iftmp.0;
  int show_tokens.1;
  int token.2;
  int D.19142;
  const char * iftmp.3;
  unsigned int D.19147;
  const char * D.19148;
  const char * iftmp.4;
  const char * D.19153;
  const char * iftmp.5;
  char D.19155;
  guint32 cols[6];
  const char * ns;
  char * tstring;
  char * result;
  guint32 token;

  try
    {
      if (idx == 1) goto <D.19127>; else goto <D.19128>;
      <D.19127>:
      D.19129 = 0B;
      return D.19129;
      <D.19128>:
      D.19130 = idx + -1;
      D.19131 = &m->tables[2];
      mono_metadata_decode_row (D.19131, D.19130, &cols, 6);
      D.19132 = cols[2];
      ns = mono_metadata_string_heap (m, D.19132);
      D.19133 = idx | 33554432;
      token = (guint32) D.19133;
      token = mono_metadata_nested_in_typedef (m, token);
      show_tokens.1 = show_tokens;
      if (show_tokens.1 != 0) goto <D.19136>; else goto <D.19137>;
      <D.19136>:
      iftmp.0 = monoeg_g_strdup_printf ("/*%08x*/", token);
      goto <D.19138>;
      <D.19137>:
      iftmp.0 = 0B;
      <D.19138>:
      tstring = iftmp.0;
      if (token != 0) goto <D.19139>; else goto <D.19140>;
      <D.19139>:
      {
        char * outer;

        token.2 = (int) token;
        D.19142 = token.2 & 16777215;
        outer = get_typedef (m, D.19142);
        if (tstring != 0B) goto <D.19144>; else goto <D.19145>;
        <D.19144>:
        iftmp.3 = tstring;
        goto <D.19146>;
        <D.19145>:
        iftmp.3 = "";
        <D.19146>:
        D.19147 = cols[1];
        D.19148 = mono_metadata_string_heap (m, D.19147);
        result = monoeg_g_strdup_printf ("%s/%s%s", outer, D.19148, iftmp.3);
        monoeg_g_free (outer);
        monoeg_g_free (tstring);
        D.19129 = result;
        return D.19129;
      }
      <D.19140>:
      if (tstring != 0B) goto <D.19150>; else goto <D.19151>;
      <D.19150>:
      iftmp.4 = tstring;
      goto <D.19152>;
      <D.19151>:
      iftmp.4 = "";
      <D.19152>:
      D.19147 = cols[1];
      D.19153 = mono_metadata_string_heap (m, D.19147);
      D.19155 = *ns;
      if (D.19155 != 0) goto <D.19156>; else goto <D.19157>;
      <D.19156>:
      iftmp.5 = ".";
      goto <D.19158>;
      <D.19157>:
      iftmp.5 = "";
      <D.19158>:
      result = monoeg_g_strdup_printf ("%s%s%s%s", ns, iftmp.5, D.19153, iftmp.4);
      monoeg_g_free (tstring);
      D.19129 = result;
      return D.19129;
    }
  finally
    {
      cols = {CLOBBER};
    }
}


get_module (struct MonoImage * m, int idx)
{
  _Bool D.19161;
  long int D.19162;
  long int D.19163;
  int D.19166;
  struct MonoTableInfo * D.19167;
  char * D.19168;
  unsigned int D.19169;
  const char * D.19170;
  guint32 cols[5];

  try
    {
      D.19161 = idx != 1;
      D.19162 = (long int) D.19161;
      D.19163 = __builtin_expect (D.19162, 0);
      if (D.19163 != 0) goto <D.19164>; else goto <D.19165>;
      <D.19164>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "get.c", 92, "idx == 1");
      <D.19165>:
      D.19166 = idx + -1;
      D.19167 = &m->tables[0];
      mono_metadata_decode_row (D.19167, D.19166, &cols, 5);
      D.19169 = cols[1];
      D.19170 = mono_metadata_string_heap (m, D.19169);
      D.19168 = get_escaped_name (D.19170);
      return D.19168;
    }
  finally
    {
      cols = {CLOBBER};
    }
}


get_moduleref (struct MonoImage * m, int idx)
{
  int D.19173;
  struct MonoTableInfo * D.19174;
  char * D.19175;
  unsigned int D.19176;
  const char * D.19177;
  guint32 cols[1];

  try
    {
      D.19173 = idx + -1;
      D.19174 = &m->tables[26];
      mono_metadata_decode_row (D.19174, D.19173, &cols, 1);
      D.19176 = cols[0];
      D.19177 = mono_metadata_string_heap (m, D.19176);
      D.19175 = get_escaped_name (D.19177);
      return D.19175;
    }
  finally
    {
      cols = {CLOBBER};
    }
}


get_assemblyref (struct MonoImage * m, int idx)
{
  int D.19180;
  struct MonoTableInfo * D.19181;
  char * D.19182;
  unsigned int D.19183;
  const char * D.19184;
  guint32 cols[9];

  try
    {
      D.19180 = idx + -1;
      D.19181 = &m->tables[35];
      mono_metadata_decode_row (D.19181, D.19180, &cols, 9);
      D.19183 = cols[6];
      D.19184 = mono_metadata_string_heap (m, D.19183);
      D.19182 = get_escaped_name (D.19184);
      return D.19182;
    }
  finally
    {
      cols = {CLOBBER};
    }
}


get_typespec (struct MonoImage * m, guint32 idx, gboolean is_def, struct MonoGenericContainer * container)
{
  unsigned int D.19187;
  int D.19188;
  struct MonoTableInfo * D.19189;
  unsigned int D.19190;
  const char * ptr.6;
  const char * ptr.7;
  unsigned int D.19193;
  const char * ptr.8;
  const char * ptr.9;
  char D.19196;
  int D.19197;
  const char * ptr.10;
  char * s.11;
  char D.19202;
  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.19216;
  const char * ptr.18;
  int show_tokens.19;
  unsigned int D.19221;
  char * D.19222;
  char * D.19224;
  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.19187 = idx + 4294967295;
      D.19188 = (int) D.19187;
      D.19189 = &m->tables[27];
      mono_metadata_decode_row (D.19189, D.19188, &cols, 1);
      D.19190 = cols[0];
      ptr.6 = mono_metadata_blob_heap (m, D.19190);
      ptr = ptr.6;
      ptr.7 = ptr;
      D.19193 = mono_metadata_decode_value (ptr.7, &ptr);
      len = (int) D.19193;
      ptr.7 = ptr;
      ptr.8 = ptr.7;
      ptr.9 = ptr.8 + 1;
      ptr = ptr.9;
      D.19196 = *ptr.8;
      D.19197 = (int) D.19196;
      switch (D.19197) <default: <D.18248>, case 15: <D.18243>, case 20: <D.18246>, case 27: <D.18245>, case 29: <D.18247>>
      <D.18243>:
      ptr.7 = ptr;
      ptr.10 = get_custom_mod (m, ptr.7, &s);
      ptr = ptr.10;
      s.11 = s;
      if (s.11 != 0B) goto <D.19200>; else goto <D.19201>;
      <D.19200>:
      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.19201>:
      ptr.7 = ptr;
      D.19202 = *ptr.7;
      if (D.19202 == 1) goto <D.19203>; else goto <D.19204>;
      <D.19203>:
      monoeg_g_string_append (res, "void");
      goto <D.19205>;
      <D.19204>:
      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.19207>; else goto <D.19208>;
      <D.19207>:
      s.11 = s;
      monoeg_g_string_append (res, s.11);
      <D.19208>:
      <D.19205>:
      monoeg_g_string_append (res, "*");
      goto <D.18244>;
      <D.18245>:
      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.18244>;
      <D.18246>:
      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.18244>;
      <D.18247>:
      ptr.7 = ptr;
      ptr.16 = get_custom_mod (m, ptr.7, &s);
      ptr = ptr.16;
      s.11 = s;
      if (s.11 != 0B) goto <D.19213>; else goto <D.19214>;
      <D.19213>:
      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.19214>:
      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.18244>;
      <D.18248>:
      ptr.7 = ptr;
      D.19216 = ptr.7 + 4294967295;
      ptr.18 = get_type (m, D.19216, &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.18244>;
      <D.18244>:
      show_tokens.19 = show_tokens;
      if (show_tokens.19 != 0) goto <D.19219>; else goto <D.19220>;
      <D.19219>:
      {
        int token;

        D.19221 = idx | 452984832;
        token = (int) D.19221;
        D.19222 = res->str;
        result = monoeg_g_strdup_printf ("%s/*%08x*/", D.19222, token);
      }
      goto <D.19223>;
      <D.19220>:
      result = res->str;
      <D.19223>:
      monoeg_g_string_free (res, 0);
      D.19224 = result;
      return D.19224;
    }
  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.19230;
  unsigned int i.21;
  unsigned int D.19232;
  gint32 * D.19233;
  unsigned int D.19234;
  int D.19235;
  unsigned int i.22;
  unsigned int D.19239;
  gint32 * D.19240;
  int D.19241;
  char * D.19242;
  const char * D.19243;
  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.19228>; else goto <D.19229>;
  <D.19228>:
  D.19230 = num_sizes * 4;
  sizes = monoeg_malloc (D.19230);
  <D.19229>:
  i = 0;
  goto <D.18225>;
  <D.18224>:
  i.21 = (unsigned int) i;
  D.19232 = i.21 * 4;
  D.19233 = sizes + D.19232;
  ptr.20 = ptr;
  D.19234 = mono_metadata_decode_value (ptr.20, &ptr);
  D.19235 = (int) D.19234;
  *D.19233 = D.19235;
  i = i + 1;
  <D.18225>:
  i.22 = (unsigned int) i;
  if (i.22 < num_sizes) goto <D.18224>; else goto <D.18226>;
  <D.18226>:
  ptr.20 = ptr;
  num_lo_bounds = mono_metadata_decode_value (ptr.20, &ptr);
  if (num_lo_bounds != 0) goto <D.19237>; else goto <D.19238>;
  <D.19237>:
  D.19239 = num_lo_bounds * 4;
  lo_bounds = monoeg_malloc (D.19239);
  <D.19238>:
  i = 0;
  goto <D.18228>;
  <D.18227>:
  i.21 = (unsigned int) i;
  D.19232 = i.21 * 4;
  D.19240 = lo_bounds + D.19232;
  ptr.20 = ptr;
  D.19241 = mono_metadata_decode_signed_value (ptr.20, &ptr);
  *D.19240 = D.19241;
  i = i + 1;
  <D.18228>:
  i.22 = (unsigned int) i;
  if (i.22 < num_lo_bounds) goto <D.18227>; else goto <D.18229>;
  <D.18229>:
  D.19242 = stringify_array (rank, num_sizes, num_lo_bounds, sizes, lo_bounds);
  *result = D.19242;
  monoeg_g_free (sizes);
  monoeg_g_free (lo_bounds);
  D.19243 = ptr;
  return D.19243;
}


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.19251;
  gint32 * D.19252;
  int D.19253;
  gint32 * D.19258;
  int D.19259;
  int D.19260;
  int D.19261;
  char * D.19263;
  struct GString * res;
  int i;

  res = monoeg_g_string_new ("[");
  i = 0;
  goto <D.18211>;
  <D.18210>:
  if (i != 0) goto <D.19245>; else goto <D.19246>;
  <D.19245>:
  monoeg_g_string_append_c (res, 44);
  <D.19246>:
  i.23 = (unsigned int) i;
  if (i.23 < num_lo_bounds) goto <D.19248>; else goto <D.19249>;
  <D.19248>:
  i.24 = (unsigned int) i;
  D.19251 = i.24 * 4;
  D.19252 = lo_bounds + D.19251;
  D.19253 = *D.19252;
  monoeg_g_string_append_printf (res, "%d...", D.19253);
  <D.19249>:
  i.23 = (unsigned int) i;
  if (i.23 < num_sizes) goto <D.19254>; else goto <D.19255>;
  <D.19254>:
  i.23 = (unsigned int) i;
  if (i.23 < num_lo_bounds) goto <D.19256>; else goto <D.19257>;
  <D.19256>:
  i.24 = (unsigned int) i;
  D.19251 = i.24 * 4;
  D.19252 = lo_bounds + D.19251;
  D.19253 = *D.19252;
  i.24 = (unsigned int) i;
  D.19251 = i.24 * 4;
  D.19258 = sizes + D.19251;
  D.19259 = *D.19258;
  D.19260 = D.19253 + D.19259;
  D.19261 = D.19260 + -1;
  monoeg_g_string_append_printf (res, "%d", D.19261);
  goto <D.19262>;
  <D.19257>:
  i.24 = (unsigned int) i;
  D.19251 = i.24 * 4;
  D.19258 = sizes + D.19251;
  D.19259 = *D.19258;
  monoeg_g_string_append_printf (res, "%d", D.19259);
  <D.19262>:
  <D.19255>:
  i = i + 1;
  <D.18211>:
  i.23 = (unsigned int) i;
  if (i.23 < rank) goto <D.18210>; else goto <D.18212>;
  <D.18212>:
  monoeg_g_string_append (res, "]");
  D.19263 = monoeg_g_string_free (res, 0);
  return D.19263;
}


get_typeref (struct MonoImage * m, int idx)
{
  int D.19265;
  struct MonoTableInfo * D.19266;
  unsigned int D.19267;
  unsigned int D.19268;
  unsigned int D.19269;
  int rs_idx.25;
  const char * iftmp.26;
  char D.19272;
  const char * iftmp.27;
  const char * iftmp.28;
  int show_tokens.29;
  char * D.19287;
  guint32 cols[3];
  const char * s;
  const char * t;
  char * x;
  char * ret;
  guint32 rs_idx;
  guint32 table;

  try
    {
      D.19265 = idx + -1;
      D.19266 = &m->tables[1];
      mono_metadata_decode_row (D.19266, D.19265, &cols, 3);
      D.19267 = cols[1];
      t = mono_metadata_string_heap (m, D.19267);
      D.19268 = cols[2];
      s = mono_metadata_string_heap (m, D.19268);
      D.19269 = cols[0];
      rs_idx = D.19269 >> 2;
      D.19269 = cols[0];
      table = D.19269 & 3;
      switch (table) <default: <D.18266>, case 0: <D.18261>, case 1: <D.18263>, case 2: <D.18264>, case 3: <D.18265>>
      <D.18261>:
      rs_idx.25 = (int) rs_idx;
      x = get_module (m, rs_idx.25);
      D.19272 = *s;
      if (D.19272 != 0) goto <D.19273>; else goto <D.19274>;
      <D.19273>:
      iftmp.26 = ".";
      goto <D.19275>;
      <D.19274>:
      iftmp.26 = "";
      <D.19275>:
      ret = monoeg_g_strdup_printf ("[%s] %s%s%s", x, s, iftmp.26, t);
      monoeg_g_free (x);
      goto <D.18262>;
      <D.18263>:
      rs_idx.25 = (int) rs_idx;
      x = get_moduleref (m, rs_idx.25);
      D.19272 = *s;
      if (D.19272 != 0) goto <D.19277>; else goto <D.19278>;
      <D.19277>:
      iftmp.27 = ".";
      goto <D.19279>;
      <D.19278>:
      iftmp.27 = "";
      <D.19279>:
      ret = monoeg_g_strdup_printf ("[.module %s]%s%s%s", x, s, iftmp.27, t);
      goto <D.18262>;
      <D.18264>:
      rs_idx.25 = (int) rs_idx;
      x = get_assemblyref (m, rs_idx.25);
      D.19272 = *s;
      if (D.19272 != 0) goto <D.19281>; else goto <D.19282>;
      <D.19281>:
      iftmp.28 = ".";
      goto <D.19283>;
      <D.19282>:
      iftmp.28 = "";
      <D.19283>:
      ret = monoeg_g_strdup_printf ("[%s]%s%s%s", x, s, iftmp.28, t);
      monoeg_g_free (x);
      goto <D.18262>;
      <D.18265>:
      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.18262>;
      <D.18266>:
      ret = monoeg_g_strdup_printf ("Unknown table in TypeRef %d", table);
      <D.18262>:
      show_tokens.29 = show_tokens;
      if (show_tokens.29 != 0) goto <D.19285>; else goto <D.19286>;
      <D.19285>:
      {
        int token;
        char * temp;

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


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

  temp = 0B;
  s = 0B;
  dor_token.30 = (int) dor_token;
  table = dor_token.30 & 3;
  D.19291 = dor_token >> 2;
  idx = (int) D.19291;
  switch (table) <default: <D.18282>, case 0: <D.18278>, case 1: <D.18280>, case 2: <D.18281>>
  <D.18278>:
  temp = get_typedef (m, idx);
  s = monoeg_g_strdup_printf ("%s", temp);
  goto <D.18279>;
  <D.18280>:
  temp = get_typeref (m, idx);
  s = monoeg_g_strdup_printf ("%s", temp);
  goto <D.18279>;
  <D.18281>:
  idx.31 = (unsigned int) idx;
  s = get_typespec (m, idx.31, 0, container);
  goto <D.18279>;
  <D.18282>:
  monoeg_g_log (0B, 4, "Unhandled encoding for typedef-or-ref coded index 0x%08x", dor_token);
  <D.18283>:
  goto <D.18283>;
  <D.18279>:
  if (temp != 0B) goto <D.19293>; else goto <D.19294>;
  <D.19293>:
  monoeg_g_free (temp);
  <D.19294>:
  D.19295 = s;
  return D.19295;
}


get_type_or_methdef (struct MonoImage * m, guint32 dor_token)
{
  unsigned int D.19297;
  char * D.19300;
  unsigned int D.19301;
  int D.19302;

  D.19297 = dor_token & 1;
  if (D.19297 != 0) goto <D.19298>; else goto <D.19299>;
  <D.19298>:
  D.19301 = dor_token >> 1;
  D.19300 = get_methoddef (m, D.19301);
  return D.19300;
  <D.19299>:
  D.19301 = dor_token >> 1;
  D.19302 = (int) D.19301;
  D.19300 = get_typedef (m, D.19302);
  return D.19300;
}


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

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


get_custom_mod (struct MonoImage * m, const char * ptr, char * * return_value)
{
  const char * iftmp.33;
  char D.19309;
  char * D.19313;
  char * s.34;
  gchar * D.19317;
  gchar * D.19319;
  unsigned char D.19320;
  unsigned char D.19321;
  const char * D.19322;
  char * s;
  const char * mod;

  try
    {
      *return_value = 0B;
      goto <D.18302>;
      <D.18301>:
      D.19309 = *ptr;
      if (D.19309 == 31) goto <D.19310>; else goto <D.19311>;
      <D.19310>:
      iftmp.33 = "modreq";
      goto <D.19312>;
      <D.19311>:
      iftmp.33 = "modopt";
      <D.19312>:
      mod = iftmp.33;
      ptr = ptr + 1;
      ptr = get_encoded_typedef_or_ref (m, ptr, &s);
      D.19313 = *return_value;
      if (D.19313 == 0B) goto <D.19314>; else goto <D.19315>;
      <D.19314>:
      s.34 = s;
      D.19317 = monoeg_g_strconcat (" ", mod, " (", s.34, ")", 0B);
      *return_value = D.19317;
      goto <D.19318>;
      <D.19315>:
      s.34 = s;
      D.19313 = *return_value;
      D.19319 = monoeg_g_strconcat (D.19313, " ", mod, " (", s.34, ")", 0B);
      *return_value = D.19319;
      <D.19318>:
      s.34 = s;
      monoeg_g_free (s.34);
      <D.18302>:
      D.19309 = *ptr;
      D.19320 = (unsigned char) D.19309;
      D.19321 = D.19320 + 225;
      if (D.19321 <= 1) goto <D.18301>; else goto <D.18303>;
      <D.18303>:
      D.19322 = ptr;
      return D.19322;
    }
  finally
    {
      s = {CLOBBER};
    }
}


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

  idx = token & 16777215;
  D.19325 = token >> 24;
  switch (D.19325) <default: <D.18314>, case 1: <D.18312>, case 2: <D.18311>, case 27: <D.18313>>
  <D.18311>:
  idx.35 = (int) idx;
  D.19326 = get_typedef (m, idx.35);
  return D.19326;
  <D.18312>:
  idx.35 = (int) idx;
  D.19326 = get_typeref (m, idx.35);
  return D.19326;
  <D.18313>:
  D.19326 = get_typespec (m, idx, 0, 0B);
  return D.19326;
  <D.18314>:
  goto <D.18315>;
  <D.18315>:
  D.19326 = monoeg_g_strdup_printf ("0x%08x", token);
  return D.19326;
}


dis_stringify_array (struct MonoImage * m, struct MonoArrayType * array, gboolean is_def)
{
  struct MonoClass * D.19330;
  struct MonoType * D.19331;
  int * D.19332;
  int * D.19333;
  unsigned char D.19334;
  unsigned int D.19335;
  unsigned char D.19336;
  unsigned int D.19337;
  unsigned char D.19338;
  unsigned int D.19339;
  char * D.19340;
  char * type;
  char * arr_str;
  char * ret;

  D.19330 = array->eklass;
  D.19331 = &D.19330->byval_arg;
  type = dis_stringify_type (m, D.19331, is_def);
  D.19332 = array->lobounds;
  D.19333 = array->sizes;
  D.19334 = array->numlobounds;
  D.19335 = (unsigned int) D.19334;
  D.19336 = array->numsizes;
  D.19337 = (unsigned int) D.19336;
  D.19338 = array->rank;
  D.19339 = (unsigned int) D.19338;
  arr_str = stringify_array (D.19339, D.19337, D.19335, D.19333, D.19332);
  ret = monoeg_g_strconcat (type, arr_str, 0B);
  monoeg_g_free (arr_str);
  monoeg_g_free (type);
  D.19340 = ret;
  return D.19340;
}


dis_stringify_modifiers (struct MonoImage * m, int n, struct MonoCustomMod * mod)
{
  unsigned int i.36;
  unsigned int D.19343;
  struct MonoCustomMod * D.19344;
  <unnamed-unsigned:31> D.19345;
  unsigned int D.19346;
  const char * iftmp.37;
  unsigned char D.19350;
  unsigned char D.19351;
  char * D.19355;
  struct GString * s;
  char * result;
  int i;

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

    i.36 = (unsigned int) i;
    D.19343 = i.36 * 4;
    D.19344 = mod + D.19343;
    D.19345 = D.19344->token;
    D.19346 = (unsigned int) D.19345;
    tok = dis_stringify_token (m, D.19346);
    if (i > 0) goto <D.19347>; else goto <D.19348>;
    <D.19347>:
    monoeg_g_string_append_printf (s, " ");
    <D.19348>:
    i.36 = (unsigned int) i;
    D.19343 = i.36 * 4;
    D.19344 = mod + D.19343;
    D.19350 = BIT_FIELD_REF <*D.19344, 8, 0>;
    D.19351 = D.19350 & 1;
    if (D.19351 != 0) goto <D.19352>; else goto <D.19353>;
    <D.19352>:
    iftmp.37 = "modreq";
    goto <D.19354>;
    <D.19353>:
    iftmp.37 = "modopt";
    <D.19354>:
    monoeg_g_string_append_printf (s, " %s (%s)", iftmp.37, tok);
    monoeg_g_free (tok);
  }
  i = i + 1;
  <D.18334>:
  if (i < n) goto <D.18333>; else goto <D.18335>;
  <D.18335>:
  monoeg_g_string_append_c (s, 32);
  result = s->str;
  monoeg_g_string_free (s, 0);
  D.19355 = result;
  return D.19355;
}


dis_stringify_param (struct MonoImage * m, struct MonoType * param)
{
  const char * iftmp.38;
  short unsigned int D.19358;
  int D.19359;
  int D.19360;
  const char * iftmp.39;
  int D.19365;
  const char * iftmp.40;
  int D.19370;
  const gchar * iftmp.41;
  char D.19375;
  char * D.19379;
  char * t;
  char * result;
  char * attribs;
  const char * in;
  const char * out;
  const char * opt;

  D.19358 = param->attrs;
  D.19359 = (int) D.19358;
  D.19360 = D.19359 & 1;
  if (D.19360 != 0) goto <D.19361>; else goto <D.19362>;
  <D.19361>:
  iftmp.38 = "[in]";
  goto <D.19363>;
  <D.19362>:
  iftmp.38 = "";
  <D.19363>:
  in = iftmp.38;
  D.19358 = param->attrs;
  D.19359 = (int) D.19358;
  D.19365 = D.19359 & 2;
  if (D.19365 != 0) goto <D.19366>; else goto <D.19367>;
  <D.19366>:
  iftmp.39 = "[out]";
  goto <D.19368>;
  <D.19367>:
  iftmp.39 = "";
  <D.19368>:
  out = iftmp.39;
  D.19358 = param->attrs;
  D.19359 = (int) D.19358;
  D.19370 = D.19359 & 16;
  if (D.19370 != 0) goto <D.19371>; else goto <D.19372>;
  <D.19371>:
  iftmp.40 = "[opt]";
  goto <D.19373>;
  <D.19372>:
  iftmp.40 = "";
  <D.19373>:
  opt = iftmp.40;
  attribs = monoeg_g_strconcat (in, out, opt, 0B);
  t = dis_stringify_type (m, param, 1);
  D.19375 = *attribs;
  if (D.19375 != 0) goto <D.19376>; else goto <D.19377>;
  <D.19376>:
  iftmp.41 = " ";
  goto <D.19378>;
  <D.19377>:
  iftmp.41 = "";
  <D.19378>:
  result = monoeg_g_strjoin (iftmp.41, attribs, t, 0B);
  monoeg_g_free (t);
  monoeg_g_free (attribs);
  D.19379 = result;
  return D.19379;
}


dis_stringify_marshal_spec (struct MonoMarshalSpec * spec)
{
  <unnamed type> D.19381;
  char * D.19382;
  int D.19383;
  short int D.19384;
  <unnamed type> D.19385;
  _Bool D.19386;
  _Bool D.19387;
  _Bool D.19388;
  short int D.19396;
  unsigned int D.19397;
  <unnamed type> D.19401;
  const char * iftmp.42;
  const char * iftmp.43;
  char * D.19409;
  const char * iftmp.44;
  char * D.19414;

  D.19381 = spec->native;
  switch (D.19381) <default: <D.18446>, case 23: <D.18434>, case 29: <D.18442>, case 30: <D.18435>, case 42: <D.18436>, case 44: <D.18445>>
  <D.18434>:
  D.19383 = spec->data.array_data.num_elem;
  D.19382 = monoeg_g_strdup_printf (" marshal (fixed sysstring [%d])", D.19383);
  return D.19382;
  <D.18435>:
  D.19383 = spec->data.array_data.num_elem;
  D.19382 = monoeg_g_strdup_printf (" marshal (fixed array [%d])", D.19383);
  return D.19382;
  <D.18436>:
  {
    char * elem_type;
    char * elems;
    char * ret;
    guint32 num_elem;
    guint32 param_num;

    D.19383 = spec->data.array_data.num_elem;
    num_elem = (guint32) D.19383;
    D.19384 = spec->data.array_data.param_num;
    param_num = (guint32) D.19384;
    D.19385 = spec->data.array_data.elem_type;
    elem_type = dis_stringify_native_type (D.19385);
    D.19386 = num_elem == 4294967295;
    D.19387 = param_num == 4294967295;
    D.19388 = D.19386 & D.19387;
    if (D.19388 != 0) goto <D.19389>; else goto <D.19390>;
    <D.19389>:
    elems = monoeg_strdup ("");
    goto <D.19391>;
    <D.19390>:
    if (param_num == 4294967295) goto <D.19392>; else goto <D.19395>;
    <D.19395>:
    D.19396 = spec->data.array_data.elem_mult;
    if (D.19396 == 0) goto <D.19392>; else goto <D.19393>;
    <D.19392>:
    elems = monoeg_g_strdup_printf ("%d", num_elem);
    goto <D.19394>;
    <D.19393>:
    D.19397 = num_elem + 4294967295;
    if (D.19397 > 4294967293) goto <D.19398>; else goto <D.19399>;
    <D.19398>:
    elems = monoeg_g_strdup_printf ("+ %d", param_num);
    goto <D.19400>;
    <D.19399>:
    elems = monoeg_g_strdup_printf ("%d + %d", num_elem, param_num);
    <D.19400>:
    <D.19394>:
    <D.19391>:
    ret = monoeg_g_strdup_printf (" marshal (%s[%s])", elem_type, elems);
    monoeg_g_free (elem_type);
    monoeg_g_free (elems);
    D.19382 = ret;
    return D.19382;
  }
  <D.18442>:
  {
    char * elem_type;
    char * ret;

    elem_type = 0B;
    D.19401 = spec->data.safearray_data.elem_type;
    if (D.19401 != 0) goto <D.19402>; else goto <D.19403>;
    <D.19402>:
    D.19401 = spec->data.safearray_data.elem_type;
    elem_type = dis_stringify_variant_type (D.19401);
    <D.19403>:
    if (elem_type != 0B) goto <D.19405>; else goto <D.19406>;
    <D.19405>:
    iftmp.42 = elem_type;
    goto <D.19407>;
    <D.19406>:
    iftmp.42 = "";
    <D.19407>:
    ret = monoeg_g_strdup_printf (" marshal (safearray %s)", iftmp.42);
    monoeg_g_free (elem_type);
    D.19382 = ret;
    return D.19382;
  }
  <D.18445>:
  D.19409 = spec->data.custom_data.cookie;
  if (D.19409 != 0B) goto <D.19410>; else goto <D.19411>;
  <D.19410>:
  iftmp.43 = spec->data.custom_data.cookie;
  goto <D.19412>;
  <D.19411>:
  iftmp.43 = "";
  <D.19412>:
  D.19414 = spec->data.custom_data.custom_name;
  if (D.19414 != 0B) goto <D.19415>; else goto <D.19416>;
  <D.19415>:
  iftmp.44 = spec->data.custom_data.custom_name;
  goto <D.19417>;
  <D.19416>:
  iftmp.44 = "";
  <D.19417>:
  D.19382 = monoeg_g_strdup_printf (" marshal (custom (\"%s\", \"%s\"))", iftmp.44, iftmp.43);
  return D.19382;
  <D.18446>:
  {
    char * native_type;
    char * ret;

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


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

  if (str != 0B) goto <D.19419>; else goto <D.19420>;
  <D.19419>:
  D.19421 = __strdup (str);
  return D.19421;
  <D.19420>:
  D.19421 = 0B;
  return D.19421;
}


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

  switch (variant) <default: <D.18393>, case 0: <D.18349>, case 1: <D.18350>, case 2: <D.18351>, case 3: <D.18352>, case 4: <D.18353>, case 5: <D.18354>, case 6: <D.18355>, case 7: <D.18356>, case 8: <D.18357>, case 9: <D.18358>, case 10: <D.18359>, case 11: <D.18360>, case 12: <D.18361>, case 13: <D.18362>, case 14: <D.18363>, case 16: <D.18364>, case 17: <D.18365>, case 18: <D.18366>, case 19: <D.18367>, case 20: <D.18368>, case 21: <D.18369>, case 22: <D.18370>, case 23: <D.18371>, case 24: <D.18372>, case 25: <D.18373>, case 26: <D.18374>, case 27: <D.18375>, case 28: <D.18376>, case 29: <D.18377>, case 30: <D.18378>, case 31: <D.18379>, case 36: <D.18380>, case 64: <D.18381>, case 65: <D.18382>, case 66: <D.18383>, case 67: <D.18384>, case 68: <D.18385>, case 69: <D.18386>, case 70: <D.18387>, case 71: <D.18388>, case 72: <D.18389>, case 4096: <D.18390>, case 8192: <D.18391>, case 16384: <D.18392>>
  <D.18349>:
  D.19423 = monoeg_strdup ("");
  return D.19423;
  <D.18350>:
  D.19423 = monoeg_strdup ("null");
  return D.19423;
  <D.18351>:
  D.19423 = monoeg_strdup ("int16");
  return D.19423;
  <D.18352>:
  D.19423 = monoeg_strdup ("int32");
  return D.19423;
  <D.18353>:
  D.19423 = monoeg_strdup ("float32");
  return D.19423;
  <D.18354>:
  D.19423 = monoeg_strdup ("float64");
  return D.19423;
  <D.18355>:
  D.19423 = monoeg_strdup ("currency");
  return D.19423;
  <D.18356>:
  D.19423 = monoeg_strdup ("date");
  return D.19423;
  <D.18357>:
  D.19423 = monoeg_strdup ("bstr");
  return D.19423;
  <D.18358>:
  D.19423 = monoeg_strdup ("idispatch");
  return D.19423;
  <D.18359>:
  D.19423 = monoeg_strdup ("error");
  return D.19423;
  <D.18360>:
  D.19423 = monoeg_strdup ("bool");
  return D.19423;
  <D.18361>:
  D.19423 = monoeg_strdup ("variant");
  return D.19423;
  <D.18362>:
  D.19423 = monoeg_strdup ("iunknown");
  return D.19423;
  <D.18363>:
  D.19423 = monoeg_strdup ("decimal");
  return D.19423;
  <D.18364>:
  D.19423 = monoeg_strdup ("int8");
  return D.19423;
  <D.18365>:
  D.19423 = monoeg_strdup ("unsigned int8");
  return D.19423;
  <D.18366>:
  D.19423 = monoeg_strdup ("unsigned int16");
  return D.19423;
  <D.18367>:
  D.19423 = monoeg_strdup ("unsigned int32");
  return D.19423;
  <D.18368>:
  D.19423 = monoeg_strdup ("int64");
  return D.19423;
  <D.18369>:
  D.19423 = monoeg_strdup ("unsigned int64");
  return D.19423;
  <D.18370>:
  D.19423 = monoeg_strdup ("int");
  return D.19423;
  <D.18371>:
  D.19423 = monoeg_strdup ("unsigned int");
  return D.19423;
  <D.18372>:
  D.19423 = monoeg_strdup ("void");
  return D.19423;
  <D.18373>:
  D.19423 = monoeg_strdup ("hresult");
  return D.19423;
  <D.18374>:
  D.19423 = monoeg_strdup ("*");
  return D.19423;
  <D.18375>:
  D.19423 = monoeg_strdup ("safearray");
  return D.19423;
  <D.18376>:
  D.19423 = monoeg_strdup ("carray");
  return D.19423;
  <D.18377>:
  D.19423 = monoeg_strdup ("userdefined");
  return D.19423;
  <D.18378>:
  D.19423 = monoeg_strdup ("lpstr");
  return D.19423;
  <D.18379>:
  D.19423 = monoeg_strdup ("lpwstr");
  return D.19423;
  <D.18380>:
  D.19423 = monoeg_strdup ("record");
  return D.19423;
  <D.18381>:
  D.19423 = monoeg_strdup ("filetime");
  return D.19423;
  <D.18382>:
  D.19423 = monoeg_strdup ("blob");
  return D.19423;
  <D.18383>:
  D.19423 = monoeg_strdup ("stream");
  return D.19423;
  <D.18384>:
  D.19423 = monoeg_strdup ("storage");
  return D.19423;
  <D.18385>:
  D.19423 = monoeg_strdup ("streamed_object");
  return D.19423;
  <D.18386>:
  D.19423 = monoeg_strdup ("stored_object");
  return D.19423;
  <D.18387>:
  D.19423 = monoeg_strdup ("blob_object");
  return D.19423;
  <D.18388>:
  D.19423 = monoeg_strdup ("cf");
  return D.19423;
  <D.18389>:
  D.19423 = monoeg_strdup ("clsid");
  return D.19423;
  <D.18390>:
  D.19423 = monoeg_strdup ("vector");
  return D.19423;
  <D.18391>:
  D.19423 = monoeg_strdup ("[]");
  return D.19423;
  <D.18392>:
  D.19423 = monoeg_strdup ("&");
  return D.19423;
  <D.18393>:
  D.19423 = monoeg_strdup ("unknown");
  return D.19423;
}


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

  switch (native) <default: <D.18430>, case 2: <D.18397>, case 3: <D.18398>, case 4: <D.18399>, case 5: <D.18400>, case 6: <D.18401>, case 7: <D.18402>, case 8: <D.18403>, case 9: <D.18404>, case 10: <D.18405>, case 11: <D.18406>, case 12: <D.18407>, case 15: <D.18408>, case 19: <D.18409>, case 20: <D.18410>, case 21: <D.18411>, case 22: <D.18412>, case 25: <D.18413>, case 26: <D.18414>, case 27: <D.18415>, case 28: <D.18416>, case 29: <D.18417>, case 31: <D.18418>, case 32: <D.18419>, case 34: <D.18420>, case 35: <D.18421>, case 36: <D.18422>, case 37: <D.18423>, case 38: <D.18424>, case 40: <D.18425>, case 43: <D.18426>, case 44: <D.18427>, case 45: <D.18428>, case 80: <D.18429>>
  <D.18397>:
  D.19425 = monoeg_strdup ("bool");
  return D.19425;
  <D.18398>:
  D.19425 = monoeg_strdup ("int8");
  return D.19425;
  <D.18399>:
  D.19425 = monoeg_strdup ("unsigned int8");
  return D.19425;
  <D.18400>:
  D.19425 = monoeg_strdup ("int16");
  return D.19425;
  <D.18401>:
  D.19425 = monoeg_strdup ("unsigned int16");
  return D.19425;
  <D.18402>:
  D.19425 = monoeg_strdup ("int32");
  return D.19425;
  <D.18403>:
  D.19425 = monoeg_strdup ("unsigned int32");
  return D.19425;
  <D.18404>:
  D.19425 = monoeg_strdup ("int64");
  return D.19425;
  <D.18405>:
  D.19425 = monoeg_strdup ("unsigned int64");
  return D.19425;
  <D.18406>:
  D.19425 = monoeg_strdup ("float32");
  return D.19425;
  <D.18407>:
  D.19425 = monoeg_strdup ("float64");
  return D.19425;
  <D.18408>:
  D.19425 = monoeg_strdup ("currency");
  return D.19425;
  <D.18409>:
  D.19425 = monoeg_strdup ("bstr");
  return D.19425;
  <D.18410>:
  D.19425 = monoeg_strdup ("lpstr");
  return D.19425;
  <D.18411>:
  D.19425 = monoeg_strdup ("lpwstr");
  return D.19425;
  <D.18412>:
  D.19425 = monoeg_strdup ("lptstr");
  return D.19425;
  <D.18413>:
  D.19425 = monoeg_strdup ("iunknown");
  return D.19425;
  <D.18414>:
  D.19425 = monoeg_strdup ("idispatch");
  return D.19425;
  <D.18415>:
  D.19425 = monoeg_strdup ("struct");
  return D.19425;
  <D.18416>:
  D.19425 = monoeg_strdup ("interface");
  return D.19425;
  <D.18417>:
  D.19425 = monoeg_strdup ("safearray");
  return D.19425;
  <D.18418>:
  D.19425 = monoeg_strdup ("int");
  return D.19425;
  <D.18419>:
  D.19425 = monoeg_strdup ("unsigned int");
  return D.19425;
  <D.18420>:
  D.19425 = monoeg_strdup ("vbbyrefstr");
  return D.19425;
  <D.18421>:
  D.19425 = monoeg_strdup ("ansi bstr");
  return D.19425;
  <D.18422>:
  D.19425 = monoeg_strdup ("tbstr");
  return D.19425;
  <D.18423>:
  D.19425 = monoeg_strdup ("variant bool");
  return D.19425;
  <D.18424>:
  D.19425 = monoeg_strdup ("method");
  return D.19425;
  <D.18425>:
  D.19425 = monoeg_strdup ("as any");
  return D.19425;
  <D.18426>:
  D.19425 = monoeg_strdup ("lpstruct");
  return D.19425;
  <D.18427>:
  D.19425 = monoeg_strdup ("custom");
  return D.19425;
  <D.18428>:
  D.19425 = monoeg_strdup ("error");
  return D.19425;
  <D.18429>:
  D.19425 = monoeg_strdup ("");
  return D.19425;
  <D.18430>:
  D.19425 = monoeg_strdup ("unknown");
  return D.19425;
}


get_generic_param (struct MonoImage * m, struct MonoGenericContainer * container)
{
  char * D.19429;
  struct MonoGenericParamFull * D.19430;
  unsigned int i.45;
  unsigned int D.19432;
  struct MonoGenericParamInfo * iftmp.46;
  struct MonoGenericContainer * D.19434;
  short unsigned int D.19440;
  int D.19441;
  int D.19442;
  int D.19445;
  int D.19448;
  int D.19451;
  int D.19454;
  struct MonoClass * D.19460;
  struct MonoType * D.19461;
  struct MonoGenericParamInfo * iftmp.47;
  const char * D.19469;
  <unnamed-signed:31> D.19470;
  int D.19471;
  struct GString * result;
  char * retval;
  int i;

  if (container == 0B) goto <D.19427>; else goto <D.19428>;
  <D.19427>:
  D.19429 = 0B;
  return D.19429;
  <D.19428>:
  result = monoeg_g_string_new ("");
  monoeg_g_string_append_c (result, 60);
  i = 0;
  goto <D.18467>;
  <D.18466>:
  {
    struct MonoGenericParam * param;
    struct MonoGenericParamInfo * param_info;
    struct MonoClass * * constr;
    int first;
    guint16 flags;
    char * esname;

    D.19430 = container->type_params;
    i.45 = (unsigned int) i;
    D.19432 = i.45 * 32;
    param = D.19430 + D.19432;
    D.19434 = param->owner;
    if (D.19434 != 0B) goto <D.19435>; else goto <D.19436>;
    <D.19435>:
    iftmp.46 = &MEM[(struct MonoGenericParamFull *)param].info;
    goto <D.19437>;
    <D.19436>:
    iftmp.46 = 0B;
    <D.19437>:
    param_info = iftmp.46;
    first = 1;
    if (i > 0) goto <D.19438>; else goto <D.19439>;
    <D.19438>:
    monoeg_g_string_append (result, ",");
    <D.19439>:
    D.19440 = param_info->flags;
    flags = D.19440 & 3;
    D.19441 = (int) flags;
    D.19442 = D.19441 & 1;
    if (D.19442 != 0) goto <D.19443>; else goto <D.19444>;
    <D.19443>:
    monoeg_g_string_append (result, "+ ");
    <D.19444>:
    D.19441 = (int) flags;
    D.19445 = D.19441 & 2;
    if (D.19445 != 0) goto <D.19446>; else goto <D.19447>;
    <D.19446>:
    monoeg_g_string_append (result, "- ");
    <D.19447>:
    D.19440 = param_info->flags;
    flags = D.19440 & 28;
    D.19441 = (int) flags;
    D.19448 = D.19441 & 4;
    if (D.19448 != 0) goto <D.19449>; else goto <D.19450>;
    <D.19449>:
    monoeg_g_string_append (result, "class ");
    <D.19450>:
    D.19441 = (int) flags;
    D.19451 = D.19441 & 8;
    if (D.19451 != 0) goto <D.19452>; else goto <D.19453>;
    <D.19452>:
    monoeg_g_string_append (result, "valuetype ");
    <D.19453>:
    D.19441 = (int) flags;
    D.19454 = D.19441 & 16;
    if (D.19454 != 0) goto <D.19455>; else goto <D.19456>;
    <D.19455>:
    monoeg_g_string_append (result, ".ctor ");
    <D.19456>:
    constr = param_info->constraints;
    goto <D.18464>;
    <D.18463>:
    {
      char * sig;

      if (first != 0) goto <D.19457>; else goto <D.19458>;
      <D.19457>:
      monoeg_g_string_append_c (result, 40);
      first = 0;
      goto <D.19459>;
      <D.19458>:
      monoeg_g_string_append (result, ", ");
      <D.19459>:
      D.19460 = *constr;
      D.19461 = &D.19460->byval_arg;
      sig = dis_stringify_type (m, D.19461, 1);
      monoeg_g_string_append (result, sig);
      monoeg_g_free (sig);
    }
    constr = constr + 4;
    <D.18464>:
    if (constr != 0B) goto <D.19462>; else goto <D.18465>;
    <D.19462>:
    D.19460 = *constr;
    if (D.19460 != 0B) goto <D.18463>; else goto <D.18465>;
    <D.18465>:
    if (first == 0) goto <D.19463>; else goto <D.19464>;
    <D.19463>:
    monoeg_g_string_append (result, ") ");
    <D.19464>:
    D.19434 = param->owner;
    if (D.19434 != 0B) goto <D.19466>; else goto <D.19467>;
    <D.19466>:
    iftmp.47 = &MEM[(struct MonoGenericParamFull *)param].info;
    goto <D.19468>;
    <D.19467>:
    iftmp.47 = 0B;
    <D.19468>:
    D.19469 = iftmp.47->name;
    esname = get_escaped_name (D.19469);
    monoeg_g_string_append (result, esname);
    monoeg_g_free (esname);
  }
  i = i + 1;
  <D.18467>:
  D.19470 = container->type_argc;
  D.19471 = (int) D.19470;
  if (D.19471 > i) goto <D.18466>; else goto <D.18468>;
  <D.18468>:
  monoeg_g_string_append_c (result, 62);
  retval = result->str;
  monoeg_g_string_free (result, 0);
  D.19429 = retval;
  return D.19429;
}


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

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


dis_stringify_method_signature_full (struct MonoImage * m, struct MonoMethodSignature * method, int methoddef_row, struct MonoGenericContainer * container, gboolean fully_qualified, gboolean with_marshal_info)
{
  _Bool D.19475;
  _Bool D.19476;
  _Bool D.19477;
  int D.19478;
  _Bool D.19479;
  long int D.19480;
  long int D.19481;
  int D.19486;
  struct MonoTableInfo * D.19487;
  unsigned int methoddef_row.48;
  int type_idx.49;
  unsigned int D.19495;
  unsigned int D.19498;
  const char * sig.50;
  int D.19500;
  unsigned int D.19501;
  const char * sig.51;
  unsigned char D.19507;
  unsigned char D.19508;
  <unnamed-unsigned:24> D.19511;
  int D.19512;
  <unnamed-unsigned:24> D.19516;
  int D.19517;
  int D.19518;
  unsigned char D.19519;
  unsigned char D.19520;
  _Bool D.19521;
  _Bool D.19522;
  _Bool D.19523;
  _Bool D.19524;
  short unsigned int D.19525;
  unsigned int D.19532;
  int D.19533;
  struct MonoTableInfo * D.19534;
  unsigned int i.52;
  unsigned int D.19539;
  unsigned int D.19543;
  const char * D.19544;
  unsigned int D.19547;
  unsigned int D.19548;
  int D.19562;
  int D.19567;
  struct MonoType * D.19568;
  const char * iftmp.53;
  int D.19573;
  struct MonoType * D.19574;
  <unnamed-unsigned:6> D.19577;
  unsigned int D.19578;
  const char * D.19579;
  const char * iftmp.54;
  char * D.19588;
  int show_method_tokens.55;
  int D.19594;
  int D.19595;
  char * D.19598;
  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 ("");
      D.19475 = method == 0B;
      D.19476 = methoddef_row == 0;
      D.19477 = D.19475 & D.19476;
      D.19478 = (int) D.19477;
      D.19479 = D.19478 != 0;
      D.19480 = (long int) D.19479;
      D.19481 = __builtin_expect (D.19480, 0);
      if (D.19481 != 0) goto <D.19482>; else goto <D.19483>;
      <D.19482>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "get.c", 878, "method || methoddef_row");
      <D.19483>:
      if (methoddef_row != 0) goto <D.19484>; else goto <D.19485>;
      <D.19484>:
      D.19486 = methoddef_row + -1;
      D.19487 = &m->tables[6];
      mono_metadata_decode_row (D.19487, D.19486, &cols, 6);
      if (fully_qualified != 0) goto <D.19488>; else goto <D.19489>;
      <D.19488>:
      {
        guint32 type_idx;

        methoddef_row.48 = (unsigned int) methoddef_row;
        type_idx = mono_metadata_typedef_from_method (m, methoddef_row.48);
        if (type_idx != 0) goto <D.19491>; else goto <D.19492>;
        <D.19491>:
        type_idx.49 = (int) type_idx;
        type = get_typedef (m, type_idx.49);
        goto <D.19494>;
        <D.19492>:
        type = monoeg_strdup ("<invalid>");
        <D.19494>:
      }
      <D.19489>:
      D.19495 = cols[3];
      method_name = mono_metadata_string_heap (m, D.19495);
      param_index = cols[5];
      if (method == 0B) goto <D.19496>; else goto <D.19497>;
      <D.19496>:
      {
        const char * sig;

        try
          {
            D.19498 = cols[4];
            sig.50 = mono_metadata_blob_heap (m, D.19498);
            sig = sig.50;
            D.19500 = methoddef_row | 100663296;
            D.19501 = (unsigned int) D.19500;
            container = mono_metadata_load_generic_params (m, D.19501, container);
            if (container != 0B) goto <D.19502>; else goto <D.19503>;
            <D.19502>:
            D.19500 = methoddef_row | 100663296;
            D.19501 = (unsigned int) D.19500;
            mono_metadata_load_generic_param_constraints (m, D.19501, container);
            <D.19503>:
            sig.51 = sig;
            mono_metadata_decode_blob_size (sig.51, &sig);
            sig.51 = sig;
            method = mono_metadata_parse_method_signature_full (m, container, methoddef_row, sig.51, &sig);
            free_method = 1;
          }
        finally
          {
            sig = {CLOBBER};
          }
      }
      <D.19497>:
      if (container != 0B) goto <D.19505>; else goto <D.19506>;
      <D.19505>:
      D.19507 = BIT_FIELD_REF <*container, 8, 152>;
      D.19508 = D.19507 & 128;
      if (D.19508 != 0) goto <D.19509>; else goto <D.19510>;
      <D.19509>:
      gen_param = get_generic_param (m, container);
      <D.19510>:
      <D.19506>:
      D.19511 = m->tables[6].rows;
      D.19512 = (int) D.19511;
      if (D.19512 > methoddef_row) goto <D.19513>; else goto <D.19514>;
      <D.19513>:
      D.19487 = &m->tables[6];
      mono_metadata_decode_row (D.19487, methoddef_row, &cols, 6);
      next_param_index = cols[5];
      goto <D.19515>;
      <D.19514>:
      D.19516 = m->tables[8].rows;
      D.19517 = (int) D.19516;
      D.19518 = D.19517 + 1;
      next_param_index = (guint32) D.19518;
      <D.19515>:
      <D.19485>:
      D.19519 = BIT_FIELD_REF <*method, 8, 80>;
      D.19520 = D.19519 & 64;
      D.19521 = D.19520 == 0;
      start = (int) D.19521;
      i = 0;
      goto <D.18507>;
      <D.18506>:
      marshal_info = 0B;
      D.19522 = param_index != 0;
      D.19523 = param_index < next_param_index;
      D.19524 = D.19522 & D.19523;
      has_param_row = (gboolean) D.19524;
      esname = 0B;
      D.19525 = method->param_count;
      if (D.19525 == 0) goto <D.19526>; else goto <D.19527>;
      <D.19526>:
      if (has_param_row == 0) goto <D.19528>; else goto <D.19529>;
      <D.19528>:
      // predicted unlikely by continue predictor.
      goto <D.18503>;
      <D.19529>:
      <D.19527>:
      if (has_param_row != 0) goto <D.19530>; else goto <D.19531>;
      <D.19530>:
      D.19532 = param_index + 4294967295;
      D.19533 = (int) D.19532;
      D.19534 = &m->tables[8];
      mono_metadata_decode_row (D.19534, D.19533, &pcols, 3);
      <D.19531>:
      if (has_param_row != 0) goto <D.19537>; else goto <D.19535>;
      <D.19537>:
      i.52 = (unsigned int) i;
      D.19539 = pcols[1];
      if (i.52 == D.19539) goto <D.19540>; else goto <D.19535>;
      <D.19540>:
      if (i != 0) goto <D.19541>; else goto <D.19542>;
      <D.19541>:
      D.19543 = pcols[2];
      D.19544 = mono_metadata_string_heap (m, D.19543);
      esname = get_escaped_name (D.19544);
      <D.19542>:
      if (with_marshal_info != 0) goto <D.19545>; else goto <D.19546>;
      <D.19545>:
      D.19547 = pcols[0];
      D.19548 = D.19547 & 8192;
      if (D.19548 != 0) goto <D.19549>; else goto <D.19550>;
      <D.19549>:
      {
        const char * tp;
        struct MonoMarshalSpec * spec;

        D.19532 = param_index + 4294967295;
        tp = mono_metadata_get_marshal_info (m, D.19532, 0);
        if (tp != 0B) goto <D.19551>; else goto <D.19552>;
        <D.19551>:
        spec = mono_metadata_parse_marshal_spec (m, tp);
        if (i != 0) goto <D.19553>; else goto <D.19554>;
        <D.19553>:
        marshal_info = dis_stringify_marshal_spec (spec);
        goto <D.19555>;
        <D.19554>:
        ret_marshal_info = dis_stringify_marshal_spec (spec);
        <D.19555>:
        goto <D.19556>;
        <D.19552>:
        if (i != 0) goto <D.19557>; else goto <D.19558>;
        <D.19557>:
        marshal_info = monoeg_strdup ("(missing)");
        goto <D.19559>;
        <D.19558>:
        ret_marshal_info = monoeg_strdup ("(missing)");
        <D.19559>:
        <D.19556>:
      }
      <D.19550>:
      <D.19546>:
      param_index = param_index + 1;
      goto <D.19536>;
      <D.19535>:
      if (i != 0) goto <D.19560>; else goto <D.19561>;
      <D.19560>:
      D.19562 = i - start;
      esname = monoeg_g_strdup_printf ("A_%i", D.19562);
      <D.19561>:
      <D.19536>:
      if (i == 0) goto <D.19563>; else goto <D.19564>;
      <D.19563>:
      // predicted unlikely by continue predictor.
      goto <D.18503>;
      <D.19564>:
      if (i > 1) goto <D.19565>; else goto <D.19566>;
      <D.19565>:
      monoeg_g_string_append (result, ", ");
      <D.19566>:
      D.19567 = i + -1;
      D.19568 = method->params[D.19567];
      retval = dis_stringify_param (m, D.19568);
      if (marshal_info != 0B) goto <D.19570>; else goto <D.19571>;
      <D.19570>:
      iftmp.53 = marshal_info;
      goto <D.19572>;
      <D.19571>:
      iftmp.53 = "";
      <D.19572>:
      monoeg_g_string_append_printf (result, "%s%s %s", retval, iftmp.53, esname);
      monoeg_g_free (retval);
      monoeg_g_free (esname);
      monoeg_g_free (marshal_info);
      <D.18503>:
      i = i + 1;
      <D.18507>:
      D.19525 = method->param_count;
      D.19573 = (int) D.19525;
      if (D.19573 >= i) goto <D.18506>; else goto <D.18508>;
      <D.18508>:
      monoeg_g_string_append (result, ") ");
      D.19574 = method->ret;
      retval = dis_stringify_param (m, D.19574);
      D.19519 = BIT_FIELD_REF <*method, 8, 80>;
      D.19520 = D.19519 & 64;
      if (D.19520 != 0) goto <D.19575>; else goto <D.19576>;
      <D.19575>:
      monoeg_g_string_append (result_ret, "instance ");
      <D.19576>:
      D.19577 = method->call_convention;
      D.19578 = (unsigned int) D.19577;
      D.19579 = map (D.19578, &call_conv_type_map);
      monoeg_g_string_append (result_ret, D.19579);
      if (ret_marshal_info != 0B) goto <D.19581>; else goto <D.19582>;
      <D.19581>:
      iftmp.54 = ret_marshal_info;
      goto <D.19583>;
      <D.19582>:
      iftmp.54 = "";
      <D.19583>:
      monoeg_g_string_append_printf (result_ret, " %s%s ", retval, iftmp.54);
      monoeg_g_free (ret_marshal_info);
      if (type != 0B) goto <D.19584>; else goto <D.19585>;
      <D.19584>:
      {
        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.19585>:
      esname = get_escaped_name (method_name);
      monoeg_g_string_append (result_ret, esname);
      monoeg_g_free (esname);
      if (gen_param != 0B) goto <D.19586>; else goto <D.19587>;
      <D.19586>:
      monoeg_g_string_append (result_ret, gen_param);
      monoeg_g_free (gen_param);
      <D.19587>:
      monoeg_g_string_append (result_ret, " (");
      monoeg_g_free (retval);
      D.19588 = result_ret->str;
      monoeg_g_string_prepend (result, D.19588);
      monoeg_g_string_free (result_ret, 0);
      show_method_tokens.55 = show_method_tokens;
      if (show_method_tokens.55 != 0) goto <D.19590>; else goto <D.19591>;
      <D.19590>:
      if (methoddef_row != 0) goto <D.19592>; else goto <D.19593>;
      <D.19592>:
      D.19594 = methoddef_row >> 1;
      D.19595 = D.19594 | 100663296;
      monoeg_g_string_append_printf (result, " /* 0x%X */ ", D.19595);
      <D.19593>:
      <D.19591>:
      if (free_method != 0) goto <D.19596>; else goto <D.19597>;
      <D.19596>:
      mono_metadata_free_method_signature (method);
      <D.19597>:
      retval = result->str;
      monoeg_g_string_free (result, 0);
      D.19598 = retval;
      return D.19598;
    }
  finally
    {
      cols = {CLOBBER};
      pcols = {CLOBBER};
    }
}


dis_stringify_function_ptr (struct MonoImage * m, struct MonoMethodSignature * method)
{
  _Bool D.19601;
  long int D.19602;
  long int D.19603;
  <unnamed-unsigned:6> D.19606;
  unsigned int D.19607;
  const char * D.19608;
  struct MonoType * D.19609;
  struct MonoType * D.19612;
  short unsigned int D.19613;
  int D.19614;
  char * D.19615;
  char * retval;
  struct GString * result;
  int i;

  result = monoeg_g_string_new ("");
  D.19601 = method == 0B;
  D.19602 = (long int) D.19601;
  D.19603 = __builtin_expect (D.19602, 0);
  if (D.19603 != 0) goto <D.19604>; else goto <D.19605>;
  <D.19604>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "get.c", 1017, "method");
  <D.19605>:
  D.19606 = method->call_convention;
  D.19607 = (unsigned int) D.19606;
  D.19608 = map (D.19607, &call_conv_type_map);
  monoeg_g_string_append (result, D.19608);
  D.19609 = method->ret;
  retval = dis_stringify_param (m, D.19609);
  monoeg_g_string_append_printf (result, " %s ", retval);
  monoeg_g_free (retval);
  monoeg_g_string_append (result, " *(");
  i = 0;
  goto <D.18518>;
  <D.18517>:
  if (i != 0) goto <D.19610>; else goto <D.19611>;
  <D.19610>:
  monoeg_g_string_append (result, ", ");
  <D.19611>:
  D.19612 = method->params[i];
  retval = dis_stringify_param (m, D.19612);
  monoeg_g_string_append (result, retval);
  monoeg_g_free (retval);
  i = i + 1;
  <D.18518>:
  D.19613 = method->param_count;
  D.19614 = (int) D.19613;
  if (D.19614 > i) goto <D.18517>; else goto <D.18519>;
  <D.18519>:
  monoeg_g_string_append (result, ") ");
  retval = result->str;
  monoeg_g_string_free (result, 0);
  D.19615 = retval;
  return D.19615;
}


dis_stringify_object_with_class (struct MonoImage * m, struct MonoClass * c, gboolean prefix, gboolean is_def)
{
  const char * iftmp.56;
  unsigned char D.19618;
  unsigned int D.19622;
  char * D.19625;
  struct MonoImage * D.19626;
  const char * D.19629;
  int substitute_with_mscorlib_p.57;
  int D.18546;
  int iftmp.58;
  int D.18542;
  const char[7] * D.19639;
  unsigned char D.19640;
  int D.19641;
  unsigned char D.19642;
  int D.19643;
  _Bool D.19644;
  _Bool D.19645;
  _Bool D.19646;
  const unsigned char * D.19649;
  unsigned char D.19650;
  int D.19651;
  const unsigned char * D.19652;
  unsigned char D.19653;
  int D.19654;
  _Bool D.19655;
  _Bool D.19656;
  const unsigned char * D.19659;
  unsigned char D.19660;
  int D.19661;
  const unsigned char * D.19662;
  unsigned char D.19663;
  int D.19664;
  _Bool D.19665;
  _Bool D.19666;
  const unsigned char * D.19669;
  unsigned char D.19670;
  int D.19671;
  const unsigned char * D.19672;
  unsigned char D.19673;
  int D.19674;
  struct MonoAssembly * D.19677;
  const char * D.19678;
  const char * D.19680;
  struct MonoGenericClass * D.19681;
  struct MonoType * D.19684;
  int D.19685;
  <unnamed-unsigned:22> D.19686;
  int D.19687;
  char * D.19690;
  const char * iftmp.59;
  const char * iftmp.60;
  const char * iftmp.61;
  struct MonoType * type;
  const char * otype;
  char * assemblyref;
  char * result;
  char * esname;
  char * generic;

  type = &c->byval_arg;
  D.19618 = type->type;
  if (D.19618 == 17) goto <D.19619>; else goto <D.19620>;
  <D.19619>:
  iftmp.56 = "valuetype ";
  goto <D.19621>;
  <D.19620>:
  iftmp.56 = "class ";
  <D.19621>:
  otype = iftmp.56;
  assemblyref = 0B;
  generic = 0B;
  D.19622 = c->type_token;
  if (D.19622 == 33554433) goto <D.19623>; else goto <D.19624>;
  <D.19623>:
  D.19625 = 0B;
  return D.19625;
  <D.19624>:
  D.19626 = c->image;
  if (D.19626 != m) goto <D.19627>; else goto <D.19628>;
  <D.19627>:
  D.19626 = c->image;
  D.19629 = D.19626->assembly_name;
  if (D.19629 != 0B) goto <D.19630>; else goto <D.19631>;
  <D.19630>:
  substitute_with_mscorlib_p.57 = substitute_with_mscorlib_p;
  if (substitute_with_mscorlib_p.57 != 0) goto <D.19635>; else goto <D.19632>;
  <D.19635>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      D.19626 = c->image;
      __s2 = D.19626->assembly_name;
      D.19639 = "corlib";
      D.19640 = MEM[(const unsigned char *)D.19639];
      D.19641 = (int) D.19640;
      D.19642 = *__s2;
      D.19643 = (int) D.19642;
      __result = D.19641 - D.19643;
      {
        D.19644 = __s1_len != 0;
        D.19645 = __result == 0;
        D.19646 = D.19644 & D.19645;
        if (D.19646 != 0) goto <D.19647>; else goto <D.19648>;
        <D.19647>:
        D.19649 = &MEM[(void *)"corlib" + 1B];
        D.19650 = *D.19649;
        D.19651 = (int) D.19650;
        D.19652 = __s2 + 1;
        D.19653 = *D.19652;
        D.19654 = (int) D.19653;
        __result = D.19651 - D.19654;
        D.19655 = __s1_len > 1;
        D.19645 = __result == 0;
        D.19656 = D.19655 & D.19645;
        if (D.19656 != 0) goto <D.19657>; else goto <D.19658>;
        <D.19657>:
        D.19659 = &MEM[(void *)"corlib" + 2B];
        D.19660 = *D.19659;
        D.19661 = (int) D.19660;
        D.19662 = __s2 + 2;
        D.19663 = *D.19662;
        D.19664 = (int) D.19663;
        __result = D.19661 - D.19664;
        D.19665 = __s1_len > 2;
        D.19645 = __result == 0;
        D.19666 = D.19665 & D.19645;
        if (D.19666 != 0) goto <D.19667>; else goto <D.19668>;
        <D.19667>:
        D.19669 = &MEM[(void *)"corlib" + 3B];
        D.19670 = *D.19669;
        D.19671 = (int) D.19670;
        D.19672 = __s2 + 3;
        D.19673 = *D.19672;
        D.19674 = (int) D.19673;
        __result = D.19671 - D.19674;
        <D.19668>:
        <D.19658>:
        <D.19648>:
      }
      D.18542 = __result;
    }
    iftmp.58 = D.18542;
    goto <D.19675>;
    <D.19638>:
    D.19626 = c->image;
    D.19629 = D.19626->assembly_name;
    iftmp.58 = __builtin_strcmp ("corlib", D.19629);
    <D.19675>:
    D.18546 = iftmp.58;
  }
  if (D.18546 == 0) goto <D.19676>; else goto <D.19632>;
  <D.19676>:
  assemblyref = monoeg_g_strdup_printf ("[%s]", "mscorlib");
  goto <D.19633>;
  <D.19632>:
  {
    char * esc;

    D.19626 = c->image;
    D.19677 = D.19626->assembly;
    D.19678 = D.19677->aname.name;
    esc = get_escaped_name (D.19678);
    assemblyref = monoeg_g_strdup_printf ("[%s]", esc);
    monoeg_g_free (esc);
  }
  <D.19633>:
  goto <D.19679>;
  <D.19631>:
  D.19626 = c->image;
  D.19680 = D.19626->module_name;
  assemblyref = monoeg_g_strdup_printf ("[.module %s]", D.19680);
  <D.19679>:
  <D.19628>:
  esname = get_escaped_class_name (c);
  D.19681 = c->generic_class;
  if (D.19681 != 0B) goto <D.19682>; else goto <D.19683>;
  <D.19682>:
  {
    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.18554>;
    <D.18553>:
    {
      char * t;

      D.19684 = inst->type_argv[i];
      t = dis_stringify_type (m, D.19684, is_def);
      monoeg_g_string_append (str, t);
      D.19685 = i + 1;
      D.19686 = inst->type_argc;
      D.19687 = (int) D.19686;
      if (D.19685 != D.19687) goto <D.19688>; else goto <D.19689>;
      <D.19688>:
      monoeg_g_string_append (str, ", ");
      <D.19689>:
      monoeg_g_free (t);
    }
    i = i + 1;
    <D.18554>:
    D.19686 = inst->type_argc;
    D.19687 = (int) D.19686;
    if (D.19687 > i) goto <D.18553>; else goto <D.18555>;
    <D.18555>:
    D.19690 = str->str;
    generic = monoeg_g_strdup_printf ("<%s>", D.19690);
    monoeg_g_string_free (str, 1);
  }
  <D.19683>:
  if (generic != 0B) goto <D.19692>; else goto <D.19693>;
  <D.19692>:
  iftmp.59 = generic;
  goto <D.19694>;
  <D.19693>:
  iftmp.59 = "";
  <D.19694>:
  if (assemblyref != 0B) goto <D.19696>; else goto <D.19697>;
  <D.19696>:
  iftmp.60 = assemblyref;
  goto <D.19698>;
  <D.19697>:
  iftmp.60 = "";
  <D.19698>:
  if (prefix != 0) goto <D.19700>; else goto <D.19701>;
  <D.19700>:
  iftmp.61 = otype;
  goto <D.19702>;
  <D.19701>:
  iftmp.61 = "";
  <D.19702>:
  result = monoeg_g_strdup_printf ("%s%s%s%s", iftmp.61, iftmp.60, esname, iftmp.59);
  monoeg_g_free (generic);
  monoeg_g_free (assemblyref);
  monoeg_g_free (esname);
  D.19625 = result;
  return D.19625;
}


get_escaped_class_name (struct MonoClass * c)
{
  unsigned int D.19704;
  char * D.19707;
  unsigned char D.19710;
  unsigned char D.19712;
  const char * D.19715;
  struct MonoClass * D.19716;
  const char * D.19720;
  char D.19721;
  char * result;
  char * esname;

  D.19704 = c->type_token;
  if (D.19704 == 33554433) goto <D.19705>; else goto <D.19706>;
  <D.19705>:
  D.19707 = 0B;
  return D.19707;
  <D.19706>:
  D.19710 = c->rank;
  if (D.19710 != 0) goto <D.19708>; else goto <D.19711>;
  <D.19711>:
  D.19712 = c->byval_arg.type;
  if (D.19712 == 15) goto <D.19708>; else goto <D.19709>;
  <D.19708>:
  if (1 != 0) goto <D.19713>; else goto <D.19714>;
  <D.19713>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "get.c", 1051, "0");
  <D.19714>:
  <D.19709>:
  D.19715 = c->name;
  esname = get_escaped_name (D.19715);
  D.19716 = c->nested_in;
  if (D.19716 != 0B) goto <D.19717>; else goto <D.19718>;
  <D.19717>:
  {
    char * part_a;

    D.19716 = c->nested_in;
    part_a = get_escaped_class_name (D.19716);
    result = monoeg_g_strdup_printf ("%s/%s", part_a, esname);
    monoeg_g_free (part_a);
  }
  goto <D.19719>;
  <D.19718>:
  D.19720 = c->name_space;
  D.19721 = *D.19720;
  if (D.19721 != 0) goto <D.19722>; else goto <D.19723>;
  <D.19722>:
  D.19720 = c->name_space;
  result = monoeg_g_strdup_printf ("%s.%s", D.19720, esname);
  goto <D.19724>;
  <D.19723>:
  result = monoeg_strdup (esname);
  <D.19724>:
  <D.19719>:
  monoeg_g_free (esname);
  D.19707 = result;
  return D.19707;
}


dis_stringify_type (struct MonoImage * m, struct MonoType * type, gboolean is_def)
{
  unsigned char D.19726;
  unsigned char D.19727;
  struct MonoCustomMod[0:] * D.19730;
  <unnamed-unsigned:6> D.19731;
  int D.19732;
  unsigned char D.19733;
  int D.19734;
  unsigned int D.19735;
  const char * D.19736;
  struct MonoMethodSignature * D.19737;
  struct MonoType * D.19738;
  struct MonoClass * D.19739;
  struct MonoType * D.19740;
  struct MonoArrayType * D.19741;
  struct MonoGenericParam * D.19745;
  int D.19746;
  struct MonoGenericParamInfo * iftmp.62;
  struct MonoGenericContainer * D.19749;
  const char * D.19753;
  char * D.19754;
  short unsigned int D.19755;
  int D.19756;
  int D.19760;
  struct MonoGenericParamInfo * iftmp.63;
  const char * D.19766;
  char * D.19767;
  struct MonoGenericClass * D.19768;
  struct MonoClass * D.19769;
  struct MonoType * D.19770;
  struct MonoType * D.19771;
  int D.19772;
  <unnamed-unsigned:22> D.19773;
  int D.19774;
  char * D.19777;
  unsigned char D.19778;
  unsigned char D.19781;
  char * D.19786;
  const char * iftmp.64;
  const char * pinned;
  const char * byref;
  char * bare;
  char * mods;
  char * result;

  pinned = "";
  byref = "";
  bare = 0B;
  mods = 0B;
  D.19726 = BIT_FIELD_REF <*type, 8, 56>;
  D.19727 = D.19726 & 63;
  if (D.19727 != 0) goto <D.19728>; else goto <D.19729>;
  <D.19728>:
  D.19730 = &type->modifiers;
  D.19731 = type->num_mods;
  D.19732 = (int) D.19731;
  mods = dis_stringify_modifiers (m, D.19732, D.19730);
  <D.19729>:
  D.19733 = type->type;
  D.19734 = (int) D.19733;
  switch (D.19734) <default: <D.18611>, case 1: <D.18599>, case 2: <D.18572>, case 3: <D.18573>, case 4: <D.18574>, case 5: <D.18575>, case 6: <D.18576>, case 7: <D.18577>, case 8: <D.18578>, case 9: <D.18579>, case 10: <D.18580>, case 11: <D.18581>, case 12: <D.18582>, case 13: <D.18583>, case 14: <D.18586>, case 15: <D.18594>, case 17: <D.18590>, case 18: <D.18591>, case 19: <D.18601>, case 20: <D.18598>, case 21: <D.18602>, case 22: <D.18588>, case 24: <D.18584>, case 25: <D.18585>, case 27: <D.18592>, case 28: <D.18587>, case 29: <D.18596>, case 30: <D.18600>>
  <D.18572>:
  <D.18573>:
  <D.18574>:
  <D.18575>:
  <D.18576>:
  <D.18577>:
  <D.18578>:
  <D.18579>:
  <D.18580>:
  <D.18581>:
  <D.18582>:
  <D.18583>:
  <D.18584>:
  <D.18585>:
  <D.18586>:
  <D.18587>:
  <D.18588>:
  D.19733 = type->type;
  D.19735 = (unsigned int) D.19733;
  D.19736 = map (D.19735, &element_type_map);
  bare = monoeg_strdup (D.19736);
  goto <D.18589>;
  <D.18590>:
  <D.18591>:
  bare = dis_stringify_object (m, type, is_def);
  goto <D.18589>;
  <D.18592>:
  {
    char * child_type;

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

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

    D.19739 = type->data.klass;
    D.19740 = &D.19739->byval_arg;
    child_type = dis_stringify_type (m, D.19740, is_def);
    bare = monoeg_g_strdup_printf ("%s[]", child_type);
    monoeg_g_free (child_type);
    goto <D.18589>;
  }
  <D.18598>:
  D.19741 = type->data.array;
  bare = dis_stringify_array (m, D.19741, is_def);
  goto <D.18589>;
  <D.18599>:
  bare = monoeg_strdup ("void");
  goto <D.18589>;
  <D.18600>:
  if (is_def != 0) goto <D.19744>; else goto <D.19742>;
  <D.19744>:
  D.19745 = type->data.generic_param;
  D.19746 = cant_print_generic_param_name (D.19745);
  if (D.19746 == 0) goto <D.19747>; else goto <D.19742>;
  <D.19747>:
  D.19745 = type->data.generic_param;
  D.19749 = D.19745->owner;
  if (D.19749 != 0B) goto <D.19750>; else goto <D.19751>;
  <D.19750>:
  D.19745 = type->data.generic_param;
  iftmp.62 = &MEM[(struct MonoGenericParamFull *)D.19745].info;
  goto <D.19752>;
  <D.19751>:
  iftmp.62 = 0B;
  <D.19752>:
  D.19753 = iftmp.62->name;
  D.19754 = get_escaped_name (D.19753);
  bare = monoeg_g_strdup_printf ("!!%s", D.19754);
  goto <D.19743>;
  <D.19742>:
  D.19745 = type->data.generic_param;
  D.19755 = D.19745->num;
  D.19756 = (int) D.19755;
  bare = monoeg_g_strdup_printf ("!!%d", D.19756);
  <D.19743>:
  goto <D.18589>;
  <D.18601>:
  if (is_def != 0) goto <D.19759>; else goto <D.19757>;
  <D.19759>:
  D.19745 = type->data.generic_param;
  D.19760 = cant_print_generic_param_name (D.19745);
  if (D.19760 == 0) goto <D.19761>; else goto <D.19757>;
  <D.19761>:
  D.19745 = type->data.generic_param;
  D.19749 = D.19745->owner;
  if (D.19749 != 0B) goto <D.19763>; else goto <D.19764>;
  <D.19763>:
  D.19745 = type->data.generic_param;
  iftmp.63 = &MEM[(struct MonoGenericParamFull *)D.19745].info;
  goto <D.19765>;
  <D.19764>:
  iftmp.63 = 0B;
  <D.19765>:
  D.19766 = iftmp.63->name;
  D.19767 = get_escaped_name (D.19766);
  bare = monoeg_g_strdup_printf ("!%s", D.19767);
  goto <D.19758>;
  <D.19757>:
  D.19745 = type->data.generic_param;
  D.19755 = D.19745->num;
  D.19756 = (int) D.19755;
  bare = monoeg_g_strdup_printf ("!%d", D.19756);
  <D.19758>:
  goto <D.18589>;
  <D.18602>:
  {
    struct GString * str;
    struct MonoGenericInst * inst;
    int i;
    char * generic_type;

    str = monoeg_g_string_new ("");
    D.19768 = type->data.generic_class;
    D.19769 = D.19768->container_class;
    D.19770 = &D.19769->byval_arg;
    generic_type = dis_stringify_type (m, D.19770, is_def);
    D.19768 = type->data.generic_class;
    inst = D.19768->context.class_inst;
    i = 0;
    goto <D.18609>;
    <D.18608>:
    {
      char * t;

      D.19771 = inst->type_argv[i];
      t = dis_stringify_type (m, D.19771, is_def);
      monoeg_g_string_append (str, t);
      D.19772 = i + 1;
      D.19773 = inst->type_argc;
      D.19774 = (int) D.19773;
      if (D.19772 != D.19774) goto <D.19775>; else goto <D.19776>;
      <D.19775>:
      monoeg_g_string_append (str, ", ");
      <D.19776>:
      monoeg_g_free (t);
    }
    i = i + 1;
    <D.18609>:
    D.19773 = inst->type_argc;
    D.19774 = (int) D.19773;
    if (D.19774 > i) goto <D.18608>; else goto <D.18610>;
    <D.18610>:
    D.19777 = str->str;
    bare = monoeg_g_strdup_printf ("%s<%s>", generic_type, D.19777);
    monoeg_g_string_free (str, 1);
    goto <D.18589>;
  }
  <D.18611>:
  D.19733 = type->type;
  D.19734 = (int) D.19733;
  monoeg_g_log (0B, 4, "Do not know how to stringify type 0x%x", D.19734);
  <D.18612>:
  goto <D.18612>;
  <D.18589>:
  D.19726 = BIT_FIELD_REF <*type, 8, 56>;
  D.19778 = D.19726 & 128;
  if (D.19778 != 0) goto <D.19779>; else goto <D.19780>;
  <D.19779>:
  pinned = " pinned";
  <D.19780>:
  D.19726 = BIT_FIELD_REF <*type, 8, 56>;
  D.19781 = D.19726 & 64;
  if (D.19781 != 0) goto <D.19782>; else goto <D.19783>;
  <D.19782>:
  byref = "&";
  <D.19783>:
  if (bare == 0B) goto <D.19784>; else goto <D.19785>;
  <D.19784>:
  D.19786 = bare;
  return D.19786;
  <D.19785>:
  if (mods != 0B) goto <D.19788>; else goto <D.19789>;
  <D.19788>:
  iftmp.64 = mods;
  goto <D.19790>;
  <D.19789>:
  iftmp.64 = "";
  <D.19790>:
  result = monoeg_g_strconcat (bare, byref, pinned, iftmp.64, 0B);
  monoeg_g_free (bare);
  D.19786 = result;
  return D.19786;
}


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

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


cant_print_generic_param_name (struct MonoGenericParam * gparam)
{
  _Bool D.19794;
  long int D.19795;
  long int D.19796;
  gboolean D.19799;
  int iftmp.65;
  struct GHashTable * mono_generic_params_with_ambiguous_names.66;
  void * D.19807;
  struct MonoGenericContainer * container;

  D.19794 = gparam == 0B;
  D.19795 = (long int) D.19794;
  D.19796 = __builtin_expect (D.19795, 0);
  if (D.19796 != 0) goto <D.19797>; else goto <D.19798>;
  <D.19797>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "get.c", 3166, "gparam");
  <D.19798>:
  container = gparam->owner;
  check_ambiguous_genparams (container);
  if (container == 0B) goto <D.19801>; else goto <D.19804>;
  <D.19804>:
  mono_generic_params_with_ambiguous_names.66 = mono_generic_params_with_ambiguous_names;
  if (mono_generic_params_with_ambiguous_names.66 != 0B) goto <D.19806>; else goto <D.19802>;
  <D.19806>:
  mono_generic_params_with_ambiguous_names.66 = mono_generic_params_with_ambiguous_names;
  D.19807 = monoeg_g_hash_table_lookup (mono_generic_params_with_ambiguous_names.66, gparam);
  if (D.19807 != 0B) goto <D.19801>; else goto <D.19802>;
  <D.19801>:
  iftmp.65 = 1;
  goto <D.19803>;
  <D.19802>:
  iftmp.65 = 0;
  <D.19803>:
  D.19799 = iftmp.65;
  return D.19799;
}


check_ambiguous_genparams (struct MonoGenericContainer * container)
{
  struct GHashTable * generic_containers.67;
  void * D.19814;
  struct MonoGenericParamFull * D.19817;
  unsigned int i.68;
  unsigned int D.19819;
  struct MonoGenericParamInfo * iftmp.69;
  struct MonoGenericContainer * D.19821;
  const char * D.19825;
  int D.19828;
  void * D.19829;
  struct GSList * D.19830;
  struct MonoGenericParamInfo * iftmp.70;
  const char * D.19836;
  <unnamed-signed:31> D.19837;
  int D.19838;
  struct GHashTable * mono_generic_params_with_ambiguous_names.71;
  struct GHashTable * mono_generic_params_with_ambiguous_names.72;
  void * D.19845;
  sizetype param.73;
  sizetype D.19847;
  sizetype D.19848;
  struct MonoGenericParamFull * D.19849;
  struct GHashTable * generic_containers.74;
  struct GSList * dup_list;
  struct GSList * l;
  struct GHashTable * table;
  void * * p;
  int i;

  dup_list = 0B;
  table = 0B;
  if (container == 0B) goto <D.19809>; else goto <D.19810>;
  <D.19809>:
  return;
  <D.19810>:
  generic_containers.67 = generic_containers;
  if (generic_containers.67 != 0B) goto <D.19812>; else goto <D.19813>;
  <D.19812>:
  generic_containers.67 = generic_containers;
  D.19814 = monoeg_g_hash_table_lookup (generic_containers.67, container);
  if (D.19814 != 0B) goto <D.19815>; else goto <D.19816>;
  <D.19815>:
  return;
  <D.19816>:
  <D.19813>:
  table = monoeg_g_hash_table_new (monoeg_g_str_hash, monoeg_g_str_equal);
  i = 0;
  goto <D.19105>;
  <D.19104>:
  {
    struct MonoGenericParam * param;

    D.19817 = container->type_params;
    i.68 = (unsigned int) i;
    D.19819 = i.68 * 32;
    param = D.19817 + D.19819;
    D.19821 = param->owner;
    if (D.19821 != 0B) goto <D.19822>; else goto <D.19823>;
    <D.19822>:
    iftmp.69 = &MEM[(struct MonoGenericParamFull *)param].info;
    goto <D.19824>;
    <D.19823>:
    iftmp.69 = 0B;
    <D.19824>:
    D.19825 = iftmp.69->name;
    p = monoeg_g_hash_table_lookup (table, D.19825);
    if (p != 0B) goto <D.19826>; else goto <D.19827>;
    <D.19826>:
    D.19828 = i + 1;
    D.19829 = (void *) D.19828;
    D.19830 = monoeg_g_slist_prepend (dup_list, D.19829);
    dup_list = monoeg_g_slist_prepend (D.19830, p);
    goto <D.19831>;
    <D.19827>:
    D.19828 = i + 1;
    D.19829 = (void *) D.19828;
    D.19821 = param->owner;
    if (D.19821 != 0B) goto <D.19833>; else goto <D.19834>;
    <D.19833>:
    iftmp.70 = &MEM[(struct MonoGenericParamFull *)param].info;
    goto <D.19835>;
    <D.19834>:
    iftmp.70 = 0B;
    <D.19835>:
    D.19836 = iftmp.70->name;
    monoeg_g_hash_table_insert_replace (table, D.19836, D.19829, 0);
    <D.19831>:
  }
  i = i + 1;
  <D.19105>:
  D.19837 = container->type_argc;
  D.19838 = (int) D.19837;
  if (D.19838 > i) goto <D.19104>; else goto <D.19106>;
  <D.19106>:
  if (dup_list != 0B) goto <D.19839>; else goto <D.19840>;
  <D.19839>:
  mono_generic_params_with_ambiguous_names.71 = mono_generic_params_with_ambiguous_names;
  if (mono_generic_params_with_ambiguous_names.71 == 0B) goto <D.19842>; else goto <D.19843>;
  <D.19842>:
  mono_generic_params_with_ambiguous_names.72 = monoeg_g_hash_table_new (0B, 0B);
  mono_generic_params_with_ambiguous_names = mono_generic_params_with_ambiguous_names.72;
  <D.19843>:
  l = dup_list;
  goto <D.19109>;
  <D.19108>:
  {
    int param;

    D.19845 = l->data;
    param = (int) D.19845;
    D.19817 = container->type_params;
    param.73 = (sizetype) param;
    D.19847 = param.73 + 134217727;
    D.19848 = D.19847 * 32;
    D.19849 = D.19817 + D.19848;
    D.19817 = container->type_params;
    param.73 = (sizetype) param;
    D.19847 = param.73 + 134217727;
    D.19848 = D.19847 * 32;
    D.19849 = D.19817 + D.19848;
    mono_generic_params_with_ambiguous_names.71 = mono_generic_params_with_ambiguous_names;
    monoeg_g_hash_table_insert_replace (mono_generic_params_with_ambiguous_names.71, D.19849, D.19849, 0);
  }
  l = l->next;
  <D.19109>:
  if (l != 0B) goto <D.19108>; else goto <D.19110>;
  <D.19110>:
  monoeg_g_slist_free (dup_list);
  <D.19840>:
  generic_containers.67 = generic_containers;
  if (generic_containers.67 == 0B) goto <D.19850>; else goto <D.19851>;
  <D.19850>:
  generic_containers.74 = monoeg_g_hash_table_new (0B, 0B);
  generic_containers = generic_containers.74;
  <D.19851>:
  generic_containers.67 = generic_containers;
  monoeg_g_hash_table_insert_replace (generic_containers.67, 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.75;
  char D.19855;
  const char * ptr.76;
  int show_tokens.77;
  gchar * D.19865;
  const char * ptr.78;
  char * temp.79;
  unsigned int D.19869;
  const char * ptr.80;
  char * D.19873;
  char * D.19876;
  gchar * D.19883;
  const char * D.19884;
  const char * start;
  guint32 type;
  struct MonoType * t;

  start = ptr;
  ptr.75 = ptr;
  D.19855 = *ptr.75;
  if (D.19855 == 16) goto <D.19856>; else goto <D.19857>;
  <D.19856>:
  ptr.75 = ptr;
  ptr.76 = ptr.75 + 1;
  ptr = ptr.76;
  <D.19857>:
  ptr.75 = ptr;
  type = mono_metadata_decode_value (ptr.75, &ptr);
  switch (type) <default: <D.18637>, case 17: <D.18623>, case 18: <D.18624>, case 21: <D.18629>>
  <D.18623>:
  <D.18624>:
  {
    guint32 token;
    struct MonoClass * klass;
    char * temp;

    ptr.75 = ptr;
    token = mono_metadata_parse_typedef_or_ref (m, ptr.75, &ptr);
    klass = mono_class_get (m, token);
    if (klass != 0B) goto <D.19859>; else goto <D.19860>;
    <D.19859>:
    temp = dis_stringify_object_with_class (m, klass, 1, 0);
    goto <D.19861>;
    <D.19860>:
    temp = monoeg_g_strdup_printf ("<BROKEN CLASS token_%8x>", token);
    <D.19861>:
    show_tokens.77 = show_tokens;
    if (show_tokens.77 != 0) goto <D.19863>; else goto <D.19864>;
    <D.19863>:
    D.19865 = monoeg_g_strdup_printf ("%s/*%08x*/", temp, token);
    *result = D.19865;
    monoeg_g_free (temp);
    goto <D.19866>;
    <D.19864>:
    *result = temp;
    <D.19866>:
    goto <D.18628>;
  }
  <D.18629>:
  {
    struct GString * str;
    int count;
    int i;
    char * temp;

    try
      {
        str = monoeg_g_string_new ("");
        ptr.75 = ptr;
        ptr.78 = get_type (m, ptr.75, &temp, is_def, container);
        ptr = ptr.78;
        temp.79 = temp;
        monoeg_g_string_append (str, temp.79);
        temp.79 = temp;
        monoeg_g_free (temp.79);
        ptr.75 = ptr;
        D.19869 = mono_metadata_decode_value (ptr.75, &ptr);
        count = (int) D.19869;
        monoeg_g_string_append (str, "<");
        i = 0;
        goto <D.18635>;
        <D.18634>:
        if (i != 0) goto <D.19870>; else goto <D.19871>;
        <D.19870>:
        monoeg_g_string_append (str, ",");
        <D.19871>:
        ptr.75 = ptr;
        ptr.80 = get_type (m, ptr.75, &temp, is_def, container);
        ptr = ptr.80;
        temp.79 = temp;
        monoeg_g_string_append (str, temp.79);
        i = i + 1;
        <D.18635>:
        if (i < count) goto <D.18634>; else goto <D.18636>;
        <D.18636>:
        monoeg_g_string_append (str, ">");
        D.19873 = str->str;
        *result = D.19873;
        monoeg_g_string_free (str, 0);
        goto <D.18628>;
      }
    finally
      {
        temp = {CLOBBER};
      }
  }
  <D.18637>:
  t = mono_metadata_parse_type_full (m, container, 0, 0, start, &ptr);
  if (t != 0B) goto <D.19874>; else goto <D.19875>;
  <D.19874>:
  D.19876 = dis_stringify_type (m, t, is_def);
  *result = D.19876;
  goto <D.19877>;
  <D.19875>:
  {
    struct GString * err;

    err = monoeg_g_string_new ("@!#$<InvalidType>$#!@");
    if (container != 0B) goto <D.19878>; else goto <D.19879>;
    <D.19878>:
    t = mono_metadata_parse_type_full (m, 0B, 0, 0, start, &ptr);
    <D.19879>:
    if (t != 0B) goto <D.19880>; else goto <D.19881>;
    <D.19880>:
    {
      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.19882>;
    <D.19881>:
    monoeg_g_log (0B, 16, "Encountered an invalid type");
    <D.19882>:
    D.19883 = monoeg_g_string_free (err, 0);
    *result = D.19883;
  }
  <D.19877>:
  goto <D.18628>;
  <D.18628>:
  D.19884 = ptr;
  return D.19884;
}


get_field_signature (struct MonoImage * m, guint32 blob_signature, struct MonoGenericContainer * container)
{
  const char * ptr.81;
  const char * ptr.82;
  unsigned int D.19889;
  char D.19890;
  _Bool D.19891;
  long int D.19892;
  long int D.19893;
  const char * ptr.83;
  const char * ptr.84;
  const char * ptr.85;
  const char * iftmp.86;
  char * allocated_modifier_string.87;
  char * allocated_type_string.88;
  char * D.19909;
  char * allocated_modifier_string;
  char * allocated_type_string;
  const char * ptr;
  const char * base;
  char * res;
  int len;

  try
    {
      ptr.81 = mono_metadata_blob_heap (m, blob_signature);
      ptr = ptr.81;
      ptr.82 = ptr;
      D.19889 = mono_metadata_decode_value (ptr.82, &ptr);
      len = (int) D.19889;
      base = ptr;
      ptr.82 = ptr;
      D.19890 = *ptr.82;
      D.19891 = D.19890 != 6;
      D.19892 = (long int) D.19891;
      D.19893 = __builtin_expect (D.19892, 0);
      if (D.19893 != 0) goto <D.19894>; else goto <D.19895>;
      <D.19894>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "get.c", 1361, "*ptr == 0x06");
      <D.19895>:
      ptr.82 = ptr;
      ptr.83 = ptr.82 + 1;
      ptr = ptr.83;
      len = len + -1;
      ptr.82 = ptr;
      ptr.84 = get_custom_mod (m, ptr.82, &allocated_modifier_string);
      ptr = ptr.84;
      ptr.82 = ptr;
      ptr.85 = get_type (m, ptr.82, &allocated_type_string, 0, container);
      ptr = ptr.85;
      allocated_modifier_string.87 = allocated_modifier_string;
      if (allocated_modifier_string.87 != 0B) goto <D.19901>; else goto <D.19902>;
      <D.19901>:
      iftmp.86 = allocated_modifier_string;
      goto <D.19903>;
      <D.19902>:
      iftmp.86 = "";
      <D.19903>:
      allocated_type_string.88 = allocated_type_string;
      res = monoeg_g_strdup_printf ("%s%s", allocated_type_string.88, iftmp.86);
      allocated_modifier_string.87 = allocated_modifier_string;
      if (allocated_modifier_string.87 != 0B) goto <D.19905>; else goto <D.19906>;
      <D.19905>:
      allocated_modifier_string.87 = allocated_modifier_string;
      monoeg_g_free (allocated_modifier_string.87);
      <D.19906>:
      allocated_type_string.88 = allocated_type_string;
      if (allocated_type_string.88 != 0B) goto <D.19907>; else goto <D.19908>;
      <D.19907>:
      allocated_type_string.88 = allocated_type_string;
      monoeg_g_free (allocated_type_string.88);
      <D.19908>:
      D.19909 = res;
      return D.19909;
    }
  finally
    {
      allocated_modifier_string = {CLOBBER};
      allocated_type_string = {CLOBBER};
      ptr = {CLOBBER};
    }
}


get_field_literal_type (struct MonoImage * m, guint32 blob_signature)
{
  const char * ptr.89;
  const char * ptr.90;
  unsigned int D.19914;
  char D.19915;
  _Bool D.19916;
  long int D.19917;
  long int D.19918;
  const char * ptr.91;
  const char * ptr.92;
  char * allocated_modifier_string.93;
  MonoTypeEnum D.19926;
  const char * ptr;
  int len;
  char * allocated_modifier_string;

  try
    {
      ptr.89 = mono_metadata_blob_heap (m, blob_signature);
      ptr = ptr.89;
      ptr.90 = ptr;
      D.19914 = mono_metadata_decode_value (ptr.90, &ptr);
      len = (int) D.19914;
      ptr.90 = ptr;
      D.19915 = *ptr.90;
      D.19916 = D.19915 != 6;
      D.19917 = (long int) D.19916;
      D.19918 = __builtin_expect (D.19917, 0);
      if (D.19918 != 0) goto <D.19919>; else goto <D.19920>;
      <D.19919>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "get.c", 1391, "*ptr == 0x06");
      <D.19920>:
      ptr.90 = ptr;
      ptr.91 = ptr.90 + 1;
      ptr = ptr.91;
      len = len + -1;
      ptr.90 = ptr;
      ptr.92 = get_custom_mod (m, ptr.90, &allocated_modifier_string);
      ptr = ptr.92;
      allocated_modifier_string.93 = allocated_modifier_string;
      if (allocated_modifier_string.93 != 0B) goto <D.19924>; else goto <D.19925>;
      <D.19924>:
      allocated_modifier_string.93 = allocated_modifier_string;
      monoeg_g_free (allocated_modifier_string.93);
      <D.19925>:
      ptr.90 = ptr;
      D.19915 = *ptr.90;
      D.19926 = (MonoTypeEnum) D.19915;
      return D.19926;
    }
  finally
    {
      ptr = {CLOBBER};
      allocated_modifier_string = {CLOBBER};
    }
}


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

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


get_ret_type (struct MonoImage * m, const char * ptr, char * * ret_type, struct MonoGenericContainer * container)
{
  char D.19931;
  char * allocated_type_string.94;
  char * mod.95;
  char * D.19946;
  const char * D.19947;
  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.19931 = *ptr;
      if (D.19931 == 22) goto <D.19932>; else goto <D.19933>;
      <D.19932>:
      monoeg_g_string_append (str, "typedref");
      ptr = ptr + 1;
      goto <D.19934>;
      <D.19933>:
      D.19931 = *ptr;
      if (D.19931 == 1) goto <D.19935>; else goto <D.19936>;
      <D.19935>:
      monoeg_g_string_append (str, "void");
      ptr = ptr + 1;
      goto <D.19937>;
      <D.19936>:
      D.19931 = *ptr;
      if (D.19931 == 16) goto <D.19938>; else goto <D.19939>;
      <D.19938>:
      has_byref = 1;
      ptr = ptr + 1;
      <D.19939>:
      ptr = get_type (m, ptr, &allocated_type_string, 0, container);
      allocated_type_string.94 = allocated_type_string;
      monoeg_g_string_append (str, allocated_type_string.94);
      if (has_byref != 0) goto <D.19941>; else goto <D.19942>;
      <D.19941>:
      monoeg_g_string_append (str, "& ");
      <D.19942>:
      allocated_type_string.94 = allocated_type_string;
      monoeg_g_free (allocated_type_string.94);
      <D.19937>:
      <D.19934>:
      mod.95 = mod;
      if (mod.95 != 0B) goto <D.19944>; else goto <D.19945>;
      <D.19944>:
      mod.95 = mod;
      monoeg_g_string_append (str, mod.95);
      monoeg_g_string_append_c (str, 32);
      mod.95 = mod;
      monoeg_g_free (mod.95);
      <D.19945>:
      D.19946 = str->str;
      *ret_type = D.19946;
      monoeg_g_string_free (str, 0);
      D.19947 = ptr;
      return D.19947;
    }
  finally
    {
      mod = {CLOBBER};
      allocated_type_string = {CLOBBER};
    }
}


get_param (struct MonoImage * m, const char * ptr, char * * retval, struct MonoGenericContainer * container)
{
  char D.19950;
  char * allocated_type_string.96;
  char * allocated_mod_string.97;
  char * D.19962;
  const char * D.19963;
  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.19950 = *ptr;
      if (D.19950 == 22) goto <D.19951>; else goto <D.19952>;
      <D.19951>:
      monoeg_g_string_append (str, " typedref ");
      ptr = ptr + 1;
      goto <D.19953>;
      <D.19952>:
      {
        gboolean by_ref;

        by_ref = 0;
        D.19950 = *ptr;
        if (D.19950 == 16) goto <D.19954>; else goto <D.19955>;
        <D.19954>:
        monoeg_g_string_append (str, "[out] ");
        ptr = ptr + 1;
        by_ref = 1;
        <D.19955>:
        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 (by_ref != 0) goto <D.19957>; else goto <D.19958>;
        <D.19957>:
        monoeg_g_string_append_c (str, 38);
        <D.19958>:
        allocated_type_string.96 = allocated_type_string;
        monoeg_g_free (allocated_type_string.96);
      }
      <D.19953>:
      allocated_mod_string.97 = allocated_mod_string;
      if (allocated_mod_string.97 != 0B) goto <D.19960>; else goto <D.19961>;
      <D.19960>:
      allocated_mod_string.97 = allocated_mod_string;
      monoeg_g_string_append (str, allocated_mod_string.97);
      monoeg_g_string_append_c (str, 32);
      allocated_mod_string.97 = allocated_mod_string;
      monoeg_g_free (allocated_mod_string.97);
      <D.19961>:
      D.19962 = str->str;
      *retval = D.19962;
      monoeg_g_string_free (str, 0);
      D.19963 = ptr;
      return D.19963;
    }
  finally
    {
      allocated_mod_string = {CLOBBER};
      allocated_type_string = {CLOBBER};
    }
}


get_escaped_name (const char * name)
{
  char * D.19968;
  struct GHashTable * key_table.98;
  _Bool D.19970;
  long int D.19971;
  long int D.19972;
  char D.19975;
  char D.19978;
  int s.99;
  int name.100;
  int D.19983;
  unsigned int D.19984;
  const char * D.19985;
  char * D.19986;
  char * D.19987;
  const short unsigned int * * D.19991;
  const short unsigned int * D.19992;
  unsigned int D.19993;
  unsigned int D.19994;
  const short unsigned int * D.19995;
  short unsigned int D.19996;
  int D.19997;
  int D.19998;
  void * D.20007;
  const char * s;
  char * ret;
  char * esc;

  if (name == 0B) goto <D.19966>; else goto <D.19967>;
  <D.19966>:
  D.19968 = 0B;
  return D.19968;
  <D.19967>:
  key_table.98 = key_table;
  D.19970 = key_table.98 == 0B;
  D.19971 = (long int) D.19970;
  D.19972 = __builtin_expect (D.19971, 0);
  if (D.19972 != 0) goto <D.19973>; else goto <D.19974>;
  <D.19973>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "get.c", 1557, "key_table");
  <D.19974>:
  D.19975 = *name;
  if (D.19975 == 0) goto <D.19976>; else goto <D.19977>;
  <D.19976>:
  D.19968 = monoeg_strdup (name);
  return D.19968;
  <D.19977>:
  s = name;
  goto <D.18703>;
  <D.18702>:
  {
    char * first;
    char * result;

    D.19978 = *s;
    if (D.19978 != 47) goto <D.19979>; else goto <D.19980>;
    <D.19979>:
    // predicted unlikely by continue predictor.
    goto <D.18701>;
    <D.19980>:
    s.99 = (int) s;
    name.100 = (int) name;
    D.19983 = s.99 - name.100;
    D.19984 = (unsigned int) D.19983;
    first = monoeg_g_strndup (name, D.19984);
    D.19985 = s + 1;
    D.19986 = get_escaped_name (D.19985);
    D.19987 = get_escaped_name (first);
    result = monoeg_g_strdup_printf ("%s/%s", D.19987, D.19986);
    monoeg_g_free (first);
    D.19968 = result;
    return D.19968;
  }
  <D.18701>:
  s = s + 1;
  <D.18703>:
  D.19978 = *s;
  if (D.19978 != 0) goto <D.18702>; else goto <D.18704>;
  <D.18704>:
  s = name;
  goto <D.18707>;
  <D.18706>:
  D.19991 = __ctype_b_loc ();
  D.19992 = *D.19991;
  D.19978 = *s;
  D.19993 = (unsigned int) D.19978;
  D.19994 = D.19993 * 2;
  D.19995 = D.19992 + D.19994;
  D.19996 = *D.19995;
  D.19997 = (int) D.19996;
  D.19998 = D.19997 & 8;
  if (D.19998 != 0) goto <D.19988>; else goto <D.19999>;
  <D.19999>:
  D.19978 = *s;
  if (D.19978 == 95) goto <D.19988>; else goto <D.20000>;
  <D.20000>:
  D.19978 = *s;
  if (D.19978 == 36) goto <D.19988>; else goto <D.20001>;
  <D.20001>:
  D.19978 = *s;
  if (D.19978 == 64) goto <D.19988>; else goto <D.20002>;
  <D.20002>:
  D.19978 = *s;
  if (D.19978 == 63) goto <D.19988>; else goto <D.20003>;
  <D.20003>:
  D.19978 = *s;
  if (D.19978 == 46) goto <D.20004>; else goto <D.19989>;
  <D.20004>:
  if (s != name) goto <D.19988>; else goto <D.19989>;
  <D.19989>:
  D.19978 = *s;
  if (D.19978 == 0) goto <D.19988>; else goto <D.20005>;
  <D.20005>:
  D.19978 = *s;
  if (D.19978 == 33) goto <D.19988>; else goto <D.20006>;
  <D.20006>:
  D.19978 = *s;
  if (D.19978 == 96) goto <D.19988>; else goto <D.19990>;
  <D.19988>:
  // predicted unlikely by continue predictor.
  goto <D.18705>;
  <D.19990>:
  esc = str_escape (name, "\'\\");
  ret = monoeg_g_strdup_printf ("\'%s\'", esc);
  monoeg_g_free (esc);
  D.19968 = ret;
  return D.19968;
  <D.18705>:
  s = s + 1;
  <D.18707>:
  D.19978 = *s;
  if (D.19978 != 0) goto <D.18706>; else goto <D.18708>;
  <D.18708>:
  key_table.98 = key_table;
  D.20007 = monoeg_g_hash_table_lookup (key_table.98, name);
  if (D.20007 != 0B) goto <D.20008>; else goto <D.20009>;
  <D.20008>:
  D.19968 = monoeg_g_strdup_printf ("\'%s\'", name);
  return D.19968;
  <D.20009>:
  D.19968 = str_escape (name, "\'\\");
  return D.19968;
}


str_escape (const char * str, const char * list)
{
  unsigned int D.20011;
  char D.20012;
  int D.20015;
  int D.20016;
  void * D.20019;
  char * D.20020;
  int p.101;
  int str.102;
  int D.20023;
  char * D.20025;
  const char * p;
  struct GString * res;

  p = str;
  D.20011 = strlen (str);
  res = monoeg_g_string_sized_new (D.20011);
  <D.18692>:
  goto <D.18689>;
  <D.18688>:
  p = p + 1;
  <D.18689>:
  D.20012 = *p;
  if (D.20012 != 0) goto <D.20013>; else goto <D.18690>;
  <D.20013>:
  D.20012 = *p;
  D.20015 = (int) D.20012;
  D.20016 = __builtin_constant_p (D.20015);
  if (D.20016 != 0) goto <D.20017>; else goto <D.20014>;
  <D.20017>:
  D.20012 = *p;
  if (D.20012 == 0) goto <D.20018>; else goto <D.20014>;
  <D.20018>:
  D.20012 = *p;
  D.20015 = (int) D.20012;
  D.20019 = __rawmemchr (list, D.20015);
  if (D.20019 == 0B) goto <D.18688>; else goto <D.18690>;
  <D.20014>:
  D.20012 = *p;
  D.20015 = (int) D.20012;
  D.20020 = __builtin_strchr (list, D.20015);
  if (D.20020 == 0B) goto <D.18688>; else goto <D.18690>;
  <D.18690>:
  p.101 = (int) p;
  str.102 = (int) str;
  D.20023 = p.101 - str.102;
  monoeg_g_string_append_len (res, str, D.20023);
  D.20012 = *p;
  if (D.20012 == 0) goto <D.18691>; else goto <D.20024>;
  <D.20024>:
  monoeg_g_string_append_c (res, 92);
  str = p;
  p = p + 1;
  goto <D.18692>;
  <D.18691>:
  D.20025 = monoeg_g_string_free (res, 0);
  return D.20025;
}


param_flags (guint32 f)
{
  char * D.20027;
  const char * D.20028;

  D.20028 = flags (f, &param_map);
  D.20027 = monoeg_strdup (D.20028);
  return D.20027;
}


field_flags (guint32 f)
{
  int f.103;
  int D.20031;
  unsigned int D.20032;
  unsigned int D.20033;
  unsigned int access.104;
  const char * D.20035;
  unsigned int rest.105;
  const char * D.20037;
  char * D.20038;
  char buffer[1024];
  int access;
  int rest;

  try
    {
      f.103 = (int) f;
      access = f.103 & 7;
      D.20031 = ~access;
      D.20032 = (unsigned int) D.20031;
      D.20033 = D.20032 & f;
      rest = (int) D.20033;
      buffer[0] = 0;
      access.104 = (unsigned int) access;
      D.20035 = map (access.104, &field_access_map);
      strcat (&buffer, D.20035);
      rest.105 = (unsigned int) rest;
      D.20037 = flags (rest.105, &field_flags_map);
      strcat (&buffer, D.20037);
      D.20038 = monoeg_strdup (&buffer);
      return D.20038;
    }
  finally
    {
      buffer = {CLOBBER};
    }
}


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

  D.20042 = __builtin_object_size (__dest, 1);
  D.20041 = __builtin___strcat_chk (__dest, __src, D.20042);
  return D.20041;
}


get_methodref_signature (struct MonoImage * m, guint32 blob_signature, const char * fancy_name)
{
  const char * ptr.106;
  const char * ptr.107;
  unsigned int D.20046;
  char D.20047;
  int D.20048;
  int D.20049;
  int D.20052;
  int D.20056;
  unsigned int cconv.108;
  int D.18745;
  int iftmp.109;
  int D.18744;
  const char[8] * D.20063;
  unsigned char D.20064;
  int D.20065;
  unsigned char D.20066;
  int D.20067;
  _Bool D.20068;
  _Bool D.20069;
  _Bool D.20070;
  const unsigned char * D.20073;
  unsigned char D.20074;
  int D.20075;
  const unsigned char * D.20076;
  unsigned char D.20077;
  int D.20078;
  _Bool D.20079;
  _Bool D.20080;
  const unsigned char * D.20083;
  unsigned char D.20084;
  int D.20085;
  const unsigned char * D.20086;
  unsigned char D.20087;
  int D.20088;
  _Bool D.20089;
  _Bool D.20090;
  const unsigned char * D.20093;
  unsigned char D.20094;
  int D.20095;
  const unsigned char * D.20096;
  unsigned char D.20097;
  int D.20098;
  const char * ptr.110;
  unsigned int D.20105;
  unsigned int D.20106;
  const char * ptr.111;
  char * allocated_ret_type.112;
  const char * ptr.113;
  char * param.114;
  int D.20119;
  char * D.20122;
  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.106 = mono_metadata_blob_heap (m, blob_signature);
      ptr = ptr.106;
      seen_vararg = 0;
      gen_count = 0;
      ptr.107 = ptr;
      D.20046 = mono_metadata_decode_value (ptr.107, &ptr);
      signature_len = (int) D.20046;
      ptr.107 = ptr;
      D.20047 = *ptr.107;
      D.20048 = (int) D.20047;
      D.20049 = D.20048 & 32;
      if (D.20049 != 0) goto <D.20050>; else goto <D.20051>;
      <D.20050>:
      ptr.107 = ptr;
      D.20047 = *ptr.107;
      D.20048 = (int) D.20047;
      D.20052 = D.20048 & 64;
      if (D.20052 != 0) goto <D.20053>; else goto <D.20054>;
      <D.20053>:
      monoeg_g_string_append (res, "explicit-this ");
      goto <D.20055>;
      <D.20054>:
      monoeg_g_string_append (res, "instance ");
      <D.20055>:
      <D.20051>:
      ptr.107 = ptr;
      D.20047 = *ptr.107;
      D.20048 = (int) D.20047;
      D.20056 = D.20048 & 16;
      if (D.20056 != 0) goto <D.20057>; else goto <D.20058>;
      <D.20057>:
      gen_count = 1;
      <D.20058>:
      ptr.107 = ptr;
      D.20047 = *ptr.107;
      D.20048 = (int) D.20047;
      cconv = D.20048 & 15;
      cconv.108 = (unsigned int) cconv;
      cconv_str = map (cconv.108, &call_conv_type_map);
      {
        size_t __s1_len;
        size_t __s2_len;

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

          __s2 = cconv_str;
          D.20063 = "default";
          D.20064 = MEM[(const unsigned char *)D.20063];
          D.20065 = (int) D.20064;
          D.20066 = *__s2;
          D.20067 = (int) D.20066;
          __result = D.20065 - D.20067;
          {
            D.20068 = __s2_len != 0;
            D.20069 = __result == 0;
            D.20070 = D.20068 & D.20069;
            if (D.20070 != 0) goto <D.20071>; else goto <D.20072>;
            <D.20071>:
            D.20073 = &MEM[(void *)"default" + 1B];
            D.20074 = *D.20073;
            D.20075 = (int) D.20074;
            D.20076 = __s2 + 1;
            D.20077 = *D.20076;
            D.20078 = (int) D.20077;
            __result = D.20075 - D.20078;
            D.20079 = __s2_len > 1;
            D.20069 = __result == 0;
            D.20080 = D.20079 & D.20069;
            if (D.20080 != 0) goto <D.20081>; else goto <D.20082>;
            <D.20081>:
            D.20083 = &MEM[(void *)"default" + 2B];
            D.20084 = *D.20083;
            D.20085 = (int) D.20084;
            D.20086 = __s2 + 2;
            D.20087 = *D.20086;
            D.20088 = (int) D.20087;
            __result = D.20085 - D.20088;
            D.20089 = __s2_len > 2;
            D.20069 = __result == 0;
            D.20090 = D.20089 & D.20069;
            if (D.20090 != 0) goto <D.20091>; else goto <D.20092>;
            <D.20091>:
            D.20093 = &MEM[(void *)"default" + 3B];
            D.20094 = *D.20093;
            D.20095 = (int) D.20094;
            D.20096 = __s2 + 3;
            D.20097 = *D.20096;
            D.20098 = (int) D.20097;
            __result = D.20095 - D.20098;
            <D.20092>:
            <D.20082>:
            <D.20072>:
          }
          D.18744 = __result;
        }
        iftmp.109 = -D.18744;
        goto <D.20099>;
        <D.20062>:
        iftmp.109 = __builtin_strcmp (cconv_str, "default");
        <D.20099>:
        D.18745 = iftmp.109;
      }
      if (D.18745 != 0) goto <D.20100>; else goto <D.20101>;
      <D.20100>:
      monoeg_g_string_append (res, cconv_str);
      monoeg_g_string_append (res, " ");
      <D.20101>:
      ptr.107 = ptr;
      ptr.110 = ptr.107 + 1;
      ptr = ptr.110;
      if (gen_count != 0) goto <D.20103>; else goto <D.20104>;
      <D.20103>:
      ptr.107 = ptr;
      D.20105 = mono_metadata_decode_value (ptr.107, &ptr);
      gen_count = (int) D.20105;
      <D.20104>:
      ptr.107 = ptr;
      D.20106 = mono_metadata_decode_value (ptr.107, &ptr);
      param_count = (int) D.20106;
      if (cconv != 10) goto <D.20107>; else goto <D.20108>;
      <D.20107>:
      ptr.107 = ptr;
      ptr.111 = get_ret_type (m, ptr.107, &allocated_ret_type, 0B);
      ptr = ptr.111;
      allocated_ret_type.112 = allocated_ret_type;
      monoeg_g_string_append (res, allocated_ret_type.112);
      allocated_ret_type.112 = allocated_ret_type;
      monoeg_g_free (allocated_ret_type.112);
      <D.20108>:
      if (fancy_name != 0B) goto <D.20111>; else goto <D.20112>;
      <D.20111>:
      monoeg_g_string_append_c (res, 32);
      monoeg_g_string_append (res, fancy_name);
      <D.20112>:
      monoeg_g_string_append (res, "(");
      i = 0;
      goto <D.18748>;
      <D.18747>:
      {
        char * param;

        try
          {
            param = 0B;
            ptr.107 = ptr;
            D.20047 = *ptr.107;
            if (D.20047 == 65) goto <D.20113>; else goto <D.20114>;
            <D.20113>:
            if (seen_vararg == 0) goto <D.20115>; else goto <D.20116>;
            <D.20115>:
            monoeg_g_string_append (res, "..., ");
            seen_vararg = 1;
            <D.20116>:
            ptr.107 = ptr;
            ptr.110 = ptr.107 + 1;
            ptr = ptr.110;
            <D.20114>:
            ptr.107 = ptr;
            ptr.113 = get_param (m, ptr.107, &param, 0B);
            ptr = ptr.113;
            param.114 = param;
            monoeg_g_string_append (res, param.114);
            D.20119 = i + 1;
            if (D.20119 != param_count) goto <D.20120>; else goto <D.20121>;
            <D.20120>:
            monoeg_g_string_append (res, ", ");
            <D.20121>:
            param.114 = param;
            monoeg_g_free (param.114);
          }
        finally
          {
            param = {CLOBBER};
          }
      }
      i = i + 1;
      <D.18748>:
      if (i < param_count) goto <D.18747>; else goto <D.18749>;
      <D.18749>:
      monoeg_g_string_append (res, ")");
      s = res->str;
      monoeg_g_string_free (res, 0);
      D.20122 = s;
      return D.20122;
    }
  finally
    {
      ptr = {CLOBBER};
      allocated_ret_type = {CLOBBER};
    }
}


get_fieldref_signature (struct MonoImage * m, int idx, struct MonoGenericContainer * container)
{
  int D.20125;
  struct MonoTableInfo * D.20126;
  unsigned int D.20127;
  unsigned int D.20128;
  unsigned int D.20129;
  const char * D.20130;
  const char * iftmp.115;
  const char * iftmp.116;
  char * D.20139;
  guint32 cols[3];
  struct MonoGenericContainer * new_container;
  char * type;
  char * esname;
  char * sig;
  char * full_sig;

  try
    {
      D.20125 = idx + -1;
      D.20126 = &m->tables[10];
      mono_metadata_decode_row (D.20126, D.20125, &cols, 3);
      D.20127 = cols[0];
      new_container = get_memberref_container (m, D.20127, container);
      D.20128 = cols[2];
      sig = get_field_signature (m, D.20128, new_container);
      D.20127 = cols[0];
      type = get_memberref_parent (m, D.20127, container);
      D.20129 = cols[1];
      D.20130 = mono_metadata_string_heap (m, D.20129);
      esname = get_escaped_name (D.20130);
      if (type != 0B) goto <D.20132>; else goto <D.20133>;
      <D.20132>:
      iftmp.115 = "::";
      goto <D.20134>;
      <D.20133>:
      iftmp.115 = "";
      <D.20134>:
      if (type != 0B) goto <D.20136>; else goto <D.20137>;
      <D.20136>:
      iftmp.116 = type;
      goto <D.20138>;
      <D.20137>:
      iftmp.116 = "";
      <D.20138>:
      full_sig = monoeg_g_strdup_printf ("%s %s%s%s", sig, iftmp.116, iftmp.115, esname);
      monoeg_g_free (sig);
      monoeg_g_free (type);
      monoeg_g_free (esname);
      D.20139 = full_sig;
      return D.20139;
    }
  finally
    {
      cols = {CLOBBER};
    }
}


get_memberref_container (struct MonoImage * m, guint32 mrp_token, struct MonoGenericContainer * container)
{
  struct MonoGenericContainer * D.20142;
  unsigned int D.20143;
  unsigned int D.20144;
  _Bool D.20145;
  long int D.20146;
  long int D.20147;
  struct MonoGenericContainer * iftmp.117;
  struct MonoGenericClass * D.20151;
  struct MonoClass * D.20154;
  struct MonoClass * klass;
  guint32 table;
  guint32 idx;

  table = mrp_token & 7;
  idx = mrp_token >> 3;
  switch (table) <default: <D.20156>, case 0: <D.18782>, case 1: <D.18783>, case 4: <D.18784>>
  <D.18782>:
  D.20143 = idx | 33554432;
  D.20142 = mono_metadata_load_generic_params (m, D.20143, 0B);
  return D.20142;
  <D.18783>:
  D.20142 = 0B;
  return D.20142;
  <D.18784>:
  D.20144 = idx | 452984832;
  klass = mono_class_get_full (m, D.20144, container);
  D.20145 = klass == 0B;
  D.20146 = (long int) D.20145;
  D.20147 = __builtin_expect (D.20146, 0);
  if (D.20147 != 0) goto <D.20148>; else goto <D.20149>;
  <D.20148>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "get.c", 1852, "klass");
  <D.20149>:
  D.20151 = klass->generic_class;
  if (D.20151 != 0B) goto <D.20152>; else goto <D.20153>;
  <D.20152>:
  D.20151 = klass->generic_class;
  D.20154 = D.20151->container_class;
  iftmp.117 = D.20154->generic_container;
  goto <D.20155>;
  <D.20153>:
  iftmp.117 = 0B;
  <D.20155>:
  D.20142 = iftmp.117;
  return D.20142;
  <D.20156>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "get.c", 1855);
  D.20142 = 0B;
  return D.20142;
}


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

  table = mrp_token & 7;
  idx = mrp_token >> 3;
  switch (table) <default: <D.20160>, case 0: <D.18792>, case 1: <D.18793>, case 2: <D.18794>, case 3: <D.18795>, case 4: <D.18796>>
  <D.18792>:
  idx.118 = (int) idx;
  D.20158 = get_typedef (m, idx.118);
  return D.20158;
  <D.18793>:
  idx.118 = (int) idx;
  D.20158 = get_typeref (m, idx.118);
  return D.20158;
  <D.18794>:
  D.20158 = monoeg_g_strdup_printf ("TODO:MemberRefParent-ModuleRef");
  return D.20158;
  <D.18795>:
  D.20158 = monoeg_strdup ("TODO:MethodDef");
  return D.20158;
  <D.18796>:
  D.20158 = get_typespec (m, idx, 0, container);
  return D.20158;
  <D.20160>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "get.c", 1884);
  D.20158 = 0B;
  return D.20158;
}


get_field (struct MonoImage * m, guint32 token, struct MonoGenericContainer * container)
{
  int token.119;
  unsigned int D.20163;
  char * D.20166;
  _Bool D.20167;
  long int D.20168;
  long int D.20169;
  int D.20172;
  struct MonoTableInfo * D.20173;
  unsigned int D.20174;
  unsigned int idx.120;
  int type_idx.121;
  unsigned int D.20179;
  const char * D.20180;
  const char * iftmp.122;
  const char * iftmp.123;
  int idx;
  guint32 cols[3];
  char * sig;
  char * res;
  char * type;
  char * estype;
  char * esname;
  guint32 type_idx;

  try
    {
      token.119 = (int) token;
      idx = token.119 & 16777215;
      D.20163 = token & 4278190080;
      if (D.20163 == 167772160) goto <D.20164>; else goto <D.20165>;
      <D.20164>:
      D.20166 = get_fieldref_signature (m, idx, container);
      return D.20166;
      <D.20165>:
      D.20163 = token & 4278190080;
      D.20167 = D.20163 != 67108864;
      D.20168 = (long int) D.20167;
      D.20169 = __builtin_expect (D.20168, 0);
      if (D.20169 != 0) goto <D.20170>; else goto <D.20171>;
      <D.20170>:
      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.20171>:
      D.20172 = idx + -1;
      D.20173 = &m->tables[4];
      mono_metadata_decode_row (D.20173, D.20172, &cols, 3);
      D.20174 = cols[2];
      sig = get_field_signature (m, D.20174, container);
      idx.120 = (unsigned int) idx;
      type_idx = mono_metadata_typedef_from_field (m, idx.120);
      if (type_idx == 0) goto <D.20176>; else goto <D.20177>;
      <D.20176>:
      res = monoeg_g_strdup_printf ("<invalid> %s", sig);
      monoeg_g_free (sig);
      D.20166 = res;
      return D.20166;
      <D.20177>:
      type_idx.121 = (int) type_idx;
      type = get_typedef (m, type_idx.121);
      estype = get_escaped_name (type);
      D.20179 = cols[1];
      D.20180 = mono_metadata_string_heap (m, D.20179);
      esname = get_escaped_name (D.20180);
      if (estype != 0B) goto <D.20182>; else goto <D.20183>;
      <D.20182>:
      iftmp.122 = "::";
      goto <D.20184>;
      <D.20183>:
      iftmp.122 = "";
      <D.20184>:
      if (estype != 0B) goto <D.20186>; else goto <D.20187>;
      <D.20186>:
      iftmp.123 = estype;
      goto <D.20188>;
      <D.20187>:
      iftmp.123 = "";
      <D.20188>:
      res = monoeg_g_strdup_printf ("%s %s%s%s", sig, iftmp.123, iftmp.122, esname);
      monoeg_g_free (type);
      monoeg_g_free (sig);
      monoeg_g_free (estype);
      monoeg_g_free (esname);
      D.20166 = res;
      return D.20166;
    }
  finally
    {
      cols = {CLOBBER};
    }
}


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

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


get_method_core (struct MonoImage * m, guint32 token, gboolean fullsig, struct MonoGenericContainer * container)
{
  int token.124;
  struct MonoMethodSignature * D.20196;
  unsigned char D.20197;
  unsigned char D.20198;
  struct MonoMethod * D.20201;
  const char * D.20202;
  struct MonoClass * D.20203;
  struct MonoType * D.20204;
  int show_tokens.125;
  const char * iftmp.126;
  const char * iftmp.127;
  const char * iftmp.128;
  const char * iftmp.129;
  unsigned int D.20226;
  int D.20227;
  struct MonoTableInfo * D.20228;
  unsigned int D.20229;
  struct MonoTableInfo * D.20230;
  unsigned int D.20233;
  unsigned int D.20234;
  const char * D.20235;
  const char * iftmp.130;
  const char * iftmp.131;
  unsigned char D.20246;
  unsigned char D.20247;
  struct MonoGenericContainer * D.20250;
  <unnamed-signed:31> D.20251;
  unsigned char D.20253;
  unsigned char D.20256;
  unsigned char D.20257;
  struct MonoGenericContainer * D.20260;
  <unnamed-signed:31> D.20261;
  unsigned int D.20264;
  struct MonoTableInfo * D.20265;
  char * D.20269;
  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.124 = (int) token;
      idx = token.124 & 16777215;
      sig = 0B;
      type_container = container;
      mh = mono_get_method_full (m, token, 0B, container);
      if (mh != 0B) goto <D.20194>; else goto <D.20195>;
      <D.20194>:
      D.20196 = mono_method_signature (mh);
      D.20197 = BIT_FIELD_REF <*D.20196, 8, 88>;
      D.20198 = D.20197 & 2;
      if (D.20198 != 0) goto <D.20199>; else goto <D.20200>;
      <D.20199>:
      D.20201 = MEM[(struct MonoMethodInflated *)mh].declaring;
      container = mono_method_get_generic_container (D.20201);
      <D.20200>:
      D.20202 = mh->name;
      esname = get_escaped_name (D.20202);
      D.20203 = mh->klass;
      D.20204 = &D.20203->byval_arg;
      sig = dis_stringify_type (m, D.20204, 1);
      show_tokens.125 = show_tokens;
      if (show_tokens.125 != 0) goto <D.20206>; else goto <D.20207>;
      <D.20206>:
      if (sig != 0B) goto <D.20209>; else goto <D.20210>;
      <D.20209>:
      iftmp.126 = "::";
      goto <D.20211>;
      <D.20210>:
      iftmp.126 = "";
      <D.20211>:
      if (sig != 0B) goto <D.20213>; else goto <D.20214>;
      <D.20213>:
      iftmp.127 = sig;
      goto <D.20215>;
      <D.20214>:
      iftmp.127 = "";
      <D.20215>:
      name = monoeg_g_strdup_printf ("%s/*%08x*/%s%s", iftmp.127, token, iftmp.126, esname);
      goto <D.20216>;
      <D.20207>:
      if (sig != 0B) goto <D.20218>; else goto <D.20219>;
      <D.20218>:
      iftmp.128 = "::";
      goto <D.20220>;
      <D.20219>:
      iftmp.128 = "";
      <D.20220>:
      if (sig != 0B) goto <D.20222>; else goto <D.20223>;
      <D.20222>:
      iftmp.129 = sig;
      goto <D.20224>;
      <D.20223>:
      iftmp.129 = "";
      <D.20224>:
      name = monoeg_g_strdup_printf ("%s%s%s", iftmp.129, iftmp.128, esname);
      <D.20216>:
      monoeg_g_free (sig);
      monoeg_g_free (esname);
      goto <D.20225>;
      <D.20195>:
      name = 0B;
      <D.20225>:
      D.20226 = token & 4278190080;
      switch (D.20226) <default: <D.18818>, case 100663296: <D.18811>, case 167772160: <D.18813>, case 721420288: <D.18817>>
      <D.18811>:
      D.20227 = idx + -1;
      D.20228 = &m->tables[6];
      mono_metadata_decode_row (D.20228, D.20227, &method_cols, 6);
      D.20229 = method_cols[4];
      sig = get_methodref_signature (m, D.20229, name);
      goto <D.18812>;
      <D.18813>:
      D.20227 = idx + -1;
      D.20230 = &m->tables[10];
      mono_metadata_decode_row (D.20230, D.20227, &member_cols, 3);
      if (name == 0B) goto <D.20231>; else goto <D.20232>;
      <D.20231>:
      {
        char * parent;

        D.20233 = member_cols[0];
        parent = get_memberref_parent (m, D.20233, container);
        D.20234 = member_cols[1];
        D.20235 = mono_metadata_string_heap (m, D.20234);
        if (parent != 0B) goto <D.20237>; else goto <D.20238>;
        <D.20237>:
        iftmp.130 = "::";
        goto <D.20239>;
        <D.20238>:
        iftmp.130 = "";
        <D.20239>:
        if (parent != 0B) goto <D.20241>; else goto <D.20242>;
        <D.20241>:
        iftmp.131 = parent;
        goto <D.20243>;
        <D.20242>:
        iftmp.131 = "";
        <D.20243>:
        name = monoeg_g_strdup_printf ("%s%s%s", iftmp.131, iftmp.130, D.20235);
        monoeg_g_free (parent);
      }
      <D.20232>:
      if (mh != 0B) goto <D.20244>; else goto <D.20245>;
      <D.20244>:
      {
        int arity;

        arity = 0;
        D.20246 = BIT_FIELD_REF <*mh, 8, 168>;
        D.20247 = D.20246 & 8;
        if (D.20247 != 0) goto <D.20248>; else goto <D.20249>;
        <D.20248>:
        D.20250 = mono_method_get_generic_container (mh);
        D.20251 = D.20250->type_argc;
        arity = (int) D.20251;
        goto <D.20252>;
        <D.20249>:
        D.20246 = BIT_FIELD_REF <*mh, 8, 168>;
        D.20253 = D.20246 & 16;
        if (D.20253 != 0) goto <D.20254>; else goto <D.20255>;
        <D.20254>:
        D.20201 = MEM[(struct MonoMethodInflated *)mh].declaring;
        D.20256 = BIT_FIELD_REF <*D.20201, 8, 168>;
        D.20257 = D.20256 & 8;
        if (D.20257 != 0) goto <D.20258>; else goto <D.20259>;
        <D.20258>:
        D.20201 = MEM[(struct MonoMethodInflated *)mh].declaring;
        D.20260 = mono_method_get_generic_container (D.20201);
        D.20261 = D.20260->type_argc;
        arity = (int) D.20261;
        <D.20259>:
        <D.20255>:
        <D.20252>:
        if (arity > 0) goto <D.20262>; else goto <D.20263>;
        <D.20262>:
        {
          char * str;

          str = monoeg_g_strdup_printf ("%s <[%d]>", name, arity);
          monoeg_g_free (name);
          name = str;
        }
        <D.20263>:
      }
      <D.20245>:
      D.20264 = member_cols[2];
      sig = get_methodref_signature (m, D.20264, name);
      goto <D.18812>;
      <D.18817>:
      D.20227 = idx + -1;
      D.20265 = &m->tables[43];
      mono_metadata_decode_row (D.20265, D.20227, &member_cols, 2);
      token = member_cols[0];
      sig = get_methodspec (m, idx, token, name, type_container);
      goto <D.18812>;
      <D.18818>:
      monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "get.c", 1971);
      <D.18812>:
      if (fullsig != 0) goto <D.20266>; else goto <D.20267>;
      <D.20266>:
      monoeg_g_free (name);
      goto <D.20268>;
      <D.20267>:
      monoeg_g_free (sig);
      D.20269 = name;
      return D.20269;
      <D.20268>:
      show_tokens.125 = show_tokens;
      if (show_tokens.125 != 0) goto <D.20270>; else goto <D.20271>;
      <D.20270>:
      {
        char * retval;

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


get_methoddef (struct MonoImage * m, guint32 idx)
{
  unsigned int D.20274;
  struct MonoClass * D.20277;
  struct MonoType * D.20278;
  const char * D.20279;
  const char * iftmp.132;
  const char * iftmp.133;
  unsigned int D.20289;
  int D.20290;
  struct MonoTableInfo * D.20291;
  unsigned int D.20292;
  char * D.20293;
  guint32 cols[6];
  char * sig;
  const char * name;
  struct MonoMethod * mh;

  try
    {
      D.20274 = idx | 100663296;
      mh = mono_get_method (m, D.20274, 0B);
      if (mh != 0B) goto <D.20275>; else goto <D.20276>;
      <D.20275>:
      D.20277 = mh->klass;
      D.20278 = &D.20277->byval_arg;
      sig = dis_stringify_type (m, D.20278, 0);
      D.20279 = mh->name;
      if (sig != 0B) goto <D.20281>; else goto <D.20282>;
      <D.20281>:
      iftmp.132 = "::";
      goto <D.20283>;
      <D.20282>:
      iftmp.132 = "";
      <D.20283>:
      if (sig != 0B) goto <D.20285>; else goto <D.20286>;
      <D.20285>:
      iftmp.133 = sig;
      goto <D.20287>;
      <D.20286>:
      iftmp.133 = "";
      <D.20287>:
      name = monoeg_g_strdup_printf ("%s%s%s", iftmp.133, iftmp.132, D.20279);
      monoeg_g_free (sig);
      goto <D.20288>;
      <D.20276>:
      name = 0B;
      <D.20288>:
      D.20289 = idx + 4294967295;
      D.20290 = (int) D.20289;
      D.20291 = &m->tables[6];
      mono_metadata_decode_row (D.20291, D.20290, &cols, 6);
      D.20292 = cols[4];
      sig = get_methodref_signature (m, D.20292, name);
      D.20293 = sig;
      return D.20293;
    }
  finally
    {
      cols = {CLOBBER};
    }
}


get_method_type_param (struct MonoImage * m, guint32 blob_signature, struct MonoGenericContainer * container)
{
  const char * ptr.134;
  const char * ptr.135;
  const char * ptr.136;
  unsigned int D.20299;
  const char * ptr.137;
  char * param.138;
  int D.20302;
  char * D.20305;
  struct GString * res;
  const char * ptr;
  int param_count;
  int i;
  char * s;

  try
    {
      res = monoeg_g_string_new ("");
      ptr.134 = mono_metadata_blob_heap (m, blob_signature);
      ptr = ptr.134;
      i = 0;
      ptr.135 = ptr;
      mono_metadata_decode_value (ptr.135, &ptr);
      ptr.135 = ptr;
      ptr.136 = ptr.135 + 1;
      ptr = ptr.136;
      ptr.135 = ptr;
      D.20299 = mono_metadata_decode_value (ptr.135, &ptr);
      param_count = (int) D.20299;
      monoeg_g_string_append_c (res, 60);
      i = 0;
      goto <D.18845>;
      <D.18844>:
      {
        char * param;

        try
          {
            param = 0B;
            ptr.135 = ptr;
            ptr.137 = get_param (m, ptr.135, &param, container);
            ptr = ptr.137;
            param.138 = param;
            monoeg_g_string_append (res, param.138);
            D.20302 = i + 1;
            if (D.20302 != param_count) goto <D.20303>; else goto <D.20304>;
            <D.20303>:
            monoeg_g_string_append (res, ", ");
            <D.20304>:
            param.138 = param;
            monoeg_g_free (param.138);
          }
        finally
          {
            param = {CLOBBER};
          }
      }
      i = i + 1;
      <D.18845>:
      if (i < param_count) goto <D.18844>; else goto <D.18846>;
      <D.18846>:
      monoeg_g_string_append_c (res, 62);
      s = res->str;
      monoeg_g_string_free (res, 0);
      D.20305 = s;
      return D.20305;
    }
  finally
    {
      ptr = {CLOBBER};
    }
}


get_methodspec (struct MonoImage * m, int idx, guint32 token, const char * fancy_name, struct MonoGenericContainer * type_container)
{
  unsigned int D.20308;
  unsigned int D.20309;
  unsigned int D.20310;
  int D.20311;
  struct MonoTableInfo * D.20312;
  struct MonoTableInfo * D.20313;
  const char * ptr.139;
  const char * ptr.140;
  unsigned int D.20316;
  _Bool D.20317;
  long int D.20318;
  long int D.20319;
  char D.20324;
  int D.20325;
  int D.20326;
  int D.20329;
  int D.20333;
  const char * ptr.141;
  unsigned int D.20339;
  unsigned int D.20340;
  const char * ptr.142;
  char * allocated_ret_type.143;
  int D.20347;
  struct MonoTableInfo * D.20348;
  const char * ptr.144;
  char * param.145;
  int D.20351;
  char * D.20354;
  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.20308 = token & 1;
      switch (D.20308) <default: <D.18870>, case 0: <D.18867>, case 1: <D.18869>>
      <D.18867>:
      D.20309 = token >> 1;
      D.20310 = D.20309 + 4294967295;
      D.20311 = (int) D.20310;
      D.20312 = &m->tables[6];
      mono_metadata_decode_row (D.20312, D.20311, &method_cols, 6);
      sig = method_cols[4];
      goto <D.18868>;
      <D.18869>:
      D.20309 = token >> 1;
      D.20310 = D.20309 + 4294967295;
      D.20311 = (int) D.20310;
      D.20313 = &m->tables[10];
      mono_metadata_decode_row (D.20313, D.20311, &member_cols, 3);
      sig = member_cols[2];
      goto <D.18868>;
      <D.18870>:
      monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "get.c", 2091);
      <D.18868>:
      ptr.139 = mono_metadata_blob_heap (m, sig);
      ptr = ptr.139;
      ptr.140 = ptr;
      mono_metadata_decode_value (ptr.140, &ptr);
      D.20316 = method_dor_to_token (token);
      mh = mono_get_method_full (m, D.20316, 0B, type_container);
      D.20317 = mh == 0B;
      D.20318 = (long int) D.20317;
      D.20319 = __builtin_expect (D.20318, 0);
      if (D.20319 != 0) goto <D.20320>; else goto <D.20321>;
      <D.20320>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "get.c", 2098, "mh");
      <D.20321>:
      container = mono_method_get_generic_container (mh);
      if (container == 0B) goto <D.20322>; else goto <D.20323>;
      <D.20322>:
      container = type_container;
      <D.20323>:
      ptr.140 = ptr;
      D.20324 = *ptr.140;
      D.20325 = (int) D.20324;
      D.20326 = D.20325 & 32;
      if (D.20326 != 0) goto <D.20327>; else goto <D.20328>;
      <D.20327>:
      ptr.140 = ptr;
      D.20324 = *ptr.140;
      D.20325 = (int) D.20324;
      D.20329 = D.20325 & 64;
      if (D.20329 != 0) goto <D.20330>; else goto <D.20331>;
      <D.20330>:
      monoeg_g_string_append (res, "explicit-this ");
      goto <D.20332>;
      <D.20331>:
      monoeg_g_string_append (res, "instance ");
      <D.20332>:
      <D.20328>:
      ptr.140 = ptr;
      D.20324 = *ptr.140;
      D.20325 = (int) D.20324;
      D.20333 = D.20325 & 16;
      if (D.20333 != 0) goto <D.20334>; else goto <D.20335>;
      <D.20334>:
      gen_count = 1;
      <D.20335>:
      ptr.140 = ptr;
      D.20324 = *ptr.140;
      D.20325 = (int) D.20324;
      cconv = D.20325 & 15;
      ptr.140 = ptr;
      ptr.141 = ptr.140 + 1;
      ptr = ptr.141;
      if (gen_count != 0) goto <D.20337>; else goto <D.20338>;
      <D.20337>:
      ptr.140 = ptr;
      D.20339 = mono_metadata_decode_value (ptr.140, &ptr);
      gen_count = (int) D.20339;
      <D.20338>:
      ptr.140 = ptr;
      D.20340 = mono_metadata_decode_value (ptr.140, &ptr);
      param_count = (int) D.20340;
      if (cconv != 10) goto <D.20341>; else goto <D.20342>;
      <D.20341>:
      {
        char * allocated_ret_type;

        try
          {
            ptr.140 = ptr;
            ptr.142 = get_ret_type (m, ptr.140, &allocated_ret_type, container);
            ptr = ptr.142;
            allocated_ret_type.143 = allocated_ret_type;
            monoeg_g_string_append (res, allocated_ret_type.143);
            allocated_ret_type.143 = allocated_ret_type;
            monoeg_g_free (allocated_ret_type.143);
          }
        finally
          {
            allocated_ret_type = {CLOBBER};
          }
      }
      <D.20342>:
      if (fancy_name != 0B) goto <D.20345>; else goto <D.20346>;
      <D.20345>:
      monoeg_g_string_append_c (res, 32);
      monoeg_g_string_append (res, fancy_name);
      <D.20346>:
      D.20347 = idx + -1;
      D.20348 = &m->tables[43];
      mono_metadata_decode_row (D.20348, D.20347, &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.18874>;
      <D.18873>:
      {
        char * param;

        try
          {
            param = 0B;
            ptr.140 = ptr;
            ptr.144 = get_param (m, ptr.140, &param, container);
            ptr = ptr.144;
            param.145 = param;
            monoeg_g_string_append (res, param.145);
            D.20351 = i + 1;
            if (D.20351 != param_count) goto <D.20352>; else goto <D.20353>;
            <D.20352>:
            monoeg_g_string_append (res, ", ");
            <D.20353>:
            param.145 = param;
            monoeg_g_free (param.145);
          }
        finally
          {
            param = {CLOBBER};
          }
      }
      i = i + 1;
      <D.18874>:
      if (i < param_count) goto <D.18873>; else goto <D.18875>;
      <D.18875>:
      monoeg_g_string_append (res, ")");
      s = res->str;
      monoeg_g_string_free (res, 0);
      D.20354 = s;
      return D.20354;
    }
  finally
    {
      member_cols = {CLOBBER};
      method_cols = {CLOBBER};
      ptr = {CLOBBER};
    }
}


get_encoded_user_string_or_bytearray (const unsigned char * ptr, int len)
{
  int D.20357;
  int D.20358;
  unsigned int D.20359;
  sizetype i.146;
  sizetype D.20363;
  const unsigned char * D.20364;
  unsigned char D.20365;
  const short unsigned int * * D.20367;
  const short unsigned int * D.20368;
  const unsigned char * D.20369;
  unsigned char D.20370;
  unsigned int D.20371;
  unsigned int D.20372;
  const short unsigned int * D.20373;
  short unsigned int D.20374;
  int D.20375;
  int D.20376;
  char * D.20382;
  int D.20383;
  sizetype D.20384;
  char * D.20385;
  char D.20386;
  int D.20387;
  sizetype D.20388;
  char * D.20389;
  char * res;
  char * eres;
  char * result;
  int i;

  D.20357 = len >> 1;
  D.20358 = D.20357 + 1;
  D.20359 = (unsigned int) D.20358;
  res = monoeg_malloc (D.20359);
  i = 0;
  goto <D.18906>;
  <D.18905>:
  i.146 = (sizetype) i;
  D.20363 = i.146 + 1;
  D.20364 = ptr + D.20363;
  D.20365 = *D.20364;
  if (D.20365 != 0) goto <D.20360>; else goto <D.20366>;
  <D.20366>:
  D.20367 = __ctype_b_loc ();
  D.20368 = *D.20367;
  i.146 = (sizetype) i;
  D.20369 = ptr + i.146;
  D.20370 = *D.20369;
  D.20371 = (unsigned int) D.20370;
  D.20372 = D.20371 * 2;
  D.20373 = D.20368 + D.20372;
  D.20374 = *D.20373;
  D.20375 = (int) D.20374;
  D.20376 = D.20375 & 16384;
  if (D.20376 == 0) goto <D.20377>; else goto <D.20361>;
  <D.20377>:
  i.146 = (sizetype) i;
  D.20369 = ptr + i.146;
  D.20370 = *D.20369;
  if (D.20370 != 92) goto <D.20378>; else goto <D.20361>;
  <D.20378>:
  i.146 = (sizetype) i;
  D.20369 = ptr + i.146;
  D.20370 = *D.20369;
  if (D.20370 != 34) goto <D.20379>; else goto <D.20361>;
  <D.20379>:
  i.146 = (sizetype) i;
  D.20369 = ptr + i.146;
  D.20370 = *D.20369;
  if (D.20370 != 13) goto <D.20380>; else goto <D.20361>;
  <D.20380>:
  i.146 = (sizetype) i;
  D.20369 = ptr + i.146;
  D.20370 = *D.20369;
  if (D.20370 != 10) goto <D.20381>; else goto <D.20361>;
  <D.20381>:
  i.146 = (sizetype) i;
  D.20369 = ptr + i.146;
  D.20370 = *D.20369;
  if (D.20370 != 9) goto <D.20360>; else goto <D.20361>;
  <D.20360>:
  monoeg_g_free (res);
  D.20382 = get_encoded_user_string_bytearray (ptr, len);
  return D.20382;
  <D.20361>:
  D.20383 = i >> 1;
  D.20384 = (sizetype) D.20383;
  D.20385 = res + D.20384;
  i.146 = (sizetype) i;
  D.20369 = ptr + i.146;
  D.20370 = *D.20369;
  D.20386 = (char) D.20370;
  *D.20385 = D.20386;
  i = i + 2;
  <D.18906>:
  D.20387 = i + 1;
  if (D.20387 < len) goto <D.18905>; else goto <D.18907>;
  <D.18907>:
  D.20357 = len >> 1;
  D.20388 = (sizetype) D.20357;
  D.20389 = res + D.20388;
  *D.20389 = 0;
  eres = monoeg_g_strescape (res, 0B);
  result = monoeg_g_strdup_printf ("\"%s\"", eres);
  monoeg_g_free (res);
  monoeg_g_free (eres);
  D.20382 = result;
  return D.20382;
}


get_encoded_user_string_bytearray (const unsigned char * ptr, int len)
{
  char * D.20393;
  sizetype i.147;
  sizetype D.20395;
  const unsigned char * D.20396;
  unsigned char D.20397;
  int D.20398;
  unsigned int i.148;
  unsigned int D.20400;
  int iftmp.149;
  const short unsigned int * * D.20407;
  const short unsigned int * D.20408;
  sizetype j.150;
  const unsigned char * D.20410;
  unsigned char D.20411;
  unsigned int D.20412;
  unsigned int D.20413;
  const short unsigned int * D.20414;
  short unsigned int D.20415;
  int D.20416;
  int D.20417;
  int iftmp.151;
  const unsigned char * D.20424;
  unsigned char D.20425;
  unsigned int D.20426;
  unsigned int D.20427;
  const short unsigned int * D.20428;
  short unsigned int D.20429;
  int D.20430;
  int D.20431;
  gchar * str;
  int i;
  int j;
  int tspaces;
  struct GString * res;

  tspaces = len % 16;
  if (len == 0) goto <D.20391>; else goto <D.20392>;
  <D.20391>:
  D.20393 = monoeg_g_strdup_printf ("\"\"");
  return D.20393;
  <D.20392>:
  res = monoeg_g_string_new ("bytearray (\n\t");
  i = 1;
  goto <D.18889>;
  <D.18888>:
  i.147 = (sizetype) i;
  D.20395 = i.147 + 4294967295;
  D.20396 = ptr + D.20395;
  D.20397 = *D.20396;
  D.20398 = (int) D.20397;
  monoeg_g_string_append_printf (res, "%02x ", D.20398);
  i.148 = (unsigned int) i;
  D.20400 = i.148 & 15;
  if (D.20400 == 0) goto <D.20401>; else goto <D.20402>;
  <D.20401>:
  if (i == len) goto <D.20403>; else goto <D.20404>;
  <D.20403>:
  monoeg_g_string_append (res, ")// ");
  goto <D.20405>;
  <D.20404>:
  monoeg_g_string_append (res, " // ");
  <D.20405>:
  j = i + -16;
  goto <D.18886>;
  <D.18885>:
  D.20407 = __ctype_b_loc ();
  D.20408 = *D.20407;
  j.150 = (sizetype) j;
  D.20410 = ptr + j.150;
  D.20411 = *D.20410;
  D.20412 = (unsigned int) D.20411;
  D.20413 = D.20412 * 2;
  D.20414 = D.20408 + D.20413;
  D.20415 = *D.20414;
  D.20416 = (int) D.20415;
  D.20417 = D.20416 & 16384;
  if (D.20417 != 0) goto <D.20418>; else goto <D.20419>;
  <D.20418>:
  j.150 = (sizetype) j;
  D.20410 = ptr + j.150;
  D.20411 = *D.20410;
  iftmp.149 = (int) D.20411;
  goto <D.20420>;
  <D.20419>:
  iftmp.149 = 46;
  <D.20420>:
  monoeg_g_string_append_printf (res, "%c", iftmp.149);
  j = j + 1;
  <D.18886>:
  if (j < i) goto <D.18885>; else goto <D.18887>;
  <D.18887>:
  monoeg_g_string_append (res, "\n\t");
  <D.20402>:
  i = i + 1;
  <D.18889>:
  if (i <= len) goto <D.18888>; else goto <D.18890>;
  <D.18890>:
  if (tspaces != 0) goto <D.20421>; else goto <D.20422>;
  <D.20421>:
  monoeg_g_string_append (res, ")  ");
  i = tspaces + 1;
  goto <D.18892>;
  <D.18891>:
  monoeg_g_string_append_printf (res, "   ");
  i = i + 1;
  <D.18892>:
  if (i <= 15) goto <D.18891>; else goto <D.18893>;
  <D.18893>:
  monoeg_g_string_append (res, " // ");
  i = len - tspaces;
  goto <D.18895>;
  <D.18894>:
  D.20407 = __ctype_b_loc ();
  D.20408 = *D.20407;
  i.147 = (sizetype) i;
  D.20424 = ptr + i.147;
  D.20425 = *D.20424;
  D.20426 = (unsigned int) D.20425;
  D.20427 = D.20426 * 2;
  D.20428 = D.20408 + D.20427;
  D.20429 = *D.20428;
  D.20430 = (int) D.20429;
  D.20431 = D.20430 & 16384;
  if (D.20431 != 0) goto <D.20432>; else goto <D.20433>;
  <D.20432>:
  i.147 = (sizetype) i;
  D.20424 = ptr + i.147;
  D.20425 = *D.20424;
  iftmp.151 = (int) D.20425;
  goto <D.20434>;
  <D.20433>:
  iftmp.151 = 46;
  <D.20434>:
  monoeg_g_string_append_printf (res, "%c", iftmp.151);
  i = i + 1;
  <D.18895>:
  if (i < len) goto <D.18894>; else goto <D.18896>;
  <D.18896>:
  monoeg_g_string_append (res, "\n\t");
  <D.20422>:
  str = res->str;
  monoeg_g_string_free (res, 0);
  D.20393 = str;
  return D.20393;
}


stringify_double (double r)
{
  unsigned int D.20436;
  sizetype D.20437;
  char * D.18916;
  char * iftmp.152;
  char * iftmp.153;
  int D.20445;
  char * iftmp.154;
  int D.20450;
  char * iftmp.155;
  char D.20453;
  int D.20456;
  char * D.20460;
  char * ret;
  char * ptr;

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

    __a0 = 46;
    if (__a0 == 0) goto <D.20439>; else goto <D.20440>;
    <D.20439>:
    iftmp.152 = 0B;
    goto <D.20441>;
    <D.20440>:
    __a1 = 101;
    if (__a1 == 0) goto <D.20443>; else goto <D.20444>;
    <D.20443>:
    D.20445 = (int) __a0;
    iftmp.153 = __builtin_strchr (ret, D.20445);
    goto <D.20446>;
    <D.20444>:
    __a2 = 69;
    if (__a2 == 0) goto <D.20448>; else goto <D.20449>;
    <D.20448>:
    D.20450 = (int) __a1;
    D.20445 = (int) __a0;
    iftmp.154 = __strpbrk_c2 (ret, D.20445, D.20450);
    goto <D.20451>;
    <D.20449>:
    D.20453 = 0;
    if (D.20453 == 0) goto <D.20454>; else goto <D.20455>;
    <D.20454>:
    D.20456 = (int) __a2;
    D.20450 = (int) __a1;
    D.20445 = (int) __a0;
    iftmp.155 = __strpbrk_c3 (ret, D.20445, D.20450, D.20456);
    goto <D.20457>;
    <D.20455>:
    iftmp.155 = __builtin_strpbrk (ret, ".eE");
    <D.20457>:
    iftmp.154 = iftmp.155;
    <D.20451>:
    iftmp.153 = iftmp.154;
    <D.20446>:
    iftmp.152 = iftmp.153;
    <D.20441>:
    D.18916 = iftmp.152;
  }
  if (D.18916 != ptr) goto <D.20458>; else goto <D.20459>;
  <D.20458>:
  *ptr = 0;
  <D.20459>:
  D.20460 = ret;
  return D.20460;
}


__strpbrk_c2 (const char * __s, int __accept1, int __accept2)
{
  char D.20462;
  int D.20464;
  char * D.20466;
  char * iftmp.156;

  goto <D.3198>;
  <D.3197>:
  __s = __s + 1;
  <D.3198>:
  D.20462 = *__s;
  if (D.20462 != 0) goto <D.20463>; else goto <D.3199>;
  <D.20463>:
  D.20462 = *__s;
  D.20464 = (int) D.20462;
  if (D.20464 != __accept1) goto <D.20465>; else goto <D.3199>;
  <D.20465>:
  D.20462 = *__s;
  D.20464 = (int) D.20462;
  if (D.20464 != __accept2) goto <D.3197>; else goto <D.3199>;
  <D.3199>:
  D.20462 = *__s;
  if (D.20462 != 0) goto <D.20468>; else goto <D.20469>;
  <D.20468>:
  iftmp.156 = __s;
  goto <D.20470>;
  <D.20469>:
  iftmp.156 = 0B;
  <D.20470>:
  D.20466 = iftmp.156;
  return D.20466;
}


__strpbrk_c3 (const char * __s, int __accept1, int __accept2, int __accept3)
{
  char D.20472;
  int D.20474;
  char * D.20477;
  char * iftmp.157;

  goto <D.3212>;
  <D.3211>:
  __s = __s + 1;
  <D.3212>:
  D.20472 = *__s;
  if (D.20472 != 0) goto <D.20473>; else goto <D.3213>;
  <D.20473>:
  D.20472 = *__s;
  D.20474 = (int) D.20472;
  if (D.20474 != __accept1) goto <D.20475>; else goto <D.3213>;
  <D.20475>:
  D.20472 = *__s;
  D.20474 = (int) D.20472;
  if (D.20474 != __accept2) goto <D.20476>; else goto <D.3213>;
  <D.20476>:
  D.20472 = *__s;
  D.20474 = (int) D.20472;
  if (D.20474 != __accept3) goto <D.3211>; else goto <D.3213>;
  <D.3213>:
  D.20472 = *__s;
  if (D.20472 != 0) goto <D.20479>; else goto <D.20480>;
  <D.20479>:
  iftmp.157 = __s;
  goto <D.20481>;
  <D.20480>:
  iftmp.157 = 0B;
  <D.20481>:
  D.20477 = iftmp.157;
  return D.20477;
}


get_constant (struct MonoImage * m, MonoTypeEnum t, guint32 blob_index)
{
  const char * ptr.158;
  const char * ptr.159;
  unsigned int D.20485;
  char * D.20486;
  const char * iftmp.160;
  char D.20488;
  short unsigned int D.20492;
  int D.20493;
  int D.20494;
  int D.20495;
  unsigned int D.20496;
  float r.161;
  float r.162;
  double D.20501;
  long long unsigned int D.20502;
  double r.163;
  double r.164;
  const char * ptr;
  int len;

  try
    {
      ptr.158 = mono_metadata_blob_heap (m, blob_index);
      ptr = ptr.158;
      ptr.159 = ptr;
      D.20485 = mono_metadata_decode_value (ptr.159, &ptr);
      len = (int) D.20485;
      switch (t) <default: <D.18952>, case 2: <D.18924>, case 3: <D.18925>, case 4: <D.18927>, case 5: <D.18926>, case 6: <D.18929>, case 7: <D.18928>, case 8: <D.18931>, case 9: <D.18930>, case 10: <D.18933>, case 11: <D.18932>, case 12: <D.18936>, case 13: <D.18942>, case 14: <D.18950>, case 18: <D.18951>>
      <D.18924>:
      ptr.159 = ptr;
      D.20488 = *ptr.159;
      if (D.20488 != 0) goto <D.20489>; else goto <D.20490>;
      <D.20489>:
      iftmp.160 = "bool(true)";
      goto <D.20491>;
      <D.20490>:
      iftmp.160 = "bool(false)";
      <D.20491>:
      D.20486 = monoeg_g_strdup_printf ("%s", iftmp.160);
      return D.20486;
      <D.18925>:
      ptr.159 = ptr;
      D.20492 = MEM[(const guint16 *)ptr.159];
      D.20493 = (int) D.20492;
      D.20486 = monoeg_g_strdup_printf ("char(0x%04x)", D.20493);
      return D.20486;
      <D.18926>:
      <D.18927>:
      ptr.159 = ptr;
      D.20488 = *ptr.159;
      D.20494 = (int) D.20488;
      D.20495 = D.20494 & 255;
      D.20486 = monoeg_g_strdup_printf ("int8(0x%02x)", D.20495);
      return D.20486;
      <D.18928>:
      <D.18929>:
      ptr.159 = ptr;
      D.20492 = MEM[(const guint16 *)ptr.159];
      D.20493 = (int) D.20492;
      D.20486 = monoeg_g_strdup_printf ("int16(0x%08x)", D.20493);
      return D.20486;
      <D.18930>:
      <D.18931>:
      ptr.159 = ptr;
      D.20496 = MEM[(const guint32 *)ptr.159];
      D.20486 = monoeg_g_strdup_printf ("int32(0x%08x)", D.20496);
      return D.20486;
      <D.18932>:
      <D.18933>:
      {
        guint32 low;
        guint32 high;

        ptr.159 = ptr;
        low = MEM[(const guint32 *)ptr.159];
        ptr.159 = ptr;
        high = MEM[(const guint32 *)ptr.159 + 4B];
        D.20486 = monoeg_g_strdup_printf ("int64(0x%08x%08x)", high, low);
        return D.20486;
      }
      <D.18936>:
      {
        gboolean normal;
        float r;

        try
          {
            {
              union mono_rfloat mf;

              try
                {
                  ptr.159 = ptr;
                  D.20496 = MEM[(const guint32 *)ptr.159];
                  mf.ival = D.20496;
                  r.161 = mf.fval;
                  r = r.161;
                }
              finally
                {
                  mf = {CLOBBER};
                }
            }
            r.162 = r;
            normal = __finitef (r.162);
            if (normal == 0) goto <D.20499>; else goto <D.20500>;
            <D.20499>:
            ptr.159 = ptr;
            D.20496 = MEM[(const guint32 *)ptr.159];
            D.20486 = monoeg_g_strdup_printf ("float32(0x%08x)", D.20496);
            return D.20486;
            <D.20500>:
            {
              char * str;
              char * ret;

              r.162 = r;
              D.20501 = (double) r.162;
              str = stringify_double (D.20501);
              ret = monoeg_g_strdup_printf ("float32(%s)", str);
              monoeg_g_free (str);
              D.20486 = ret;
              return D.20486;
            }
          }
        finally
          {
            r = {CLOBBER};
          }
      }
      <D.18942>:
      {
        gboolean normal;
        double r;

        try
          {
            {
              union mono_rdouble mf;

              try
                {
                  ptr.159 = ptr;
                  D.20502 = MEM[(const guint64 *)ptr.159];
                  mf.ival = D.20502;
                  r.163 = mf.fval;
                  r = r.163;
                }
              finally
                {
                  mf = {CLOBBER};
                }
            }
            r.164 = r;
            normal = __finite (r.164);
            if (normal == 0) goto <D.20505>; else goto <D.20506>;
            <D.20505>:
            {
              guint32 low;
              guint32 high;

              ptr.159 = ptr;
              low = MEM[(const guint32 *)ptr.159];
              ptr.159 = ptr;
              high = MEM[(const guint32 *)ptr.159 + 4B];
              D.20486 = monoeg_g_strdup_printf ("float64(0x%08x%08x)", high, low);
              return D.20486;
            }
            <D.20506>:
            {
              char * str;
              char * ret;

              r.164 = r;
              str = stringify_double (r.164);
              ret = monoeg_g_strdup_printf ("float64(%s)", str);
              monoeg_g_free (str);
              D.20486 = ret;
              return D.20486;
            }
          }
        finally
          {
            r = {CLOBBER};
          }
      }
      <D.18950>:
      ptr.159 = ptr;
      D.20486 = get_encoded_user_string_or_bytearray (ptr.159, len);
      return D.20486;
      <D.18951>:
      D.20486 = monoeg_strdup ("nullref");
      return D.20486;
      <D.18952>:
      ptr.159 = ptr;
      D.20488 = *ptr.159;
      D.20494 = (int) D.20488;
      monoeg_g_log (0B, 4, "Unknown MONO_TYPE (%d) on constant at Blob index (0x%08x)\n", D.20494, blob_index);
      <D.18953>:
      goto <D.18953>;
      D.20486 = monoeg_g_strdup_printf ("Unknown");
      return D.20486;
    }
  finally
    {
      ptr = {CLOBBER};
    }
}


__finite (double __x)
{
  int D.20511;
  union 
{
  double __d;
  int __i[2];
} D.5781;
  int D.20512;
  unsigned int D.20513;
  unsigned int D.20514;
  unsigned int D.20515;
  unsigned int D.20516;
  typedef union 
{
  double __d;
  int __i[2];
} unionunion 
{
  double __d;
  int __i[2];
};

  D.5781.__d = __x;
  D.20512 = D.5781.__i[1];
  D.20513 = (unsigned int) D.20512;
  D.20514 = D.20513 | 2148532223;
  D.20515 = D.20514 + 1;
  D.20516 = D.20515 >> 31;
  D.20511 = (int) D.20516;
  return D.20511;
}


get_token (struct MonoImage * m, guint32 token, struct MonoGenericContainer * container)
{
  unsigned int D.20518;
  char * D.20519;
  int idx.165;
  unsigned int D.20521;
  unsigned int D.20522;
  int D.20523;
  struct MonoTableInfo * D.20524;
  unsigned int D.20525;
  const char * sig.166;
  const char * sig.167;
  char D.20528;
  char * temp;
  char * result;
  guint32 idx;

  idx = token & 16777215;
  D.20518 = token & 4278190080;
  switch (D.20518) <default: <D.18971>, case 16777216: <D.18966>, case 33554432: <D.18965>, case 67108864: <D.18962>, case 100663296: <D.18963>, case 167772160: <D.18968>, case 452984832: <D.18967>, case 721420288: <D.18964>>
  <D.18962>:
  temp = get_field (m, token, container);
  result = monoeg_g_strdup_printf ("field %s", temp);
  monoeg_g_free (temp);
  D.20519 = result;
  return D.20519;
  <D.18963>:
  <D.18964>:
  temp = get_method (m, token, container);
  result = monoeg_g_strdup_printf ("method %s", temp);
  monoeg_g_free (temp);
  D.20519 = result;
  return D.20519;
  <D.18965>:
  idx.165 = (int) idx;
  temp = get_typedef (m, idx.165);
  result = get_escaped_name (temp);
  monoeg_g_free (temp);
  D.20519 = result;
  return D.20519;
  <D.18966>:
  idx.165 = (int) idx;
  D.20519 = get_typeref (m, idx.165);
  return D.20519;
  <D.18967>:
  D.20519 = get_typespec (m, idx, 1, container);
  return D.20519;
  <D.18968>:
  {
    guint32 cols[3];
    const char * sig;

    try
      {
        D.20521 = token & 16777215;
        D.20522 = D.20521 + 4294967295;
        D.20523 = (int) D.20522;
        D.20524 = &m->tables[10];
        mono_metadata_decode_row (D.20524, D.20523, &cols, 3);
        D.20525 = cols[2];
        sig.166 = mono_metadata_blob_heap (m, D.20525);
        sig = sig.166;
        sig.167 = sig;
        mono_metadata_decode_blob_size (sig.167, &sig);
        sig.167 = sig;
        D.20528 = *sig.167;
        if (D.20528 == 6) goto <D.20529>; else goto <D.20530>;
        <D.20529>:
        temp = get_field (m, token, container);
        result = monoeg_g_strdup_printf ("field %s", temp);
        monoeg_g_free (temp);
        D.20519 = result;
        return D.20519;
        <D.20530>:
        temp = get_method (m, token, container);
        result = monoeg_g_strdup_printf ("method %s", temp);
        monoeg_g_free (temp);
        D.20519 = result;
        return D.20519;
      }
    finally
      {
        cols = {CLOBBER};
        sig = {CLOBBER};
      }
  }
  <D.18971>:
  monoeg_g_log (0B, 4, "Do not know how to decode tokens of type 0x%08x", token);
  <D.18972>:
  goto <D.18972>;
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "get.c", 2419);
  D.20519 = monoeg_strdup ("ERROR");
  return D.20519;
}


get_token_type (struct MonoImage * m, guint32 token, struct MonoGenericContainer * container)
{
  int token.168;
  unsigned int D.20534;
  unsigned int idx.169;
  char * D.20538;
  char * temp;
  char * s;
  int idx;

  temp = 0B;
  s = 0B;
  token.168 = (int) token;
  idx = token.168 & 16777215;
  D.20534 = token & 4278190080;
  switch (D.20534) <default: <D.18985>, case 16777216: <D.18983>, case 33554432: <D.18981>, case 452984832: <D.18984>>
  <D.18981>:
  temp = get_typedef (m, idx);
  s = monoeg_g_strdup_printf ("%s", temp);
  goto <D.18982>;
  <D.18983>:
  temp = get_typeref (m, idx);
  s = monoeg_g_strdup_printf ("%s", temp);
  goto <D.18982>;
  <D.18984>:
  idx.169 = (unsigned int) idx;
  s = get_typespec (m, idx.169, 0, container);
  goto <D.18982>;
  <D.18985>:
  monoeg_g_log (0B, 4, "Unhandled encoding for token 0x%08x", token);
  <D.18986>:
  goto <D.18986>;
  <D.18982>:
  if (temp != 0B) goto <D.20536>; else goto <D.20537>;
  <D.20536>:
  monoeg_g_free (temp);
  <D.20537>:
  D.20538 = s;
  return D.20538;
}


get_guid (struct MonoImage * m, guint32 guid_index)
{
  const unsigned char * D.20540;
  unsigned char D.20541;
  int D.20542;
  const unsigned char * D.20543;
  unsigned char D.20544;
  int D.20545;
  const unsigned char * D.20546;
  unsigned char D.20547;
  int D.20548;
  const unsigned char * D.20549;
  unsigned char D.20550;
  int D.20551;
  const unsigned char * D.20552;
  unsigned char D.20553;
  int D.20554;
  const unsigned char * D.20555;
  unsigned char D.20556;
  int D.20557;
  const unsigned char * D.20558;
  unsigned char D.20559;
  int D.20560;
  const unsigned char * D.20561;
  unsigned char D.20562;
  int D.20563;
  const unsigned char * D.20564;
  unsigned char D.20565;
  int D.20566;
  const unsigned char * D.20567;
  unsigned char D.20568;
  int D.20569;
  const unsigned char * D.20570;
  unsigned char D.20571;
  int D.20572;
  const unsigned char * D.20573;
  unsigned char D.20574;
  int D.20575;
  unsigned char D.20576;
  int D.20577;
  const unsigned char * D.20578;
  unsigned char D.20579;
  int D.20580;
  const unsigned char * D.20581;
  unsigned char D.20582;
  int D.20583;
  const unsigned char * D.20584;
  unsigned char D.20585;
  int D.20586;
  char * D.20587;
  const unsigned char * guid;
  char * result;

  guid = mono_metadata_guid_heap (m, guid_index);
  D.20540 = guid + 15;
  D.20541 = *D.20540;
  D.20542 = (int) D.20541;
  D.20543 = guid + 14;
  D.20544 = *D.20543;
  D.20545 = (int) D.20544;
  D.20546 = guid + 13;
  D.20547 = *D.20546;
  D.20548 = (int) D.20547;
  D.20549 = guid + 12;
  D.20550 = *D.20549;
  D.20551 = (int) D.20550;
  D.20552 = guid + 11;
  D.20553 = *D.20552;
  D.20554 = (int) D.20553;
  D.20555 = guid + 10;
  D.20556 = *D.20555;
  D.20557 = (int) D.20556;
  D.20558 = guid + 9;
  D.20559 = *D.20558;
  D.20560 = (int) D.20559;
  D.20561 = guid + 8;
  D.20562 = *D.20561;
  D.20563 = (int) D.20562;
  D.20564 = guid + 6;
  D.20565 = *D.20564;
  D.20566 = (int) D.20565;
  D.20567 = guid + 7;
  D.20568 = *D.20567;
  D.20569 = (int) D.20568;
  D.20570 = guid + 4;
  D.20571 = *D.20570;
  D.20572 = (int) D.20571;
  D.20573 = guid + 5;
  D.20574 = *D.20573;
  D.20575 = (int) D.20574;
  D.20576 = *guid;
  D.20577 = (int) D.20576;
  D.20578 = guid + 1;
  D.20579 = *D.20578;
  D.20580 = (int) D.20579;
  D.20581 = guid + 2;
  D.20582 = *D.20581;
  D.20583 = (int) D.20582;
  D.20584 = guid + 3;
  D.20585 = *D.20584;
  D.20586 = (int) D.20585;
  result = monoeg_g_strdup_printf ("{%02X%02X%02X%02X-%02X%02X-%02X%02X-%02X%02X-%02X%02X%02X%02X%02X%02X}", D.20586, D.20583, D.20580, D.20577, D.20575, D.20572, D.20569, D.20566, D.20563, D.20560, D.20557, D.20554, D.20551, D.20548, D.20545, D.20542);
  D.20587 = result;
  return D.20587;
}


dis_get_custom_attrs (struct MonoImage * m, guint32 token)
{
  unsigned int D.20589;
  struct GList * D.20590;
  int i.170;
  unsigned int D.20592;
  unsigned int D.20595;
  unsigned int D.20596;
  unsigned int D.20597;
  const char * val.171;
  const char * val.172;
  int len.173;
  char * D.20601;
  <unnamed-unsigned:24> D.20602;
  unsigned int D.20603;
  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.20589 = token >> 24;
      switch (D.20589) <default: <D.19018>, case 0: <D.19011>, case 2: <D.19007>, case 4: <D.19014>, case 6: <D.19015>, case 8: <D.19016>, case 20: <D.19013>, case 23: <D.19012>, case 32: <D.19009>, case 35: <D.19010>, case 42: <D.19017>>
      <D.19007>:
      idx = idx | 3;
      goto <D.19008>;
      <D.19009>:
      idx = idx | 14;
      goto <D.19008>;
      <D.19010>:
      idx = idx | 15;
      goto <D.19008>;
      <D.19011>:
      idx = idx | 7;
      goto <D.19008>;
      <D.19012>:
      idx = idx | 9;
      goto <D.19008>;
      <D.19013>:
      idx = idx | 10;
      goto <D.19008>;
      <D.19014>:
      idx = idx | 1;
      goto <D.19008>;
      <D.19015>:
      idx = idx;
      goto <D.19008>;
      <D.19016>:
      idx = idx | 4;
      goto <D.19008>;
      <D.19017>:
      idx = idx | 19;
      goto <D.19008>;
      <D.19018>:
      monoeg_g_print ("Missing custom attr get support for token 0x%08x\n", token);
      D.20590 = 0B;
      return D.20590;
      <D.19008>:
      ca = &m->tables[12];
      i = 0;
      goto <D.19027>;
      <D.19026>:
      {
        char * dump;

        i.170 = (int) i;
        mono_metadata_decode_row (ca, i.170, &cols, 3);
        D.20592 = cols[0];
        if (D.20592 != idx) goto <D.20593>; else goto <D.20594>;
        <D.20593>:
        // predicted unlikely by continue predictor.
        goto <D.19020>;
        <D.20594>:
        D.20595 = cols[1];
        mtoken = D.20595 >> 3;
        D.20595 = cols[1];
        D.20596 = D.20595 & 7;
        switch (D.20596) <default: <D.19024>, case 2: <D.19021>, case 3: <D.19023>>
        <D.19021>:
        mtoken = mtoken | 100663296;
        goto <D.19022>;
        <D.19023>:
        mtoken = mtoken | 167772160;
        goto <D.19022>;
        <D.19024>:
        D.20595 = cols[1];
        monoeg_g_log (0B, 4, "Unknown table for custom attr type %08x", D.20595);
        <D.19025>:
        goto <D.19025>;
        <D.19022>:
        method = get_method (m, mtoken, 0B);
        D.20597 = cols[2];
        val.171 = mono_metadata_blob_heap (m, D.20597);
        val = val.171;
        val.172 = val;
        len = mono_metadata_decode_value (val.172, &val);
        attr = monoeg_g_string_new (".custom ");
        len.173 = (int) len;
        val.172 = val;
        dump = data_dump (val.172, len.173, "\t\t");
        monoeg_g_string_append_printf (attr, "%s = %s", method, dump);
        monoeg_g_free (dump);
        D.20601 = attr->str;
        list = monoeg_g_list_append (list, D.20601);
        monoeg_g_string_free (attr, 0);
        monoeg_g_free (method);
      }
      <D.19020>:
      i = i + 1;
      <D.19027>:
      D.20602 = ca->rows;
      D.20603 = (unsigned int) D.20602;
      if (D.20603 > i) goto <D.19026>; else goto <D.19028>;
      <D.19028>:
      D.20590 = list;
      return D.20590;
    }
  finally
    {
      cols = {CLOBBER};
      val = {CLOBBER};
    }
}


get_marshal_info (struct MonoImage * m, const char * blob)
{
  const char * blob.174;
  unsigned int D.20607;
  char D.20608;
  int D.20609;
  char * D.20610;
  const char * D.20611;
  unsigned int D.20612;
  unsigned int D.20613;
  int len;
  int size;

  size = 0;
  blob.174 = blob;
  D.20607 = mono_metadata_decode_blob_size (blob.174, &blob);
  len = (int) D.20607;
  blob.174 = blob;
  D.20608 = *blob.174;
  D.20609 = (int) D.20608;
  switch (D.20609) <default: <D.19070>, case 2: <D.19035>, case 3: <D.19036>, case 4: <D.19037>, case 5: <D.19038>, case 6: <D.19039>, case 7: <D.19040>, case 8: <D.19041>, case 9: <D.19042>, case 10: <D.19043>, case 11: <D.19044>, case 12: <D.19045>, case 15: <D.19046>, case 19: <D.19047>, case 20: <D.19048>, case 21: <D.19049>, case 22: <D.19050>, case 23: <D.19051>, case 25: <D.19052>, case 26: <D.19053>, case 27: <D.19054>, case 28: <D.19055>, case 29: <D.19056>, case 30: <D.19057>, case 31: <D.19058>, case 32: <D.19059>, case 34: <D.19060>, case 35: <D.19061>, case 36: <D.19062>, case 37: <D.19063>, case 38: <D.19064>, case 40: <D.19065>, case 42: <D.19066>, case 43: <D.19067>, case 44: <D.19068>, case 45: <D.19069>>
  <D.19035>:
  D.20610 = monoeg_strdup ("bool");
  return D.20610;
  <D.19036>:
  D.20610 = monoeg_strdup ("int8");
  return D.20610;
  <D.19037>:
  D.20610 = monoeg_strdup ("unsigned int8");
  return D.20610;
  <D.19038>:
  D.20610 = monoeg_strdup ("int16");
  return D.20610;
  <D.19039>:
  D.20610 = monoeg_strdup ("unsigned int16");
  return D.20610;
  <D.19040>:
  D.20610 = monoeg_strdup ("int32");
  return D.20610;
  <D.19041>:
  D.20610 = monoeg_strdup ("unsigned int32");
  return D.20610;
  <D.19042>:
  D.20610 = monoeg_strdup ("int64");
  return D.20610;
  <D.19043>:
  D.20610 = monoeg_strdup ("unsigned int64");
  return D.20610;
  <D.19044>:
  D.20610 = monoeg_strdup ("float32");
  return D.20610;
  <D.19045>:
  D.20610 = monoeg_strdup ("float64");
  return D.20610;
  <D.19046>:
  D.20610 = monoeg_strdup ("currency");
  return D.20610;
  <D.19047>:
  D.20610 = monoeg_strdup ("bstr");
  return D.20610;
  <D.19048>:
  D.20610 = monoeg_strdup ("lpstr");
  return D.20610;
  <D.19049>:
  D.20610 = monoeg_strdup ("lpwstr");
  return D.20610;
  <D.19050>:
  D.20610 = monoeg_strdup ("lptstr");
  return D.20610;
  <D.19051>:
  blob.174 = blob;
  D.20611 = blob.174 + 1;
  D.20612 = mono_metadata_decode_value (D.20611, &blob);
  size = (int) D.20612;
  D.20610 = monoeg_g_strdup_printf ("fixed sysstring [%d]", size);
  return D.20610;
  <D.19052>:
  D.20610 = monoeg_strdup ("iunknown");
  return D.20610;
  <D.19053>:
  D.20610 = monoeg_strdup ("idispatch");
  return D.20610;
  <D.19054>:
  D.20610 = monoeg_strdup ("struct");
  return D.20610;
  <D.19055>:
  D.20610 = monoeg_strdup ("interface");
  return D.20610;
  <D.19056>:
  D.20610 = monoeg_strdup ("safearray");
  return D.20610;
  <D.19057>:
  blob.174 = blob;
  D.20611 = blob.174 + 1;
  D.20613 = mono_metadata_decode_value (D.20611, &blob);
  size = (int) D.20613;
  D.20610 = monoeg_g_strdup_printf ("fixed array [%d]", size);
  return D.20610;
  <D.19058>:
  D.20610 = monoeg_strdup ("int");
  return D.20610;
  <D.19059>:
  D.20610 = monoeg_strdup ("unsigned int");
  return D.20610;
  <D.19060>:
  D.20610 = monoeg_strdup ("vbbyrefstr");
  return D.20610;
  <D.19061>:
  D.20610 = monoeg_strdup ("ansi bstr");
  return D.20610;
  <D.19062>:
  D.20610 = monoeg_strdup ("tbstr");
  return D.20610;
  <D.19063>:
  D.20610 = monoeg_strdup ("variant bool");
  return D.20610;
  <D.19064>:
  D.20610 = monoeg_strdup ("method");
  return D.20610;
  <D.19065>:
  D.20610 = monoeg_strdup ("as any");
  return D.20610;
  <D.19066>:
  D.20610 = monoeg_strdup ("[]");
  return D.20610;
  <D.19067>:
  D.20610 = monoeg_strdup ("lpstruct");
  return D.20610;
  <D.19068>:
  D.20610 = monoeg_strdup ("custom");
  return D.20610;
  <D.19069>:
  D.20610 = monoeg_strdup ("error");
  return D.20610;
  <D.19070>:
  D.20610 = monoeg_strdup ("unknown");
  return D.20610;
}


init_key_table ()
{
  struct GHashTable * key_table.175;
  struct GHashTable * key_table.176;

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


method_dor_to_token (guint32 idx)
{
  unsigned int D.20617;
  guint32 D.20618;
  unsigned int D.20619;

  D.20617 = idx & 1;
  switch (D.20617) <default: <D.20620>, case 0: <D.19077>, case 1: <D.19078>>
  <D.19077>:
  D.20619 = idx >> 1;
  D.20618 = D.20619 | 100663296;
  return D.20618;
  <D.19078>:
  D.20619 = idx >> 1;
  D.20618 = D.20619 | 167772160;
  return D.20618;
  <D.20620>:
  D.20618 = 4294967295;
  return D.20618;
}


get_method_override (struct MonoImage * m, guint32 token, struct MonoGenericContainer * container)
{
  int D.20622;
  unsigned int D.20623;
  unsigned int D.20624;
  struct MonoClass * D.20630;
  struct MonoGenericClass * D.20632;
  struct MonoGenericContainer * D.20634;
  char * D.20635;
  <unnamed-unsigned:24> D.20636;
  int D.20637;
  struct MonoTableInfo * t;
  int i;

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

    try
      {
        D.20622 = i + -1;
        mono_metadata_decode_row (t, D.20622, &cols, 3);
        D.20623 = cols[1];
        impl = method_dor_to_token (D.20623);
        D.20624 = cols[2];
        decl = method_dor_to_token (D.20624);
        if (token == impl) goto <D.20625>; else goto <D.20626>;
        <D.20625>:
        {
          struct MonoMethod * mh;

          mh = 0B;
          mh = mono_get_method_full (m, decl, 0B, container);
          if (mh != 0B) goto <D.20629>; else goto <D.20627>;
          <D.20629>:
          D.20630 = mh->klass;
          if (D.20630 != 0B) goto <D.20631>; else goto <D.20627>;
          <D.20631>:
          D.20630 = mh->klass;
          D.20632 = D.20630->generic_class;
          if (D.20632 != 0B) goto <D.20628>; else goto <D.20633>;
          <D.20633>:
          D.20630 = mh->klass;
          D.20634 = D.20630->generic_container;
          if (D.20634 != 0B) goto <D.20628>; else goto <D.20627>;
          <D.20628>:
          {
            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.20635 = ret;
            return D.20635;
          }
          <D.20627>:
          D.20635 = get_method_core (m, decl, 0, container);
          return D.20635;
        }
        <D.20626>:
      }
    finally
      {
        cols = {CLOBBER};
      }
  }
  i = i + 1;
  <D.19093>:
  D.20636 = t->rows;
  D.20637 = (int) D.20636;
  if (D.20637 >= i) goto <D.19092>; else goto <D.19094>;
  <D.19094>:
  D.20635 = 0B;
  return D.20635;
}


get_method_impl_flags (guint32 f)
{
  int f.177;
  int D.20642;
  int D.20643;
  unsigned int D.20644;
  unsigned int D.20645;
  unsigned int code_type.178;
  const char * D.20647;
  unsigned int managed_type.179;
  const char * D.20649;
  unsigned int rest.180;
  const char * D.20651;
  char * D.20652;
  struct GString * str;
  char * s;
  int code_type;
  int managed_type;
  int rest;

  str = monoeg_g_string_new ("");
  f.177 = (int) f;
  code_type = f.177 & 3;
  f.177 = (int) f;
  managed_type = f.177 & 4;
  D.20642 = code_type | managed_type;
  D.20643 = ~D.20642;
  D.20644 = (unsigned int) D.20643;
  D.20645 = D.20644 & f;
  rest = (int) D.20645;
  code_type.178 = (unsigned int) code_type;
  D.20647 = map (code_type.178, &method_impl_map);
  monoeg_g_string_append (str, D.20647);
  managed_type.179 = (unsigned int) managed_type;
  D.20649 = map (managed_type.179, &managed_type_map);
  monoeg_g_string_append (str, D.20649);
  rest.180 = (unsigned int) rest;
  D.20651 = flags (rest.180, &managed_impl_flags);
  monoeg_g_string_append (str, D.20651);
  s = str->str;
  monoeg_g_string_free (str, 0);
  D.20652 = s;
  return D.20652;
}