get_typedef (struct MonoImage * m, int idx)
{
  char * D.19927;
  struct MonoTableInfo * D.19928;
  int D.19929;
  unsigned int D.19930;
  int D.19931;
  char * iftmp.0;
  int show_tokens.1;
  int token.2;
  int D.19940;
  unsigned int D.19941;
  const char * D.19942;
  const char * iftmp.3;
  const char * iftmp.4;
  char D.19948;
  const char * D.19952;
  const char * iftmp.5;
  guint32 cols[6];
  const char * ns;
  char * tstring;
  char * result;
  guint32 token;

  try
    {
      if (idx == 1) goto <D.19925>; else goto <D.19926>;
      <D.19925>:
      D.19927 = 0B;
      return D.19927;
      <D.19926>:
      D.19928 = &m->tables[2];
      D.19929 = idx + -1;
      mono_metadata_decode_row (D.19928, D.19929, &cols, 6);
      D.19930 = cols[2];
      ns = mono_metadata_string_heap (m, D.19930);
      D.19931 = idx | 33554432;
      token = (guint32) D.19931;
      token = mono_metadata_nested_in_typedef (m, token);
      show_tokens.1 = show_tokens;
      if (show_tokens.1 != 0) goto <D.19934>; else goto <D.19935>;
      <D.19934>:
      iftmp.0 = monoeg_g_strdup_printf ("/*%08x*/", token);
      goto <D.19936>;
      <D.19935>:
      iftmp.0 = 0B;
      <D.19936>:
      tstring = iftmp.0;
      if (token != 0) goto <D.19937>; else goto <D.19938>;
      <D.19937>:
      {
        char * outer;

        token.2 = (int) token;
        D.19940 = token.2 & 16777215;
        outer = get_typedef (m, D.19940);
        D.19941 = cols[1];
        D.19942 = mono_metadata_string_heap (m, D.19941);
        if (tstring != 0B) goto <D.19944>; else goto <D.19945>;
        <D.19944>:
        iftmp.3 = tstring;
        goto <D.19946>;
        <D.19945>:
        iftmp.3 = "";
        <D.19946>:
        result = monoeg_g_strdup_printf ("%s/%s%s", outer, D.19942, iftmp.3);
        monoeg_g_free (outer);
        monoeg_g_free (tstring);
        D.19927 = result;
        return D.19927;
      }
      <D.19938>:
      D.19948 = *ns;
      if (D.19948 != 0) goto <D.19949>; else goto <D.19950>;
      <D.19949>:
      iftmp.4 = ".";
      goto <D.19951>;
      <D.19950>:
      iftmp.4 = "";
      <D.19951>:
      D.19941 = cols[1];
      D.19952 = mono_metadata_string_heap (m, D.19941);
      if (tstring != 0B) goto <D.19954>; else goto <D.19955>;
      <D.19954>:
      iftmp.5 = tstring;
      goto <D.19956>;
      <D.19955>:
      iftmp.5 = "";
      <D.19956>:
      result = monoeg_g_strdup_printf ("%s%s%s%s", ns, iftmp.4, D.19952, iftmp.5);
      monoeg_g_free (tstring);
      D.19927 = result;
      return D.19927;
    }
  finally
    {
      cols = {CLOBBER};
    }
}


get_module (struct MonoImage * m, int idx)
{
  _Bool D.19959;
  long int D.19960;
  long int D.19961;
  struct MonoTableInfo * D.19964;
  int D.19965;
  char * D.19966;
  unsigned int D.19967;
  const char * D.19968;
  guint32 cols[5];

  try
    {
      D.19959 = idx != 1;
      D.19960 = (long int) D.19959;
      D.19961 = __builtin_expect (D.19960, 0);
      if (D.19961 != 0) goto <D.19962>; else goto <D.19963>;
      <D.19962>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "get.c", 92, "idx == 1");
      <D.19963>:
      D.19964 = &m->tables[0];
      D.19965 = idx + -1;
      mono_metadata_decode_row (D.19964, D.19965, &cols, 5);
      D.19967 = cols[1];
      D.19968 = mono_metadata_string_heap (m, D.19967);
      D.19966 = get_escaped_name (D.19968);
      return D.19966;
    }
  finally
    {
      cols = {CLOBBER};
    }
}


get_moduleref (struct MonoImage * m, int idx)
{
  struct MonoTableInfo * D.19971;
  int D.19972;
  char * D.19973;
  unsigned int D.19974;
  const char * D.19975;
  guint32 cols[1];

  try
    {
      D.19971 = &m->tables[26];
      D.19972 = idx + -1;
      mono_metadata_decode_row (D.19971, D.19972, &cols, 1);
      D.19974 = cols[0];
      D.19975 = mono_metadata_string_heap (m, D.19974);
      D.19973 = get_escaped_name (D.19975);
      return D.19973;
    }
  finally
    {
      cols = {CLOBBER};
    }
}


get_assemblyref (struct MonoImage * m, int idx)
{
  struct MonoTableInfo * D.19978;
  int D.19979;
  char * D.19980;
  unsigned int D.19981;
  const char * D.19982;
  guint32 cols[9];

  try
    {
      D.19978 = &m->tables[35];
      D.19979 = idx + -1;
      mono_metadata_decode_row (D.19978, D.19979, &cols, 9);
      D.19981 = cols[6];
      D.19982 = mono_metadata_string_heap (m, D.19981);
      D.19980 = get_escaped_name (D.19982);
      return D.19980;
    }
  finally
    {
      cols = {CLOBBER};
    }
}


get_typespec (struct MonoImage * m, guint32 idx, gboolean is_def, struct MonoGenericContainer * container)
{
  struct MonoTableInfo * D.19985;
  unsigned int D.19986;
  int D.19987;
  unsigned int D.19988;
  const char * ptr.6;
  const char * ptr.7;
  unsigned int D.19991;
  const char * ptr.8;
  const char * ptr.9;
  char D.19994;
  int D.19995;
  const char * ptr.10;
  char * s.11;
  char D.20000;
  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.20014;
  const char * ptr.18;
  int show_tokens.19;
  unsigned int D.20019;
  char * D.20020;
  char * D.20022;
  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.19985 = &m->tables[27];
      D.19986 = idx + 4294967295;
      D.19987 = (int) D.19986;
      mono_metadata_decode_row (D.19985, D.19987, &cols, 1);
      D.19988 = cols[0];
      ptr.6 = mono_metadata_blob_heap (m, D.19988);
      ptr = ptr.6;
      ptr.7 = ptr;
      D.19991 = mono_metadata_decode_value (ptr.7, &ptr);
      len = (int) D.19991;
      ptr.7 = ptr;
      ptr.8 = ptr.7;
      ptr.9 = ptr.8 + 1;
      ptr = ptr.9;
      D.19994 = *ptr.8;
      D.19995 = (int) D.19994;
      switch (D.19995) <default: <D.19046>, case 15: <D.19041>, case 20: <D.19044>, case 27: <D.19043>, case 29: <D.19045>>
      <D.19041>:
      ptr.7 = ptr;
      ptr.10 = get_custom_mod (m, ptr.7, &s);
      ptr = ptr.10;
      s.11 = s;
      if (s.11 != 0B) goto <D.19998>; else goto <D.19999>;
      <D.19998>:
      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.19999>:
      ptr.7 = ptr;
      D.20000 = *ptr.7;
      if (D.20000 == 1) goto <D.20001>; else goto <D.20002>;
      <D.20001>:
      monoeg_g_string_append (res, "void");
      goto <D.20003>;
      <D.20002>:
      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.20005>; else goto <D.20006>;
      <D.20005>:
      s.11 = s;
      monoeg_g_string_append (res, s.11);
      <D.20006>:
      <D.20003>:
      monoeg_g_string_append (res, "*");
      goto <D.19042>;
      <D.19043>:
      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.19042>;
      <D.19044>:
      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.19042>;
      <D.19045>:
      ptr.7 = ptr;
      ptr.16 = get_custom_mod (m, ptr.7, &s);
      ptr = ptr.16;
      s.11 = s;
      if (s.11 != 0B) goto <D.20011>; else goto <D.20012>;
      <D.20011>:
      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.20012>:
      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.19042>;
      <D.19046>:
      ptr.7 = ptr;
      D.20014 = ptr.7 + 18446744073709551615;
      ptr.18 = get_type (m, D.20014, &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.19042>;
      <D.19042>:
      show_tokens.19 = show_tokens;
      if (show_tokens.19 != 0) goto <D.20017>; else goto <D.20018>;
      <D.20017>:
      {
        int token;

        D.20019 = idx | 452984832;
        token = (int) D.20019;
        D.20020 = res->str;
        result = monoeg_g_strdup_printf ("%s/*%08x*/", D.20020, token);
      }
      goto <D.20021>;
      <D.20018>:
      result = res->str;
      <D.20021>:
      monoeg_g_string_free (res, 0);
      D.20022 = result;
      return D.20022;
    }
  finally
    {
      cols = {CLOBBER};
      ptr = {CLOBBER};
      s = {CLOBBER};
    }
}


get_array_shape (struct MonoImage * m, const char * ptr, char * * result)
{
  const char * ptr.20;
  long unsigned int D.20028;
  long unsigned int D.20029;
  long unsigned int D.20030;
  long unsigned int D.20031;
  gint32 * D.20032;
  unsigned int D.20033;
  int D.20034;
  unsigned int i.21;
  long unsigned int D.20038;
  long unsigned int D.20039;
  gint32 * D.20040;
  int D.20041;
  char * D.20042;
  const char * D.20043;
  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.20026>; else goto <D.20027>;
  <D.20026>:
  D.20028 = (long unsigned int) num_sizes;
  D.20029 = D.20028 * 4;
  sizes = monoeg_malloc (D.20029);
  <D.20027>:
  i = 0;
  goto <D.19023>;
  <D.19022>:
  D.20030 = (long unsigned int) i;
  D.20031 = D.20030 * 4;
  D.20032 = sizes + D.20031;
  ptr.20 = ptr;
  D.20033 = mono_metadata_decode_value (ptr.20, &ptr);
  D.20034 = (int) D.20033;
  *D.20032 = D.20034;
  i = i + 1;
  <D.19023>:
  i.21 = (unsigned int) i;
  if (i.21 < num_sizes) goto <D.19022>; else goto <D.19024>;
  <D.19024>:
  ptr.20 = ptr;
  num_lo_bounds = mono_metadata_decode_value (ptr.20, &ptr);
  if (num_lo_bounds != 0) goto <D.20036>; else goto <D.20037>;
  <D.20036>:
  D.20038 = (long unsigned int) num_lo_bounds;
  D.20039 = D.20038 * 4;
  lo_bounds = monoeg_malloc (D.20039);
  <D.20037>:
  i = 0;
  goto <D.19026>;
  <D.19025>:
  D.20030 = (long unsigned int) i;
  D.20031 = D.20030 * 4;
  D.20040 = lo_bounds + D.20031;
  ptr.20 = ptr;
  D.20041 = mono_metadata_decode_signed_value (ptr.20, &ptr);
  *D.20040 = D.20041;
  i = i + 1;
  <D.19026>:
  i.21 = (unsigned int) i;
  if (i.21 < num_lo_bounds) goto <D.19025>; else goto <D.19027>;
  <D.19027>:
  D.20042 = stringify_array (rank, num_sizes, num_lo_bounds, sizes, lo_bounds);
  *result = D.20042;
  monoeg_g_free (sizes);
  monoeg_g_free (lo_bounds);
  D.20043 = ptr;
  return D.20043;
}


stringify_array (guint32 rank, guint32 num_sizes, guint32 num_lo_bounds, gint32 * sizes, gint32 * lo_bounds)
{
  unsigned int i.22;
  long unsigned int D.20050;
  long unsigned int D.20051;
  gint32 * D.20052;
  int D.20053;
  gint32 * D.20058;
  int D.20059;
  int D.20060;
  int D.20061;
  char * D.20063;
  struct GString * res;
  int i;

  res = monoeg_g_string_new ("[");
  i = 0;
  goto <D.19009>;
  <D.19008>:
  if (i != 0) goto <D.20045>; else goto <D.20046>;
  <D.20045>:
  monoeg_g_string_append_c (res, 44);
  <D.20046>:
  i.22 = (unsigned int) i;
  if (i.22 < num_lo_bounds) goto <D.20048>; else goto <D.20049>;
  <D.20048>:
  D.20050 = (long unsigned int) i;
  D.20051 = D.20050 * 4;
  D.20052 = lo_bounds + D.20051;
  D.20053 = *D.20052;
  monoeg_g_string_append_printf (res, "%d...", D.20053);
  <D.20049>:
  i.22 = (unsigned int) i;
  if (i.22 < num_sizes) goto <D.20054>; else goto <D.20055>;
  <D.20054>:
  i.22 = (unsigned int) i;
  if (i.22 < num_lo_bounds) goto <D.20056>; else goto <D.20057>;
  <D.20056>:
  D.20050 = (long unsigned int) i;
  D.20051 = D.20050 * 4;
  D.20052 = lo_bounds + D.20051;
  D.20053 = *D.20052;
  D.20050 = (long unsigned int) i;
  D.20051 = D.20050 * 4;
  D.20058 = sizes + D.20051;
  D.20059 = *D.20058;
  D.20060 = D.20053 + D.20059;
  D.20061 = D.20060 + -1;
  monoeg_g_string_append_printf (res, "%d", D.20061);
  goto <D.20062>;
  <D.20057>:
  D.20050 = (long unsigned int) i;
  D.20051 = D.20050 * 4;
  D.20058 = sizes + D.20051;
  D.20059 = *D.20058;
  monoeg_g_string_append_printf (res, "%d", D.20059);
  <D.20062>:
  <D.20055>:
  i = i + 1;
  <D.19009>:
  i.22 = (unsigned int) i;
  if (i.22 < rank) goto <D.19008>; else goto <D.19010>;
  <D.19010>:
  monoeg_g_string_append (res, "]");
  D.20063 = monoeg_g_string_free (res, 0);
  return D.20063;
}


get_typeref (struct MonoImage * m, int idx)
{
  struct MonoTableInfo * D.20065;
  int D.20066;
  unsigned int D.20067;
  unsigned int D.20068;
  unsigned int D.20069;
  int rs_idx.23;
  const char * iftmp.24;
  char D.20072;
  const char * iftmp.25;
  const char * iftmp.26;
  int show_tokens.27;
  char * D.20087;
  guint32 cols[3];
  const char * s;
  const char * t;
  char * x;
  char * ret;
  guint32 rs_idx;
  guint32 table;

  try
    {
      D.20065 = &m->tables[1];
      D.20066 = idx + -1;
      mono_metadata_decode_row (D.20065, D.20066, &cols, 3);
      D.20067 = cols[1];
      t = mono_metadata_string_heap (m, D.20067);
      D.20068 = cols[2];
      s = mono_metadata_string_heap (m, D.20068);
      D.20069 = cols[0];
      rs_idx = D.20069 >> 2;
      D.20069 = cols[0];
      table = D.20069 & 3;
      switch (table) <default: <D.19064>, case 0: <D.19059>, case 1: <D.19061>, case 2: <D.19062>, case 3: <D.19063>>
      <D.19059>:
      rs_idx.23 = (int) rs_idx;
      x = get_module (m, rs_idx.23);
      D.20072 = *s;
      if (D.20072 != 0) goto <D.20073>; else goto <D.20074>;
      <D.20073>:
      iftmp.24 = ".";
      goto <D.20075>;
      <D.20074>:
      iftmp.24 = "";
      <D.20075>:
      ret = monoeg_g_strdup_printf ("[%s] %s%s%s", x, s, iftmp.24, t);
      monoeg_g_free (x);
      goto <D.19060>;
      <D.19061>:
      rs_idx.23 = (int) rs_idx;
      x = get_moduleref (m, rs_idx.23);
      D.20072 = *s;
      if (D.20072 != 0) goto <D.20077>; else goto <D.20078>;
      <D.20077>:
      iftmp.25 = ".";
      goto <D.20079>;
      <D.20078>:
      iftmp.25 = "";
      <D.20079>:
      ret = monoeg_g_strdup_printf ("[.module %s]%s%s%s", x, s, iftmp.25, t);
      goto <D.19060>;
      <D.19062>:
      rs_idx.23 = (int) rs_idx;
      x = get_assemblyref (m, rs_idx.23);
      D.20072 = *s;
      if (D.20072 != 0) goto <D.20081>; else goto <D.20082>;
      <D.20081>:
      iftmp.26 = ".";
      goto <D.20083>;
      <D.20082>:
      iftmp.26 = "";
      <D.20083>:
      ret = monoeg_g_strdup_printf ("[%s]%s%s%s", x, s, iftmp.26, t);
      monoeg_g_free (x);
      goto <D.19060>;
      <D.19063>:
      rs_idx.23 = (int) rs_idx;
      x = get_typeref (m, rs_idx.23);
      ret = monoeg_g_strdup_printf ("%s/%s", x, t);
      monoeg_g_free (x);
      goto <D.19060>;
      <D.19064>:
      ret = monoeg_g_strdup_printf ("Unknown table in TypeRef %d", table);
      <D.19060>:
      show_tokens.27 = show_tokens;
      if (show_tokens.27 != 0) goto <D.20085>; else goto <D.20086>;
      <D.20085>:
      {
        int token;
        char * temp;

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


get_typedef_or_ref (struct MonoImage * m, guint32 dor_token, struct MonoGenericContainer * container)
{
  int dor_token.28;
  unsigned int D.20091;
  unsigned int idx.29;
  char * D.20095;
  char * temp;
  char * s;
  int table;
  int idx;

  temp = 0B;
  s = 0B;
  dor_token.28 = (int) dor_token;
  table = dor_token.28 & 3;
  D.20091 = dor_token >> 2;
  idx = (int) D.20091;
  switch (table) <default: <D.19080>, case 0: <D.19076>, case 1: <D.19078>, case 2: <D.19079>>
  <D.19076>:
  temp = get_typedef (m, idx);
  s = monoeg_g_strdup_printf ("%s", temp);
  goto <D.19077>;
  <D.19078>:
  temp = get_typeref (m, idx);
  s = monoeg_g_strdup_printf ("%s", temp);
  goto <D.19077>;
  <D.19079>:
  idx.29 = (unsigned int) idx;
  s = get_typespec (m, idx.29, 0, container);
  goto <D.19077>;
  <D.19080>:
  monoeg_g_log (0B, 4, "Unhandled encoding for typedef-or-ref coded index 0x%08x", dor_token);
  <D.19081>:
  goto <D.19081>;
  <D.19077>:
  if (temp != 0B) goto <D.20093>; else goto <D.20094>;
  <D.20093>:
  monoeg_g_free (temp);
  <D.20094>:
  D.20095 = s;
  return D.20095;
}


get_type_or_methdef (struct MonoImage * m, guint32 dor_token)
{
  unsigned int D.20097;
  char * D.20100;
  unsigned int D.20101;
  int D.20102;

  D.20097 = dor_token & 1;
  if (D.20097 != 0) goto <D.20098>; else goto <D.20099>;
  <D.20098>:
  D.20101 = dor_token >> 1;
  D.20100 = get_methoddef (m, D.20101);
  return D.20100;
  <D.20099>:
  D.20101 = dor_token >> 1;
  D.20102 = (int) D.20101;
  D.20100 = get_typedef (m, D.20102);
  return D.20100;
}


get_encoded_typedef_or_ref (struct MonoImage * m, const char * ptr, char * * result)
{
  const char * ptr.30;
  char * D.20105;
  const char * D.20106;
  guint32 token;

  ptr.30 = ptr;
  token = mono_metadata_decode_value (ptr.30, &ptr);
  D.20105 = get_typedef_or_ref (m, token, 0B);
  *result = D.20105;
  D.20106 = ptr;
  return D.20106;
}


get_custom_mod (struct MonoImage * m, const char * ptr, char * * return_value)
{
  const char * iftmp.31;
  char D.20109;
  char * D.20113;
  char * s.32;
  gchar * D.20117;
  gchar * D.20119;
  char D.20120;
  const char * D.20121;
  char * s;
  const char * mod;

  try
    {
      *return_value = 0B;
      goto <D.19100>;
      <D.19099>:
      D.20109 = *ptr;
      if (D.20109 == 31) goto <D.20110>; else goto <D.20111>;
      <D.20110>:
      iftmp.31 = "modreq";
      goto <D.20112>;
      <D.20111>:
      iftmp.31 = "modopt";
      <D.20112>:
      mod = iftmp.31;
      ptr = ptr + 1;
      ptr = get_encoded_typedef_or_ref (m, ptr, &s);
      D.20113 = *return_value;
      if (D.20113 == 0B) goto <D.20114>; else goto <D.20115>;
      <D.20114>:
      s.32 = s;
      D.20117 = monoeg_g_strconcat (" ", mod, " (", s.32, ")", 0B);
      *return_value = D.20117;
      goto <D.20118>;
      <D.20115>:
      D.20113 = *return_value;
      s.32 = s;
      D.20119 = monoeg_g_strconcat (D.20113, " ", mod, " (", s.32, ")", 0B);
      *return_value = D.20119;
      <D.20118>:
      s.32 = s;
      monoeg_g_free (s.32);
      <D.19100>:
      D.20109 = *ptr;
      D.20120 = D.20109 + 225;
      if (D.20120 <= 1) goto <D.19099>; else goto <D.19101>;
      <D.19101>:
      D.20121 = ptr;
      return D.20121;
    }
  finally
    {
      s = {CLOBBER};
    }
}


dis_stringify_token (struct MonoImage * m, guint32 token)
{
  unsigned int D.20124;
  char * D.20125;
  int idx.33;
  guint idx;

  idx = token & 16777215;
  D.20124 = token >> 24;
  switch (D.20124) <default: <D.19112>, case 1: <D.19110>, case 2: <D.19109>, case 27: <D.19111>>
  <D.19109>:
  idx.33 = (int) idx;
  D.20125 = get_typedef (m, idx.33);
  return D.20125;
  <D.19110>:
  idx.33 = (int) idx;
  D.20125 = get_typeref (m, idx.33);
  return D.20125;
  <D.19111>:
  D.20125 = get_typespec (m, idx, 0, 0B);
  return D.20125;
  <D.19112>:
  goto <D.19113>;
  <D.19113>:
  D.20125 = monoeg_g_strdup_printf ("0x%08x", token);
  return D.20125;
}


dis_stringify_array (struct MonoImage * m, struct MonoArrayType * array, gboolean is_def)
{
  struct MonoClass * D.20129;
  struct MonoType * D.20130;
  unsigned char D.20131;
  unsigned int D.20132;
  unsigned char D.20133;
  unsigned int D.20134;
  unsigned char D.20135;
  unsigned int D.20136;
  int * D.20137;
  int * D.20138;
  char * D.20139;
  char * type;
  char * arr_str;
  char * ret;

  D.20129 = array->eklass;
  D.20130 = &D.20129->byval_arg;
  type = dis_stringify_type (m, D.20130, is_def);
  D.20131 = array->rank;
  D.20132 = (unsigned int) D.20131;
  D.20133 = array->numsizes;
  D.20134 = (unsigned int) D.20133;
  D.20135 = array->numlobounds;
  D.20136 = (unsigned int) D.20135;
  D.20137 = array->sizes;
  D.20138 = array->lobounds;
  arr_str = stringify_array (D.20132, D.20134, D.20136, D.20137, D.20138);
  ret = monoeg_g_strconcat (type, arr_str, 0B);
  monoeg_g_free (arr_str);
  monoeg_g_free (type);
  D.20139 = ret;
  return D.20139;
}


dis_stringify_modifiers (struct MonoImage * m, int n, struct MonoCustomMod * mod)
{
  long unsigned int D.20141;
  long unsigned int D.20142;
  struct MonoCustomMod * D.20143;
  <unnamed-unsigned:31> D.20144;
  unsigned int D.20145;
  const char * iftmp.34;
  unsigned int D.20149;
  unsigned int D.20150;
  char * D.20154;
  struct GString * s;
  char * result;
  int i;

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

    D.20141 = (long unsigned int) i;
    D.20142 = D.20141 * 4;
    D.20143 = mod + D.20142;
    D.20144 = D.20143->token;
    D.20145 = (unsigned int) D.20144;
    tok = dis_stringify_token (m, D.20145);
    if (i > 0) goto <D.20146>; else goto <D.20147>;
    <D.20146>:
    monoeg_g_string_append_printf (s, " ");
    <D.20147>:
    D.20141 = (long unsigned int) i;
    D.20142 = D.20141 * 4;
    D.20143 = mod + D.20142;
    D.20149 = BIT_FIELD_REF <*D.20143, 32, 0>;
    D.20150 = D.20149 & 1;
    if (D.20150 != 0) goto <D.20151>; else goto <D.20152>;
    <D.20151>:
    iftmp.34 = "modreq";
    goto <D.20153>;
    <D.20152>:
    iftmp.34 = "modopt";
    <D.20153>:
    monoeg_g_string_append_printf (s, " %s (%s)", iftmp.34, tok);
    monoeg_g_free (tok);
  }
  i = i + 1;
  <D.19132>:
  if (i < n) goto <D.19131>; else goto <D.19133>;
  <D.19133>:
  monoeg_g_string_append_c (s, 32);
  result = s->str;
  monoeg_g_string_free (s, 0);
  D.20154 = result;
  return D.20154;
}


dis_stringify_param (struct MonoImage * m, struct MonoType * param)
{
  const char * iftmp.35;
  short unsigned int D.20157;
  int D.20158;
  int D.20159;
  const char * iftmp.36;
  int D.20164;
  const char * iftmp.37;
  int D.20169;
  const gchar * iftmp.38;
  char D.20174;
  char * D.20178;
  char * t;
  char * result;
  char * attribs;
  const char * in;
  const char * out;
  const char * opt;

  D.20157 = param->attrs;
  D.20158 = (int) D.20157;
  D.20159 = D.20158 & 1;
  if (D.20159 != 0) goto <D.20160>; else goto <D.20161>;
  <D.20160>:
  iftmp.35 = "[in]";
  goto <D.20162>;
  <D.20161>:
  iftmp.35 = "";
  <D.20162>:
  in = iftmp.35;
  D.20157 = param->attrs;
  D.20158 = (int) D.20157;
  D.20164 = D.20158 & 2;
  if (D.20164 != 0) goto <D.20165>; else goto <D.20166>;
  <D.20165>:
  iftmp.36 = "[out]";
  goto <D.20167>;
  <D.20166>:
  iftmp.36 = "";
  <D.20167>:
  out = iftmp.36;
  D.20157 = param->attrs;
  D.20158 = (int) D.20157;
  D.20169 = D.20158 & 16;
  if (D.20169 != 0) goto <D.20170>; else goto <D.20171>;
  <D.20170>:
  iftmp.37 = "[opt]";
  goto <D.20172>;
  <D.20171>:
  iftmp.37 = "";
  <D.20172>:
  opt = iftmp.37;
  attribs = monoeg_g_strconcat (in, out, opt, 0B);
  t = dis_stringify_type (m, param, 1);
  D.20174 = *attribs;
  if (D.20174 != 0) goto <D.20175>; else goto <D.20176>;
  <D.20175>:
  iftmp.38 = " ";
  goto <D.20177>;
  <D.20176>:
  iftmp.38 = "";
  <D.20177>:
  result = monoeg_g_strjoin (iftmp.38, attribs, t, 0B);
  monoeg_g_free (t);
  monoeg_g_free (attribs);
  D.20178 = result;
  return D.20178;
}


dis_stringify_marshal_spec (struct MonoMarshalSpec * spec)
{
  <unnamed type> D.20180;
  char * D.20181;
  int D.20182;
  short int D.20183;
  <unnamed type> D.20184;
  short int D.20193;
  unsigned int D.20194;
  <unnamed type> D.20198;
  const char * iftmp.39;
  const char * iftmp.40;
  char * D.20206;
  const char * iftmp.41;
  char * D.20211;

  D.20180 = spec->native;
  switch (D.20180) <default: <D.19244>, case 23: <D.19232>, case 29: <D.19240>, case 30: <D.19233>, case 42: <D.19234>, case 44: <D.19243>>
  <D.19232>:
  D.20182 = spec->data.array_data.num_elem;
  D.20181 = monoeg_g_strdup_printf (" marshal (fixed sysstring [%d])", D.20182);
  return D.20181;
  <D.19233>:
  D.20182 = spec->data.array_data.num_elem;
  D.20181 = monoeg_g_strdup_printf (" marshal (fixed array [%d])", D.20182);
  return D.20181;
  <D.19234>:
  {
    char * elem_type;
    char * elems;
    char * ret;
    guint32 num_elem;
    guint32 param_num;

    D.20182 = spec->data.array_data.num_elem;
    num_elem = (guint32) D.20182;
    D.20183 = spec->data.array_data.param_num;
    param_num = (guint32) D.20183;
    D.20184 = spec->data.array_data.elem_type;
    elem_type = dis_stringify_native_type (D.20184);
    if (num_elem == 4294967295) goto <D.20187>; else goto <D.20185>;
    <D.20187>:
    if (param_num == 4294967295) goto <D.20188>; else goto <D.20185>;
    <D.20188>:
    elems = monoeg_strdup ("");
    goto <D.20186>;
    <D.20185>:
    if (param_num == 4294967295) goto <D.20189>; else goto <D.20192>;
    <D.20192>:
    D.20193 = spec->data.array_data.elem_mult;
    if (D.20193 == 0) goto <D.20189>; else goto <D.20190>;
    <D.20189>:
    elems = monoeg_g_strdup_printf ("%d", num_elem);
    goto <D.20191>;
    <D.20190>:
    D.20194 = num_elem + 4294967295;
    if (D.20194 > 4294967293) goto <D.20195>; else goto <D.20196>;
    <D.20195>:
    elems = monoeg_g_strdup_printf ("+ %d", param_num);
    goto <D.20197>;
    <D.20196>:
    elems = monoeg_g_strdup_printf ("%d + %d", num_elem, param_num);
    <D.20197>:
    <D.20191>:
    <D.20186>:
    ret = monoeg_g_strdup_printf (" marshal (%s[%s])", elem_type, elems);
    monoeg_g_free (elem_type);
    monoeg_g_free (elems);
    D.20181 = ret;
    return D.20181;
  }
  <D.19240>:
  {
    char * elem_type;
    char * ret;

    elem_type = 0B;
    D.20198 = spec->data.safearray_data.elem_type;
    if (D.20198 != 0) goto <D.20199>; else goto <D.20200>;
    <D.20199>:
    D.20198 = spec->data.safearray_data.elem_type;
    elem_type = dis_stringify_variant_type (D.20198);
    <D.20200>:
    if (elem_type != 0B) goto <D.20202>; else goto <D.20203>;
    <D.20202>:
    iftmp.39 = elem_type;
    goto <D.20204>;
    <D.20203>:
    iftmp.39 = "";
    <D.20204>:
    ret = monoeg_g_strdup_printf (" marshal (safearray %s)", iftmp.39);
    monoeg_g_free (elem_type);
    D.20181 = ret;
    return D.20181;
  }
  <D.19243>:
  D.20206 = spec->data.custom_data.custom_name;
  if (D.20206 != 0B) goto <D.20207>; else goto <D.20208>;
  <D.20207>:
  iftmp.40 = spec->data.custom_data.custom_name;
  goto <D.20209>;
  <D.20208>:
  iftmp.40 = "";
  <D.20209>:
  D.20211 = spec->data.custom_data.cookie;
  if (D.20211 != 0B) goto <D.20212>; else goto <D.20213>;
  <D.20212>:
  iftmp.41 = spec->data.custom_data.cookie;
  goto <D.20214>;
  <D.20213>:
  iftmp.41 = "";
  <D.20214>:
  D.20181 = monoeg_g_strdup_printf (" marshal (custom (\"%s\", \"%s\"))", iftmp.40, iftmp.41);
  return D.20181;
  <D.19244>:
  {
    char * native_type;
    char * ret;

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


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

  if (str != 0B) goto <D.20216>; else goto <D.20217>;
  <D.20216>:
  D.20218 = __strdup (str);
  return D.20218;
  <D.20217>:
  D.20218 = 0B;
  return D.20218;
}


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

  switch (variant) <default: <D.19191>, case 0: <D.19147>, case 1: <D.19148>, case 2: <D.19149>, case 3: <D.19150>, case 4: <D.19151>, case 5: <D.19152>, case 6: <D.19153>, case 7: <D.19154>, case 8: <D.19155>, case 9: <D.19156>, case 10: <D.19157>, case 11: <D.19158>, case 12: <D.19159>, case 13: <D.19160>, case 14: <D.19161>, case 16: <D.19162>, case 17: <D.19163>, case 18: <D.19164>, case 19: <D.19165>, case 20: <D.19166>, case 21: <D.19167>, case 22: <D.19168>, case 23: <D.19169>, case 24: <D.19170>, case 25: <D.19171>, case 26: <D.19172>, case 27: <D.19173>, case 28: <D.19174>, case 29: <D.19175>, case 30: <D.19176>, case 31: <D.19177>, case 36: <D.19178>, case 64: <D.19179>, case 65: <D.19180>, case 66: <D.19181>, case 67: <D.19182>, case 68: <D.19183>, case 69: <D.19184>, case 70: <D.19185>, case 71: <D.19186>, case 72: <D.19187>, case 4096: <D.19188>, case 8192: <D.19189>, case 16384: <D.19190>>
  <D.19147>:
  D.20220 = monoeg_strdup ("");
  return D.20220;
  <D.19148>:
  D.20220 = monoeg_strdup ("null");
  return D.20220;
  <D.19149>:
  D.20220 = monoeg_strdup ("int16");
  return D.20220;
  <D.19150>:
  D.20220 = monoeg_strdup ("int32");
  return D.20220;
  <D.19151>:
  D.20220 = monoeg_strdup ("float32");
  return D.20220;
  <D.19152>:
  D.20220 = monoeg_strdup ("float64");
  return D.20220;
  <D.19153>:
  D.20220 = monoeg_strdup ("currency");
  return D.20220;
  <D.19154>:
  D.20220 = monoeg_strdup ("date");
  return D.20220;
  <D.19155>:
  D.20220 = monoeg_strdup ("bstr");
  return D.20220;
  <D.19156>:
  D.20220 = monoeg_strdup ("idispatch");
  return D.20220;
  <D.19157>:
  D.20220 = monoeg_strdup ("error");
  return D.20220;
  <D.19158>:
  D.20220 = monoeg_strdup ("bool");
  return D.20220;
  <D.19159>:
  D.20220 = monoeg_strdup ("variant");
  return D.20220;
  <D.19160>:
  D.20220 = monoeg_strdup ("iunknown");
  return D.20220;
  <D.19161>:
  D.20220 = monoeg_strdup ("decimal");
  return D.20220;
  <D.19162>:
  D.20220 = monoeg_strdup ("int8");
  return D.20220;
  <D.19163>:
  D.20220 = monoeg_strdup ("unsigned int8");
  return D.20220;
  <D.19164>:
  D.20220 = monoeg_strdup ("unsigned int16");
  return D.20220;
  <D.19165>:
  D.20220 = monoeg_strdup ("unsigned int32");
  return D.20220;
  <D.19166>:
  D.20220 = monoeg_strdup ("int64");
  return D.20220;
  <D.19167>:
  D.20220 = monoeg_strdup ("unsigned int64");
  return D.20220;
  <D.19168>:
  D.20220 = monoeg_strdup ("int");
  return D.20220;
  <D.19169>:
  D.20220 = monoeg_strdup ("unsigned int");
  return D.20220;
  <D.19170>:
  D.20220 = monoeg_strdup ("void");
  return D.20220;
  <D.19171>:
  D.20220 = monoeg_strdup ("hresult");
  return D.20220;
  <D.19172>:
  D.20220 = monoeg_strdup ("*");
  return D.20220;
  <D.19173>:
  D.20220 = monoeg_strdup ("safearray");
  return D.20220;
  <D.19174>:
  D.20220 = monoeg_strdup ("carray");
  return D.20220;
  <D.19175>:
  D.20220 = monoeg_strdup ("userdefined");
  return D.20220;
  <D.19176>:
  D.20220 = monoeg_strdup ("lpstr");
  return D.20220;
  <D.19177>:
  D.20220 = monoeg_strdup ("lpwstr");
  return D.20220;
  <D.19178>:
  D.20220 = monoeg_strdup ("record");
  return D.20220;
  <D.19179>:
  D.20220 = monoeg_strdup ("filetime");
  return D.20220;
  <D.19180>:
  D.20220 = monoeg_strdup ("blob");
  return D.20220;
  <D.19181>:
  D.20220 = monoeg_strdup ("stream");
  return D.20220;
  <D.19182>:
  D.20220 = monoeg_strdup ("storage");
  return D.20220;
  <D.19183>:
  D.20220 = monoeg_strdup ("streamed_object");
  return D.20220;
  <D.19184>:
  D.20220 = monoeg_strdup ("stored_object");
  return D.20220;
  <D.19185>:
  D.20220 = monoeg_strdup ("blob_object");
  return D.20220;
  <D.19186>:
  D.20220 = monoeg_strdup ("cf");
  return D.20220;
  <D.19187>:
  D.20220 = monoeg_strdup ("clsid");
  return D.20220;
  <D.19188>:
  D.20220 = monoeg_strdup ("vector");
  return D.20220;
  <D.19189>:
  D.20220 = monoeg_strdup ("[]");
  return D.20220;
  <D.19190>:
  D.20220 = monoeg_strdup ("&");
  return D.20220;
  <D.19191>:
  D.20220 = monoeg_strdup ("unknown");
  return D.20220;
}


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

  switch (native) <default: <D.19228>, case 2: <D.19195>, case 3: <D.19196>, case 4: <D.19197>, case 5: <D.19198>, case 6: <D.19199>, case 7: <D.19200>, case 8: <D.19201>, case 9: <D.19202>, case 10: <D.19203>, case 11: <D.19204>, case 12: <D.19205>, case 15: <D.19206>, case 19: <D.19207>, case 20: <D.19208>, case 21: <D.19209>, case 22: <D.19210>, case 25: <D.19211>, case 26: <D.19212>, case 27: <D.19213>, case 28: <D.19214>, case 29: <D.19215>, case 31: <D.19216>, case 32: <D.19217>, case 34: <D.19218>, case 35: <D.19219>, case 36: <D.19220>, case 37: <D.19221>, case 38: <D.19222>, case 40: <D.19223>, case 43: <D.19224>, case 44: <D.19225>, case 45: <D.19226>, case 80: <D.19227>>
  <D.19195>:
  D.20222 = monoeg_strdup ("bool");
  return D.20222;
  <D.19196>:
  D.20222 = monoeg_strdup ("int8");
  return D.20222;
  <D.19197>:
  D.20222 = monoeg_strdup ("unsigned int8");
  return D.20222;
  <D.19198>:
  D.20222 = monoeg_strdup ("int16");
  return D.20222;
  <D.19199>:
  D.20222 = monoeg_strdup ("unsigned int16");
  return D.20222;
  <D.19200>:
  D.20222 = monoeg_strdup ("int32");
  return D.20222;
  <D.19201>:
  D.20222 = monoeg_strdup ("unsigned int32");
  return D.20222;
  <D.19202>:
  D.20222 = monoeg_strdup ("int64");
  return D.20222;
  <D.19203>:
  D.20222 = monoeg_strdup ("unsigned int64");
  return D.20222;
  <D.19204>:
  D.20222 = monoeg_strdup ("float32");
  return D.20222;
  <D.19205>:
  D.20222 = monoeg_strdup ("float64");
  return D.20222;
  <D.19206>:
  D.20222 = monoeg_strdup ("currency");
  return D.20222;
  <D.19207>:
  D.20222 = monoeg_strdup ("bstr");
  return D.20222;
  <D.19208>:
  D.20222 = monoeg_strdup ("lpstr");
  return D.20222;
  <D.19209>:
  D.20222 = monoeg_strdup ("lpwstr");
  return D.20222;
  <D.19210>:
  D.20222 = monoeg_strdup ("lptstr");
  return D.20222;
  <D.19211>:
  D.20222 = monoeg_strdup ("iunknown");
  return D.20222;
  <D.19212>:
  D.20222 = monoeg_strdup ("idispatch");
  return D.20222;
  <D.19213>:
  D.20222 = monoeg_strdup ("struct");
  return D.20222;
  <D.19214>:
  D.20222 = monoeg_strdup ("interface");
  return D.20222;
  <D.19215>:
  D.20222 = monoeg_strdup ("safearray");
  return D.20222;
  <D.19216>:
  D.20222 = monoeg_strdup ("int");
  return D.20222;
  <D.19217>:
  D.20222 = monoeg_strdup ("unsigned int");
  return D.20222;
  <D.19218>:
  D.20222 = monoeg_strdup ("vbbyrefstr");
  return D.20222;
  <D.19219>:
  D.20222 = monoeg_strdup ("ansi bstr");
  return D.20222;
  <D.19220>:
  D.20222 = monoeg_strdup ("tbstr");
  return D.20222;
  <D.19221>:
  D.20222 = monoeg_strdup ("variant bool");
  return D.20222;
  <D.19222>:
  D.20222 = monoeg_strdup ("method");
  return D.20222;
  <D.19223>:
  D.20222 = monoeg_strdup ("as any");
  return D.20222;
  <D.19224>:
  D.20222 = monoeg_strdup ("lpstruct");
  return D.20222;
  <D.19225>:
  D.20222 = monoeg_strdup ("custom");
  return D.20222;
  <D.19226>:
  D.20222 = monoeg_strdup ("error");
  return D.20222;
  <D.19227>:
  D.20222 = monoeg_strdup ("");
  return D.20222;
  <D.19228>:
  D.20222 = monoeg_strdup ("unknown");
  return D.20222;
}


get_generic_param (struct MonoImage * m, struct MonoGenericContainer * container)
{
  char * D.20226;
  struct MonoGenericParamFull * D.20227;
  long unsigned int D.20228;
  long unsigned int D.20229;
  struct MonoGenericParamInfo * iftmp.42;
  struct MonoGenericContainer * D.20231;
  short unsigned int D.20237;
  int D.20238;
  int D.20239;
  int D.20242;
  int D.20245;
  int D.20248;
  int D.20251;
  struct MonoClass * D.20257;
  struct MonoType * D.20258;
  struct MonoGenericParamInfo * iftmp.43;
  const char * D.20266;
  <unnamed-signed:31> D.20267;
  int D.20268;
  struct GString * result;
  char * retval;
  int i;

  if (container == 0B) goto <D.20224>; else goto <D.20225>;
  <D.20224>:
  D.20226 = 0B;
  return D.20226;
  <D.20225>:
  result = monoeg_g_string_new ("");
  monoeg_g_string_append_c (result, 60);
  i = 0;
  goto <D.19265>;
  <D.19264>:
  {
    struct MonoGenericParam * param;
    struct MonoGenericParamInfo * param_info;
    struct MonoClass * * constr;
    int first;
    guint16 flags;
    char * esname;

    D.20227 = container->type_params;
    D.20228 = (long unsigned int) i;
    D.20229 = D.20228 * 56;
    param = D.20227 + D.20229;
    D.20231 = param->owner;
    if (D.20231 != 0B) goto <D.20232>; else goto <D.20233>;
    <D.20232>:
    iftmp.42 = &MEM[(struct MonoGenericParamFull *)param].info;
    goto <D.20234>;
    <D.20233>:
    iftmp.42 = 0B;
    <D.20234>:
    param_info = iftmp.42;
    first = 1;
    if (i > 0) goto <D.20235>; else goto <D.20236>;
    <D.20235>:
    monoeg_g_string_append (result, ",");
    <D.20236>:
    D.20237 = param_info->flags;
    flags = D.20237 & 3;
    D.20238 = (int) flags;
    D.20239 = D.20238 & 1;
    if (D.20239 != 0) goto <D.20240>; else goto <D.20241>;
    <D.20240>:
    monoeg_g_string_append (result, "+ ");
    <D.20241>:
    D.20238 = (int) flags;
    D.20242 = D.20238 & 2;
    if (D.20242 != 0) goto <D.20243>; else goto <D.20244>;
    <D.20243>:
    monoeg_g_string_append (result, "- ");
    <D.20244>:
    D.20237 = param_info->flags;
    flags = D.20237 & 28;
    D.20238 = (int) flags;
    D.20245 = D.20238 & 4;
    if (D.20245 != 0) goto <D.20246>; else goto <D.20247>;
    <D.20246>:
    monoeg_g_string_append (result, "class ");
    <D.20247>:
    D.20238 = (int) flags;
    D.20248 = D.20238 & 8;
    if (D.20248 != 0) goto <D.20249>; else goto <D.20250>;
    <D.20249>:
    monoeg_g_string_append (result, "valuetype ");
    <D.20250>:
    D.20238 = (int) flags;
    D.20251 = D.20238 & 16;
    if (D.20251 != 0) goto <D.20252>; else goto <D.20253>;
    <D.20252>:
    monoeg_g_string_append (result, ".ctor ");
    <D.20253>:
    constr = param_info->constraints;
    goto <D.19262>;
    <D.19261>:
    {
      char * sig;

      if (first != 0) goto <D.20254>; else goto <D.20255>;
      <D.20254>:
      monoeg_g_string_append_c (result, 40);
      first = 0;
      goto <D.20256>;
      <D.20255>:
      monoeg_g_string_append (result, ", ");
      <D.20256>:
      D.20257 = *constr;
      D.20258 = &D.20257->byval_arg;
      sig = dis_stringify_type (m, D.20258, 1);
      monoeg_g_string_append (result, sig);
      monoeg_g_free (sig);
    }
    constr = constr + 8;
    <D.19262>:
    if (constr != 0B) goto <D.20259>; else goto <D.19263>;
    <D.20259>:
    D.20257 = *constr;
    if (D.20257 != 0B) goto <D.19261>; else goto <D.19263>;
    <D.19263>:
    if (first == 0) goto <D.20260>; else goto <D.20261>;
    <D.20260>:
    monoeg_g_string_append (result, ") ");
    <D.20261>:
    D.20231 = param->owner;
    if (D.20231 != 0B) goto <D.20263>; else goto <D.20264>;
    <D.20263>:
    iftmp.43 = &MEM[(struct MonoGenericParamFull *)param].info;
    goto <D.20265>;
    <D.20264>:
    iftmp.43 = 0B;
    <D.20265>:
    D.20266 = iftmp.43->name;
    esname = get_escaped_name (D.20266);
    monoeg_g_string_append (result, esname);
    monoeg_g_free (esname);
  }
  i = i + 1;
  <D.19265>:
  D.20267 = container->type_argc;
  D.20268 = (int) D.20267;
  if (D.20268 > i) goto <D.19264>; else goto <D.19266>;
  <D.19266>:
  monoeg_g_string_append_c (result, 62);
  retval = result->str;
  monoeg_g_string_free (result, 0);
  D.20226 = retval;
  return D.20226;
}


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

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


dis_stringify_method_signature_full (struct MonoImage * m, struct MonoMethodSignature * method, int methoddef_row, struct MonoGenericContainer * container, gboolean fully_qualified, gboolean with_marshal_info)
{
  int iftmp.44;
  _Bool D.20277;
  long int D.20278;
  long int D.20279;
  struct MonoTableInfo * D.20284;
  int D.20285;
  unsigned int methoddef_row.45;
  int type_idx.46;
  unsigned int D.20293;
  unsigned int D.20296;
  const char * sig.47;
  int D.20298;
  unsigned int D.20299;
  const char * sig.48;
  long unsigned int D.20305;
  long unsigned int D.20306;
  <unnamed-unsigned:24> D.20309;
  int D.20310;
  <unnamed-unsigned:24> D.20314;
  int D.20315;
  int D.20316;
  long unsigned int D.20317;
  long unsigned int D.20318;
  _Bool D.20319;
  int iftmp.49;
  short unsigned int D.20325;
  struct MonoTableInfo * D.20332;
  unsigned int D.20333;
  int D.20334;
  unsigned int i.50;
  unsigned int D.20339;
  unsigned int D.20343;
  const char * D.20344;
  unsigned int D.20347;
  unsigned int D.20348;
  int D.20362;
  int D.20367;
  struct MonoType * D.20368;
  const char * iftmp.51;
  int D.20373;
  struct MonoType * D.20374;
  <unnamed-unsigned:6> D.20377;
  unsigned int D.20378;
  const char * D.20379;
  const char * iftmp.52;
  char * D.20388;
  int show_method_tokens.53;
  int D.20394;
  int D.20395;
  char * D.20398;
  guint32 cols[6];
  guint32 pcols[3];
  guint32 param_index;
  guint32 next_param_index;
  gboolean has_param_row;
  const char * method_name;
  int free_method;
  char * retval;
  char * esname;
  char * type;
  char * marshal_info;
  char * ret_marshal_info;
  char * gen_param;
  struct GString * result;
  struct GString * result_ret;
  int i;
  int start;

  try
    {
      param_index = 0;
      next_param_index = 0;
      method_name = "";
      free_method = 0;
      type = 0B;
      marshal_info = 0B;
      ret_marshal_info = 0B;
      gen_param = 0B;
      result = monoeg_g_string_new ("");
      result_ret = monoeg_g_string_new ("");
      if (method == 0B) goto <D.20275>; else goto <D.20273>;
      <D.20275>:
      if (methoddef_row == 0) goto <D.20276>; else goto <D.20273>;
      <D.20276>:
      iftmp.44 = 1;
      goto <D.20274>;
      <D.20273>:
      iftmp.44 = 0;
      <D.20274>:
      D.20277 = iftmp.44 != 0;
      D.20278 = (long int) D.20277;
      D.20279 = __builtin_expect (D.20278, 0);
      if (D.20279 != 0) goto <D.20280>; else goto <D.20281>;
      <D.20280>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "get.c", 878, "method || methoddef_row");
      <D.20281>:
      if (methoddef_row != 0) goto <D.20282>; else goto <D.20283>;
      <D.20282>:
      D.20284 = &m->tables[6];
      D.20285 = methoddef_row + -1;
      mono_metadata_decode_row (D.20284, D.20285, &cols, 6);
      if (fully_qualified != 0) goto <D.20286>; else goto <D.20287>;
      <D.20286>:
      {
        guint32 type_idx;

        methoddef_row.45 = (unsigned int) methoddef_row;
        type_idx = mono_metadata_typedef_from_method (m, methoddef_row.45);
        if (type_idx != 0) goto <D.20289>; else goto <D.20290>;
        <D.20289>:
        type_idx.46 = (int) type_idx;
        type = get_typedef (m, type_idx.46);
        goto <D.20292>;
        <D.20290>:
        type = monoeg_strdup ("<invalid>");
        <D.20292>:
      }
      <D.20287>:
      D.20293 = cols[3];
      method_name = mono_metadata_string_heap (m, D.20293);
      param_index = cols[5];
      if (method == 0B) goto <D.20294>; else goto <D.20295>;
      <D.20294>:
      {
        const char * sig;

        try
          {
            D.20296 = cols[4];
            sig.47 = mono_metadata_blob_heap (m, D.20296);
            sig = sig.47;
            D.20298 = methoddef_row | 100663296;
            D.20299 = (unsigned int) D.20298;
            container = mono_metadata_load_generic_params (m, D.20299, container);
            if (container != 0B) goto <D.20300>; else goto <D.20301>;
            <D.20300>:
            D.20298 = methoddef_row | 100663296;
            D.20299 = (unsigned int) D.20298;
            mono_metadata_load_generic_param_constraints (m, D.20299, container);
            <D.20301>:
            sig.48 = sig;
            mono_metadata_decode_blob_size (sig.48, &sig);
            sig.48 = sig;
            method = mono_metadata_parse_method_signature_full (m, container, methoddef_row, sig.48, &sig);
            free_method = 1;
          }
        finally
          {
            sig = {CLOBBER};
          }
      }
      <D.20295>:
      if (container != 0B) goto <D.20303>; else goto <D.20304>;
      <D.20303>:
      D.20305 = BIT_FIELD_REF <*container, 64, 256>;
      D.20306 = D.20305 & 2147483648;
      if (D.20306 != 0) goto <D.20307>; else goto <D.20308>;
      <D.20307>:
      gen_param = get_generic_param (m, container);
      <D.20308>:
      <D.20304>:
      D.20309 = m->tables[6].rows;
      D.20310 = (int) D.20309;
      if (D.20310 > methoddef_row) goto <D.20311>; else goto <D.20312>;
      <D.20311>:
      D.20284 = &m->tables[6];
      mono_metadata_decode_row (D.20284, methoddef_row, &cols, 6);
      next_param_index = cols[5];
      goto <D.20313>;
      <D.20312>:
      D.20314 = m->tables[8].rows;
      D.20315 = (int) D.20314;
      D.20316 = D.20315 + 1;
      next_param_index = (guint32) D.20316;
      <D.20313>:
      <D.20283>:
      D.20317 = BIT_FIELD_REF <*method, 64, 64>;
      D.20318 = D.20317 & 18014398509481984;
      D.20319 = D.20318 == 0;
      start = (int) D.20319;
      i = 0;
      goto <D.19305>;
      <D.19304>:
      marshal_info = 0B;
      if (param_index != 0) goto <D.20323>; else goto <D.20321>;
      <D.20323>:
      if (param_index < next_param_index) goto <D.20324>; else goto <D.20321>;
      <D.20324>:
      iftmp.49 = 1;
      goto <D.20322>;
      <D.20321>:
      iftmp.49 = 0;
      <D.20322>:
      has_param_row = iftmp.49;
      esname = 0B;
      D.20325 = method->param_count;
      if (D.20325 == 0) goto <D.20326>; else goto <D.20327>;
      <D.20326>:
      if (has_param_row == 0) goto <D.20328>; else goto <D.20329>;
      <D.20328>:
      // predicted unlikely by continue predictor.
      goto <D.19301>;
      <D.20329>:
      <D.20327>:
      if (has_param_row != 0) goto <D.20330>; else goto <D.20331>;
      <D.20330>:
      D.20332 = &m->tables[8];
      D.20333 = param_index + 4294967295;
      D.20334 = (int) D.20333;
      mono_metadata_decode_row (D.20332, D.20334, &pcols, 3);
      <D.20331>:
      if (has_param_row != 0) goto <D.20337>; else goto <D.20335>;
      <D.20337>:
      i.50 = (unsigned int) i;
      D.20339 = pcols[1];
      if (i.50 == D.20339) goto <D.20340>; else goto <D.20335>;
      <D.20340>:
      if (i != 0) goto <D.20341>; else goto <D.20342>;
      <D.20341>:
      D.20343 = pcols[2];
      D.20344 = mono_metadata_string_heap (m, D.20343);
      esname = get_escaped_name (D.20344);
      <D.20342>:
      if (with_marshal_info != 0) goto <D.20345>; else goto <D.20346>;
      <D.20345>:
      D.20347 = pcols[0];
      D.20348 = D.20347 & 8192;
      if (D.20348 != 0) goto <D.20349>; else goto <D.20350>;
      <D.20349>:
      {
        const char * tp;
        struct MonoMarshalSpec * spec;

        D.20333 = param_index + 4294967295;
        tp = mono_metadata_get_marshal_info (m, D.20333, 0);
        if (tp != 0B) goto <D.20351>; else goto <D.20352>;
        <D.20351>:
        spec = mono_metadata_parse_marshal_spec (m, tp);
        if (i != 0) goto <D.20353>; else goto <D.20354>;
        <D.20353>:
        marshal_info = dis_stringify_marshal_spec (spec);
        goto <D.20355>;
        <D.20354>:
        ret_marshal_info = dis_stringify_marshal_spec (spec);
        <D.20355>:
        goto <D.20356>;
        <D.20352>:
        if (i != 0) goto <D.20357>; else goto <D.20358>;
        <D.20357>:
        marshal_info = monoeg_strdup ("(missing)");
        goto <D.20359>;
        <D.20358>:
        ret_marshal_info = monoeg_strdup ("(missing)");
        <D.20359>:
        <D.20356>:
      }
      <D.20350>:
      <D.20346>:
      param_index = param_index + 1;
      goto <D.20336>;
      <D.20335>:
      if (i != 0) goto <D.20360>; else goto <D.20361>;
      <D.20360>:
      D.20362 = i - start;
      esname = monoeg_g_strdup_printf ("A_%i", D.20362);
      <D.20361>:
      <D.20336>:
      if (i == 0) goto <D.20363>; else goto <D.20364>;
      <D.20363>:
      // predicted unlikely by continue predictor.
      goto <D.19301>;
      <D.20364>:
      if (i > 1) goto <D.20365>; else goto <D.20366>;
      <D.20365>:
      monoeg_g_string_append (result, ", ");
      <D.20366>:
      D.20367 = i + -1;
      D.20368 = method->params[D.20367];
      retval = dis_stringify_param (m, D.20368);
      if (marshal_info != 0B) goto <D.20370>; else goto <D.20371>;
      <D.20370>:
      iftmp.51 = marshal_info;
      goto <D.20372>;
      <D.20371>:
      iftmp.51 = "";
      <D.20372>:
      monoeg_g_string_append_printf (result, "%s%s %s", retval, iftmp.51, esname);
      monoeg_g_free (retval);
      monoeg_g_free (esname);
      monoeg_g_free (marshal_info);
      <D.19301>:
      i = i + 1;
      <D.19305>:
      D.20325 = method->param_count;
      D.20373 = (int) D.20325;
      if (D.20373 >= i) goto <D.19304>; else goto <D.19306>;
      <D.19306>:
      monoeg_g_string_append (result, ") ");
      D.20374 = method->ret;
      retval = dis_stringify_param (m, D.20374);
      D.20317 = BIT_FIELD_REF <*method, 64, 64>;
      D.20318 = D.20317 & 18014398509481984;
      if (D.20318 != 0) goto <D.20375>; else goto <D.20376>;
      <D.20375>:
      monoeg_g_string_append (result_ret, "instance ");
      <D.20376>:
      D.20377 = method->call_convention;
      D.20378 = (unsigned int) D.20377;
      D.20379 = map (D.20378, &call_conv_type_map);
      monoeg_g_string_append (result_ret, D.20379);
      if (ret_marshal_info != 0B) goto <D.20381>; else goto <D.20382>;
      <D.20381>:
      iftmp.52 = ret_marshal_info;
      goto <D.20383>;
      <D.20382>:
      iftmp.52 = "";
      <D.20383>:
      monoeg_g_string_append_printf (result_ret, " %s%s ", retval, iftmp.52);
      monoeg_g_free (ret_marshal_info);
      if (type != 0B) goto <D.20384>; else goto <D.20385>;
      <D.20384>:
      {
        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.20385>:
      esname = get_escaped_name (method_name);
      monoeg_g_string_append (result_ret, esname);
      monoeg_g_free (esname);
      if (gen_param != 0B) goto <D.20386>; else goto <D.20387>;
      <D.20386>:
      monoeg_g_string_append (result_ret, gen_param);
      monoeg_g_free (gen_param);
      <D.20387>:
      monoeg_g_string_append (result_ret, " (");
      monoeg_g_free (retval);
      D.20388 = result_ret->str;
      monoeg_g_string_prepend (result, D.20388);
      monoeg_g_string_free (result_ret, 0);
      show_method_tokens.53 = show_method_tokens;
      if (show_method_tokens.53 != 0) goto <D.20390>; else goto <D.20391>;
      <D.20390>:
      if (methoddef_row != 0) goto <D.20392>; else goto <D.20393>;
      <D.20392>:
      D.20394 = methoddef_row >> 1;
      D.20395 = D.20394 | 100663296;
      monoeg_g_string_append_printf (result, " /* 0x%X */ ", D.20395);
      <D.20393>:
      <D.20391>:
      if (free_method != 0) goto <D.20396>; else goto <D.20397>;
      <D.20396>:
      mono_metadata_free_method_signature (method);
      <D.20397>:
      retval = result->str;
      monoeg_g_string_free (result, 0);
      D.20398 = retval;
      return D.20398;
    }
  finally
    {
      cols = {CLOBBER};
      pcols = {CLOBBER};
    }
}


dis_stringify_function_ptr (struct MonoImage * m, struct MonoMethodSignature * method)
{
  _Bool D.20401;
  long int D.20402;
  long int D.20403;
  <unnamed-unsigned:6> D.20406;
  unsigned int D.20407;
  const char * D.20408;
  struct MonoType * D.20409;
  struct MonoType * D.20412;
  short unsigned int D.20413;
  int D.20414;
  char * D.20415;
  char * retval;
  struct GString * result;
  int i;

  result = monoeg_g_string_new ("");
  D.20401 = method == 0B;
  D.20402 = (long int) D.20401;
  D.20403 = __builtin_expect (D.20402, 0);
  if (D.20403 != 0) goto <D.20404>; else goto <D.20405>;
  <D.20404>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "get.c", 1017, "method");
  <D.20405>:
  D.20406 = method->call_convention;
  D.20407 = (unsigned int) D.20406;
  D.20408 = map (D.20407, &call_conv_type_map);
  monoeg_g_string_append (result, D.20408);
  D.20409 = method->ret;
  retval = dis_stringify_param (m, D.20409);
  monoeg_g_string_append_printf (result, " %s ", retval);
  monoeg_g_free (retval);
  monoeg_g_string_append (result, " *(");
  i = 0;
  goto <D.19316>;
  <D.19315>:
  if (i != 0) goto <D.20410>; else goto <D.20411>;
  <D.20410>:
  monoeg_g_string_append (result, ", ");
  <D.20411>:
  D.20412 = method->params[i];
  retval = dis_stringify_param (m, D.20412);
  monoeg_g_string_append (result, retval);
  monoeg_g_free (retval);
  i = i + 1;
  <D.19316>:
  D.20413 = method->param_count;
  D.20414 = (int) D.20413;
  if (D.20414 > i) goto <D.19315>; else goto <D.19317>;
  <D.19317>:
  monoeg_g_string_append (result, ") ");
  retval = result->str;
  monoeg_g_string_free (result, 0);
  D.20415 = retval;
  return D.20415;
}


dis_stringify_object_with_class (struct MonoImage * m, struct MonoClass * c, gboolean prefix, gboolean is_def)
{
  const char * iftmp.54;
  unsigned char D.20418;
  unsigned int D.20422;
  char * D.20425;
  struct MonoImage * D.20426;
  const char * D.20429;
  int substitute_with_mscorlib_p.55;
  int D.19344;
  int iftmp.56;
  int D.19340;
  const char[7] * D.20439;
  unsigned char D.20440;
  int D.20441;
  unsigned char D.20442;
  int D.20443;
  const unsigned char * D.20448;
  unsigned char D.20449;
  int D.20450;
  const unsigned char * D.20451;
  unsigned char D.20452;
  int D.20453;
  const unsigned char * D.20458;
  unsigned char D.20459;
  int D.20460;
  const unsigned char * D.20461;
  unsigned char D.20462;
  int D.20463;
  const unsigned char * D.20468;
  unsigned char D.20469;
  int D.20470;
  const unsigned char * D.20471;
  unsigned char D.20472;
  int D.20473;
  struct MonoAssembly * D.20476;
  const char * D.20477;
  const char * D.20479;
  struct MonoGenericClass * D.20480;
  struct MonoType * D.20483;
  int D.20484;
  <unnamed-unsigned:22> D.20485;
  int D.20486;
  char * D.20489;
  const char * iftmp.57;
  const char * iftmp.58;
  const char * iftmp.59;
  struct MonoType * type;
  const char * otype;
  char * assemblyref;
  char * result;
  char * esname;
  char * generic;

  type = &c->byval_arg;
  D.20418 = type->type;
  if (D.20418 == 17) goto <D.20419>; else goto <D.20420>;
  <D.20419>:
  iftmp.54 = "valuetype ";
  goto <D.20421>;
  <D.20420>:
  iftmp.54 = "class ";
  <D.20421>:
  otype = iftmp.54;
  assemblyref = 0B;
  generic = 0B;
  D.20422 = c->type_token;
  if (D.20422 == 33554433) goto <D.20423>; else goto <D.20424>;
  <D.20423>:
  D.20425 = 0B;
  return D.20425;
  <D.20424>:
  D.20426 = c->image;
  if (D.20426 != m) goto <D.20427>; else goto <D.20428>;
  <D.20427>:
  D.20426 = c->image;
  D.20429 = D.20426->assembly_name;
  if (D.20429 != 0B) goto <D.20430>; else goto <D.20431>;
  <D.20430>:
  substitute_with_mscorlib_p.55 = substitute_with_mscorlib_p;
  if (substitute_with_mscorlib_p.55 != 0) goto <D.20435>; else goto <D.20432>;
  <D.20435>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      D.20426 = c->image;
      __s2 = D.20426->assembly_name;
      D.20439 = "corlib";
      D.20440 = MEM[(const unsigned char *)D.20439];
      D.20441 = (int) D.20440;
      D.20442 = *__s2;
      D.20443 = (int) D.20442;
      __result = D.20441 - D.20443;
      {
        if (__s1_len != 0) goto <D.20444>; else goto <D.20445>;
        <D.20444>:
        if (__result == 0) goto <D.20446>; else goto <D.20447>;
        <D.20446>:
        D.20448 = &MEM[(void *)"corlib" + 1B];
        D.20449 = *D.20448;
        D.20450 = (int) D.20449;
        D.20451 = __s2 + 1;
        D.20452 = *D.20451;
        D.20453 = (int) D.20452;
        __result = D.20450 - D.20453;
        if (__s1_len > 1) goto <D.20454>; else goto <D.20455>;
        <D.20454>:
        if (__result == 0) goto <D.20456>; else goto <D.20457>;
        <D.20456>:
        D.20458 = &MEM[(void *)"corlib" + 2B];
        D.20459 = *D.20458;
        D.20460 = (int) D.20459;
        D.20461 = __s2 + 2;
        D.20462 = *D.20461;
        D.20463 = (int) D.20462;
        __result = D.20460 - D.20463;
        if (__s1_len > 2) goto <D.20464>; else goto <D.20465>;
        <D.20464>:
        if (__result == 0) goto <D.20466>; else goto <D.20467>;
        <D.20466>:
        D.20468 = &MEM[(void *)"corlib" + 3B];
        D.20469 = *D.20468;
        D.20470 = (int) D.20469;
        D.20471 = __s2 + 3;
        D.20472 = *D.20471;
        D.20473 = (int) D.20472;
        __result = D.20470 - D.20473;
        <D.20467>:
        <D.20465>:
        <D.20457>:
        <D.20455>:
        <D.20447>:
        <D.20445>:
      }
      D.19340 = __result;
    }
    iftmp.56 = D.19340;
    goto <D.20474>;
    <D.20438>:
    D.20426 = c->image;
    D.20429 = D.20426->assembly_name;
    iftmp.56 = __builtin_strcmp ("corlib", D.20429);
    <D.20474>:
    D.19344 = iftmp.56;
  }
  if (D.19344 == 0) goto <D.20475>; else goto <D.20432>;
  <D.20475>:
  assemblyref = monoeg_g_strdup_printf ("[%s]", "mscorlib");
  goto <D.20433>;
  <D.20432>:
  {
    char * esc;

    D.20426 = c->image;
    D.20476 = D.20426->assembly;
    D.20477 = D.20476->aname.name;
    esc = get_escaped_name (D.20477);
    assemblyref = monoeg_g_strdup_printf ("[%s]", esc);
    monoeg_g_free (esc);
  }
  <D.20433>:
  goto <D.20478>;
  <D.20431>:
  D.20426 = c->image;
  D.20479 = D.20426->module_name;
  assemblyref = monoeg_g_strdup_printf ("[.module %s]", D.20479);
  <D.20478>:
  <D.20428>:
  esname = get_escaped_class_name (c);
  D.20480 = c->generic_class;
  if (D.20480 != 0B) goto <D.20481>; else goto <D.20482>;
  <D.20481>:
  {
    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.19352>;
    <D.19351>:
    {
      char * t;

      D.20483 = inst->type_argv[i];
      t = dis_stringify_type (m, D.20483, is_def);
      monoeg_g_string_append (str, t);
      D.20484 = i + 1;
      D.20485 = inst->type_argc;
      D.20486 = (int) D.20485;
      if (D.20484 != D.20486) goto <D.20487>; else goto <D.20488>;
      <D.20487>:
      monoeg_g_string_append (str, ", ");
      <D.20488>:
      monoeg_g_free (t);
    }
    i = i + 1;
    <D.19352>:
    D.20485 = inst->type_argc;
    D.20486 = (int) D.20485;
    if (D.20486 > i) goto <D.19351>; else goto <D.19353>;
    <D.19353>:
    D.20489 = str->str;
    generic = monoeg_g_strdup_printf ("<%s>", D.20489);
    monoeg_g_string_free (str, 1);
  }
  <D.20482>:
  if (prefix != 0) goto <D.20491>; else goto <D.20492>;
  <D.20491>:
  iftmp.57 = otype;
  goto <D.20493>;
  <D.20492>:
  iftmp.57 = "";
  <D.20493>:
  if (assemblyref != 0B) goto <D.20495>; else goto <D.20496>;
  <D.20495>:
  iftmp.58 = assemblyref;
  goto <D.20497>;
  <D.20496>:
  iftmp.58 = "";
  <D.20497>:
  if (generic != 0B) goto <D.20499>; else goto <D.20500>;
  <D.20499>:
  iftmp.59 = generic;
  goto <D.20501>;
  <D.20500>:
  iftmp.59 = "";
  <D.20501>:
  result = monoeg_g_strdup_printf ("%s%s%s%s", iftmp.57, iftmp.58, esname, iftmp.59);
  monoeg_g_free (generic);
  monoeg_g_free (assemblyref);
  monoeg_g_free (esname);
  D.20425 = result;
  return D.20425;
}


get_escaped_class_name (struct MonoClass * c)
{
  unsigned int D.20503;
  char * D.20506;
  unsigned char D.20509;
  unsigned char D.20511;
  const char * D.20514;
  struct MonoClass * D.20515;
  const char * D.20519;
  char D.20520;
  char * result;
  char * esname;

  D.20503 = c->type_token;
  if (D.20503 == 33554433) goto <D.20504>; else goto <D.20505>;
  <D.20504>:
  D.20506 = 0B;
  return D.20506;
  <D.20505>:
  D.20509 = c->rank;
  if (D.20509 != 0) goto <D.20507>; else goto <D.20510>;
  <D.20510>:
  D.20511 = c->byval_arg.type;
  if (D.20511 == 15) goto <D.20507>; else goto <D.20508>;
  <D.20507>:
  if (1 != 0) goto <D.20512>; else goto <D.20513>;
  <D.20512>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "get.c", 1051, "0");
  <D.20513>:
  <D.20508>:
  D.20514 = c->name;
  esname = get_escaped_name (D.20514);
  D.20515 = c->nested_in;
  if (D.20515 != 0B) goto <D.20516>; else goto <D.20517>;
  <D.20516>:
  {
    char * part_a;

    D.20515 = c->nested_in;
    part_a = get_escaped_class_name (D.20515);
    result = monoeg_g_strdup_printf ("%s/%s", part_a, esname);
    monoeg_g_free (part_a);
  }
  goto <D.20518>;
  <D.20517>:
  D.20519 = c->name_space;
  D.20520 = *D.20519;
  if (D.20520 != 0) goto <D.20521>; else goto <D.20522>;
  <D.20521>:
  D.20519 = c->name_space;
  result = monoeg_g_strdup_printf ("%s.%s", D.20519, esname);
  goto <D.20523>;
  <D.20522>:
  result = monoeg_strdup (esname);
  <D.20523>:
  <D.20518>:
  monoeg_g_free (esname);
  D.20506 = result;
  return D.20506;
}


dis_stringify_type (struct MonoImage * m, struct MonoType * type, gboolean is_def)
{
  long unsigned int D.20525;
  long unsigned int D.20526;
  <unnamed-unsigned:6> D.20529;
  int D.20530;
  struct MonoCustomMod[0:] * D.20531;
  unsigned char D.20532;
  int D.20533;
  unsigned int D.20534;
  const char * D.20535;
  struct MonoMethodSignature * D.20536;
  struct MonoType * D.20537;
  struct MonoClass * D.20538;
  struct MonoType * D.20539;
  struct MonoArrayType * D.20540;
  struct MonoGenericParam * D.20544;
  int D.20545;
  struct MonoGenericParamInfo * iftmp.60;
  struct MonoGenericContainer * D.20548;
  const char * D.20552;
  char * D.20553;
  short unsigned int D.20554;
  int D.20555;
  int D.20559;
  struct MonoGenericParamInfo * iftmp.61;
  const char * D.20565;
  char * D.20566;
  struct MonoGenericClass * D.20567;
  struct MonoClass * D.20568;
  struct MonoType * D.20569;
  struct MonoType * D.20570;
  int D.20571;
  <unnamed-unsigned:22> D.20572;
  int D.20573;
  char * D.20576;
  long unsigned int D.20577;
  long unsigned int D.20580;
  char * D.20585;
  const char * iftmp.62;
  const char * pinned;
  const char * byref;
  char * bare;
  char * mods;
  char * result;

  pinned = "";
  byref = "";
  bare = 0B;
  mods = 0B;
  D.20525 = BIT_FIELD_REF <*type, 64, 64>;
  D.20526 = D.20525 & 1056964608;
  if (D.20526 != 0) goto <D.20527>; else goto <D.20528>;
  <D.20527>:
  D.20529 = type->num_mods;
  D.20530 = (int) D.20529;
  D.20531 = &type->modifiers;
  mods = dis_stringify_modifiers (m, D.20530, D.20531);
  <D.20528>:
  D.20532 = type->type;
  D.20533 = (int) D.20532;
  switch (D.20533) <default: <D.19409>, case 1: <D.19397>, case 2: <D.19370>, case 3: <D.19371>, case 4: <D.19372>, case 5: <D.19373>, case 6: <D.19374>, case 7: <D.19375>, case 8: <D.19376>, case 9: <D.19377>, case 10: <D.19378>, case 11: <D.19379>, case 12: <D.19380>, case 13: <D.19381>, case 14: <D.19384>, case 15: <D.19392>, case 17: <D.19388>, case 18: <D.19389>, case 19: <D.19399>, case 20: <D.19396>, case 21: <D.19400>, case 22: <D.19386>, case 24: <D.19382>, case 25: <D.19383>, case 27: <D.19390>, case 28: <D.19385>, case 29: <D.19394>, case 30: <D.19398>>
  <D.19370>:
  <D.19371>:
  <D.19372>:
  <D.19373>:
  <D.19374>:
  <D.19375>:
  <D.19376>:
  <D.19377>:
  <D.19378>:
  <D.19379>:
  <D.19380>:
  <D.19381>:
  <D.19382>:
  <D.19383>:
  <D.19384>:
  <D.19385>:
  <D.19386>:
  D.20532 = type->type;
  D.20534 = (unsigned int) D.20532;
  D.20535 = map (D.20534, &element_type_map);
  bare = monoeg_strdup (D.20535);
  goto <D.19387>;
  <D.19388>:
  <D.19389>:
  bare = dis_stringify_object (m, type, is_def);
  goto <D.19387>;
  <D.19390>:
  {
    char * child_type;

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

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

    D.20538 = type->data.klass;
    D.20539 = &D.20538->byval_arg;
    child_type = dis_stringify_type (m, D.20539, is_def);
    bare = monoeg_g_strdup_printf ("%s[]", child_type);
    monoeg_g_free (child_type);
    goto <D.19387>;
  }
  <D.19396>:
  D.20540 = type->data.array;
  bare = dis_stringify_array (m, D.20540, is_def);
  goto <D.19387>;
  <D.19397>:
  bare = monoeg_strdup ("void");
  goto <D.19387>;
  <D.19398>:
  if (is_def != 0) goto <D.20543>; else goto <D.20541>;
  <D.20543>:
  D.20544 = type->data.generic_param;
  D.20545 = cant_print_generic_param_name (D.20544);
  if (D.20545 == 0) goto <D.20546>; else goto <D.20541>;
  <D.20546>:
  D.20544 = type->data.generic_param;
  D.20548 = D.20544->owner;
  if (D.20548 != 0B) goto <D.20549>; else goto <D.20550>;
  <D.20549>:
  D.20544 = type->data.generic_param;
  iftmp.60 = &MEM[(struct MonoGenericParamFull *)D.20544].info;
  goto <D.20551>;
  <D.20550>:
  iftmp.60 = 0B;
  <D.20551>:
  D.20552 = iftmp.60->name;
  D.20553 = get_escaped_name (D.20552);
  bare = monoeg_g_strdup_printf ("!!%s", D.20553);
  goto <D.20542>;
  <D.20541>:
  D.20544 = type->data.generic_param;
  D.20554 = D.20544->num;
  D.20555 = (int) D.20554;
  bare = monoeg_g_strdup_printf ("!!%d", D.20555);
  <D.20542>:
  goto <D.19387>;
  <D.19399>:
  if (is_def != 0) goto <D.20558>; else goto <D.20556>;
  <D.20558>:
  D.20544 = type->data.generic_param;
  D.20559 = cant_print_generic_param_name (D.20544);
  if (D.20559 == 0) goto <D.20560>; else goto <D.20556>;
  <D.20560>:
  D.20544 = type->data.generic_param;
  D.20548 = D.20544->owner;
  if (D.20548 != 0B) goto <D.20562>; else goto <D.20563>;
  <D.20562>:
  D.20544 = type->data.generic_param;
  iftmp.61 = &MEM[(struct MonoGenericParamFull *)D.20544].info;
  goto <D.20564>;
  <D.20563>:
  iftmp.61 = 0B;
  <D.20564>:
  D.20565 = iftmp.61->name;
  D.20566 = get_escaped_name (D.20565);
  bare = monoeg_g_strdup_printf ("!%s", D.20566);
  goto <D.20557>;
  <D.20556>:
  D.20544 = type->data.generic_param;
  D.20554 = D.20544->num;
  D.20555 = (int) D.20554;
  bare = monoeg_g_strdup_printf ("!%d", D.20555);
  <D.20557>:
  goto <D.19387>;
  <D.19400>:
  {
    struct GString * str;
    struct MonoGenericInst * inst;
    int i;
    char * generic_type;

    str = monoeg_g_string_new ("");
    D.20567 = type->data.generic_class;
    D.20568 = D.20567->container_class;
    D.20569 = &D.20568->byval_arg;
    generic_type = dis_stringify_type (m, D.20569, is_def);
    D.20567 = type->data.generic_class;
    inst = D.20567->context.class_inst;
    i = 0;
    goto <D.19407>;
    <D.19406>:
    {
      char * t;

      D.20570 = inst->type_argv[i];
      t = dis_stringify_type (m, D.20570, is_def);
      monoeg_g_string_append (str, t);
      D.20571 = i + 1;
      D.20572 = inst->type_argc;
      D.20573 = (int) D.20572;
      if (D.20571 != D.20573) goto <D.20574>; else goto <D.20575>;
      <D.20574>:
      monoeg_g_string_append (str, ", ");
      <D.20575>:
      monoeg_g_free (t);
    }
    i = i + 1;
    <D.19407>:
    D.20572 = inst->type_argc;
    D.20573 = (int) D.20572;
    if (D.20573 > i) goto <D.19406>; else goto <D.19408>;
    <D.19408>:
    D.20576 = str->str;
    bare = monoeg_g_strdup_printf ("%s<%s>", generic_type, D.20576);
    monoeg_g_string_free (str, 1);
    goto <D.19387>;
  }
  <D.19409>:
  D.20532 = type->type;
  D.20533 = (int) D.20532;
  monoeg_g_log (0B, 4, "Do not know how to stringify type 0x%x", D.20533);
  <D.19410>:
  goto <D.19410>;
  <D.19387>:
  D.20525 = BIT_FIELD_REF <*type, 64, 64>;
  D.20577 = D.20525 & 2147483648;
  if (D.20577 != 0) goto <D.20578>; else goto <D.20579>;
  <D.20578>:
  pinned = " pinned";
  <D.20579>:
  D.20525 = BIT_FIELD_REF <*type, 64, 64>;
  D.20580 = D.20525 & 1073741824;
  if (D.20580 != 0) goto <D.20581>; else goto <D.20582>;
  <D.20581>:
  byref = "&";
  <D.20582>:
  if (bare == 0B) goto <D.20583>; else goto <D.20584>;
  <D.20583>:
  D.20585 = bare;
  return D.20585;
  <D.20584>:
  if (mods != 0B) goto <D.20587>; else goto <D.20588>;
  <D.20587>:
  iftmp.62 = mods;
  goto <D.20589>;
  <D.20588>:
  iftmp.62 = "";
  <D.20589>:
  result = monoeg_g_strconcat (bare, byref, pinned, iftmp.62, 0B);
  monoeg_g_free (bare);
  D.20585 = result;
  return D.20585;
}


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

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


cant_print_generic_param_name (struct MonoGenericParam * gparam)
{
  _Bool D.20593;
  long int D.20594;
  long int D.20595;
  gboolean D.20598;
  int iftmp.63;
  struct GHashTable * mono_generic_params_with_ambiguous_names.64;
  void * D.20606;
  struct MonoGenericContainer * container;

  D.20593 = gparam == 0B;
  D.20594 = (long int) D.20593;
  D.20595 = __builtin_expect (D.20594, 0);
  if (D.20595 != 0) goto <D.20596>; else goto <D.20597>;
  <D.20596>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "get.c", 3166, "gparam");
  <D.20597>:
  container = gparam->owner;
  check_ambiguous_genparams (container);
  if (container == 0B) goto <D.20600>; else goto <D.20603>;
  <D.20603>:
  mono_generic_params_with_ambiguous_names.64 = mono_generic_params_with_ambiguous_names;
  if (mono_generic_params_with_ambiguous_names.64 != 0B) goto <D.20605>; else goto <D.20601>;
  <D.20605>:
  mono_generic_params_with_ambiguous_names.64 = mono_generic_params_with_ambiguous_names;
  D.20606 = monoeg_g_hash_table_lookup (mono_generic_params_with_ambiguous_names.64, gparam);
  if (D.20606 != 0B) goto <D.20600>; else goto <D.20601>;
  <D.20600>:
  iftmp.63 = 1;
  goto <D.20602>;
  <D.20601>:
  iftmp.63 = 0;
  <D.20602>:
  D.20598 = iftmp.63;
  return D.20598;
}


check_ambiguous_genparams (struct MonoGenericContainer * container)
{
  struct GHashTable * generic_containers.65;
  void * D.20613;
  struct MonoGenericParamFull * D.20616;
  long unsigned int D.20617;
  long unsigned int D.20618;
  struct MonoGenericParamInfo * iftmp.66;
  struct MonoGenericContainer * D.20620;
  const char * D.20624;
  int D.20627;
  long unsigned int D.20628;
  void * D.20629;
  struct GSList * D.20630;
  struct MonoGenericParamInfo * iftmp.67;
  const char * D.20636;
  <unnamed-signed:31> D.20637;
  int D.20638;
  struct GHashTable * mono_generic_params_with_ambiguous_names.68;
  struct GHashTable * mono_generic_params_with_ambiguous_names.69;
  void * D.20645;
  long int D.20646;
  long unsigned int D.20647;
  long unsigned int D.20648;
  sizetype D.20649;
  struct MonoGenericParamFull * D.20650;
  struct GHashTable * generic_containers.70;
  struct GSList * dup_list;
  struct GSList * l;
  struct GHashTable * table;
  void * * p;
  int i;

  dup_list = 0B;
  table = 0B;
  if (container == 0B) goto <D.20608>; else goto <D.20609>;
  <D.20608>:
  return;
  <D.20609>:
  generic_containers.65 = generic_containers;
  if (generic_containers.65 != 0B) goto <D.20611>; else goto <D.20612>;
  <D.20611>:
  generic_containers.65 = generic_containers;
  D.20613 = monoeg_g_hash_table_lookup (generic_containers.65, container);
  if (D.20613 != 0B) goto <D.20614>; else goto <D.20615>;
  <D.20614>:
  return;
  <D.20615>:
  <D.20612>:
  table = monoeg_g_hash_table_new (monoeg_g_str_hash, monoeg_g_str_equal);
  i = 0;
  goto <D.19903>;
  <D.19902>:
  {
    struct MonoGenericParam * param;

    D.20616 = container->type_params;
    D.20617 = (long unsigned int) i;
    D.20618 = D.20617 * 56;
    param = D.20616 + D.20618;
    D.20620 = param->owner;
    if (D.20620 != 0B) goto <D.20621>; else goto <D.20622>;
    <D.20621>:
    iftmp.66 = &MEM[(struct MonoGenericParamFull *)param].info;
    goto <D.20623>;
    <D.20622>:
    iftmp.66 = 0B;
    <D.20623>:
    D.20624 = iftmp.66->name;
    p = monoeg_g_hash_table_lookup (table, D.20624);
    if (p != 0B) goto <D.20625>; else goto <D.20626>;
    <D.20625>:
    D.20627 = i + 1;
    D.20628 = (long unsigned int) D.20627;
    D.20629 = (void *) D.20628;
    D.20630 = monoeg_g_slist_prepend (dup_list, D.20629);
    dup_list = monoeg_g_slist_prepend (D.20630, p);
    goto <D.20631>;
    <D.20626>:
    D.20620 = param->owner;
    if (D.20620 != 0B) goto <D.20633>; else goto <D.20634>;
    <D.20633>:
    iftmp.67 = &MEM[(struct MonoGenericParamFull *)param].info;
    goto <D.20635>;
    <D.20634>:
    iftmp.67 = 0B;
    <D.20635>:
    D.20636 = iftmp.67->name;
    D.20627 = i + 1;
    D.20628 = (long unsigned int) D.20627;
    D.20629 = (void *) D.20628;
    monoeg_g_hash_table_insert_replace (table, D.20636, D.20629, 0);
    <D.20631>:
  }
  i = i + 1;
  <D.19903>:
  D.20637 = container->type_argc;
  D.20638 = (int) D.20637;
  if (D.20638 > i) goto <D.19902>; else goto <D.19904>;
  <D.19904>:
  if (dup_list != 0B) goto <D.20639>; else goto <D.20640>;
  <D.20639>:
  mono_generic_params_with_ambiguous_names.68 = mono_generic_params_with_ambiguous_names;
  if (mono_generic_params_with_ambiguous_names.68 == 0B) goto <D.20642>; else goto <D.20643>;
  <D.20642>:
  mono_generic_params_with_ambiguous_names.69 = monoeg_g_hash_table_new (0B, 0B);
  mono_generic_params_with_ambiguous_names = mono_generic_params_with_ambiguous_names.69;
  <D.20643>:
  l = dup_list;
  goto <D.19907>;
  <D.19906>:
  {
    int param;

    D.20645 = l->data;
    D.20646 = (long int) D.20645;
    param = (int) D.20646;
    mono_generic_params_with_ambiguous_names.68 = mono_generic_params_with_ambiguous_names;
    D.20616 = container->type_params;
    D.20647 = (long unsigned int) param;
    D.20648 = D.20647 * 56;
    D.20649 = D.20648 + 18446744073709551560;
    D.20650 = D.20616 + D.20649;
    D.20616 = container->type_params;
    D.20647 = (long unsigned int) param;
    D.20648 = D.20647 * 56;
    D.20649 = D.20648 + 18446744073709551560;
    D.20650 = D.20616 + D.20649;
    monoeg_g_hash_table_insert_replace (mono_generic_params_with_ambiguous_names.68, D.20650, D.20650, 0);
  }
  l = l->next;
  <D.19907>:
  if (l != 0B) goto <D.19906>; else goto <D.19908>;
  <D.19908>:
  monoeg_g_slist_free (dup_list);
  <D.20640>:
  generic_containers.65 = generic_containers;
  if (generic_containers.65 == 0B) goto <D.20651>; else goto <D.20652>;
  <D.20651>:
  generic_containers.70 = monoeg_g_hash_table_new (0B, 0B);
  generic_containers = generic_containers.70;
  <D.20652>:
  generic_containers.65 = generic_containers;
  monoeg_g_hash_table_insert_replace (generic_containers.65, 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.71;
  char D.20656;
  const char * ptr.72;
  int show_tokens.73;
  gchar * D.20666;
  const char * ptr.74;
  char * temp.75;
  unsigned int D.20670;
  const char * ptr.76;
  char * D.20674;
  char * D.20677;
  gchar * D.20684;
  const char * D.20685;
  const char * start;
  guint32 type;
  struct MonoType * t;

  start = ptr;
  ptr.71 = ptr;
  D.20656 = *ptr.71;
  if (D.20656 == 16) goto <D.20657>; else goto <D.20658>;
  <D.20657>:
  ptr.71 = ptr;
  ptr.72 = ptr.71 + 1;
  ptr = ptr.72;
  <D.20658>:
  ptr.71 = ptr;
  type = mono_metadata_decode_value (ptr.71, &ptr);
  switch (type) <default: <D.19435>, case 17: <D.19421>, case 18: <D.19422>, case 21: <D.19427>>
  <D.19421>:
  <D.19422>:
  {
    guint32 token;
    struct MonoClass * klass;
    char * temp;

    ptr.71 = ptr;
    token = mono_metadata_parse_typedef_or_ref (m, ptr.71, &ptr);
    klass = mono_class_get (m, token);
    if (klass != 0B) goto <D.20660>; else goto <D.20661>;
    <D.20660>:
    temp = dis_stringify_object_with_class (m, klass, 1, 0);
    goto <D.20662>;
    <D.20661>:
    temp = monoeg_g_strdup_printf ("<BROKEN CLASS token_%8x>", token);
    <D.20662>:
    show_tokens.73 = show_tokens;
    if (show_tokens.73 != 0) goto <D.20664>; else goto <D.20665>;
    <D.20664>:
    D.20666 = monoeg_g_strdup_printf ("%s/*%08x*/", temp, token);
    *result = D.20666;
    monoeg_g_free (temp);
    goto <D.20667>;
    <D.20665>:
    *result = temp;
    <D.20667>:
    goto <D.19426>;
  }
  <D.19427>:
  {
    struct GString * str;
    int count;
    int i;
    char * temp;

    try
      {
        str = monoeg_g_string_new ("");
        ptr.71 = ptr;
        ptr.74 = get_type (m, ptr.71, &temp, is_def, container);
        ptr = ptr.74;
        temp.75 = temp;
        monoeg_g_string_append (str, temp.75);
        temp.75 = temp;
        monoeg_g_free (temp.75);
        ptr.71 = ptr;
        D.20670 = mono_metadata_decode_value (ptr.71, &ptr);
        count = (int) D.20670;
        monoeg_g_string_append (str, "<");
        i = 0;
        goto <D.19433>;
        <D.19432>:
        if (i != 0) goto <D.20671>; else goto <D.20672>;
        <D.20671>:
        monoeg_g_string_append (str, ",");
        <D.20672>:
        ptr.71 = ptr;
        ptr.76 = get_type (m, ptr.71, &temp, is_def, container);
        ptr = ptr.76;
        temp.75 = temp;
        monoeg_g_string_append (str, temp.75);
        i = i + 1;
        <D.19433>:
        if (i < count) goto <D.19432>; else goto <D.19434>;
        <D.19434>:
        monoeg_g_string_append (str, ">");
        D.20674 = str->str;
        *result = D.20674;
        monoeg_g_string_free (str, 0);
        goto <D.19426>;
      }
    finally
      {
        temp = {CLOBBER};
      }
  }
  <D.19435>:
  t = mono_metadata_parse_type_full (m, container, 0, 0, start, &ptr);
  if (t != 0B) goto <D.20675>; else goto <D.20676>;
  <D.20675>:
  D.20677 = dis_stringify_type (m, t, is_def);
  *result = D.20677;
  goto <D.20678>;
  <D.20676>:
  {
    struct GString * err;

    err = monoeg_g_string_new ("@!#$<InvalidType>$#!@");
    if (container != 0B) goto <D.20679>; else goto <D.20680>;
    <D.20679>:
    t = mono_metadata_parse_type_full (m, 0B, 0, 0, start, &ptr);
    <D.20680>:
    if (t != 0B) goto <D.20681>; else goto <D.20682>;
    <D.20681>:
    {
      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.20683>;
    <D.20682>:
    monoeg_g_log (0B, 16, "Encountered an invalid type");
    <D.20683>:
    D.20684 = monoeg_g_string_free (err, 0);
    *result = D.20684;
  }
  <D.20678>:
  goto <D.19426>;
  <D.19426>:
  D.20685 = ptr;
  return D.20685;
}


get_field_signature (struct MonoImage * m, guint32 blob_signature, struct MonoGenericContainer * container)
{
  const char * ptr.77;
  const char * ptr.78;
  unsigned int D.20690;
  char D.20691;
  _Bool D.20692;
  long int D.20693;
  long int D.20694;
  const char * ptr.79;
  const char * ptr.80;
  const char * ptr.81;
  char * allocated_type_string.82;
  const char * iftmp.83;
  char * allocated_modifier_string.84;
  char * D.20710;
  char * allocated_modifier_string;
  char * allocated_type_string;
  const char * ptr;
  const char * base;
  char * res;
  int len;

  try
    {
      ptr.77 = mono_metadata_blob_heap (m, blob_signature);
      ptr = ptr.77;
      ptr.78 = ptr;
      D.20690 = mono_metadata_decode_value (ptr.78, &ptr);
      len = (int) D.20690;
      base = ptr;
      ptr.78 = ptr;
      D.20691 = *ptr.78;
      D.20692 = D.20691 != 6;
      D.20693 = (long int) D.20692;
      D.20694 = __builtin_expect (D.20693, 0);
      if (D.20694 != 0) goto <D.20695>; else goto <D.20696>;
      <D.20695>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "get.c", 1361, "*ptr == 0x06");
      <D.20696>:
      ptr.78 = ptr;
      ptr.79 = ptr.78 + 1;
      ptr = ptr.79;
      len = len + -1;
      ptr.78 = ptr;
      ptr.80 = get_custom_mod (m, ptr.78, &allocated_modifier_string);
      ptr = ptr.80;
      ptr.78 = ptr;
      ptr.81 = get_type (m, ptr.78, &allocated_type_string, 0, container);
      ptr = ptr.81;
      allocated_type_string.82 = allocated_type_string;
      allocated_modifier_string.84 = allocated_modifier_string;
      if (allocated_modifier_string.84 != 0B) goto <D.20703>; else goto <D.20704>;
      <D.20703>:
      iftmp.83 = allocated_modifier_string;
      goto <D.20705>;
      <D.20704>:
      iftmp.83 = "";
      <D.20705>:
      res = monoeg_g_strdup_printf ("%s%s", allocated_type_string.82, iftmp.83);
      allocated_modifier_string.84 = allocated_modifier_string;
      if (allocated_modifier_string.84 != 0B) goto <D.20706>; else goto <D.20707>;
      <D.20706>:
      allocated_modifier_string.84 = allocated_modifier_string;
      monoeg_g_free (allocated_modifier_string.84);
      <D.20707>:
      allocated_type_string.82 = allocated_type_string;
      if (allocated_type_string.82 != 0B) goto <D.20708>; else goto <D.20709>;
      <D.20708>:
      allocated_type_string.82 = allocated_type_string;
      monoeg_g_free (allocated_type_string.82);
      <D.20709>:
      D.20710 = res;
      return D.20710;
    }
  finally
    {
      allocated_modifier_string = {CLOBBER};
      allocated_type_string = {CLOBBER};
      ptr = {CLOBBER};
    }
}


get_field_literal_type (struct MonoImage * m, guint32 blob_signature)
{
  const char * ptr.85;
  const char * ptr.86;
  unsigned int D.20715;
  char D.20716;
  _Bool D.20717;
  long int D.20718;
  long int D.20719;
  const char * ptr.87;
  const char * ptr.88;
  char * allocated_modifier_string.89;
  MonoTypeEnum D.20727;
  const char * ptr;
  int len;
  char * allocated_modifier_string;

  try
    {
      ptr.85 = mono_metadata_blob_heap (m, blob_signature);
      ptr = ptr.85;
      ptr.86 = ptr;
      D.20715 = mono_metadata_decode_value (ptr.86, &ptr);
      len = (int) D.20715;
      ptr.86 = ptr;
      D.20716 = *ptr.86;
      D.20717 = D.20716 != 6;
      D.20718 = (long int) D.20717;
      D.20719 = __builtin_expect (D.20718, 0);
      if (D.20719 != 0) goto <D.20720>; else goto <D.20721>;
      <D.20720>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "get.c", 1391, "*ptr == 0x06");
      <D.20721>:
      ptr.86 = ptr;
      ptr.87 = ptr.86 + 1;
      ptr = ptr.87;
      len = len + -1;
      ptr.86 = ptr;
      ptr.88 = get_custom_mod (m, ptr.86, &allocated_modifier_string);
      ptr = ptr.88;
      allocated_modifier_string.89 = allocated_modifier_string;
      if (allocated_modifier_string.89 != 0B) goto <D.20725>; else goto <D.20726>;
      <D.20725>:
      allocated_modifier_string.89 = allocated_modifier_string;
      monoeg_g_free (allocated_modifier_string.89);
      <D.20726>:
      ptr.86 = ptr;
      D.20716 = *ptr.86;
      D.20727 = (MonoTypeEnum) D.20716;
      return D.20727;
    }
  finally
    {
      ptr = {CLOBBER};
      allocated_modifier_string = {CLOBBER};
    }
}


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

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


get_ret_type (struct MonoImage * m, const char * ptr, char * * ret_type, struct MonoGenericContainer * container)
{
  char D.20732;
  char * allocated_type_string.90;
  char * mod.91;
  char * D.20747;
  const char * D.20748;
  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.20732 = *ptr;
      if (D.20732 == 22) goto <D.20733>; else goto <D.20734>;
      <D.20733>:
      monoeg_g_string_append (str, "typedref");
      ptr = ptr + 1;
      goto <D.20735>;
      <D.20734>:
      D.20732 = *ptr;
      if (D.20732 == 1) goto <D.20736>; else goto <D.20737>;
      <D.20736>:
      monoeg_g_string_append (str, "void");
      ptr = ptr + 1;
      goto <D.20738>;
      <D.20737>:
      D.20732 = *ptr;
      if (D.20732 == 16) goto <D.20739>; else goto <D.20740>;
      <D.20739>:
      has_byref = 1;
      ptr = ptr + 1;
      <D.20740>:
      ptr = get_type (m, ptr, &allocated_type_string, 0, container);
      allocated_type_string.90 = allocated_type_string;
      monoeg_g_string_append (str, allocated_type_string.90);
      if (has_byref != 0) goto <D.20742>; else goto <D.20743>;
      <D.20742>:
      monoeg_g_string_append (str, "& ");
      <D.20743>:
      allocated_type_string.90 = allocated_type_string;
      monoeg_g_free (allocated_type_string.90);
      <D.20738>:
      <D.20735>:
      mod.91 = mod;
      if (mod.91 != 0B) goto <D.20745>; else goto <D.20746>;
      <D.20745>:
      mod.91 = mod;
      monoeg_g_string_append (str, mod.91);
      monoeg_g_string_append_c (str, 32);
      mod.91 = mod;
      monoeg_g_free (mod.91);
      <D.20746>:
      D.20747 = str->str;
      *ret_type = D.20747;
      monoeg_g_string_free (str, 0);
      D.20748 = ptr;
      return D.20748;
    }
  finally
    {
      mod = {CLOBBER};
      allocated_type_string = {CLOBBER};
    }
}


get_param (struct MonoImage * m, const char * ptr, char * * retval, struct MonoGenericContainer * container)
{
  char D.20751;
  char * allocated_type_string.92;
  char * allocated_mod_string.93;
  char * D.20763;
  const char * D.20764;
  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.20751 = *ptr;
      if (D.20751 == 22) goto <D.20752>; else goto <D.20753>;
      <D.20752>:
      monoeg_g_string_append (str, " typedref ");
      ptr = ptr + 1;
      goto <D.20754>;
      <D.20753>:
      {
        gboolean by_ref;

        by_ref = 0;
        D.20751 = *ptr;
        if (D.20751 == 16) goto <D.20755>; else goto <D.20756>;
        <D.20755>:
        monoeg_g_string_append (str, "[out] ");
        ptr = ptr + 1;
        by_ref = 1;
        <D.20756>:
        ptr = get_type (m, ptr, &allocated_type_string, 0, container);
        allocated_type_string.92 = allocated_type_string;
        monoeg_g_string_append (str, allocated_type_string.92);
        if (by_ref != 0) goto <D.20758>; else goto <D.20759>;
        <D.20758>:
        monoeg_g_string_append_c (str, 38);
        <D.20759>:
        allocated_type_string.92 = allocated_type_string;
        monoeg_g_free (allocated_type_string.92);
      }
      <D.20754>:
      allocated_mod_string.93 = allocated_mod_string;
      if (allocated_mod_string.93 != 0B) goto <D.20761>; else goto <D.20762>;
      <D.20761>:
      allocated_mod_string.93 = allocated_mod_string;
      monoeg_g_string_append (str, allocated_mod_string.93);
      monoeg_g_string_append_c (str, 32);
      allocated_mod_string.93 = allocated_mod_string;
      monoeg_g_free (allocated_mod_string.93);
      <D.20762>:
      D.20763 = str->str;
      *retval = D.20763;
      monoeg_g_string_free (str, 0);
      D.20764 = ptr;
      return D.20764;
    }
  finally
    {
      allocated_mod_string = {CLOBBER};
      allocated_type_string = {CLOBBER};
    }
}


get_escaped_name (const char * name)
{
  char * D.20769;
  struct GHashTable * key_table.94;
  _Bool D.20771;
  long int D.20772;
  long int D.20773;
  char D.20776;
  char D.20779;
  long int s.95;
  long int name.96;
  long int D.20784;
  long unsigned int D.20785;
  char * D.20786;
  const char * D.20787;
  char * D.20788;
  const short unsigned int * * D.20792;
  const short unsigned int * D.20793;
  long unsigned int D.20794;
  long unsigned int D.20795;
  const short unsigned int * D.20796;
  short unsigned int D.20797;
  int D.20798;
  int D.20799;
  void * D.20808;
  const char * s;
  char * ret;
  char * esc;

  if (name == 0B) goto <D.20767>; else goto <D.20768>;
  <D.20767>:
  D.20769 = 0B;
  return D.20769;
  <D.20768>:
  key_table.94 = key_table;
  D.20771 = key_table.94 == 0B;
  D.20772 = (long int) D.20771;
  D.20773 = __builtin_expect (D.20772, 0);
  if (D.20773 != 0) goto <D.20774>; else goto <D.20775>;
  <D.20774>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "get.c", 1557, "key_table");
  <D.20775>:
  D.20776 = *name;
  if (D.20776 == 0) goto <D.20777>; else goto <D.20778>;
  <D.20777>:
  D.20769 = monoeg_strdup (name);
  return D.20769;
  <D.20778>:
  s = name;
  goto <D.19501>;
  <D.19500>:
  {
    char * first;
    char * result;

    D.20779 = *s;
    if (D.20779 != 47) goto <D.20780>; else goto <D.20781>;
    <D.20780>:
    // predicted unlikely by continue predictor.
    goto <D.19499>;
    <D.20781>:
    s.95 = (long int) s;
    name.96 = (long int) name;
    D.20784 = s.95 - name.96;
    D.20785 = (long unsigned int) D.20784;
    first = monoeg_g_strndup (name, D.20785);
    D.20786 = get_escaped_name (first);
    D.20787 = s + 1;
    D.20788 = get_escaped_name (D.20787);
    result = monoeg_g_strdup_printf ("%s/%s", D.20786, D.20788);
    monoeg_g_free (first);
    D.20769 = result;
    return D.20769;
  }
  <D.19499>:
  s = s + 1;
  <D.19501>:
  D.20779 = *s;
  if (D.20779 != 0) goto <D.19500>; else goto <D.19502>;
  <D.19502>:
  s = name;
  goto <D.19505>;
  <D.19504>:
  D.20792 = __ctype_b_loc ();
  D.20793 = *D.20792;
  D.20779 = *s;
  D.20794 = (long unsigned int) D.20779;
  D.20795 = D.20794 * 2;
  D.20796 = D.20793 + D.20795;
  D.20797 = *D.20796;
  D.20798 = (int) D.20797;
  D.20799 = D.20798 & 8;
  if (D.20799 != 0) goto <D.20789>; else goto <D.20800>;
  <D.20800>:
  D.20779 = *s;
  if (D.20779 == 95) goto <D.20789>; else goto <D.20801>;
  <D.20801>:
  D.20779 = *s;
  if (D.20779 == 36) goto <D.20789>; else goto <D.20802>;
  <D.20802>:
  D.20779 = *s;
  if (D.20779 == 64) goto <D.20789>; else goto <D.20803>;
  <D.20803>:
  D.20779 = *s;
  if (D.20779 == 63) goto <D.20789>; else goto <D.20804>;
  <D.20804>:
  D.20779 = *s;
  if (D.20779 == 46) goto <D.20805>; else goto <D.20790>;
  <D.20805>:
  if (s != name) goto <D.20789>; else goto <D.20790>;
  <D.20790>:
  D.20779 = *s;
  if (D.20779 == 0) goto <D.20789>; else goto <D.20806>;
  <D.20806>:
  D.20779 = *s;
  if (D.20779 == 33) goto <D.20789>; else goto <D.20807>;
  <D.20807>:
  D.20779 = *s;
  if (D.20779 == 96) goto <D.20789>; else goto <D.20791>;
  <D.20789>:
  // predicted unlikely by continue predictor.
  goto <D.19503>;
  <D.20791>:
  esc = str_escape (name, "\'\\");
  ret = monoeg_g_strdup_printf ("\'%s\'", esc);
  monoeg_g_free (esc);
  D.20769 = ret;
  return D.20769;
  <D.19503>:
  s = s + 1;
  <D.19505>:
  D.20779 = *s;
  if (D.20779 != 0) goto <D.19504>; else goto <D.19506>;
  <D.19506>:
  key_table.94 = key_table;
  D.20808 = monoeg_g_hash_table_lookup (key_table.94, name);
  if (D.20808 != 0B) goto <D.20809>; else goto <D.20810>;
  <D.20809>:
  D.20769 = monoeg_g_strdup_printf ("\'%s\'", name);
  return D.20769;
  <D.20810>:
  D.20769 = str_escape (name, "\'\\");
  return D.20769;
}


str_escape (const char * str, const char * list)
{
  long unsigned int D.20812;
  char D.20813;
  int D.20816;
  int D.20817;
  void * D.20820;
  char * D.20821;
  long int p.97;
  long int str.98;
  long int D.20824;
  char * D.20826;
  const char * p;
  struct GString * res;

  p = str;
  D.20812 = strlen (str);
  res = monoeg_g_string_sized_new (D.20812);
  <D.19490>:
  goto <D.19487>;
  <D.19486>:
  p = p + 1;
  <D.19487>:
  D.20813 = *p;
  if (D.20813 != 0) goto <D.20814>; else goto <D.19488>;
  <D.20814>:
  D.20813 = *p;
  D.20816 = (int) D.20813;
  D.20817 = __builtin_constant_p (D.20816);
  if (D.20817 != 0) goto <D.20818>; else goto <D.20815>;
  <D.20818>:
  D.20813 = *p;
  if (D.20813 == 0) goto <D.20819>; else goto <D.20815>;
  <D.20819>:
  D.20813 = *p;
  D.20816 = (int) D.20813;
  D.20820 = __rawmemchr (list, D.20816);
  if (D.20820 == 0B) goto <D.19486>; else goto <D.19488>;
  <D.20815>:
  D.20813 = *p;
  D.20816 = (int) D.20813;
  D.20821 = __builtin_strchr (list, D.20816);
  if (D.20821 == 0B) goto <D.19486>; else goto <D.19488>;
  <D.19488>:
  p.97 = (long int) p;
  str.98 = (long int) str;
  D.20824 = p.97 - str.98;
  monoeg_g_string_append_len (res, str, D.20824);
  D.20813 = *p;
  if (D.20813 == 0) goto <D.19489>; else goto <D.20825>;
  <D.20825>:
  monoeg_g_string_append_c (res, 92);
  str = p;
  p = p + 1;
  goto <D.19490>;
  <D.19489>:
  D.20826 = monoeg_g_string_free (res, 0);
  return D.20826;
}


param_flags (guint32 f)
{
  char * D.20828;
  const char * D.20829;

  D.20829 = flags (f, &param_map);
  D.20828 = monoeg_strdup (D.20829);
  return D.20828;
}


field_flags (guint32 f)
{
  int f.99;
  int D.20832;
  unsigned int D.20833;
  unsigned int D.20834;
  unsigned int access.100;
  const char * D.20836;
  unsigned int rest.101;
  const char * D.20838;
  char * D.20839;
  char buffer[1024];
  int access;
  int rest;

  try
    {
      f.99 = (int) f;
      access = f.99 & 7;
      D.20832 = ~access;
      D.20833 = (unsigned int) D.20832;
      D.20834 = D.20833 & f;
      rest = (int) D.20834;
      buffer[0] = 0;
      access.100 = (unsigned int) access;
      D.20836 = map (access.100, &field_access_map);
      strcat (&buffer, D.20836);
      rest.101 = (unsigned int) rest;
      D.20838 = flags (rest.101, &field_flags_map);
      strcat (&buffer, D.20838);
      D.20839 = monoeg_strdup (&buffer);
      return D.20839;
    }
  finally
    {
      buffer = {CLOBBER};
    }
}


strcat (char * restrict __dest, const char * restrict __src)
{
  char * D.20842;
  long unsigned int D.20843;

  D.20843 = __builtin_object_size (__dest, 1);
  D.20842 = __builtin___strcat_chk (__dest, __src, D.20843);
  return D.20842;
}


get_methodref_signature (struct MonoImage * m, guint32 blob_signature, const char * fancy_name)
{
  const char * ptr.102;
  const char * ptr.103;
  unsigned int D.20847;
  char D.20848;
  int D.20849;
  int D.20850;
  int D.20853;
  int D.20857;
  unsigned int cconv.104;
  int D.19543;
  int iftmp.105;
  int D.19542;
  const char[8] * D.20864;
  unsigned char D.20865;
  int D.20866;
  unsigned char D.20867;
  int D.20868;
  const unsigned char * D.20873;
  unsigned char D.20874;
  int D.20875;
  const unsigned char * D.20876;
  unsigned char D.20877;
  int D.20878;
  const unsigned char * D.20883;
  unsigned char D.20884;
  int D.20885;
  const unsigned char * D.20886;
  unsigned char D.20887;
  int D.20888;
  const unsigned char * D.20893;
  unsigned char D.20894;
  int D.20895;
  const unsigned char * D.20896;
  unsigned char D.20897;
  int D.20898;
  const char * ptr.106;
  unsigned int D.20905;
  unsigned int D.20906;
  const char * ptr.107;
  char * allocated_ret_type.108;
  const char * ptr.109;
  char * param.110;
  int D.20919;
  char * D.20922;
  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.102 = mono_metadata_blob_heap (m, blob_signature);
      ptr = ptr.102;
      seen_vararg = 0;
      gen_count = 0;
      ptr.103 = ptr;
      D.20847 = mono_metadata_decode_value (ptr.103, &ptr);
      signature_len = (int) D.20847;
      ptr.103 = ptr;
      D.20848 = *ptr.103;
      D.20849 = (int) D.20848;
      D.20850 = D.20849 & 32;
      if (D.20850 != 0) goto <D.20851>; else goto <D.20852>;
      <D.20851>:
      ptr.103 = ptr;
      D.20848 = *ptr.103;
      D.20849 = (int) D.20848;
      D.20853 = D.20849 & 64;
      if (D.20853 != 0) goto <D.20854>; else goto <D.20855>;
      <D.20854>:
      monoeg_g_string_append (res, "explicit-this ");
      goto <D.20856>;
      <D.20855>:
      monoeg_g_string_append (res, "instance ");
      <D.20856>:
      <D.20852>:
      ptr.103 = ptr;
      D.20848 = *ptr.103;
      D.20849 = (int) D.20848;
      D.20857 = D.20849 & 16;
      if (D.20857 != 0) goto <D.20858>; else goto <D.20859>;
      <D.20858>:
      gen_count = 1;
      <D.20859>:
      ptr.103 = ptr;
      D.20848 = *ptr.103;
      D.20849 = (int) D.20848;
      cconv = D.20849 & 15;
      cconv.104 = (unsigned int) cconv;
      cconv_str = map (cconv.104, &call_conv_type_map);
      {
        size_t __s1_len;
        size_t __s2_len;

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

          __s2 = cconv_str;
          D.20864 = "default";
          D.20865 = MEM[(const unsigned char *)D.20864];
          D.20866 = (int) D.20865;
          D.20867 = *__s2;
          D.20868 = (int) D.20867;
          __result = D.20866 - D.20868;
          {
            if (__s2_len != 0) goto <D.20869>; else goto <D.20870>;
            <D.20869>:
            if (__result == 0) goto <D.20871>; else goto <D.20872>;
            <D.20871>:
            D.20873 = &MEM[(void *)"default" + 1B];
            D.20874 = *D.20873;
            D.20875 = (int) D.20874;
            D.20876 = __s2 + 1;
            D.20877 = *D.20876;
            D.20878 = (int) D.20877;
            __result = D.20875 - D.20878;
            if (__s2_len > 1) goto <D.20879>; else goto <D.20880>;
            <D.20879>:
            if (__result == 0) goto <D.20881>; else goto <D.20882>;
            <D.20881>:
            D.20883 = &MEM[(void *)"default" + 2B];
            D.20884 = *D.20883;
            D.20885 = (int) D.20884;
            D.20886 = __s2 + 2;
            D.20887 = *D.20886;
            D.20888 = (int) D.20887;
            __result = D.20885 - D.20888;
            if (__s2_len > 2) goto <D.20889>; else goto <D.20890>;
            <D.20889>:
            if (__result == 0) goto <D.20891>; else goto <D.20892>;
            <D.20891>:
            D.20893 = &MEM[(void *)"default" + 3B];
            D.20894 = *D.20893;
            D.20895 = (int) D.20894;
            D.20896 = __s2 + 3;
            D.20897 = *D.20896;
            D.20898 = (int) D.20897;
            __result = D.20895 - D.20898;
            <D.20892>:
            <D.20890>:
            <D.20882>:
            <D.20880>:
            <D.20872>:
            <D.20870>:
          }
          D.19542 = __result;
        }
        iftmp.105 = -D.19542;
        goto <D.20899>;
        <D.20863>:
        iftmp.105 = __builtin_strcmp (cconv_str, "default");
        <D.20899>:
        D.19543 = iftmp.105;
      }
      if (D.19543 != 0) goto <D.20900>; else goto <D.20901>;
      <D.20900>:
      monoeg_g_string_append (res, cconv_str);
      monoeg_g_string_append (res, " ");
      <D.20901>:
      ptr.103 = ptr;
      ptr.106 = ptr.103 + 1;
      ptr = ptr.106;
      if (gen_count != 0) goto <D.20903>; else goto <D.20904>;
      <D.20903>:
      ptr.103 = ptr;
      D.20905 = mono_metadata_decode_value (ptr.103, &ptr);
      gen_count = (int) D.20905;
      <D.20904>:
      ptr.103 = ptr;
      D.20906 = mono_metadata_decode_value (ptr.103, &ptr);
      param_count = (int) D.20906;
      if (cconv != 10) goto <D.20907>; else goto <D.20908>;
      <D.20907>:
      ptr.103 = ptr;
      ptr.107 = get_ret_type (m, ptr.103, &allocated_ret_type, 0B);
      ptr = ptr.107;
      allocated_ret_type.108 = allocated_ret_type;
      monoeg_g_string_append (res, allocated_ret_type.108);
      allocated_ret_type.108 = allocated_ret_type;
      monoeg_g_free (allocated_ret_type.108);
      <D.20908>:
      if (fancy_name != 0B) goto <D.20911>; else goto <D.20912>;
      <D.20911>:
      monoeg_g_string_append_c (res, 32);
      monoeg_g_string_append (res, fancy_name);
      <D.20912>:
      monoeg_g_string_append (res, "(");
      i = 0;
      goto <D.19546>;
      <D.19545>:
      {
        char * param;

        try
          {
            param = 0B;
            ptr.103 = ptr;
            D.20848 = *ptr.103;
            if (D.20848 == 65) goto <D.20913>; else goto <D.20914>;
            <D.20913>:
            if (seen_vararg == 0) goto <D.20915>; else goto <D.20916>;
            <D.20915>:
            monoeg_g_string_append (res, "..., ");
            seen_vararg = 1;
            <D.20916>:
            ptr.103 = ptr;
            ptr.106 = ptr.103 + 1;
            ptr = ptr.106;
            <D.20914>:
            ptr.103 = ptr;
            ptr.109 = get_param (m, ptr.103, &param, 0B);
            ptr = ptr.109;
            param.110 = param;
            monoeg_g_string_append (res, param.110);
            D.20919 = i + 1;
            if (D.20919 != param_count) goto <D.20920>; else goto <D.20921>;
            <D.20920>:
            monoeg_g_string_append (res, ", ");
            <D.20921>:
            param.110 = param;
            monoeg_g_free (param.110);
          }
        finally
          {
            param = {CLOBBER};
          }
      }
      i = i + 1;
      <D.19546>:
      if (i < param_count) goto <D.19545>; else goto <D.19547>;
      <D.19547>:
      monoeg_g_string_append (res, ")");
      s = res->str;
      monoeg_g_string_free (res, 0);
      D.20922 = s;
      return D.20922;
    }
  finally
    {
      ptr = {CLOBBER};
      allocated_ret_type = {CLOBBER};
    }
}


get_fieldref_signature (struct MonoImage * m, int idx, struct MonoGenericContainer * container)
{
  struct MonoTableInfo * D.20925;
  int D.20926;
  unsigned int D.20927;
  unsigned int D.20928;
  unsigned int D.20929;
  const char * D.20930;
  const char * iftmp.111;
  const char * iftmp.112;
  char * D.20939;
  guint32 cols[3];
  struct MonoGenericContainer * new_container;
  char * type;
  char * esname;
  char * sig;
  char * full_sig;

  try
    {
      D.20925 = &m->tables[10];
      D.20926 = idx + -1;
      mono_metadata_decode_row (D.20925, D.20926, &cols, 3);
      D.20927 = cols[0];
      new_container = get_memberref_container (m, D.20927, container);
      D.20928 = cols[2];
      sig = get_field_signature (m, D.20928, new_container);
      D.20927 = cols[0];
      type = get_memberref_parent (m, D.20927, container);
      D.20929 = cols[1];
      D.20930 = mono_metadata_string_heap (m, D.20929);
      esname = get_escaped_name (D.20930);
      if (type != 0B) goto <D.20932>; else goto <D.20933>;
      <D.20932>:
      iftmp.111 = type;
      goto <D.20934>;
      <D.20933>:
      iftmp.111 = "";
      <D.20934>:
      if (type != 0B) goto <D.20936>; else goto <D.20937>;
      <D.20936>:
      iftmp.112 = "::";
      goto <D.20938>;
      <D.20937>:
      iftmp.112 = "";
      <D.20938>:
      full_sig = monoeg_g_strdup_printf ("%s %s%s%s", sig, iftmp.111, iftmp.112, esname);
      monoeg_g_free (sig);
      monoeg_g_free (type);
      monoeg_g_free (esname);
      D.20939 = full_sig;
      return D.20939;
    }
  finally
    {
      cols = {CLOBBER};
    }
}


get_memberref_container (struct MonoImage * m, guint32 mrp_token, struct MonoGenericContainer * container)
{
  struct MonoGenericContainer * D.20942;
  unsigned int D.20943;
  unsigned int D.20944;
  _Bool D.20945;
  long int D.20946;
  long int D.20947;
  struct MonoGenericContainer * iftmp.113;
  struct MonoGenericClass * D.20951;
  struct MonoClass * D.20954;
  struct MonoClass * klass;
  guint32 table;
  guint32 idx;

  table = mrp_token & 7;
  idx = mrp_token >> 3;
  switch (table) <default: <D.20956>, case 0: <D.19580>, case 1: <D.19581>, case 4: <D.19582>>
  <D.19580>:
  D.20943 = idx | 33554432;
  D.20942 = mono_metadata_load_generic_params (m, D.20943, 0B);
  return D.20942;
  <D.19581>:
  D.20942 = 0B;
  return D.20942;
  <D.19582>:
  D.20944 = idx | 452984832;
  klass = mono_class_get_full (m, D.20944, container);
  D.20945 = klass == 0B;
  D.20946 = (long int) D.20945;
  D.20947 = __builtin_expect (D.20946, 0);
  if (D.20947 != 0) goto <D.20948>; else goto <D.20949>;
  <D.20948>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "get.c", 1852, "klass");
  <D.20949>:
  D.20951 = klass->generic_class;
  if (D.20951 != 0B) goto <D.20952>; else goto <D.20953>;
  <D.20952>:
  D.20951 = klass->generic_class;
  D.20954 = D.20951->container_class;
  iftmp.113 = D.20954->generic_container;
  goto <D.20955>;
  <D.20953>:
  iftmp.113 = 0B;
  <D.20955>:
  D.20942 = iftmp.113;
  return D.20942;
  <D.20956>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "get.c", 1855);
  D.20942 = 0B;
  return D.20942;
}


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

  table = mrp_token & 7;
  idx = mrp_token >> 3;
  switch (table) <default: <D.20960>, case 0: <D.19590>, case 1: <D.19591>, case 2: <D.19592>, case 3: <D.19593>, case 4: <D.19594>>
  <D.19590>:
  idx.114 = (int) idx;
  D.20958 = get_typedef (m, idx.114);
  return D.20958;
  <D.19591>:
  idx.114 = (int) idx;
  D.20958 = get_typeref (m, idx.114);
  return D.20958;
  <D.19592>:
  D.20958 = monoeg_g_strdup_printf ("TODO:MemberRefParent-ModuleRef");
  return D.20958;
  <D.19593>:
  D.20958 = monoeg_strdup ("TODO:MethodDef");
  return D.20958;
  <D.19594>:
  D.20958 = get_typespec (m, idx, 0, container);
  return D.20958;
  <D.20960>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "get.c", 1884);
  D.20958 = 0B;
  return D.20958;
}


get_field (struct MonoImage * m, guint32 token, struct MonoGenericContainer * container)
{
  int token.115;
  unsigned int D.20963;
  char * D.20966;
  _Bool D.20967;
  long int D.20968;
  long int D.20969;
  struct MonoTableInfo * D.20972;
  int D.20973;
  unsigned int D.20974;
  unsigned int idx.116;
  int type_idx.117;
  unsigned int D.20979;
  const char * D.20980;
  const char * iftmp.118;
  const char * iftmp.119;
  int idx;
  guint32 cols[3];
  char * sig;
  char * res;
  char * type;
  char * estype;
  char * esname;
  guint32 type_idx;

  try
    {
      token.115 = (int) token;
      idx = token.115 & 16777215;
      D.20963 = token & 4278190080;
      if (D.20963 == 167772160) goto <D.20964>; else goto <D.20965>;
      <D.20964>:
      D.20966 = get_fieldref_signature (m, idx, container);
      return D.20966;
      <D.20965>:
      D.20963 = token & 4278190080;
      D.20967 = D.20963 != 67108864;
      D.20968 = (long int) D.20967;
      D.20969 = __builtin_expect (D.20968, 0);
      if (D.20969 != 0) goto <D.20970>; else goto <D.20971>;
      <D.20970>:
      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.20971>:
      D.20972 = &m->tables[4];
      D.20973 = idx + -1;
      mono_metadata_decode_row (D.20972, D.20973, &cols, 3);
      D.20974 = cols[2];
      sig = get_field_signature (m, D.20974, container);
      idx.116 = (unsigned int) idx;
      type_idx = mono_metadata_typedef_from_field (m, idx.116);
      if (type_idx == 0) goto <D.20976>; else goto <D.20977>;
      <D.20976>:
      res = monoeg_g_strdup_printf ("<invalid> %s", sig);
      monoeg_g_free (sig);
      D.20966 = res;
      return D.20966;
      <D.20977>:
      type_idx.117 = (int) type_idx;
      type = get_typedef (m, type_idx.117);
      estype = get_escaped_name (type);
      D.20979 = cols[1];
      D.20980 = mono_metadata_string_heap (m, D.20979);
      esname = get_escaped_name (D.20980);
      if (estype != 0B) goto <D.20982>; else goto <D.20983>;
      <D.20982>:
      iftmp.118 = estype;
      goto <D.20984>;
      <D.20983>:
      iftmp.118 = "";
      <D.20984>:
      if (estype != 0B) goto <D.20986>; else goto <D.20987>;
      <D.20986>:
      iftmp.119 = "::";
      goto <D.20988>;
      <D.20987>:
      iftmp.119 = "";
      <D.20988>:
      res = monoeg_g_strdup_printf ("%s %s%s%s", sig, iftmp.118, iftmp.119, esname);
      monoeg_g_free (type);
      monoeg_g_free (sig);
      monoeg_g_free (estype);
      monoeg_g_free (esname);
      D.20966 = res;
      return D.20966;
    }
  finally
    {
      cols = {CLOBBER};
    }
}


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

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


get_method_core (struct MonoImage * m, guint32 token, gboolean fullsig, struct MonoGenericContainer * container)
{
  int token.120;
  struct MonoMethodSignature * D.20996;
  long unsigned int D.20997;
  long unsigned int D.20998;
  struct MonoMethod * D.21001;
  const char * D.21002;
  struct MonoClass * D.21003;
  struct MonoType * D.21004;
  int show_tokens.121;
  const char * iftmp.122;
  const char * iftmp.123;
  const char * iftmp.124;
  const char * iftmp.125;
  unsigned int D.21026;
  struct MonoTableInfo * D.21027;
  int D.21028;
  unsigned int D.21029;
  struct MonoTableInfo * D.21030;
  unsigned int D.21033;
  const char * iftmp.126;
  const char * iftmp.127;
  unsigned int D.21042;
  const char * D.21043;
  long unsigned int D.21046;
  long unsigned int D.21047;
  struct MonoGenericContainer * D.21050;
  <unnamed-signed:31> D.21051;
  long unsigned int D.21053;
  long unsigned int D.21056;
  long unsigned int D.21057;
  struct MonoGenericContainer * D.21060;
  <unnamed-signed:31> D.21061;
  unsigned int D.21064;
  struct MonoTableInfo * D.21065;
  char * D.21069;
  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.120 = (int) token;
      idx = token.120 & 16777215;
      sig = 0B;
      type_container = container;
      mh = mono_get_method_full (m, token, 0B, container);
      if (mh != 0B) goto <D.20994>; else goto <D.20995>;
      <D.20994>:
      D.20996 = mono_method_signature (mh);
      D.20997 = BIT_FIELD_REF <*D.20996, 64, 64>;
      D.20998 = D.20997 & 144115188075855872;
      if (D.20998 != 0) goto <D.20999>; else goto <D.21000>;
      <D.20999>:
      D.21001 = MEM[(struct MonoMethodInflated *)mh].declaring;
      container = mono_method_get_generic_container (D.21001);
      <D.21000>:
      D.21002 = mh->name;
      esname = get_escaped_name (D.21002);
      D.21003 = mh->klass;
      D.21004 = &D.21003->byval_arg;
      sig = dis_stringify_type (m, D.21004, 1);
      show_tokens.121 = show_tokens;
      if (show_tokens.121 != 0) goto <D.21006>; else goto <D.21007>;
      <D.21006>:
      if (sig != 0B) goto <D.21009>; else goto <D.21010>;
      <D.21009>:
      iftmp.122 = sig;
      goto <D.21011>;
      <D.21010>:
      iftmp.122 = "";
      <D.21011>:
      if (sig != 0B) goto <D.21013>; else goto <D.21014>;
      <D.21013>:
      iftmp.123 = "::";
      goto <D.21015>;
      <D.21014>:
      iftmp.123 = "";
      <D.21015>:
      name = monoeg_g_strdup_printf ("%s/*%08x*/%s%s", iftmp.122, token, iftmp.123, esname);
      goto <D.21016>;
      <D.21007>:
      if (sig != 0B) goto <D.21018>; else goto <D.21019>;
      <D.21018>:
      iftmp.124 = sig;
      goto <D.21020>;
      <D.21019>:
      iftmp.124 = "";
      <D.21020>:
      if (sig != 0B) goto <D.21022>; else goto <D.21023>;
      <D.21022>:
      iftmp.125 = "::";
      goto <D.21024>;
      <D.21023>:
      iftmp.125 = "";
      <D.21024>:
      name = monoeg_g_strdup_printf ("%s%s%s", iftmp.124, iftmp.125, esname);
      <D.21016>:
      monoeg_g_free (sig);
      monoeg_g_free (esname);
      goto <D.21025>;
      <D.20995>:
      name = 0B;
      <D.21025>:
      D.21026 = token & 4278190080;
      switch (D.21026) <default: <D.19616>, case 100663296: <D.19609>, case 167772160: <D.19611>, case 721420288: <D.19615>>
      <D.19609>:
      D.21027 = &m->tables[6];
      D.21028 = idx + -1;
      mono_metadata_decode_row (D.21027, D.21028, &method_cols, 6);
      D.21029 = method_cols[4];
      sig = get_methodref_signature (m, D.21029, name);
      goto <D.19610>;
      <D.19611>:
      D.21030 = &m->tables[10];
      D.21028 = idx + -1;
      mono_metadata_decode_row (D.21030, D.21028, &member_cols, 3);
      if (name == 0B) goto <D.21031>; else goto <D.21032>;
      <D.21031>:
      {
        char * parent;

        D.21033 = member_cols[0];
        parent = get_memberref_parent (m, D.21033, container);
        if (parent != 0B) goto <D.21035>; else goto <D.21036>;
        <D.21035>:
        iftmp.126 = parent;
        goto <D.21037>;
        <D.21036>:
        iftmp.126 = "";
        <D.21037>:
        if (parent != 0B) goto <D.21039>; else goto <D.21040>;
        <D.21039>:
        iftmp.127 = "::";
        goto <D.21041>;
        <D.21040>:
        iftmp.127 = "";
        <D.21041>:
        D.21042 = member_cols[1];
        D.21043 = mono_metadata_string_heap (m, D.21042);
        name = monoeg_g_strdup_printf ("%s%s%s", iftmp.126, iftmp.127, D.21043);
        monoeg_g_free (parent);
      }
      <D.21032>:
      if (mh != 0B) goto <D.21044>; else goto <D.21045>;
      <D.21044>:
      {
        int arity;

        arity = 0;
        D.21046 = BIT_FIELD_REF <*mh, 64, 256>;
        D.21047 = D.21046 & 2048;
        if (D.21047 != 0) goto <D.21048>; else goto <D.21049>;
        <D.21048>:
        D.21050 = mono_method_get_generic_container (mh);
        D.21051 = D.21050->type_argc;
        arity = (int) D.21051;
        goto <D.21052>;
        <D.21049>:
        D.21046 = BIT_FIELD_REF <*mh, 64, 256>;
        D.21053 = D.21046 & 4096;
        if (D.21053 != 0) goto <D.21054>; else goto <D.21055>;
        <D.21054>:
        D.21001 = MEM[(struct MonoMethodInflated *)mh].declaring;
        D.21056 = BIT_FIELD_REF <*D.21001, 64, 256>;
        D.21057 = D.21056 & 2048;
        if (D.21057 != 0) goto <D.21058>; else goto <D.21059>;
        <D.21058>:
        D.21001 = MEM[(struct MonoMethodInflated *)mh].declaring;
        D.21060 = mono_method_get_generic_container (D.21001);
        D.21061 = D.21060->type_argc;
        arity = (int) D.21061;
        <D.21059>:
        <D.21055>:
        <D.21052>:
        if (arity > 0) goto <D.21062>; else goto <D.21063>;
        <D.21062>:
        {
          char * str;

          str = monoeg_g_strdup_printf ("%s <[%d]>", name, arity);
          monoeg_g_free (name);
          name = str;
        }
        <D.21063>:
      }
      <D.21045>:
      D.21064 = member_cols[2];
      sig = get_methodref_signature (m, D.21064, name);
      goto <D.19610>;
      <D.19615>:
      D.21065 = &m->tables[43];
      D.21028 = idx + -1;
      mono_metadata_decode_row (D.21065, D.21028, &member_cols, 2);
      token = member_cols[0];
      sig = get_methodspec (m, idx, token, name, type_container);
      goto <D.19610>;
      <D.19616>:
      monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "get.c", 1971);
      <D.19610>:
      if (fullsig != 0) goto <D.21066>; else goto <D.21067>;
      <D.21066>:
      monoeg_g_free (name);
      goto <D.21068>;
      <D.21067>:
      monoeg_g_free (sig);
      D.21069 = name;
      return D.21069;
      <D.21068>:
      show_tokens.121 = show_tokens;
      if (show_tokens.121 != 0) goto <D.21070>; else goto <D.21071>;
      <D.21070>:
      {
        char * retval;

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


get_methoddef (struct MonoImage * m, guint32 idx)
{
  unsigned int D.21074;
  struct MonoClass * D.21077;
  struct MonoType * D.21078;
  const char * iftmp.128;
  const char * iftmp.129;
  const char * D.21087;
  struct MonoTableInfo * D.21089;
  unsigned int D.21090;
  int D.21091;
  unsigned int D.21092;
  char * D.21093;
  guint32 cols[6];
  char * sig;
  const char * name;
  struct MonoMethod * mh;

  try
    {
      D.21074 = idx | 100663296;
      mh = mono_get_method (m, D.21074, 0B);
      if (mh != 0B) goto <D.21075>; else goto <D.21076>;
      <D.21075>:
      D.21077 = mh->klass;
      D.21078 = &D.21077->byval_arg;
      sig = dis_stringify_type (m, D.21078, 0);
      if (sig != 0B) goto <D.21080>; else goto <D.21081>;
      <D.21080>:
      iftmp.128 = sig;
      goto <D.21082>;
      <D.21081>:
      iftmp.128 = "";
      <D.21082>:
      if (sig != 0B) goto <D.21084>; else goto <D.21085>;
      <D.21084>:
      iftmp.129 = "::";
      goto <D.21086>;
      <D.21085>:
      iftmp.129 = "";
      <D.21086>:
      D.21087 = mh->name;
      name = monoeg_g_strdup_printf ("%s%s%s", iftmp.128, iftmp.129, D.21087);
      monoeg_g_free (sig);
      goto <D.21088>;
      <D.21076>:
      name = 0B;
      <D.21088>:
      D.21089 = &m->tables[6];
      D.21090 = idx + 4294967295;
      D.21091 = (int) D.21090;
      mono_metadata_decode_row (D.21089, D.21091, &cols, 6);
      D.21092 = cols[4];
      sig = get_methodref_signature (m, D.21092, name);
      D.21093 = sig;
      return D.21093;
    }
  finally
    {
      cols = {CLOBBER};
    }
}


get_method_type_param (struct MonoImage * m, guint32 blob_signature, struct MonoGenericContainer * container)
{
  const char * ptr.130;
  const char * ptr.131;
  const char * ptr.132;
  unsigned int D.21099;
  const char * ptr.133;
  char * param.134;
  int D.21102;
  char * D.21105;
  struct GString * res;
  const char * ptr;
  int param_count;
  int i;
  char * s;

  try
    {
      res = monoeg_g_string_new ("");
      ptr.130 = mono_metadata_blob_heap (m, blob_signature);
      ptr = ptr.130;
      i = 0;
      ptr.131 = ptr;
      mono_metadata_decode_value (ptr.131, &ptr);
      ptr.131 = ptr;
      ptr.132 = ptr.131 + 1;
      ptr = ptr.132;
      ptr.131 = ptr;
      D.21099 = mono_metadata_decode_value (ptr.131, &ptr);
      param_count = (int) D.21099;
      monoeg_g_string_append_c (res, 60);
      i = 0;
      goto <D.19643>;
      <D.19642>:
      {
        char * param;

        try
          {
            param = 0B;
            ptr.131 = ptr;
            ptr.133 = get_param (m, ptr.131, &param, container);
            ptr = ptr.133;
            param.134 = param;
            monoeg_g_string_append (res, param.134);
            D.21102 = i + 1;
            if (D.21102 != param_count) goto <D.21103>; else goto <D.21104>;
            <D.21103>:
            monoeg_g_string_append (res, ", ");
            <D.21104>:
            param.134 = param;
            monoeg_g_free (param.134);
          }
        finally
          {
            param = {CLOBBER};
          }
      }
      i = i + 1;
      <D.19643>:
      if (i < param_count) goto <D.19642>; else goto <D.19644>;
      <D.19644>:
      monoeg_g_string_append_c (res, 62);
      s = res->str;
      monoeg_g_string_free (res, 0);
      D.21105 = s;
      return D.21105;
    }
  finally
    {
      ptr = {CLOBBER};
    }
}


get_methodspec (struct MonoImage * m, int idx, guint32 token, const char * fancy_name, struct MonoGenericContainer * type_container)
{
  unsigned int D.21108;
  struct MonoTableInfo * D.21109;
  unsigned int D.21110;
  unsigned int D.21111;
  int D.21112;
  struct MonoTableInfo * D.21113;
  const char * ptr.135;
  const char * ptr.136;
  unsigned int D.21116;
  _Bool D.21117;
  long int D.21118;
  long int D.21119;
  char D.21124;
  int D.21125;
  int D.21126;
  int D.21129;
  int D.21133;
  const char * ptr.137;
  unsigned int D.21139;
  unsigned int D.21140;
  const char * ptr.138;
  char * allocated_ret_type.139;
  struct MonoTableInfo * D.21147;
  int D.21148;
  const char * ptr.140;
  char * param.141;
  int D.21151;
  char * D.21154;
  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.21108 = token & 1;
      switch (D.21108) <default: <D.19668>, case 0: <D.19665>, case 1: <D.19667>>
      <D.19665>:
      D.21109 = &m->tables[6];
      D.21110 = token >> 1;
      D.21111 = D.21110 + 4294967295;
      D.21112 = (int) D.21111;
      mono_metadata_decode_row (D.21109, D.21112, &method_cols, 6);
      sig = method_cols[4];
      goto <D.19666>;
      <D.19667>:
      D.21113 = &m->tables[10];
      D.21110 = token >> 1;
      D.21111 = D.21110 + 4294967295;
      D.21112 = (int) D.21111;
      mono_metadata_decode_row (D.21113, D.21112, &member_cols, 3);
      sig = member_cols[2];
      goto <D.19666>;
      <D.19668>:
      monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "get.c", 2091);
      <D.19666>:
      ptr.135 = mono_metadata_blob_heap (m, sig);
      ptr = ptr.135;
      ptr.136 = ptr;
      mono_metadata_decode_value (ptr.136, &ptr);
      D.21116 = method_dor_to_token (token);
      mh = mono_get_method_full (m, D.21116, 0B, type_container);
      D.21117 = mh == 0B;
      D.21118 = (long int) D.21117;
      D.21119 = __builtin_expect (D.21118, 0);
      if (D.21119 != 0) goto <D.21120>; else goto <D.21121>;
      <D.21120>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "get.c", 2098, "mh");
      <D.21121>:
      container = mono_method_get_generic_container (mh);
      if (container == 0B) goto <D.21122>; else goto <D.21123>;
      <D.21122>:
      container = type_container;
      <D.21123>:
      ptr.136 = ptr;
      D.21124 = *ptr.136;
      D.21125 = (int) D.21124;
      D.21126 = D.21125 & 32;
      if (D.21126 != 0) goto <D.21127>; else goto <D.21128>;
      <D.21127>:
      ptr.136 = ptr;
      D.21124 = *ptr.136;
      D.21125 = (int) D.21124;
      D.21129 = D.21125 & 64;
      if (D.21129 != 0) goto <D.21130>; else goto <D.21131>;
      <D.21130>:
      monoeg_g_string_append (res, "explicit-this ");
      goto <D.21132>;
      <D.21131>:
      monoeg_g_string_append (res, "instance ");
      <D.21132>:
      <D.21128>:
      ptr.136 = ptr;
      D.21124 = *ptr.136;
      D.21125 = (int) D.21124;
      D.21133 = D.21125 & 16;
      if (D.21133 != 0) goto <D.21134>; else goto <D.21135>;
      <D.21134>:
      gen_count = 1;
      <D.21135>:
      ptr.136 = ptr;
      D.21124 = *ptr.136;
      D.21125 = (int) D.21124;
      cconv = D.21125 & 15;
      ptr.136 = ptr;
      ptr.137 = ptr.136 + 1;
      ptr = ptr.137;
      if (gen_count != 0) goto <D.21137>; else goto <D.21138>;
      <D.21137>:
      ptr.136 = ptr;
      D.21139 = mono_metadata_decode_value (ptr.136, &ptr);
      gen_count = (int) D.21139;
      <D.21138>:
      ptr.136 = ptr;
      D.21140 = mono_metadata_decode_value (ptr.136, &ptr);
      param_count = (int) D.21140;
      if (cconv != 10) goto <D.21141>; else goto <D.21142>;
      <D.21141>:
      {
        char * allocated_ret_type;

        try
          {
            ptr.136 = ptr;
            ptr.138 = get_ret_type (m, ptr.136, &allocated_ret_type, container);
            ptr = ptr.138;
            allocated_ret_type.139 = allocated_ret_type;
            monoeg_g_string_append (res, allocated_ret_type.139);
            allocated_ret_type.139 = allocated_ret_type;
            monoeg_g_free (allocated_ret_type.139);
          }
        finally
          {
            allocated_ret_type = {CLOBBER};
          }
      }
      <D.21142>:
      if (fancy_name != 0B) goto <D.21145>; else goto <D.21146>;
      <D.21145>:
      monoeg_g_string_append_c (res, 32);
      monoeg_g_string_append (res, fancy_name);
      <D.21146>:
      D.21147 = &m->tables[43];
      D.21148 = idx + -1;
      mono_metadata_decode_row (D.21147, D.21148, &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.19672>;
      <D.19671>:
      {
        char * param;

        try
          {
            param = 0B;
            ptr.136 = ptr;
            ptr.140 = get_param (m, ptr.136, &param, container);
            ptr = ptr.140;
            param.141 = param;
            monoeg_g_string_append (res, param.141);
            D.21151 = i + 1;
            if (D.21151 != param_count) goto <D.21152>; else goto <D.21153>;
            <D.21152>:
            monoeg_g_string_append (res, ", ");
            <D.21153>:
            param.141 = param;
            monoeg_g_free (param.141);
          }
        finally
          {
            param = {CLOBBER};
          }
      }
      i = i + 1;
      <D.19672>:
      if (i < param_count) goto <D.19671>; else goto <D.19673>;
      <D.19673>:
      monoeg_g_string_append (res, ")");
      s = res->str;
      monoeg_g_string_free (res, 0);
      D.21154 = s;
      return D.21154;
    }
  finally
    {
      member_cols = {CLOBBER};
      method_cols = {CLOBBER};
      ptr = {CLOBBER};
    }
}


get_encoded_user_string_or_bytearray (const unsigned char * ptr, int len)
{
  int D.21157;
  int D.21158;
  long unsigned int D.21159;
  sizetype D.21162;
  sizetype D.21163;
  const unsigned char * D.21164;
  unsigned char D.21165;
  const short unsigned int * * D.21167;
  const short unsigned int * D.21168;
  const unsigned char * D.21169;
  unsigned char D.21170;
  long unsigned int D.21171;
  long unsigned int D.21172;
  const short unsigned int * D.21173;
  short unsigned int D.21174;
  int D.21175;
  int D.21176;
  char * D.21182;
  int D.21183;
  sizetype D.21184;
  char * D.21185;
  int D.21186;
  sizetype D.21187;
  char * D.21188;
  char * res;
  char * eres;
  char * result;
  int i;

  D.21157 = len >> 1;
  D.21158 = D.21157 + 1;
  D.21159 = (long unsigned int) D.21158;
  res = monoeg_malloc (D.21159);
  i = 0;
  goto <D.19704>;
  <D.19703>:
  D.21162 = (sizetype) i;
  D.21163 = D.21162 + 1;
  D.21164 = ptr + D.21163;
  D.21165 = *D.21164;
  if (D.21165 != 0) goto <D.21160>; else goto <D.21166>;
  <D.21166>:
  D.21167 = __ctype_b_loc ();
  D.21168 = *D.21167;
  D.21162 = (sizetype) i;
  D.21169 = ptr + D.21162;
  D.21170 = *D.21169;
  D.21171 = (long unsigned int) D.21170;
  D.21172 = D.21171 * 2;
  D.21173 = D.21168 + D.21172;
  D.21174 = *D.21173;
  D.21175 = (int) D.21174;
  D.21176 = D.21175 & 16384;
  if (D.21176 == 0) goto <D.21177>; else goto <D.21161>;
  <D.21177>:
  D.21162 = (sizetype) i;
  D.21169 = ptr + D.21162;
  D.21170 = *D.21169;
  if (D.21170 != 92) goto <D.21178>; else goto <D.21161>;
  <D.21178>:
  D.21162 = (sizetype) i;
  D.21169 = ptr + D.21162;
  D.21170 = *D.21169;
  if (D.21170 != 34) goto <D.21179>; else goto <D.21161>;
  <D.21179>:
  D.21162 = (sizetype) i;
  D.21169 = ptr + D.21162;
  D.21170 = *D.21169;
  if (D.21170 != 13) goto <D.21180>; else goto <D.21161>;
  <D.21180>:
  D.21162 = (sizetype) i;
  D.21169 = ptr + D.21162;
  D.21170 = *D.21169;
  if (D.21170 != 10) goto <D.21181>; else goto <D.21161>;
  <D.21181>:
  D.21162 = (sizetype) i;
  D.21169 = ptr + D.21162;
  D.21170 = *D.21169;
  if (D.21170 != 9) goto <D.21160>; else goto <D.21161>;
  <D.21160>:
  monoeg_g_free (res);
  D.21182 = get_encoded_user_string_bytearray (ptr, len);
  return D.21182;
  <D.21161>:
  D.21183 = i >> 1;
  D.21184 = (sizetype) D.21183;
  D.21185 = res + D.21184;
  D.21162 = (sizetype) i;
  D.21169 = ptr + D.21162;
  D.21170 = *D.21169;
  *D.21185 = D.21170;
  i = i + 2;
  <D.19704>:
  D.21186 = i + 1;
  if (D.21186 < len) goto <D.19703>; else goto <D.19705>;
  <D.19705>:
  D.21157 = len >> 1;
  D.21187 = (sizetype) D.21157;
  D.21188 = res + D.21187;
  *D.21188 = 0;
  eres = monoeg_g_strescape (res, 0B);
  result = monoeg_g_strdup_printf ("\"%s\"", eres);
  monoeg_g_free (res);
  monoeg_g_free (eres);
  D.21182 = result;
  return D.21182;
}


get_encoded_user_string_bytearray (const unsigned char * ptr, int len)
{
  char * D.21192;
  sizetype D.21193;
  sizetype D.21194;
  const unsigned char * D.21195;
  unsigned char D.21196;
  int D.21197;
  unsigned int i.142;
  unsigned int D.21199;
  int iftmp.143;
  const short unsigned int * * D.21206;
  const short unsigned int * D.21207;
  sizetype D.21208;
  const unsigned char * D.21209;
  unsigned char D.21210;
  long unsigned int D.21211;
  long unsigned int D.21212;
  const short unsigned int * D.21213;
  short unsigned int D.21214;
  int D.21215;
  int D.21216;
  int iftmp.144;
  const unsigned char * D.21223;
  unsigned char D.21224;
  long unsigned int D.21225;
  long unsigned int D.21226;
  const short unsigned int * D.21227;
  short unsigned int D.21228;
  int D.21229;
  int D.21230;
  gchar * str;
  int i;
  int j;
  int tspaces;
  struct GString * res;

  tspaces = len % 16;
  if (len == 0) goto <D.21190>; else goto <D.21191>;
  <D.21190>:
  D.21192 = monoeg_g_strdup_printf ("\"\"");
  return D.21192;
  <D.21191>:
  res = monoeg_g_string_new ("bytearray (\n\t");
  i = 1;
  goto <D.19687>;
  <D.19686>:
  D.21193 = (sizetype) i;
  D.21194 = D.21193 + 18446744073709551615;
  D.21195 = ptr + D.21194;
  D.21196 = *D.21195;
  D.21197 = (int) D.21196;
  monoeg_g_string_append_printf (res, "%02x ", D.21197);
  i.142 = (unsigned int) i;
  D.21199 = i.142 & 15;
  if (D.21199 == 0) goto <D.21200>; else goto <D.21201>;
  <D.21200>:
  if (i == len) goto <D.21202>; else goto <D.21203>;
  <D.21202>:
  monoeg_g_string_append (res, ")// ");
  goto <D.21204>;
  <D.21203>:
  monoeg_g_string_append (res, " // ");
  <D.21204>:
  j = i + -16;
  goto <D.19684>;
  <D.19683>:
  D.21206 = __ctype_b_loc ();
  D.21207 = *D.21206;
  D.21208 = (sizetype) j;
  D.21209 = ptr + D.21208;
  D.21210 = *D.21209;
  D.21211 = (long unsigned int) D.21210;
  D.21212 = D.21211 * 2;
  D.21213 = D.21207 + D.21212;
  D.21214 = *D.21213;
  D.21215 = (int) D.21214;
  D.21216 = D.21215 & 16384;
  if (D.21216 != 0) goto <D.21217>; else goto <D.21218>;
  <D.21217>:
  D.21208 = (sizetype) j;
  D.21209 = ptr + D.21208;
  D.21210 = *D.21209;
  iftmp.143 = (int) D.21210;
  goto <D.21219>;
  <D.21218>:
  iftmp.143 = 46;
  <D.21219>:
  monoeg_g_string_append_printf (res, "%c", iftmp.143);
  j = j + 1;
  <D.19684>:
  if (j < i) goto <D.19683>; else goto <D.19685>;
  <D.19685>:
  monoeg_g_string_append (res, "\n\t");
  <D.21201>:
  i = i + 1;
  <D.19687>:
  if (i <= len) goto <D.19686>; else goto <D.19688>;
  <D.19688>:
  if (tspaces != 0) goto <D.21220>; else goto <D.21221>;
  <D.21220>:
  monoeg_g_string_append (res, ")  ");
  i = tspaces + 1;
  goto <D.19690>;
  <D.19689>:
  monoeg_g_string_append_printf (res, "   ");
  i = i + 1;
  <D.19690>:
  if (i <= 15) goto <D.19689>; else goto <D.19691>;
  <D.19691>:
  monoeg_g_string_append (res, " // ");
  i = len - tspaces;
  goto <D.19693>;
  <D.19692>:
  D.21206 = __ctype_b_loc ();
  D.21207 = *D.21206;
  D.21193 = (sizetype) i;
  D.21223 = ptr + D.21193;
  D.21224 = *D.21223;
  D.21225 = (long unsigned int) D.21224;
  D.21226 = D.21225 * 2;
  D.21227 = D.21207 + D.21226;
  D.21228 = *D.21227;
  D.21229 = (int) D.21228;
  D.21230 = D.21229 & 16384;
  if (D.21230 != 0) goto <D.21231>; else goto <D.21232>;
  <D.21231>:
  D.21193 = (sizetype) i;
  D.21223 = ptr + D.21193;
  D.21224 = *D.21223;
  iftmp.144 = (int) D.21224;
  goto <D.21233>;
  <D.21232>:
  iftmp.144 = 46;
  <D.21233>:
  monoeg_g_string_append_printf (res, "%c", iftmp.144);
  i = i + 1;
  <D.19693>:
  if (i < len) goto <D.19692>; else goto <D.19694>;
  <D.19694>:
  monoeg_g_string_append (res, "\n\t");
  <D.21221>:
  str = res->str;
  monoeg_g_string_free (res, 0);
  D.21192 = str;
  return D.21192;
}


stringify_double (double r)
{
  long unsigned int D.21235;
  sizetype D.21236;
  char * D.19714;
  char * iftmp.145;
  char * iftmp.146;
  int D.21244;
  char * iftmp.147;
  int D.21249;
  char * iftmp.148;
  char D.21252;
  int D.21255;
  char * D.21259;
  char * ret;
  char * ptr;

  ret = monoeg_g_strdup_printf ("%.17g.", r);
  D.21235 = strlen (ret);
  D.21236 = D.21235 + 18446744073709551615;
  ptr = ret + D.21236;
  {
    char __a0;
    char __a1;
    char __a2;

    __a0 = 46;
    if (__a0 == 0) goto <D.21238>; else goto <D.21239>;
    <D.21238>:
    iftmp.145 = 0B;
    goto <D.21240>;
    <D.21239>:
    __a1 = 101;
    if (__a1 == 0) goto <D.21242>; else goto <D.21243>;
    <D.21242>:
    D.21244 = (int) __a0;
    iftmp.146 = __builtin_strchr (ret, D.21244);
    goto <D.21245>;
    <D.21243>:
    __a2 = 69;
    if (__a2 == 0) goto <D.21247>; else goto <D.21248>;
    <D.21247>:
    D.21244 = (int) __a0;
    D.21249 = (int) __a1;
    iftmp.147 = __strpbrk_c2 (ret, D.21244, D.21249);
    goto <D.21250>;
    <D.21248>:
    D.21252 = 0;
    if (D.21252 == 0) goto <D.21253>; else goto <D.21254>;
    <D.21253>:
    D.21244 = (int) __a0;
    D.21249 = (int) __a1;
    D.21255 = (int) __a2;
    iftmp.148 = __strpbrk_c3 (ret, D.21244, D.21249, D.21255);
    goto <D.21256>;
    <D.21254>:
    iftmp.148 = __builtin_strpbrk (ret, ".eE");
    <D.21256>:
    iftmp.147 = iftmp.148;
    <D.21250>:
    iftmp.146 = iftmp.147;
    <D.21245>:
    iftmp.145 = iftmp.146;
    <D.21240>:
    D.19714 = iftmp.145;
  }
  if (D.19714 != ptr) goto <D.21257>; else goto <D.21258>;
  <D.21257>:
  *ptr = 0;
  <D.21258>:
  D.21259 = ret;
  return D.21259;
}


__strpbrk_c2 (const char * __s, int __accept1, int __accept2)
{
  char D.21261;
  int D.21263;
  char * D.21265;
  char * iftmp.149;

  goto <D.4062>;
  <D.4061>:
  __s = __s + 1;
  <D.4062>:
  D.21261 = *__s;
  if (D.21261 != 0) goto <D.21262>; else goto <D.4063>;
  <D.21262>:
  D.21261 = *__s;
  D.21263 = (int) D.21261;
  if (D.21263 != __accept1) goto <D.21264>; else goto <D.4063>;
  <D.21264>:
  D.21261 = *__s;
  D.21263 = (int) D.21261;
  if (D.21263 != __accept2) goto <D.4061>; else goto <D.4063>;
  <D.4063>:
  D.21261 = *__s;
  if (D.21261 != 0) goto <D.21267>; else goto <D.21268>;
  <D.21267>:
  iftmp.149 = __s;
  goto <D.21269>;
  <D.21268>:
  iftmp.149 = 0B;
  <D.21269>:
  D.21265 = iftmp.149;
  return D.21265;
}


__strpbrk_c3 (const char * __s, int __accept1, int __accept2, int __accept3)
{
  char D.21271;
  int D.21273;
  char * D.21276;
  char * iftmp.150;

  goto <D.4076>;
  <D.4075>:
  __s = __s + 1;
  <D.4076>:
  D.21271 = *__s;
  if (D.21271 != 0) goto <D.21272>; else goto <D.4077>;
  <D.21272>:
  D.21271 = *__s;
  D.21273 = (int) D.21271;
  if (D.21273 != __accept1) goto <D.21274>; else goto <D.4077>;
  <D.21274>:
  D.21271 = *__s;
  D.21273 = (int) D.21271;
  if (D.21273 != __accept2) goto <D.21275>; else goto <D.4077>;
  <D.21275>:
  D.21271 = *__s;
  D.21273 = (int) D.21271;
  if (D.21273 != __accept3) goto <D.4075>; else goto <D.4077>;
  <D.4077>:
  D.21271 = *__s;
  if (D.21271 != 0) goto <D.21278>; else goto <D.21279>;
  <D.21278>:
  iftmp.150 = __s;
  goto <D.21280>;
  <D.21279>:
  iftmp.150 = 0B;
  <D.21280>:
  D.21276 = iftmp.150;
  return D.21276;
}


get_constant (struct MonoImage * m, MonoTypeEnum t, guint32 blob_index)
{
  const char * ptr.151;
  const char * ptr.152;
  unsigned int D.21284;
  char * D.21285;
  const char * iftmp.153;
  char D.21287;
  short unsigned int D.21291;
  int D.21292;
  int D.21293;
  unsigned int D.21294;
  float r.154;
  float r.155;
  double D.21299;
  long unsigned int D.21300;
  double r.156;
  double r.157;
  const char * ptr;
  int len;

  try
    {
      ptr.151 = mono_metadata_blob_heap (m, blob_index);
      ptr = ptr.151;
      ptr.152 = ptr;
      D.21284 = mono_metadata_decode_value (ptr.152, &ptr);
      len = (int) D.21284;
      switch (t) <default: <D.19750>, case 2: <D.19722>, case 3: <D.19723>, case 4: <D.19725>, case 5: <D.19724>, case 6: <D.19727>, case 7: <D.19726>, case 8: <D.19729>, case 9: <D.19728>, case 10: <D.19731>, case 11: <D.19730>, case 12: <D.19734>, case 13: <D.19740>, case 14: <D.19748>, case 18: <D.19749>>
      <D.19722>:
      ptr.152 = ptr;
      D.21287 = *ptr.152;
      if (D.21287 != 0) goto <D.21288>; else goto <D.21289>;
      <D.21288>:
      iftmp.153 = "bool(true)";
      goto <D.21290>;
      <D.21289>:
      iftmp.153 = "bool(false)";
      <D.21290>:
      D.21285 = monoeg_g_strdup_printf ("%s", iftmp.153);
      return D.21285;
      <D.19723>:
      ptr.152 = ptr;
      D.21291 = MEM[(const guint16 *)ptr.152];
      D.21292 = (int) D.21291;
      D.21285 = monoeg_g_strdup_printf ("char(0x%04x)", D.21292);
      return D.21285;
      <D.19724>:
      <D.19725>:
      ptr.152 = ptr;
      D.21287 = *ptr.152;
      D.21293 = (int) D.21287;
      D.21285 = monoeg_g_strdup_printf ("int8(0x%02x)", D.21293);
      return D.21285;
      <D.19726>:
      <D.19727>:
      ptr.152 = ptr;
      D.21291 = MEM[(const guint16 *)ptr.152];
      D.21292 = (int) D.21291;
      D.21285 = monoeg_g_strdup_printf ("int16(0x%08x)", D.21292);
      return D.21285;
      <D.19728>:
      <D.19729>:
      ptr.152 = ptr;
      D.21294 = MEM[(const guint32 *)ptr.152];
      D.21285 = monoeg_g_strdup_printf ("int32(0x%08x)", D.21294);
      return D.21285;
      <D.19730>:
      <D.19731>:
      {
        guint32 low;
        guint32 high;

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

        try
          {
            {
              union mono_rfloat mf;

              try
                {
                  ptr.152 = ptr;
                  D.21294 = MEM[(const guint32 *)ptr.152];
                  mf.ival = D.21294;
                  r.154 = mf.fval;
                  r = r.154;
                }
              finally
                {
                  mf = {CLOBBER};
                }
            }
            r.155 = r;
            normal = __finitef (r.155);
            if (normal == 0) goto <D.21297>; else goto <D.21298>;
            <D.21297>:
            ptr.152 = ptr;
            D.21294 = MEM[(const guint32 *)ptr.152];
            D.21285 = monoeg_g_strdup_printf ("float32(0x%08x)", D.21294);
            return D.21285;
            <D.21298>:
            {
              char * str;
              char * ret;

              r.155 = r;
              D.21299 = (double) r.155;
              str = stringify_double (D.21299);
              ret = monoeg_g_strdup_printf ("float32(%s)", str);
              monoeg_g_free (str);
              D.21285 = ret;
              return D.21285;
            }
          }
        finally
          {
            r = {CLOBBER};
          }
      }
      <D.19740>:
      {
        gboolean normal;
        double r;

        try
          {
            {
              union mono_rdouble mf;

              try
                {
                  ptr.152 = ptr;
                  D.21300 = MEM[(const guint64 *)ptr.152];
                  mf.ival = D.21300;
                  r.156 = mf.fval;
                  r = r.156;
                }
              finally
                {
                  mf = {CLOBBER};
                }
            }
            r.157 = r;
            normal = __finite (r.157);
            if (normal == 0) goto <D.21303>; else goto <D.21304>;
            <D.21303>:
            {
              guint32 low;
              guint32 high;

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

              r.157 = r;
              str = stringify_double (r.157);
              ret = monoeg_g_strdup_printf ("float64(%s)", str);
              monoeg_g_free (str);
              D.21285 = ret;
              return D.21285;
            }
          }
        finally
          {
            r = {CLOBBER};
          }
      }
      <D.19748>:
      ptr.152 = ptr;
      D.21285 = get_encoded_user_string_or_bytearray (ptr.152, len);
      return D.21285;
      <D.19749>:
      D.21285 = monoeg_strdup ("nullref");
      return D.21285;
      <D.19750>:
      ptr.152 = ptr;
      D.21287 = *ptr.152;
      D.21293 = (int) D.21287;
      monoeg_g_log (0B, 4, "Unknown MONO_TYPE (%d) on constant at Blob index (0x%08x)\n", D.21293, blob_index);
      <D.19751>:
      goto <D.19751>;
      D.21285 = monoeg_g_strdup_printf ("Unknown");
      return D.21285;
    }
  finally
    {
      ptr = {CLOBBER};
    }
}


get_token (struct MonoImage * m, guint32 token, struct MonoGenericContainer * container)
{
  unsigned int D.21309;
  char * D.21310;
  int idx.158;
  struct MonoTableInfo * D.21312;
  unsigned int D.21313;
  unsigned int D.21314;
  int D.21315;
  unsigned int D.21316;
  const char * sig.159;
  const char * sig.160;
  char D.21319;
  char * temp;
  char * result;
  guint32 idx;

  idx = token & 16777215;
  D.21309 = token & 4278190080;
  switch (D.21309) <default: <D.19769>, case 16777216: <D.19764>, case 33554432: <D.19763>, case 67108864: <D.19760>, case 100663296: <D.19761>, case 167772160: <D.19766>, case 452984832: <D.19765>, case 721420288: <D.19762>>
  <D.19760>:
  temp = get_field (m, token, container);
  result = monoeg_g_strdup_printf ("field %s", temp);
  monoeg_g_free (temp);
  D.21310 = result;
  return D.21310;
  <D.19761>:
  <D.19762>:
  temp = get_method (m, token, container);
  result = monoeg_g_strdup_printf ("method %s", temp);
  monoeg_g_free (temp);
  D.21310 = result;
  return D.21310;
  <D.19763>:
  idx.158 = (int) idx;
  temp = get_typedef (m, idx.158);
  result = get_escaped_name (temp);
  monoeg_g_free (temp);
  D.21310 = result;
  return D.21310;
  <D.19764>:
  idx.158 = (int) idx;
  D.21310 = get_typeref (m, idx.158);
  return D.21310;
  <D.19765>:
  D.21310 = get_typespec (m, idx, 1, container);
  return D.21310;
  <D.19766>:
  {
    guint32 cols[3];
    const char * sig;

    try
      {
        D.21312 = &m->tables[10];
        D.21313 = token & 16777215;
        D.21314 = D.21313 + 4294967295;
        D.21315 = (int) D.21314;
        mono_metadata_decode_row (D.21312, D.21315, &cols, 3);
        D.21316 = cols[2];
        sig.159 = mono_metadata_blob_heap (m, D.21316);
        sig = sig.159;
        sig.160 = sig;
        mono_metadata_decode_blob_size (sig.160, &sig);
        sig.160 = sig;
        D.21319 = *sig.160;
        if (D.21319 == 6) goto <D.21320>; else goto <D.21321>;
        <D.21320>:
        temp = get_field (m, token, container);
        result = monoeg_g_strdup_printf ("field %s", temp);
        monoeg_g_free (temp);
        D.21310 = result;
        return D.21310;
        <D.21321>:
        temp = get_method (m, token, container);
        result = monoeg_g_strdup_printf ("method %s", temp);
        monoeg_g_free (temp);
        D.21310 = result;
        return D.21310;
      }
    finally
      {
        cols = {CLOBBER};
        sig = {CLOBBER};
      }
  }
  <D.19769>:
  monoeg_g_log (0B, 4, "Do not know how to decode tokens of type 0x%08x", token);
  <D.19770>:
  goto <D.19770>;
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "get.c", 2419);
  D.21310 = monoeg_strdup ("ERROR");
  return D.21310;
}


get_token_type (struct MonoImage * m, guint32 token, struct MonoGenericContainer * container)
{
  int token.161;
  unsigned int D.21325;
  unsigned int idx.162;
  char * D.21329;
  char * temp;
  char * s;
  int idx;

  temp = 0B;
  s = 0B;
  token.161 = (int) token;
  idx = token.161 & 16777215;
  D.21325 = token & 4278190080;
  switch (D.21325) <default: <D.19783>, case 16777216: <D.19781>, case 33554432: <D.19779>, case 452984832: <D.19782>>
  <D.19779>:
  temp = get_typedef (m, idx);
  s = monoeg_g_strdup_printf ("%s", temp);
  goto <D.19780>;
  <D.19781>:
  temp = get_typeref (m, idx);
  s = monoeg_g_strdup_printf ("%s", temp);
  goto <D.19780>;
  <D.19782>:
  idx.162 = (unsigned int) idx;
  s = get_typespec (m, idx.162, 0, container);
  goto <D.19780>;
  <D.19783>:
  monoeg_g_log (0B, 4, "Unhandled encoding for token 0x%08x", token);
  <D.19784>:
  goto <D.19784>;
  <D.19780>:
  if (temp != 0B) goto <D.21327>; else goto <D.21328>;
  <D.21327>:
  monoeg_g_free (temp);
  <D.21328>:
  D.21329 = s;
  return D.21329;
}


get_guid (struct MonoImage * m, guint32 guid_index)
{
  const unsigned char * D.21331;
  unsigned char D.21332;
  int D.21333;
  const unsigned char * D.21334;
  unsigned char D.21335;
  int D.21336;
  const unsigned char * D.21337;
  unsigned char D.21338;
  int D.21339;
  unsigned char D.21340;
  int D.21341;
  const unsigned char * D.21342;
  unsigned char D.21343;
  int D.21344;
  const unsigned char * D.21345;
  unsigned char D.21346;
  int D.21347;
  const unsigned char * D.21348;
  unsigned char D.21349;
  int D.21350;
  const unsigned char * D.21351;
  unsigned char D.21352;
  int D.21353;
  const unsigned char * D.21354;
  unsigned char D.21355;
  int D.21356;
  const unsigned char * D.21357;
  unsigned char D.21358;
  int D.21359;
  const unsigned char * D.21360;
  unsigned char D.21361;
  int D.21362;
  const unsigned char * D.21363;
  unsigned char D.21364;
  int D.21365;
  const unsigned char * D.21366;
  unsigned char D.21367;
  int D.21368;
  const unsigned char * D.21369;
  unsigned char D.21370;
  int D.21371;
  const unsigned char * D.21372;
  unsigned char D.21373;
  int D.21374;
  const unsigned char * D.21375;
  unsigned char D.21376;
  int D.21377;
  char * D.21378;
  const unsigned char * guid;
  char * result;

  guid = mono_metadata_guid_heap (m, guid_index);
  D.21331 = guid + 3;
  D.21332 = *D.21331;
  D.21333 = (int) D.21332;
  D.21334 = guid + 2;
  D.21335 = *D.21334;
  D.21336 = (int) D.21335;
  D.21337 = guid + 1;
  D.21338 = *D.21337;
  D.21339 = (int) D.21338;
  D.21340 = *guid;
  D.21341 = (int) D.21340;
  D.21342 = guid + 5;
  D.21343 = *D.21342;
  D.21344 = (int) D.21343;
  D.21345 = guid + 4;
  D.21346 = *D.21345;
  D.21347 = (int) D.21346;
  D.21348 = guid + 7;
  D.21349 = *D.21348;
  D.21350 = (int) D.21349;
  D.21351 = guid + 6;
  D.21352 = *D.21351;
  D.21353 = (int) D.21352;
  D.21354 = guid + 8;
  D.21355 = *D.21354;
  D.21356 = (int) D.21355;
  D.21357 = guid + 9;
  D.21358 = *D.21357;
  D.21359 = (int) D.21358;
  D.21360 = guid + 10;
  D.21361 = *D.21360;
  D.21362 = (int) D.21361;
  D.21363 = guid + 11;
  D.21364 = *D.21363;
  D.21365 = (int) D.21364;
  D.21366 = guid + 12;
  D.21367 = *D.21366;
  D.21368 = (int) D.21367;
  D.21369 = guid + 13;
  D.21370 = *D.21369;
  D.21371 = (int) D.21370;
  D.21372 = guid + 14;
  D.21373 = *D.21372;
  D.21374 = (int) D.21373;
  D.21375 = guid + 15;
  D.21376 = *D.21375;
  D.21377 = (int) D.21376;
  result = monoeg_g_strdup_printf ("{%02X%02X%02X%02X-%02X%02X-%02X%02X-%02X%02X-%02X%02X%02X%02X%02X%02X}", D.21333, D.21336, D.21339, D.21341, D.21344, D.21347, D.21350, D.21353, D.21356, D.21359, D.21362, D.21365, D.21368, D.21371, D.21374, D.21377);
  D.21378 = result;
  return D.21378;
}


dis_get_custom_attrs (struct MonoImage * m, guint32 token)
{
  unsigned int D.21380;
  struct GList * D.21381;
  int i.163;
  unsigned int D.21383;
  unsigned int D.21386;
  unsigned int D.21387;
  unsigned int D.21388;
  const char * val.164;
  const char * val.165;
  int len.166;
  char * D.21392;
  <unnamed-unsigned:24> D.21393;
  unsigned int D.21394;
  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.21380 = token >> 24;
      switch (D.21380) <default: <D.19816>, case 0: <D.19809>, case 2: <D.19805>, case 4: <D.19812>, case 6: <D.19813>, case 8: <D.19814>, case 20: <D.19811>, case 23: <D.19810>, case 32: <D.19807>, case 35: <D.19808>, case 42: <D.19815>>
      <D.19805>:
      idx = idx | 3;
      goto <D.19806>;
      <D.19807>:
      idx = idx | 14;
      goto <D.19806>;
      <D.19808>:
      idx = idx | 15;
      goto <D.19806>;
      <D.19809>:
      idx = idx | 7;
      goto <D.19806>;
      <D.19810>:
      idx = idx | 9;
      goto <D.19806>;
      <D.19811>:
      idx = idx | 10;
      goto <D.19806>;
      <D.19812>:
      idx = idx | 1;
      goto <D.19806>;
      <D.19813>:
      idx = idx;
      goto <D.19806>;
      <D.19814>:
      idx = idx | 4;
      goto <D.19806>;
      <D.19815>:
      idx = idx | 19;
      goto <D.19806>;
      <D.19816>:
      monoeg_g_print ("Missing custom attr get support for token 0x%08x\n", token);
      D.21381 = 0B;
      return D.21381;
      <D.19806>:
      ca = &m->tables[12];
      i = 0;
      goto <D.19825>;
      <D.19824>:
      {
        char * dump;

        i.163 = (int) i;
        mono_metadata_decode_row (ca, i.163, &cols, 3);
        D.21383 = cols[0];
        if (D.21383 != idx) goto <D.21384>; else goto <D.21385>;
        <D.21384>:
        // predicted unlikely by continue predictor.
        goto <D.19818>;
        <D.21385>:
        D.21386 = cols[1];
        mtoken = D.21386 >> 3;
        D.21386 = cols[1];
        D.21387 = D.21386 & 7;
        switch (D.21387) <default: <D.19822>, case 2: <D.19819>, case 3: <D.19821>>
        <D.19819>:
        mtoken = mtoken | 100663296;
        goto <D.19820>;
        <D.19821>:
        mtoken = mtoken | 167772160;
        goto <D.19820>;
        <D.19822>:
        D.21386 = cols[1];
        monoeg_g_log (0B, 4, "Unknown table for custom attr type %08x", D.21386);
        <D.19823>:
        goto <D.19823>;
        <D.19820>:
        method = get_method (m, mtoken, 0B);
        D.21388 = cols[2];
        val.164 = mono_metadata_blob_heap (m, D.21388);
        val = val.164;
        val.165 = val;
        len = mono_metadata_decode_value (val.165, &val);
        attr = monoeg_g_string_new (".custom ");
        val.165 = val;
        len.166 = (int) len;
        dump = data_dump (val.165, len.166, "\t\t");
        monoeg_g_string_append_printf (attr, "%s = %s", method, dump);
        monoeg_g_free (dump);
        D.21392 = attr->str;
        list = monoeg_g_list_append (list, D.21392);
        monoeg_g_string_free (attr, 0);
        monoeg_g_free (method);
      }
      <D.19818>:
      i = i + 1;
      <D.19825>:
      D.21393 = ca->rows;
      D.21394 = (unsigned int) D.21393;
      if (D.21394 > i) goto <D.19824>; else goto <D.19826>;
      <D.19826>:
      D.21381 = list;
      return D.21381;
    }
  finally
    {
      cols = {CLOBBER};
      val = {CLOBBER};
    }
}


get_marshal_info (struct MonoImage * m, const char * blob)
{
  const char * blob.167;
  unsigned int D.21398;
  char D.21399;
  int D.21400;
  char * D.21401;
  const char * D.21402;
  unsigned int D.21403;
  unsigned int D.21404;
  int len;
  int size;

  size = 0;
  blob.167 = blob;
  D.21398 = mono_metadata_decode_blob_size (blob.167, &blob);
  len = (int) D.21398;
  blob.167 = blob;
  D.21399 = *blob.167;
  D.21400 = (int) D.21399;
  switch (D.21400) <default: <D.19868>, case 2: <D.19833>, case 3: <D.19834>, case 4: <D.19835>, case 5: <D.19836>, case 6: <D.19837>, case 7: <D.19838>, case 8: <D.19839>, case 9: <D.19840>, case 10: <D.19841>, case 11: <D.19842>, case 12: <D.19843>, case 15: <D.19844>, case 19: <D.19845>, case 20: <D.19846>, case 21: <D.19847>, case 22: <D.19848>, case 23: <D.19849>, case 25: <D.19850>, case 26: <D.19851>, case 27: <D.19852>, case 28: <D.19853>, case 29: <D.19854>, case 30: <D.19855>, case 31: <D.19856>, case 32: <D.19857>, case 34: <D.19858>, case 35: <D.19859>, case 36: <D.19860>, case 37: <D.19861>, case 38: <D.19862>, case 40: <D.19863>, case 42: <D.19864>, case 43: <D.19865>, case 44: <D.19866>, case 45: <D.19867>>
  <D.19833>:
  D.21401 = monoeg_strdup ("bool");
  return D.21401;
  <D.19834>:
  D.21401 = monoeg_strdup ("int8");
  return D.21401;
  <D.19835>:
  D.21401 = monoeg_strdup ("unsigned int8");
  return D.21401;
  <D.19836>:
  D.21401 = monoeg_strdup ("int16");
  return D.21401;
  <D.19837>:
  D.21401 = monoeg_strdup ("unsigned int16");
  return D.21401;
  <D.19838>:
  D.21401 = monoeg_strdup ("int32");
  return D.21401;
  <D.19839>:
  D.21401 = monoeg_strdup ("unsigned int32");
  return D.21401;
  <D.19840>:
  D.21401 = monoeg_strdup ("int64");
  return D.21401;
  <D.19841>:
  D.21401 = monoeg_strdup ("unsigned int64");
  return D.21401;
  <D.19842>:
  D.21401 = monoeg_strdup ("float32");
  return D.21401;
  <D.19843>:
  D.21401 = monoeg_strdup ("float64");
  return D.21401;
  <D.19844>:
  D.21401 = monoeg_strdup ("currency");
  return D.21401;
  <D.19845>:
  D.21401 = monoeg_strdup ("bstr");
  return D.21401;
  <D.19846>:
  D.21401 = monoeg_strdup ("lpstr");
  return D.21401;
  <D.19847>:
  D.21401 = monoeg_strdup ("lpwstr");
  return D.21401;
  <D.19848>:
  D.21401 = monoeg_strdup ("lptstr");
  return D.21401;
  <D.19849>:
  blob.167 = blob;
  D.21402 = blob.167 + 1;
  D.21403 = mono_metadata_decode_value (D.21402, &blob);
  size = (int) D.21403;
  D.21401 = monoeg_g_strdup_printf ("fixed sysstring [%d]", size);
  return D.21401;
  <D.19850>:
  D.21401 = monoeg_strdup ("iunknown");
  return D.21401;
  <D.19851>:
  D.21401 = monoeg_strdup ("idispatch");
  return D.21401;
  <D.19852>:
  D.21401 = monoeg_strdup ("struct");
  return D.21401;
  <D.19853>:
  D.21401 = monoeg_strdup ("interface");
  return D.21401;
  <D.19854>:
  D.21401 = monoeg_strdup ("safearray");
  return D.21401;
  <D.19855>:
  blob.167 = blob;
  D.21402 = blob.167 + 1;
  D.21404 = mono_metadata_decode_value (D.21402, &blob);
  size = (int) D.21404;
  D.21401 = monoeg_g_strdup_printf ("fixed array [%d]", size);
  return D.21401;
  <D.19856>:
  D.21401 = monoeg_strdup ("int");
  return D.21401;
  <D.19857>:
  D.21401 = monoeg_strdup ("unsigned int");
  return D.21401;
  <D.19858>:
  D.21401 = monoeg_strdup ("vbbyrefstr");
  return D.21401;
  <D.19859>:
  D.21401 = monoeg_strdup ("ansi bstr");
  return D.21401;
  <D.19860>:
  D.21401 = monoeg_strdup ("tbstr");
  return D.21401;
  <D.19861>:
  D.21401 = monoeg_strdup ("variant bool");
  return D.21401;
  <D.19862>:
  D.21401 = monoeg_strdup ("method");
  return D.21401;
  <D.19863>:
  D.21401 = monoeg_strdup ("as any");
  return D.21401;
  <D.19864>:
  D.21401 = monoeg_strdup ("[]");
  return D.21401;
  <D.19865>:
  D.21401 = monoeg_strdup ("lpstruct");
  return D.21401;
  <D.19866>:
  D.21401 = monoeg_strdup ("custom");
  return D.21401;
  <D.19867>:
  D.21401 = monoeg_strdup ("error");
  return D.21401;
  <D.19868>:
  D.21401 = monoeg_strdup ("unknown");
  return D.21401;
}


init_key_table ()
{
  struct GHashTable * key_table.168;
  struct GHashTable * key_table.169;

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


method_dor_to_token (guint32 idx)
{
  unsigned int D.21408;
  guint32 D.21409;
  unsigned int D.21410;

  D.21408 = idx & 1;
  switch (D.21408) <default: <D.21411>, case 0: <D.19875>, case 1: <D.19876>>
  <D.19875>:
  D.21410 = idx >> 1;
  D.21409 = D.21410 | 100663296;
  return D.21409;
  <D.19876>:
  D.21410 = idx >> 1;
  D.21409 = D.21410 | 167772160;
  return D.21409;
  <D.21411>:
  D.21409 = 4294967295;
  return D.21409;
}


get_method_override (struct MonoImage * m, guint32 token, struct MonoGenericContainer * container)
{
  int D.21413;
  unsigned int D.21414;
  unsigned int D.21415;
  struct MonoClass * D.21421;
  struct MonoGenericClass * D.21423;
  struct MonoGenericContainer * D.21425;
  char * D.21426;
  <unnamed-unsigned:24> D.21427;
  int D.21428;
  struct MonoTableInfo * t;
  int i;

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

    try
      {
        D.21413 = i + -1;
        mono_metadata_decode_row (t, D.21413, &cols, 3);
        D.21414 = cols[1];
        impl = method_dor_to_token (D.21414);
        D.21415 = cols[2];
        decl = method_dor_to_token (D.21415);
        if (token == impl) goto <D.21416>; else goto <D.21417>;
        <D.21416>:
        {
          struct MonoMethod * mh;

          mh = 0B;
          mh = mono_get_method_full (m, decl, 0B, container);
          if (mh != 0B) goto <D.21420>; else goto <D.21418>;
          <D.21420>:
          D.21421 = mh->klass;
          if (D.21421 != 0B) goto <D.21422>; else goto <D.21418>;
          <D.21422>:
          D.21421 = mh->klass;
          D.21423 = D.21421->generic_class;
          if (D.21423 != 0B) goto <D.21419>; else goto <D.21424>;
          <D.21424>:
          D.21421 = mh->klass;
          D.21425 = D.21421->generic_container;
          if (D.21425 != 0B) goto <D.21419>; else goto <D.21418>;
          <D.21419>:
          {
            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.21426 = ret;
            return D.21426;
          }
          <D.21418>:
          D.21426 = get_method_core (m, decl, 0, container);
          return D.21426;
        }
        <D.21417>:
      }
    finally
      {
        cols = {CLOBBER};
      }
  }
  i = i + 1;
  <D.19891>:
  D.21427 = t->rows;
  D.21428 = (int) D.21427;
  if (D.21428 >= i) goto <D.19890>; else goto <D.19892>;
  <D.19892>:
  D.21426 = 0B;
  return D.21426;
}


get_method_impl_flags (guint32 f)
{
  int f.170;
  int D.21433;
  int D.21434;
  unsigned int D.21435;
  unsigned int D.21436;
  unsigned int code_type.171;
  const char * D.21438;
  unsigned int managed_type.172;
  const char * D.21440;
  unsigned int rest.173;
  const char * D.21442;
  char * D.21443;
  struct GString * str;
  char * s;
  int code_type;
  int managed_type;
  int rest;

  str = monoeg_g_string_new ("");
  f.170 = (int) f;
  code_type = f.170 & 3;
  f.170 = (int) f;
  managed_type = f.170 & 4;
  D.21433 = code_type | managed_type;
  D.21434 = ~D.21433;
  D.21435 = (unsigned int) D.21434;
  D.21436 = D.21435 & f;
  rest = (int) D.21436;
  code_type.171 = (unsigned int) code_type;
  D.21438 = map (code_type.171, &method_impl_map);
  monoeg_g_string_append (str, D.21438);
  managed_type.172 = (unsigned int) managed_type;
  D.21440 = map (managed_type.172, &managed_type_map);
  monoeg_g_string_append (str, D.21440);
  rest.173 = (unsigned int) rest;
  D.21442 = flags (rest.173, &managed_impl_flags);
  monoeg_g_string_append (str, D.21442);
  s = str->str;
  monoeg_g_string_free (str, 0);
  D.21443 = s;
  return D.21443;
}