get_typedef (struct MonoImage * m, int idx)
{
  char * D.19389;
  int D.19390;
  struct MonoTableInfo * D.19391;
  unsigned int D.19392;
  int D.19393;
  char * iftmp.0;
  int show_tokens.1;
  int token.2;
  int D.19402;
  const char * iftmp.3;
  unsigned int D.19407;
  const char * D.19408;
  const char * iftmp.4;
  const char * D.19413;
  const char * iftmp.5;
  char D.19415;
  guint32 cols[6];
  const char * ns;
  char * tstring;
  char * result;
  guint32 token;

  try
    {
      if (idx == 1) goto <D.19387>; else goto <D.19388>;
      <D.19387>:
      D.19389 = 0B;
      return D.19389;
      <D.19388>:
      D.19390 = idx + -1;
      D.19391 = &m->tables[2];
      mono_metadata_decode_row (D.19391, D.19390, &cols, 6);
      D.19392 = cols[2];
      ns = mono_metadata_string_heap (m, D.19392);
      D.19393 = idx | 33554432;
      token = (guint32) D.19393;
      token = mono_metadata_nested_in_typedef (m, token);
      show_tokens.1 = show_tokens;
      if (show_tokens.1 != 0) goto <D.19396>; else goto <D.19397>;
      <D.19396>:
      iftmp.0 = monoeg_g_strdup_printf ("/*%08x*/", token);
      goto <D.19398>;
      <D.19397>:
      iftmp.0 = 0B;
      <D.19398>:
      tstring = iftmp.0;
      if (token != 0) goto <D.19399>; else goto <D.19400>;
      <D.19399>:
      {
        char * outer;

        token.2 = (int) token;
        D.19402 = token.2 & 16777215;
        outer = get_typedef (m, D.19402);
        if (tstring != 0B) goto <D.19404>; else goto <D.19405>;
        <D.19404>:
        iftmp.3 = tstring;
        goto <D.19406>;
        <D.19405>:
        iftmp.3 = "";
        <D.19406>:
        D.19407 = cols[1];
        D.19408 = mono_metadata_string_heap (m, D.19407);
        result = monoeg_g_strdup_printf ("%s/%s%s", outer, D.19408, iftmp.3);
        monoeg_g_free (outer);
        monoeg_g_free (tstring);
        D.19389 = result;
        return D.19389;
      }
      <D.19400>:
      if (tstring != 0B) goto <D.19410>; else goto <D.19411>;
      <D.19410>:
      iftmp.4 = tstring;
      goto <D.19412>;
      <D.19411>:
      iftmp.4 = "";
      <D.19412>:
      D.19407 = cols[1];
      D.19413 = mono_metadata_string_heap (m, D.19407);
      D.19415 = *ns;
      if (D.19415 != 0) goto <D.19416>; else goto <D.19417>;
      <D.19416>:
      iftmp.5 = ".";
      goto <D.19418>;
      <D.19417>:
      iftmp.5 = "";
      <D.19418>:
      result = monoeg_g_strdup_printf ("%s%s%s%s", ns, iftmp.5, D.19413, iftmp.4);
      monoeg_g_free (tstring);
      D.19389 = result;
      return D.19389;
    }
  finally
    {
      cols = {CLOBBER};
    }
}


get_module (struct MonoImage * m, int idx)
{
  _Bool D.19421;
  long int D.19422;
  long int D.19423;
  int D.19426;
  struct MonoTableInfo * D.19427;
  char * D.19428;
  unsigned int D.19429;
  const char * D.19430;
  guint32 cols[5];

  try
    {
      D.19421 = idx != 1;
      D.19422 = (long int) D.19421;
      D.19423 = __builtin_expect (D.19422, 0);
      if (D.19423 != 0) goto <D.19424>; else goto <D.19425>;
      <D.19424>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "get.c", 92, "idx == 1");
      <D.19425>:
      D.19426 = idx + -1;
      D.19427 = &m->tables[0];
      mono_metadata_decode_row (D.19427, D.19426, &cols, 5);
      D.19429 = cols[1];
      D.19430 = mono_metadata_string_heap (m, D.19429);
      D.19428 = get_escaped_name (D.19430);
      return D.19428;
    }
  finally
    {
      cols = {CLOBBER};
    }
}


get_moduleref (struct MonoImage * m, int idx)
{
  int D.19433;
  struct MonoTableInfo * D.19434;
  char * D.19435;
  unsigned int D.19436;
  const char * D.19437;
  guint32 cols[1];

  try
    {
      D.19433 = idx + -1;
      D.19434 = &m->tables[26];
      mono_metadata_decode_row (D.19434, D.19433, &cols, 1);
      D.19436 = cols[0];
      D.19437 = mono_metadata_string_heap (m, D.19436);
      D.19435 = get_escaped_name (D.19437);
      return D.19435;
    }
  finally
    {
      cols = {CLOBBER};
    }
}


get_assemblyref (struct MonoImage * m, int idx)
{
  int D.19440;
  struct MonoTableInfo * D.19441;
  char * D.19442;
  unsigned int D.19443;
  const char * D.19444;
  guint32 cols[9];

  try
    {
      D.19440 = idx + -1;
      D.19441 = &m->tables[35];
      mono_metadata_decode_row (D.19441, D.19440, &cols, 9);
      D.19443 = cols[6];
      D.19444 = mono_metadata_string_heap (m, D.19443);
      D.19442 = get_escaped_name (D.19444);
      return D.19442;
    }
  finally
    {
      cols = {CLOBBER};
    }
}


get_typespec (struct MonoImage * m, guint32 idx, gboolean is_def, struct MonoGenericContainer * container)
{
  unsigned int D.19447;
  int D.19448;
  struct MonoTableInfo * D.19449;
  unsigned int D.19450;
  const char * ptr.6;
  const char * ptr.7;
  unsigned int D.19453;
  const char * ptr.8;
  const char * ptr.9;
  char D.19456;
  int D.19457;
  const char * ptr.10;
  char * s.11;
  char D.19462;
  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.19476;
  const char * ptr.18;
  int show_tokens.19;
  unsigned int D.19481;
  char * D.19482;
  char * D.19484;
  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.19447 = idx + 4294967295;
      D.19448 = (int) D.19447;
      D.19449 = &m->tables[27];
      mono_metadata_decode_row (D.19449, D.19448, &cols, 1);
      D.19450 = cols[0];
      ptr.6 = mono_metadata_blob_heap (m, D.19450);
      ptr = ptr.6;
      ptr.7 = ptr;
      D.19453 = mono_metadata_decode_value (ptr.7, &ptr);
      len = (int) D.19453;
      ptr.7 = ptr;
      ptr.8 = ptr.7;
      ptr.9 = ptr.8 + 1;
      ptr = ptr.9;
      D.19456 = *ptr.8;
      D.19457 = (int) D.19456;
      switch (D.19457) <default: <D.18508>, case 15: <D.18503>, case 20: <D.18506>, case 27: <D.18505>, case 29: <D.18507>>
      <D.18503>:
      ptr.7 = ptr;
      ptr.10 = get_custom_mod (m, ptr.7, &s);
      ptr = ptr.10;
      s.11 = s;
      if (s.11 != 0B) goto <D.19460>; else goto <D.19461>;
      <D.19460>:
      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.19461>:
      ptr.7 = ptr;
      D.19462 = *ptr.7;
      if (D.19462 == 1) goto <D.19463>; else goto <D.19464>;
      <D.19463>:
      monoeg_g_string_append (res, "void");
      goto <D.19465>;
      <D.19464>:
      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.19467>; else goto <D.19468>;
      <D.19467>:
      s.11 = s;
      monoeg_g_string_append (res, s.11);
      <D.19468>:
      <D.19465>:
      monoeg_g_string_append (res, "*");
      goto <D.18504>;
      <D.18505>:
      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.18504>;
      <D.18506>:
      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.18504>;
      <D.18507>:
      ptr.7 = ptr;
      ptr.16 = get_custom_mod (m, ptr.7, &s);
      ptr = ptr.16;
      s.11 = s;
      if (s.11 != 0B) goto <D.19473>; else goto <D.19474>;
      <D.19473>:
      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.19474>:
      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.18504>;
      <D.18508>:
      ptr.7 = ptr;
      D.19476 = ptr.7 + 18446744073709551615;
      ptr.18 = get_type (m, D.19476, &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.18504>;
      <D.18504>:
      show_tokens.19 = show_tokens;
      if (show_tokens.19 != 0) goto <D.19479>; else goto <D.19480>;
      <D.19479>:
      {
        int token;

        D.19481 = idx | 452984832;
        token = (int) D.19481;
        D.19482 = res->str;
        result = monoeg_g_strdup_printf ("%s/*%08x*/", D.19482, token);
      }
      goto <D.19483>;
      <D.19480>:
      result = res->str;
      <D.19483>:
      monoeg_g_string_free (res, 0);
      D.19484 = result;
      return D.19484;
    }
  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.19490;
  long unsigned int D.19491;
  long unsigned int D.19492;
  long unsigned int D.19493;
  gint32 * D.19494;
  unsigned int D.19495;
  int D.19496;
  unsigned int i.21;
  long unsigned int D.19500;
  long unsigned int D.19501;
  gint32 * D.19502;
  int D.19503;
  char * D.19504;
  const char * D.19505;
  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.19488>; else goto <D.19489>;
  <D.19488>:
  D.19490 = (long unsigned int) num_sizes;
  D.19491 = D.19490 * 4;
  sizes = monoeg_malloc (D.19491);
  <D.19489>:
  i = 0;
  goto <D.18485>;
  <D.18484>:
  D.19492 = (long unsigned int) i;
  D.19493 = D.19492 * 4;
  D.19494 = sizes + D.19493;
  ptr.20 = ptr;
  D.19495 = mono_metadata_decode_value (ptr.20, &ptr);
  D.19496 = (int) D.19495;
  *D.19494 = D.19496;
  i = i + 1;
  <D.18485>:
  i.21 = (unsigned int) i;
  if (i.21 < num_sizes) goto <D.18484>; else goto <D.18486>;
  <D.18486>:
  ptr.20 = ptr;
  num_lo_bounds = mono_metadata_decode_value (ptr.20, &ptr);
  if (num_lo_bounds != 0) goto <D.19498>; else goto <D.19499>;
  <D.19498>:
  D.19500 = (long unsigned int) num_lo_bounds;
  D.19501 = D.19500 * 4;
  lo_bounds = monoeg_malloc (D.19501);
  <D.19499>:
  i = 0;
  goto <D.18488>;
  <D.18487>:
  D.19492 = (long unsigned int) i;
  D.19493 = D.19492 * 4;
  D.19502 = lo_bounds + D.19493;
  ptr.20 = ptr;
  D.19503 = mono_metadata_decode_signed_value (ptr.20, &ptr);
  *D.19502 = D.19503;
  i = i + 1;
  <D.18488>:
  i.21 = (unsigned int) i;
  if (i.21 < num_lo_bounds) goto <D.18487>; else goto <D.18489>;
  <D.18489>:
  D.19504 = stringify_array (rank, num_sizes, num_lo_bounds, sizes, lo_bounds);
  *result = D.19504;
  monoeg_g_free (sizes);
  monoeg_g_free (lo_bounds);
  D.19505 = ptr;
  return D.19505;
}


stringify_array (guint32 rank, guint32 num_sizes, guint32 num_lo_bounds, gint32 * sizes, gint32 * lo_bounds)
{
  unsigned int i.22;
  long unsigned int D.19512;
  long unsigned int D.19513;
  gint32 * D.19514;
  int D.19515;
  gint32 * D.19520;
  int D.19521;
  int D.19522;
  int D.19523;
  char * D.19525;
  struct GString * res;
  int i;

  res = monoeg_g_string_new ("[");
  i = 0;
  goto <D.18471>;
  <D.18470>:
  if (i != 0) goto <D.19507>; else goto <D.19508>;
  <D.19507>:
  monoeg_g_string_append_c (res, 44);
  <D.19508>:
  i.22 = (unsigned int) i;
  if (i.22 < num_lo_bounds) goto <D.19510>; else goto <D.19511>;
  <D.19510>:
  D.19512 = (long unsigned int) i;
  D.19513 = D.19512 * 4;
  D.19514 = lo_bounds + D.19513;
  D.19515 = *D.19514;
  monoeg_g_string_append_printf (res, "%d...", D.19515);
  <D.19511>:
  i.22 = (unsigned int) i;
  if (i.22 < num_sizes) goto <D.19516>; else goto <D.19517>;
  <D.19516>:
  i.22 = (unsigned int) i;
  if (i.22 < num_lo_bounds) goto <D.19518>; else goto <D.19519>;
  <D.19518>:
  D.19512 = (long unsigned int) i;
  D.19513 = D.19512 * 4;
  D.19514 = lo_bounds + D.19513;
  D.19515 = *D.19514;
  D.19512 = (long unsigned int) i;
  D.19513 = D.19512 * 4;
  D.19520 = sizes + D.19513;
  D.19521 = *D.19520;
  D.19522 = D.19515 + D.19521;
  D.19523 = D.19522 + -1;
  monoeg_g_string_append_printf (res, "%d", D.19523);
  goto <D.19524>;
  <D.19519>:
  D.19512 = (long unsigned int) i;
  D.19513 = D.19512 * 4;
  D.19520 = sizes + D.19513;
  D.19521 = *D.19520;
  monoeg_g_string_append_printf (res, "%d", D.19521);
  <D.19524>:
  <D.19517>:
  i = i + 1;
  <D.18471>:
  i.22 = (unsigned int) i;
  if (i.22 < rank) goto <D.18470>; else goto <D.18472>;
  <D.18472>:
  monoeg_g_string_append (res, "]");
  D.19525 = monoeg_g_string_free (res, 0);
  return D.19525;
}


get_typeref (struct MonoImage * m, int idx)
{
  int D.19527;
  struct MonoTableInfo * D.19528;
  unsigned int D.19529;
  unsigned int D.19530;
  unsigned int D.19531;
  int rs_idx.23;
  const char * iftmp.24;
  char D.19534;
  const char * iftmp.25;
  const char * iftmp.26;
  int show_tokens.27;
  char * D.19549;
  guint32 cols[3];
  const char * s;
  const char * t;
  char * x;
  char * ret;
  guint32 rs_idx;
  guint32 table;

  try
    {
      D.19527 = idx + -1;
      D.19528 = &m->tables[1];
      mono_metadata_decode_row (D.19528, D.19527, &cols, 3);
      D.19529 = cols[1];
      t = mono_metadata_string_heap (m, D.19529);
      D.19530 = cols[2];
      s = mono_metadata_string_heap (m, D.19530);
      D.19531 = cols[0];
      rs_idx = D.19531 >> 2;
      D.19531 = cols[0];
      table = D.19531 & 3;
      switch (table) <default: <D.18526>, case 0: <D.18521>, case 1: <D.18523>, case 2: <D.18524>, case 3: <D.18525>>
      <D.18521>:
      rs_idx.23 = (int) rs_idx;
      x = get_module (m, rs_idx.23);
      D.19534 = *s;
      if (D.19534 != 0) goto <D.19535>; else goto <D.19536>;
      <D.19535>:
      iftmp.24 = ".";
      goto <D.19537>;
      <D.19536>:
      iftmp.24 = "";
      <D.19537>:
      ret = monoeg_g_strdup_printf ("[%s] %s%s%s", x, s, iftmp.24, t);
      monoeg_g_free (x);
      goto <D.18522>;
      <D.18523>:
      rs_idx.23 = (int) rs_idx;
      x = get_moduleref (m, rs_idx.23);
      D.19534 = *s;
      if (D.19534 != 0) goto <D.19539>; else goto <D.19540>;
      <D.19539>:
      iftmp.25 = ".";
      goto <D.19541>;
      <D.19540>:
      iftmp.25 = "";
      <D.19541>:
      ret = monoeg_g_strdup_printf ("[.module %s]%s%s%s", x, s, iftmp.25, t);
      goto <D.18522>;
      <D.18524>:
      rs_idx.23 = (int) rs_idx;
      x = get_assemblyref (m, rs_idx.23);
      D.19534 = *s;
      if (D.19534 != 0) goto <D.19543>; else goto <D.19544>;
      <D.19543>:
      iftmp.26 = ".";
      goto <D.19545>;
      <D.19544>:
      iftmp.26 = "";
      <D.19545>:
      ret = monoeg_g_strdup_printf ("[%s]%s%s%s", x, s, iftmp.26, t);
      monoeg_g_free (x);
      goto <D.18522>;
      <D.18525>:
      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.18522>;
      <D.18526>:
      ret = monoeg_g_strdup_printf ("Unknown table in TypeRef %d", table);
      <D.18522>:
      show_tokens.27 = show_tokens;
      if (show_tokens.27 != 0) goto <D.19547>; else goto <D.19548>;
      <D.19547>:
      {
        int token;
        char * temp;

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


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

  temp = 0B;
  s = 0B;
  dor_token.28 = (int) dor_token;
  table = dor_token.28 & 3;
  D.19553 = dor_token >> 2;
  idx = (int) D.19553;
  switch (table) <default: <D.18542>, case 0: <D.18538>, case 1: <D.18540>, case 2: <D.18541>>
  <D.18538>:
  temp = get_typedef (m, idx);
  s = monoeg_g_strdup_printf ("%s", temp);
  goto <D.18539>;
  <D.18540>:
  temp = get_typeref (m, idx);
  s = monoeg_g_strdup_printf ("%s", temp);
  goto <D.18539>;
  <D.18541>:
  idx.29 = (unsigned int) idx;
  s = get_typespec (m, idx.29, 0, container);
  goto <D.18539>;
  <D.18542>:
  monoeg_g_log (0B, 4, "Unhandled encoding for typedef-or-ref coded index 0x%08x", dor_token);
  <D.18543>:
  goto <D.18543>;
  <D.18539>:
  if (temp != 0B) goto <D.19555>; else goto <D.19556>;
  <D.19555>:
  monoeg_g_free (temp);
  <D.19556>:
  D.19557 = s;
  return D.19557;
}


get_type_or_methdef (struct MonoImage * m, guint32 dor_token)
{
  unsigned int D.19559;
  char * D.19562;
  unsigned int D.19563;
  int D.19564;

  D.19559 = dor_token & 1;
  if (D.19559 != 0) goto <D.19560>; else goto <D.19561>;
  <D.19560>:
  D.19563 = dor_token >> 1;
  D.19562 = get_methoddef (m, D.19563);
  return D.19562;
  <D.19561>:
  D.19563 = dor_token >> 1;
  D.19564 = (int) D.19563;
  D.19562 = get_typedef (m, D.19564);
  return D.19562;
}


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

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


get_custom_mod (struct MonoImage * m, const char * ptr, char * * return_value)
{
  const char * iftmp.31;
  char D.19571;
  char * D.19575;
  char * s.32;
  gchar * D.19579;
  gchar * D.19581;
  unsigned char D.19582;
  unsigned char D.19583;
  const char * D.19584;
  char * s;
  const char * mod;

  try
    {
      *return_value = 0B;
      goto <D.18562>;
      <D.18561>:
      D.19571 = *ptr;
      if (D.19571 == 31) goto <D.19572>; else goto <D.19573>;
      <D.19572>:
      iftmp.31 = "modreq";
      goto <D.19574>;
      <D.19573>:
      iftmp.31 = "modopt";
      <D.19574>:
      mod = iftmp.31;
      ptr = ptr + 1;
      ptr = get_encoded_typedef_or_ref (m, ptr, &s);
      D.19575 = *return_value;
      if (D.19575 == 0B) goto <D.19576>; else goto <D.19577>;
      <D.19576>:
      s.32 = s;
      D.19579 = monoeg_g_strconcat (" ", mod, " (", s.32, ")", 0B);
      *return_value = D.19579;
      goto <D.19580>;
      <D.19577>:
      s.32 = s;
      D.19575 = *return_value;
      D.19581 = monoeg_g_strconcat (D.19575, " ", mod, " (", s.32, ")", 0B);
      *return_value = D.19581;
      <D.19580>:
      s.32 = s;
      monoeg_g_free (s.32);
      <D.18562>:
      D.19571 = *ptr;
      D.19582 = (unsigned char) D.19571;
      D.19583 = D.19582 + 225;
      if (D.19583 <= 1) goto <D.18561>; else goto <D.18563>;
      <D.18563>:
      D.19584 = ptr;
      return D.19584;
    }
  finally
    {
      s = {CLOBBER};
    }
}


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

  idx = token & 16777215;
  D.19587 = token >> 24;
  switch (D.19587) <default: <D.18574>, case 1: <D.18572>, case 2: <D.18571>, case 27: <D.18573>>
  <D.18571>:
  idx.33 = (int) idx;
  D.19588 = get_typedef (m, idx.33);
  return D.19588;
  <D.18572>:
  idx.33 = (int) idx;
  D.19588 = get_typeref (m, idx.33);
  return D.19588;
  <D.18573>:
  D.19588 = get_typespec (m, idx, 0, 0B);
  return D.19588;
  <D.18574>:
  goto <D.18575>;
  <D.18575>:
  D.19588 = monoeg_g_strdup_printf ("0x%08x", token);
  return D.19588;
}


dis_stringify_array (struct MonoImage * m, struct MonoArrayType * array, gboolean is_def)
{
  struct MonoClass * D.19592;
  struct MonoType * D.19593;
  int * D.19594;
  int * D.19595;
  unsigned char D.19596;
  unsigned int D.19597;
  unsigned char D.19598;
  unsigned int D.19599;
  unsigned char D.19600;
  unsigned int D.19601;
  char * D.19602;
  char * type;
  char * arr_str;
  char * ret;

  D.19592 = array->eklass;
  D.19593 = &D.19592->byval_arg;
  type = dis_stringify_type (m, D.19593, is_def);
  D.19594 = array->lobounds;
  D.19595 = array->sizes;
  D.19596 = array->numlobounds;
  D.19597 = (unsigned int) D.19596;
  D.19598 = array->numsizes;
  D.19599 = (unsigned int) D.19598;
  D.19600 = array->rank;
  D.19601 = (unsigned int) D.19600;
  arr_str = stringify_array (D.19601, D.19599, D.19597, D.19595, D.19594);
  ret = monoeg_g_strconcat (type, arr_str, 0B);
  monoeg_g_free (arr_str);
  monoeg_g_free (type);
  D.19602 = ret;
  return D.19602;
}


dis_stringify_modifiers (struct MonoImage * m, int n, struct MonoCustomMod * mod)
{
  long unsigned int D.19604;
  long unsigned int D.19605;
  struct MonoCustomMod * D.19606;
  <unnamed-unsigned:31> D.19607;
  unsigned int D.19608;
  const char * iftmp.34;
  unsigned char D.19612;
  unsigned char D.19613;
  char * D.19617;
  struct GString * s;
  char * result;
  int i;

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

    D.19604 = (long unsigned int) i;
    D.19605 = D.19604 * 4;
    D.19606 = mod + D.19605;
    D.19607 = D.19606->token;
    D.19608 = (unsigned int) D.19607;
    tok = dis_stringify_token (m, D.19608);
    if (i > 0) goto <D.19609>; else goto <D.19610>;
    <D.19609>:
    monoeg_g_string_append_printf (s, " ");
    <D.19610>:
    D.19604 = (long unsigned int) i;
    D.19605 = D.19604 * 4;
    D.19606 = mod + D.19605;
    D.19612 = BIT_FIELD_REF <*D.19606, 8, 0>;
    D.19613 = D.19612 & 1;
    if (D.19613 != 0) goto <D.19614>; else goto <D.19615>;
    <D.19614>:
    iftmp.34 = "modreq";
    goto <D.19616>;
    <D.19615>:
    iftmp.34 = "modopt";
    <D.19616>:
    monoeg_g_string_append_printf (s, " %s (%s)", iftmp.34, tok);
    monoeg_g_free (tok);
  }
  i = i + 1;
  <D.18594>:
  if (i < n) goto <D.18593>; else goto <D.18595>;
  <D.18595>:
  monoeg_g_string_append_c (s, 32);
  result = s->str;
  monoeg_g_string_free (s, 0);
  D.19617 = result;
  return D.19617;
}


dis_stringify_param (struct MonoImage * m, struct MonoType * param)
{
  const char * iftmp.35;
  short unsigned int D.19620;
  int D.19621;
  int D.19622;
  const char * iftmp.36;
  int D.19627;
  const char * iftmp.37;
  int D.19632;
  const gchar * iftmp.38;
  char D.19637;
  char * D.19641;
  char * t;
  char * result;
  char * attribs;
  const char * in;
  const char * out;
  const char * opt;

  D.19620 = param->attrs;
  D.19621 = (int) D.19620;
  D.19622 = D.19621 & 1;
  if (D.19622 != 0) goto <D.19623>; else goto <D.19624>;
  <D.19623>:
  iftmp.35 = "[in]";
  goto <D.19625>;
  <D.19624>:
  iftmp.35 = "";
  <D.19625>:
  in = iftmp.35;
  D.19620 = param->attrs;
  D.19621 = (int) D.19620;
  D.19627 = D.19621 & 2;
  if (D.19627 != 0) goto <D.19628>; else goto <D.19629>;
  <D.19628>:
  iftmp.36 = "[out]";
  goto <D.19630>;
  <D.19629>:
  iftmp.36 = "";
  <D.19630>:
  out = iftmp.36;
  D.19620 = param->attrs;
  D.19621 = (int) D.19620;
  D.19632 = D.19621 & 16;
  if (D.19632 != 0) goto <D.19633>; else goto <D.19634>;
  <D.19633>:
  iftmp.37 = "[opt]";
  goto <D.19635>;
  <D.19634>:
  iftmp.37 = "";
  <D.19635>:
  opt = iftmp.37;
  attribs = monoeg_g_strconcat (in, out, opt, 0B);
  t = dis_stringify_type (m, param, 1);
  D.19637 = *attribs;
  if (D.19637 != 0) goto <D.19638>; else goto <D.19639>;
  <D.19638>:
  iftmp.38 = " ";
  goto <D.19640>;
  <D.19639>:
  iftmp.38 = "";
  <D.19640>:
  result = monoeg_g_strjoin (iftmp.38, attribs, t, 0B);
  monoeg_g_free (t);
  monoeg_g_free (attribs);
  D.19641 = result;
  return D.19641;
}


dis_stringify_marshal_spec (struct MonoMarshalSpec * spec)
{
  <unnamed type> D.19643;
  char * D.19644;
  int D.19645;
  short int D.19646;
  <unnamed type> D.19647;
  _Bool D.19648;
  _Bool D.19649;
  _Bool D.19650;
  short int D.19658;
  unsigned int D.19659;
  <unnamed type> D.19663;
  const char * iftmp.39;
  const char * iftmp.40;
  char * D.19671;
  const char * iftmp.41;
  char * D.19676;

  D.19643 = spec->native;
  switch (D.19643) <default: <D.18706>, case 23: <D.18694>, case 29: <D.18702>, case 30: <D.18695>, case 42: <D.18696>, case 44: <D.18705>>
  <D.18694>:
  D.19645 = spec->data.array_data.num_elem;
  D.19644 = monoeg_g_strdup_printf (" marshal (fixed sysstring [%d])", D.19645);
  return D.19644;
  <D.18695>:
  D.19645 = spec->data.array_data.num_elem;
  D.19644 = monoeg_g_strdup_printf (" marshal (fixed array [%d])", D.19645);
  return D.19644;
  <D.18696>:
  {
    char * elem_type;
    char * elems;
    char * ret;
    guint32 num_elem;
    guint32 param_num;

    D.19645 = spec->data.array_data.num_elem;
    num_elem = (guint32) D.19645;
    D.19646 = spec->data.array_data.param_num;
    param_num = (guint32) D.19646;
    D.19647 = spec->data.array_data.elem_type;
    elem_type = dis_stringify_native_type (D.19647);
    D.19648 = num_elem == 4294967295;
    D.19649 = param_num == 4294967295;
    D.19650 = D.19648 & D.19649;
    if (D.19650 != 0) goto <D.19651>; else goto <D.19652>;
    <D.19651>:
    elems = monoeg_strdup ("");
    goto <D.19653>;
    <D.19652>:
    if (param_num == 4294967295) goto <D.19654>; else goto <D.19657>;
    <D.19657>:
    D.19658 = spec->data.array_data.elem_mult;
    if (D.19658 == 0) goto <D.19654>; else goto <D.19655>;
    <D.19654>:
    elems = monoeg_g_strdup_printf ("%d", num_elem);
    goto <D.19656>;
    <D.19655>:
    D.19659 = num_elem + 4294967295;
    if (D.19659 > 4294967293) goto <D.19660>; else goto <D.19661>;
    <D.19660>:
    elems = monoeg_g_strdup_printf ("+ %d", param_num);
    goto <D.19662>;
    <D.19661>:
    elems = monoeg_g_strdup_printf ("%d + %d", num_elem, param_num);
    <D.19662>:
    <D.19656>:
    <D.19653>:
    ret = monoeg_g_strdup_printf (" marshal (%s[%s])", elem_type, elems);
    monoeg_g_free (elem_type);
    monoeg_g_free (elems);
    D.19644 = ret;
    return D.19644;
  }
  <D.18702>:
  {
    char * elem_type;
    char * ret;

    elem_type = 0B;
    D.19663 = spec->data.safearray_data.elem_type;
    if (D.19663 != 0) goto <D.19664>; else goto <D.19665>;
    <D.19664>:
    D.19663 = spec->data.safearray_data.elem_type;
    elem_type = dis_stringify_variant_type (D.19663);
    <D.19665>:
    if (elem_type != 0B) goto <D.19667>; else goto <D.19668>;
    <D.19667>:
    iftmp.39 = elem_type;
    goto <D.19669>;
    <D.19668>:
    iftmp.39 = "";
    <D.19669>:
    ret = monoeg_g_strdup_printf (" marshal (safearray %s)", iftmp.39);
    monoeg_g_free (elem_type);
    D.19644 = ret;
    return D.19644;
  }
  <D.18705>:
  D.19671 = spec->data.custom_data.cookie;
  if (D.19671 != 0B) goto <D.19672>; else goto <D.19673>;
  <D.19672>:
  iftmp.40 = spec->data.custom_data.cookie;
  goto <D.19674>;
  <D.19673>:
  iftmp.40 = "";
  <D.19674>:
  D.19676 = spec->data.custom_data.custom_name;
  if (D.19676 != 0B) goto <D.19677>; else goto <D.19678>;
  <D.19677>:
  iftmp.41 = spec->data.custom_data.custom_name;
  goto <D.19679>;
  <D.19678>:
  iftmp.41 = "";
  <D.19679>:
  D.19644 = monoeg_g_strdup_printf (" marshal (custom (\"%s\", \"%s\"))", iftmp.41, iftmp.40);
  return D.19644;
  <D.18706>:
  {
    char * native_type;
    char * ret;

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


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

  if (str != 0B) goto <D.19681>; else goto <D.19682>;
  <D.19681>:
  D.19683 = __strdup (str);
  return D.19683;
  <D.19682>:
  D.19683 = 0B;
  return D.19683;
}


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

  switch (variant) <default: <D.18653>, case 0: <D.18609>, case 1: <D.18610>, case 2: <D.18611>, case 3: <D.18612>, case 4: <D.18613>, case 5: <D.18614>, case 6: <D.18615>, case 7: <D.18616>, case 8: <D.18617>, case 9: <D.18618>, case 10: <D.18619>, case 11: <D.18620>, case 12: <D.18621>, case 13: <D.18622>, case 14: <D.18623>, case 16: <D.18624>, case 17: <D.18625>, case 18: <D.18626>, case 19: <D.18627>, case 20: <D.18628>, case 21: <D.18629>, case 22: <D.18630>, case 23: <D.18631>, case 24: <D.18632>, case 25: <D.18633>, case 26: <D.18634>, case 27: <D.18635>, case 28: <D.18636>, case 29: <D.18637>, case 30: <D.18638>, case 31: <D.18639>, case 36: <D.18640>, case 64: <D.18641>, case 65: <D.18642>, case 66: <D.18643>, case 67: <D.18644>, case 68: <D.18645>, case 69: <D.18646>, case 70: <D.18647>, case 71: <D.18648>, case 72: <D.18649>, case 4096: <D.18650>, case 8192: <D.18651>, case 16384: <D.18652>>
  <D.18609>:
  D.19685 = monoeg_strdup ("");
  return D.19685;
  <D.18610>:
  D.19685 = monoeg_strdup ("null");
  return D.19685;
  <D.18611>:
  D.19685 = monoeg_strdup ("int16");
  return D.19685;
  <D.18612>:
  D.19685 = monoeg_strdup ("int32");
  return D.19685;
  <D.18613>:
  D.19685 = monoeg_strdup ("float32");
  return D.19685;
  <D.18614>:
  D.19685 = monoeg_strdup ("float64");
  return D.19685;
  <D.18615>:
  D.19685 = monoeg_strdup ("currency");
  return D.19685;
  <D.18616>:
  D.19685 = monoeg_strdup ("date");
  return D.19685;
  <D.18617>:
  D.19685 = monoeg_strdup ("bstr");
  return D.19685;
  <D.18618>:
  D.19685 = monoeg_strdup ("idispatch");
  return D.19685;
  <D.18619>:
  D.19685 = monoeg_strdup ("error");
  return D.19685;
  <D.18620>:
  D.19685 = monoeg_strdup ("bool");
  return D.19685;
  <D.18621>:
  D.19685 = monoeg_strdup ("variant");
  return D.19685;
  <D.18622>:
  D.19685 = monoeg_strdup ("iunknown");
  return D.19685;
  <D.18623>:
  D.19685 = monoeg_strdup ("decimal");
  return D.19685;
  <D.18624>:
  D.19685 = monoeg_strdup ("int8");
  return D.19685;
  <D.18625>:
  D.19685 = monoeg_strdup ("unsigned int8");
  return D.19685;
  <D.18626>:
  D.19685 = monoeg_strdup ("unsigned int16");
  return D.19685;
  <D.18627>:
  D.19685 = monoeg_strdup ("unsigned int32");
  return D.19685;
  <D.18628>:
  D.19685 = monoeg_strdup ("int64");
  return D.19685;
  <D.18629>:
  D.19685 = monoeg_strdup ("unsigned int64");
  return D.19685;
  <D.18630>:
  D.19685 = monoeg_strdup ("int");
  return D.19685;
  <D.18631>:
  D.19685 = monoeg_strdup ("unsigned int");
  return D.19685;
  <D.18632>:
  D.19685 = monoeg_strdup ("void");
  return D.19685;
  <D.18633>:
  D.19685 = monoeg_strdup ("hresult");
  return D.19685;
  <D.18634>:
  D.19685 = monoeg_strdup ("*");
  return D.19685;
  <D.18635>:
  D.19685 = monoeg_strdup ("safearray");
  return D.19685;
  <D.18636>:
  D.19685 = monoeg_strdup ("carray");
  return D.19685;
  <D.18637>:
  D.19685 = monoeg_strdup ("userdefined");
  return D.19685;
  <D.18638>:
  D.19685 = monoeg_strdup ("lpstr");
  return D.19685;
  <D.18639>:
  D.19685 = monoeg_strdup ("lpwstr");
  return D.19685;
  <D.18640>:
  D.19685 = monoeg_strdup ("record");
  return D.19685;
  <D.18641>:
  D.19685 = monoeg_strdup ("filetime");
  return D.19685;
  <D.18642>:
  D.19685 = monoeg_strdup ("blob");
  return D.19685;
  <D.18643>:
  D.19685 = monoeg_strdup ("stream");
  return D.19685;
  <D.18644>:
  D.19685 = monoeg_strdup ("storage");
  return D.19685;
  <D.18645>:
  D.19685 = monoeg_strdup ("streamed_object");
  return D.19685;
  <D.18646>:
  D.19685 = monoeg_strdup ("stored_object");
  return D.19685;
  <D.18647>:
  D.19685 = monoeg_strdup ("blob_object");
  return D.19685;
  <D.18648>:
  D.19685 = monoeg_strdup ("cf");
  return D.19685;
  <D.18649>:
  D.19685 = monoeg_strdup ("clsid");
  return D.19685;
  <D.18650>:
  D.19685 = monoeg_strdup ("vector");
  return D.19685;
  <D.18651>:
  D.19685 = monoeg_strdup ("[]");
  return D.19685;
  <D.18652>:
  D.19685 = monoeg_strdup ("&");
  return D.19685;
  <D.18653>:
  D.19685 = monoeg_strdup ("unknown");
  return D.19685;
}


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

  switch (native) <default: <D.18690>, case 2: <D.18657>, case 3: <D.18658>, case 4: <D.18659>, case 5: <D.18660>, case 6: <D.18661>, case 7: <D.18662>, case 8: <D.18663>, case 9: <D.18664>, case 10: <D.18665>, case 11: <D.18666>, case 12: <D.18667>, case 15: <D.18668>, case 19: <D.18669>, case 20: <D.18670>, case 21: <D.18671>, case 22: <D.18672>, case 25: <D.18673>, case 26: <D.18674>, case 27: <D.18675>, case 28: <D.18676>, case 29: <D.18677>, case 31: <D.18678>, case 32: <D.18679>, case 34: <D.18680>, case 35: <D.18681>, case 36: <D.18682>, case 37: <D.18683>, case 38: <D.18684>, case 40: <D.18685>, case 43: <D.18686>, case 44: <D.18687>, case 45: <D.18688>, case 80: <D.18689>>
  <D.18657>:
  D.19687 = monoeg_strdup ("bool");
  return D.19687;
  <D.18658>:
  D.19687 = monoeg_strdup ("int8");
  return D.19687;
  <D.18659>:
  D.19687 = monoeg_strdup ("unsigned int8");
  return D.19687;
  <D.18660>:
  D.19687 = monoeg_strdup ("int16");
  return D.19687;
  <D.18661>:
  D.19687 = monoeg_strdup ("unsigned int16");
  return D.19687;
  <D.18662>:
  D.19687 = monoeg_strdup ("int32");
  return D.19687;
  <D.18663>:
  D.19687 = monoeg_strdup ("unsigned int32");
  return D.19687;
  <D.18664>:
  D.19687 = monoeg_strdup ("int64");
  return D.19687;
  <D.18665>:
  D.19687 = monoeg_strdup ("unsigned int64");
  return D.19687;
  <D.18666>:
  D.19687 = monoeg_strdup ("float32");
  return D.19687;
  <D.18667>:
  D.19687 = monoeg_strdup ("float64");
  return D.19687;
  <D.18668>:
  D.19687 = monoeg_strdup ("currency");
  return D.19687;
  <D.18669>:
  D.19687 = monoeg_strdup ("bstr");
  return D.19687;
  <D.18670>:
  D.19687 = monoeg_strdup ("lpstr");
  return D.19687;
  <D.18671>:
  D.19687 = monoeg_strdup ("lpwstr");
  return D.19687;
  <D.18672>:
  D.19687 = monoeg_strdup ("lptstr");
  return D.19687;
  <D.18673>:
  D.19687 = monoeg_strdup ("iunknown");
  return D.19687;
  <D.18674>:
  D.19687 = monoeg_strdup ("idispatch");
  return D.19687;
  <D.18675>:
  D.19687 = monoeg_strdup ("struct");
  return D.19687;
  <D.18676>:
  D.19687 = monoeg_strdup ("interface");
  return D.19687;
  <D.18677>:
  D.19687 = monoeg_strdup ("safearray");
  return D.19687;
  <D.18678>:
  D.19687 = monoeg_strdup ("int");
  return D.19687;
  <D.18679>:
  D.19687 = monoeg_strdup ("unsigned int");
  return D.19687;
  <D.18680>:
  D.19687 = monoeg_strdup ("vbbyrefstr");
  return D.19687;
  <D.18681>:
  D.19687 = monoeg_strdup ("ansi bstr");
  return D.19687;
  <D.18682>:
  D.19687 = monoeg_strdup ("tbstr");
  return D.19687;
  <D.18683>:
  D.19687 = monoeg_strdup ("variant bool");
  return D.19687;
  <D.18684>:
  D.19687 = monoeg_strdup ("method");
  return D.19687;
  <D.18685>:
  D.19687 = monoeg_strdup ("as any");
  return D.19687;
  <D.18686>:
  D.19687 = monoeg_strdup ("lpstruct");
  return D.19687;
  <D.18687>:
  D.19687 = monoeg_strdup ("custom");
  return D.19687;
  <D.18688>:
  D.19687 = monoeg_strdup ("error");
  return D.19687;
  <D.18689>:
  D.19687 = monoeg_strdup ("");
  return D.19687;
  <D.18690>:
  D.19687 = monoeg_strdup ("unknown");
  return D.19687;
}


get_generic_param (struct MonoImage * m, struct MonoGenericContainer * container)
{
  char * D.19691;
  struct MonoGenericParamFull * D.19692;
  long unsigned int D.19693;
  long unsigned int D.19694;
  struct MonoGenericParamInfo * iftmp.42;
  struct MonoGenericContainer * D.19696;
  short unsigned int D.19702;
  int D.19703;
  int D.19704;
  int D.19707;
  int D.19710;
  int D.19713;
  int D.19716;
  struct MonoClass * D.19722;
  struct MonoType * D.19723;
  struct MonoGenericParamInfo * iftmp.43;
  const char * D.19731;
  <unnamed-signed:31> D.19732;
  int D.19733;
  struct GString * result;
  char * retval;
  int i;

  if (container == 0B) goto <D.19689>; else goto <D.19690>;
  <D.19689>:
  D.19691 = 0B;
  return D.19691;
  <D.19690>:
  result = monoeg_g_string_new ("");
  monoeg_g_string_append_c (result, 60);
  i = 0;
  goto <D.18727>;
  <D.18726>:
  {
    struct MonoGenericParam * param;
    struct MonoGenericParamInfo * param_info;
    struct MonoClass * * constr;
    int first;
    guint16 flags;
    char * esname;

    D.19692 = container->type_params;
    D.19693 = (long unsigned int) i;
    D.19694 = D.19693 * 56;
    param = D.19692 + D.19694;
    D.19696 = param->owner;
    if (D.19696 != 0B) goto <D.19697>; else goto <D.19698>;
    <D.19697>:
    iftmp.42 = &MEM[(struct MonoGenericParamFull *)param].info;
    goto <D.19699>;
    <D.19698>:
    iftmp.42 = 0B;
    <D.19699>:
    param_info = iftmp.42;
    first = 1;
    if (i > 0) goto <D.19700>; else goto <D.19701>;
    <D.19700>:
    monoeg_g_string_append (result, ",");
    <D.19701>:
    D.19702 = param_info->flags;
    flags = D.19702 & 3;
    D.19703 = (int) flags;
    D.19704 = D.19703 & 1;
    if (D.19704 != 0) goto <D.19705>; else goto <D.19706>;
    <D.19705>:
    monoeg_g_string_append (result, "+ ");
    <D.19706>:
    D.19703 = (int) flags;
    D.19707 = D.19703 & 2;
    if (D.19707 != 0) goto <D.19708>; else goto <D.19709>;
    <D.19708>:
    monoeg_g_string_append (result, "- ");
    <D.19709>:
    D.19702 = param_info->flags;
    flags = D.19702 & 28;
    D.19703 = (int) flags;
    D.19710 = D.19703 & 4;
    if (D.19710 != 0) goto <D.19711>; else goto <D.19712>;
    <D.19711>:
    monoeg_g_string_append (result, "class ");
    <D.19712>:
    D.19703 = (int) flags;
    D.19713 = D.19703 & 8;
    if (D.19713 != 0) goto <D.19714>; else goto <D.19715>;
    <D.19714>:
    monoeg_g_string_append (result, "valuetype ");
    <D.19715>:
    D.19703 = (int) flags;
    D.19716 = D.19703 & 16;
    if (D.19716 != 0) goto <D.19717>; else goto <D.19718>;
    <D.19717>:
    monoeg_g_string_append (result, ".ctor ");
    <D.19718>:
    constr = param_info->constraints;
    goto <D.18724>;
    <D.18723>:
    {
      char * sig;

      if (first != 0) goto <D.19719>; else goto <D.19720>;
      <D.19719>:
      monoeg_g_string_append_c (result, 40);
      first = 0;
      goto <D.19721>;
      <D.19720>:
      monoeg_g_string_append (result, ", ");
      <D.19721>:
      D.19722 = *constr;
      D.19723 = &D.19722->byval_arg;
      sig = dis_stringify_type (m, D.19723, 1);
      monoeg_g_string_append (result, sig);
      monoeg_g_free (sig);
    }
    constr = constr + 8;
    <D.18724>:
    if (constr != 0B) goto <D.19724>; else goto <D.18725>;
    <D.19724>:
    D.19722 = *constr;
    if (D.19722 != 0B) goto <D.18723>; else goto <D.18725>;
    <D.18725>:
    if (first == 0) goto <D.19725>; else goto <D.19726>;
    <D.19725>:
    monoeg_g_string_append (result, ") ");
    <D.19726>:
    D.19696 = param->owner;
    if (D.19696 != 0B) goto <D.19728>; else goto <D.19729>;
    <D.19728>:
    iftmp.43 = &MEM[(struct MonoGenericParamFull *)param].info;
    goto <D.19730>;
    <D.19729>:
    iftmp.43 = 0B;
    <D.19730>:
    D.19731 = iftmp.43->name;
    esname = get_escaped_name (D.19731);
    monoeg_g_string_append (result, esname);
    monoeg_g_free (esname);
  }
  i = i + 1;
  <D.18727>:
  D.19732 = container->type_argc;
  D.19733 = (int) D.19732;
  if (D.19733 > i) goto <D.18726>; else goto <D.18728>;
  <D.18728>:
  monoeg_g_string_append_c (result, 62);
  retval = result->str;
  monoeg_g_string_free (result, 0);
  D.19691 = retval;
  return D.19691;
}


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

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


dis_stringify_method_signature_full (struct MonoImage * m, struct MonoMethodSignature * method, int methoddef_row, struct MonoGenericContainer * container, gboolean fully_qualified, gboolean with_marshal_info)
{
  _Bool D.19737;
  _Bool D.19738;
  _Bool D.19739;
  int D.19740;
  _Bool D.19741;
  long int D.19742;
  long int D.19743;
  int D.19748;
  struct MonoTableInfo * D.19749;
  unsigned int methoddef_row.44;
  int type_idx.45;
  unsigned int D.19757;
  unsigned int D.19760;
  const char * sig.46;
  int D.19762;
  unsigned int D.19763;
  const char * sig.47;
  unsigned char D.19769;
  unsigned char D.19770;
  <unnamed-unsigned:24> D.19773;
  int D.19774;
  <unnamed-unsigned:24> D.19778;
  int D.19779;
  int D.19780;
  unsigned char D.19781;
  unsigned char D.19782;
  _Bool D.19783;
  _Bool D.19784;
  _Bool D.19785;
  _Bool D.19786;
  short unsigned int D.19787;
  unsigned int D.19794;
  int D.19795;
  struct MonoTableInfo * D.19796;
  unsigned int i.48;
  unsigned int D.19801;
  unsigned int D.19805;
  const char * D.19806;
  unsigned int D.19809;
  unsigned int D.19810;
  int D.19824;
  int D.19829;
  struct MonoType * D.19830;
  const char * iftmp.49;
  int D.19835;
  struct MonoType * D.19836;
  <unnamed-unsigned:6> D.19839;
  unsigned int D.19840;
  const char * D.19841;
  const char * iftmp.50;
  char * D.19850;
  int show_method_tokens.51;
  int D.19856;
  int D.19857;
  char * D.19860;
  guint32 cols[6];
  guint32 pcols[3];
  guint32 param_index;
  guint32 next_param_index;
  gboolean has_param_row;
  const char * method_name;
  int free_method;
  char * retval;
  char * esname;
  char * type;
  char * marshal_info;
  char * ret_marshal_info;
  char * gen_param;
  struct GString * result;
  struct GString * result_ret;
  int i;
  int start;

  try
    {
      param_index = 0;
      next_param_index = 0;
      method_name = "";
      free_method = 0;
      type = 0B;
      marshal_info = 0B;
      ret_marshal_info = 0B;
      gen_param = 0B;
      result = monoeg_g_string_new ("");
      result_ret = monoeg_g_string_new ("");
      D.19737 = method == 0B;
      D.19738 = methoddef_row == 0;
      D.19739 = D.19737 & D.19738;
      D.19740 = (int) D.19739;
      D.19741 = D.19740 != 0;
      D.19742 = (long int) D.19741;
      D.19743 = __builtin_expect (D.19742, 0);
      if (D.19743 != 0) goto <D.19744>; else goto <D.19745>;
      <D.19744>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "get.c", 878, "method || methoddef_row");
      <D.19745>:
      if (methoddef_row != 0) goto <D.19746>; else goto <D.19747>;
      <D.19746>:
      D.19748 = methoddef_row + -1;
      D.19749 = &m->tables[6];
      mono_metadata_decode_row (D.19749, D.19748, &cols, 6);
      if (fully_qualified != 0) goto <D.19750>; else goto <D.19751>;
      <D.19750>:
      {
        guint32 type_idx;

        methoddef_row.44 = (unsigned int) methoddef_row;
        type_idx = mono_metadata_typedef_from_method (m, methoddef_row.44);
        if (type_idx != 0) goto <D.19753>; else goto <D.19754>;
        <D.19753>:
        type_idx.45 = (int) type_idx;
        type = get_typedef (m, type_idx.45);
        goto <D.19756>;
        <D.19754>:
        type = monoeg_strdup ("<invalid>");
        <D.19756>:
      }
      <D.19751>:
      D.19757 = cols[3];
      method_name = mono_metadata_string_heap (m, D.19757);
      param_index = cols[5];
      if (method == 0B) goto <D.19758>; else goto <D.19759>;
      <D.19758>:
      {
        const char * sig;

        try
          {
            D.19760 = cols[4];
            sig.46 = mono_metadata_blob_heap (m, D.19760);
            sig = sig.46;
            D.19762 = methoddef_row | 100663296;
            D.19763 = (unsigned int) D.19762;
            container = mono_metadata_load_generic_params (m, D.19763, container);
            if (container != 0B) goto <D.19764>; else goto <D.19765>;
            <D.19764>:
            D.19762 = methoddef_row | 100663296;
            D.19763 = (unsigned int) D.19762;
            mono_metadata_load_generic_param_constraints (m, D.19763, container);
            <D.19765>:
            sig.47 = sig;
            mono_metadata_decode_blob_size (sig.47, &sig);
            sig.47 = sig;
            method = mono_metadata_parse_method_signature_full (m, container, methoddef_row, sig.47, &sig);
            free_method = 1;
          }
        finally
          {
            sig = {CLOBBER};
          }
      }
      <D.19759>:
      if (container != 0B) goto <D.19767>; else goto <D.19768>;
      <D.19767>:
      D.19769 = BIT_FIELD_REF <*container, 8, 280>;
      D.19770 = D.19769 & 128;
      if (D.19770 != 0) goto <D.19771>; else goto <D.19772>;
      <D.19771>:
      gen_param = get_generic_param (m, container);
      <D.19772>:
      <D.19768>:
      D.19773 = m->tables[6].rows;
      D.19774 = (int) D.19773;
      if (D.19774 > methoddef_row) goto <D.19775>; else goto <D.19776>;
      <D.19775>:
      D.19749 = &m->tables[6];
      mono_metadata_decode_row (D.19749, methoddef_row, &cols, 6);
      next_param_index = cols[5];
      goto <D.19777>;
      <D.19776>:
      D.19778 = m->tables[8].rows;
      D.19779 = (int) D.19778;
      D.19780 = D.19779 + 1;
      next_param_index = (guint32) D.19780;
      <D.19777>:
      <D.19747>:
      D.19781 = BIT_FIELD_REF <*method, 8, 112>;
      D.19782 = D.19781 & 64;
      D.19783 = D.19782 == 0;
      start = (int) D.19783;
      i = 0;
      goto <D.18767>;
      <D.18766>:
      marshal_info = 0B;
      D.19784 = param_index != 0;
      D.19785 = param_index < next_param_index;
      D.19786 = D.19784 & D.19785;
      has_param_row = (gboolean) D.19786;
      esname = 0B;
      D.19787 = method->param_count;
      if (D.19787 == 0) goto <D.19788>; else goto <D.19789>;
      <D.19788>:
      if (has_param_row == 0) goto <D.19790>; else goto <D.19791>;
      <D.19790>:
      // predicted unlikely by continue predictor.
      goto <D.18763>;
      <D.19791>:
      <D.19789>:
      if (has_param_row != 0) goto <D.19792>; else goto <D.19793>;
      <D.19792>:
      D.19794 = param_index + 4294967295;
      D.19795 = (int) D.19794;
      D.19796 = &m->tables[8];
      mono_metadata_decode_row (D.19796, D.19795, &pcols, 3);
      <D.19793>:
      if (has_param_row != 0) goto <D.19799>; else goto <D.19797>;
      <D.19799>:
      i.48 = (unsigned int) i;
      D.19801 = pcols[1];
      if (i.48 == D.19801) goto <D.19802>; else goto <D.19797>;
      <D.19802>:
      if (i != 0) goto <D.19803>; else goto <D.19804>;
      <D.19803>:
      D.19805 = pcols[2];
      D.19806 = mono_metadata_string_heap (m, D.19805);
      esname = get_escaped_name (D.19806);
      <D.19804>:
      if (with_marshal_info != 0) goto <D.19807>; else goto <D.19808>;
      <D.19807>:
      D.19809 = pcols[0];
      D.19810 = D.19809 & 8192;
      if (D.19810 != 0) goto <D.19811>; else goto <D.19812>;
      <D.19811>:
      {
        const char * tp;
        struct MonoMarshalSpec * spec;

        D.19794 = param_index + 4294967295;
        tp = mono_metadata_get_marshal_info (m, D.19794, 0);
        if (tp != 0B) goto <D.19813>; else goto <D.19814>;
        <D.19813>:
        spec = mono_metadata_parse_marshal_spec (m, tp);
        if (i != 0) goto <D.19815>; else goto <D.19816>;
        <D.19815>:
        marshal_info = dis_stringify_marshal_spec (spec);
        goto <D.19817>;
        <D.19816>:
        ret_marshal_info = dis_stringify_marshal_spec (spec);
        <D.19817>:
        goto <D.19818>;
        <D.19814>:
        if (i != 0) goto <D.19819>; else goto <D.19820>;
        <D.19819>:
        marshal_info = monoeg_strdup ("(missing)");
        goto <D.19821>;
        <D.19820>:
        ret_marshal_info = monoeg_strdup ("(missing)");
        <D.19821>:
        <D.19818>:
      }
      <D.19812>:
      <D.19808>:
      param_index = param_index + 1;
      goto <D.19798>;
      <D.19797>:
      if (i != 0) goto <D.19822>; else goto <D.19823>;
      <D.19822>:
      D.19824 = i - start;
      esname = monoeg_g_strdup_printf ("A_%i", D.19824);
      <D.19823>:
      <D.19798>:
      if (i == 0) goto <D.19825>; else goto <D.19826>;
      <D.19825>:
      // predicted unlikely by continue predictor.
      goto <D.18763>;
      <D.19826>:
      if (i > 1) goto <D.19827>; else goto <D.19828>;
      <D.19827>:
      monoeg_g_string_append (result, ", ");
      <D.19828>:
      D.19829 = i + -1;
      D.19830 = method->params[D.19829];
      retval = dis_stringify_param (m, D.19830);
      if (marshal_info != 0B) goto <D.19832>; else goto <D.19833>;
      <D.19832>:
      iftmp.49 = marshal_info;
      goto <D.19834>;
      <D.19833>:
      iftmp.49 = "";
      <D.19834>:
      monoeg_g_string_append_printf (result, "%s%s %s", retval, iftmp.49, esname);
      monoeg_g_free (retval);
      monoeg_g_free (esname);
      monoeg_g_free (marshal_info);
      <D.18763>:
      i = i + 1;
      <D.18767>:
      D.19787 = method->param_count;
      D.19835 = (int) D.19787;
      if (D.19835 >= i) goto <D.18766>; else goto <D.18768>;
      <D.18768>:
      monoeg_g_string_append (result, ") ");
      D.19836 = method->ret;
      retval = dis_stringify_param (m, D.19836);
      D.19781 = BIT_FIELD_REF <*method, 8, 112>;
      D.19782 = D.19781 & 64;
      if (D.19782 != 0) goto <D.19837>; else goto <D.19838>;
      <D.19837>:
      monoeg_g_string_append (result_ret, "instance ");
      <D.19838>:
      D.19839 = method->call_convention;
      D.19840 = (unsigned int) D.19839;
      D.19841 = map (D.19840, &call_conv_type_map);
      monoeg_g_string_append (result_ret, D.19841);
      if (ret_marshal_info != 0B) goto <D.19843>; else goto <D.19844>;
      <D.19843>:
      iftmp.50 = ret_marshal_info;
      goto <D.19845>;
      <D.19844>:
      iftmp.50 = "";
      <D.19845>:
      monoeg_g_string_append_printf (result_ret, " %s%s ", retval, iftmp.50);
      monoeg_g_free (ret_marshal_info);
      if (type != 0B) goto <D.19846>; else goto <D.19847>;
      <D.19846>:
      {
        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.19847>:
      esname = get_escaped_name (method_name);
      monoeg_g_string_append (result_ret, esname);
      monoeg_g_free (esname);
      if (gen_param != 0B) goto <D.19848>; else goto <D.19849>;
      <D.19848>:
      monoeg_g_string_append (result_ret, gen_param);
      monoeg_g_free (gen_param);
      <D.19849>:
      monoeg_g_string_append (result_ret, " (");
      monoeg_g_free (retval);
      D.19850 = result_ret->str;
      monoeg_g_string_prepend (result, D.19850);
      monoeg_g_string_free (result_ret, 0);
      show_method_tokens.51 = show_method_tokens;
      if (show_method_tokens.51 != 0) goto <D.19852>; else goto <D.19853>;
      <D.19852>:
      if (methoddef_row != 0) goto <D.19854>; else goto <D.19855>;
      <D.19854>:
      D.19856 = methoddef_row >> 1;
      D.19857 = D.19856 | 100663296;
      monoeg_g_string_append_printf (result, " /* 0x%X */ ", D.19857);
      <D.19855>:
      <D.19853>:
      if (free_method != 0) goto <D.19858>; else goto <D.19859>;
      <D.19858>:
      mono_metadata_free_method_signature (method);
      <D.19859>:
      retval = result->str;
      monoeg_g_string_free (result, 0);
      D.19860 = retval;
      return D.19860;
    }
  finally
    {
      cols = {CLOBBER};
      pcols = {CLOBBER};
    }
}


dis_stringify_function_ptr (struct MonoImage * m, struct MonoMethodSignature * method)
{
  _Bool D.19863;
  long int D.19864;
  long int D.19865;
  <unnamed-unsigned:6> D.19868;
  unsigned int D.19869;
  const char * D.19870;
  struct MonoType * D.19871;
  struct MonoType * D.19874;
  short unsigned int D.19875;
  int D.19876;
  char * D.19877;
  char * retval;
  struct GString * result;
  int i;

  result = monoeg_g_string_new ("");
  D.19863 = method == 0B;
  D.19864 = (long int) D.19863;
  D.19865 = __builtin_expect (D.19864, 0);
  if (D.19865 != 0) goto <D.19866>; else goto <D.19867>;
  <D.19866>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "get.c", 1017, "method");
  <D.19867>:
  D.19868 = method->call_convention;
  D.19869 = (unsigned int) D.19868;
  D.19870 = map (D.19869, &call_conv_type_map);
  monoeg_g_string_append (result, D.19870);
  D.19871 = method->ret;
  retval = dis_stringify_param (m, D.19871);
  monoeg_g_string_append_printf (result, " %s ", retval);
  monoeg_g_free (retval);
  monoeg_g_string_append (result, " *(");
  i = 0;
  goto <D.18778>;
  <D.18777>:
  if (i != 0) goto <D.19872>; else goto <D.19873>;
  <D.19872>:
  monoeg_g_string_append (result, ", ");
  <D.19873>:
  D.19874 = method->params[i];
  retval = dis_stringify_param (m, D.19874);
  monoeg_g_string_append (result, retval);
  monoeg_g_free (retval);
  i = i + 1;
  <D.18778>:
  D.19875 = method->param_count;
  D.19876 = (int) D.19875;
  if (D.19876 > i) goto <D.18777>; else goto <D.18779>;
  <D.18779>:
  monoeg_g_string_append (result, ") ");
  retval = result->str;
  monoeg_g_string_free (result, 0);
  D.19877 = retval;
  return D.19877;
}


dis_stringify_object_with_class (struct MonoImage * m, struct MonoClass * c, gboolean prefix, gboolean is_def)
{
  const char * iftmp.52;
  unsigned char D.19880;
  unsigned int D.19884;
  char * D.19887;
  struct MonoImage * D.19888;
  const char * D.19891;
  int substitute_with_mscorlib_p.53;
  int D.18806;
  int iftmp.54;
  int D.18802;
  const char[7] * D.19901;
  unsigned char D.19902;
  int D.19903;
  unsigned char D.19904;
  int D.19905;
  _Bool D.19906;
  _Bool D.19907;
  _Bool D.19908;
  const unsigned char * D.19911;
  unsigned char D.19912;
  int D.19913;
  const unsigned char * D.19914;
  unsigned char D.19915;
  int D.19916;
  _Bool D.19917;
  _Bool D.19918;
  const unsigned char * D.19921;
  unsigned char D.19922;
  int D.19923;
  const unsigned char * D.19924;
  unsigned char D.19925;
  int D.19926;
  _Bool D.19927;
  _Bool D.19928;
  const unsigned char * D.19931;
  unsigned char D.19932;
  int D.19933;
  const unsigned char * D.19934;
  unsigned char D.19935;
  int D.19936;
  struct MonoAssembly * D.19939;
  const char * D.19940;
  const char * D.19942;
  struct MonoGenericClass * D.19943;
  struct MonoType * D.19946;
  int D.19947;
  <unnamed-unsigned:22> D.19948;
  int D.19949;
  char * D.19952;
  const char * iftmp.55;
  const char * iftmp.56;
  const char * iftmp.57;
  struct MonoType * type;
  const char * otype;
  char * assemblyref;
  char * result;
  char * esname;
  char * generic;

  type = &c->byval_arg;
  D.19880 = type->type;
  if (D.19880 == 17) goto <D.19881>; else goto <D.19882>;
  <D.19881>:
  iftmp.52 = "valuetype ";
  goto <D.19883>;
  <D.19882>:
  iftmp.52 = "class ";
  <D.19883>:
  otype = iftmp.52;
  assemblyref = 0B;
  generic = 0B;
  D.19884 = c->type_token;
  if (D.19884 == 33554433) goto <D.19885>; else goto <D.19886>;
  <D.19885>:
  D.19887 = 0B;
  return D.19887;
  <D.19886>:
  D.19888 = c->image;
  if (D.19888 != m) goto <D.19889>; else goto <D.19890>;
  <D.19889>:
  D.19888 = c->image;
  D.19891 = D.19888->assembly_name;
  if (D.19891 != 0B) goto <D.19892>; else goto <D.19893>;
  <D.19892>:
  substitute_with_mscorlib_p.53 = substitute_with_mscorlib_p;
  if (substitute_with_mscorlib_p.53 != 0) goto <D.19897>; else goto <D.19894>;
  <D.19897>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      D.19888 = c->image;
      __s2 = D.19888->assembly_name;
      D.19901 = "corlib";
      D.19902 = MEM[(const unsigned char *)D.19901];
      D.19903 = (int) D.19902;
      D.19904 = *__s2;
      D.19905 = (int) D.19904;
      __result = D.19903 - D.19905;
      {
        D.19906 = __s1_len != 0;
        D.19907 = __result == 0;
        D.19908 = D.19906 & D.19907;
        if (D.19908 != 0) goto <D.19909>; else goto <D.19910>;
        <D.19909>:
        D.19911 = &MEM[(void *)"corlib" + 1B];
        D.19912 = *D.19911;
        D.19913 = (int) D.19912;
        D.19914 = __s2 + 1;
        D.19915 = *D.19914;
        D.19916 = (int) D.19915;
        __result = D.19913 - D.19916;
        D.19917 = __s1_len > 1;
        D.19907 = __result == 0;
        D.19918 = D.19917 & D.19907;
        if (D.19918 != 0) goto <D.19919>; else goto <D.19920>;
        <D.19919>:
        D.19921 = &MEM[(void *)"corlib" + 2B];
        D.19922 = *D.19921;
        D.19923 = (int) D.19922;
        D.19924 = __s2 + 2;
        D.19925 = *D.19924;
        D.19926 = (int) D.19925;
        __result = D.19923 - D.19926;
        D.19927 = __s1_len > 2;
        D.19907 = __result == 0;
        D.19928 = D.19927 & D.19907;
        if (D.19928 != 0) goto <D.19929>; else goto <D.19930>;
        <D.19929>:
        D.19931 = &MEM[(void *)"corlib" + 3B];
        D.19932 = *D.19931;
        D.19933 = (int) D.19932;
        D.19934 = __s2 + 3;
        D.19935 = *D.19934;
        D.19936 = (int) D.19935;
        __result = D.19933 - D.19936;
        <D.19930>:
        <D.19920>:
        <D.19910>:
      }
      D.18802 = __result;
    }
    iftmp.54 = D.18802;
    goto <D.19937>;
    <D.19900>:
    D.19888 = c->image;
    D.19891 = D.19888->assembly_name;
    iftmp.54 = __builtin_strcmp ("corlib", D.19891);
    <D.19937>:
    D.18806 = iftmp.54;
  }
  if (D.18806 == 0) goto <D.19938>; else goto <D.19894>;
  <D.19938>:
  assemblyref = monoeg_g_strdup_printf ("[%s]", "mscorlib");
  goto <D.19895>;
  <D.19894>:
  {
    char * esc;

    D.19888 = c->image;
    D.19939 = D.19888->assembly;
    D.19940 = D.19939->aname.name;
    esc = get_escaped_name (D.19940);
    assemblyref = monoeg_g_strdup_printf ("[%s]", esc);
    monoeg_g_free (esc);
  }
  <D.19895>:
  goto <D.19941>;
  <D.19893>:
  D.19888 = c->image;
  D.19942 = D.19888->module_name;
  assemblyref = monoeg_g_strdup_printf ("[.module %s]", D.19942);
  <D.19941>:
  <D.19890>:
  esname = get_escaped_class_name (c);
  D.19943 = c->generic_class;
  if (D.19943 != 0B) goto <D.19944>; else goto <D.19945>;
  <D.19944>:
  {
    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.18814>;
    <D.18813>:
    {
      char * t;

      D.19946 = inst->type_argv[i];
      t = dis_stringify_type (m, D.19946, is_def);
      monoeg_g_string_append (str, t);
      D.19947 = i + 1;
      D.19948 = inst->type_argc;
      D.19949 = (int) D.19948;
      if (D.19947 != D.19949) goto <D.19950>; else goto <D.19951>;
      <D.19950>:
      monoeg_g_string_append (str, ", ");
      <D.19951>:
      monoeg_g_free (t);
    }
    i = i + 1;
    <D.18814>:
    D.19948 = inst->type_argc;
    D.19949 = (int) D.19948;
    if (D.19949 > i) goto <D.18813>; else goto <D.18815>;
    <D.18815>:
    D.19952 = str->str;
    generic = monoeg_g_strdup_printf ("<%s>", D.19952);
    monoeg_g_string_free (str, 1);
  }
  <D.19945>:
  if (generic != 0B) goto <D.19954>; else goto <D.19955>;
  <D.19954>:
  iftmp.55 = generic;
  goto <D.19956>;
  <D.19955>:
  iftmp.55 = "";
  <D.19956>:
  if (assemblyref != 0B) goto <D.19958>; else goto <D.19959>;
  <D.19958>:
  iftmp.56 = assemblyref;
  goto <D.19960>;
  <D.19959>:
  iftmp.56 = "";
  <D.19960>:
  if (prefix != 0) goto <D.19962>; else goto <D.19963>;
  <D.19962>:
  iftmp.57 = otype;
  goto <D.19964>;
  <D.19963>:
  iftmp.57 = "";
  <D.19964>:
  result = monoeg_g_strdup_printf ("%s%s%s%s", iftmp.57, iftmp.56, esname, iftmp.55);
  monoeg_g_free (generic);
  monoeg_g_free (assemblyref);
  monoeg_g_free (esname);
  D.19887 = result;
  return D.19887;
}


get_escaped_class_name (struct MonoClass * c)
{
  unsigned int D.19966;
  char * D.19969;
  unsigned char D.19972;
  unsigned char D.19974;
  const char * D.19977;
  struct MonoClass * D.19978;
  const char * D.19982;
  char D.19983;
  char * result;
  char * esname;

  D.19966 = c->type_token;
  if (D.19966 == 33554433) goto <D.19967>; else goto <D.19968>;
  <D.19967>:
  D.19969 = 0B;
  return D.19969;
  <D.19968>:
  D.19972 = c->rank;
  if (D.19972 != 0) goto <D.19970>; else goto <D.19973>;
  <D.19973>:
  D.19974 = c->byval_arg.type;
  if (D.19974 == 15) goto <D.19970>; else goto <D.19971>;
  <D.19970>:
  if (1 != 0) goto <D.19975>; else goto <D.19976>;
  <D.19975>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "get.c", 1051, "0");
  <D.19976>:
  <D.19971>:
  D.19977 = c->name;
  esname = get_escaped_name (D.19977);
  D.19978 = c->nested_in;
  if (D.19978 != 0B) goto <D.19979>; else goto <D.19980>;
  <D.19979>:
  {
    char * part_a;

    D.19978 = c->nested_in;
    part_a = get_escaped_class_name (D.19978);
    result = monoeg_g_strdup_printf ("%s/%s", part_a, esname);
    monoeg_g_free (part_a);
  }
  goto <D.19981>;
  <D.19980>:
  D.19982 = c->name_space;
  D.19983 = *D.19982;
  if (D.19983 != 0) goto <D.19984>; else goto <D.19985>;
  <D.19984>:
  D.19982 = c->name_space;
  result = monoeg_g_strdup_printf ("%s.%s", D.19982, esname);
  goto <D.19986>;
  <D.19985>:
  result = monoeg_strdup (esname);
  <D.19986>:
  <D.19981>:
  monoeg_g_free (esname);
  D.19969 = result;
  return D.19969;
}


dis_stringify_type (struct MonoImage * m, struct MonoType * type, gboolean is_def)
{
  unsigned char D.19988;
  unsigned char D.19989;
  struct MonoCustomMod[0:] * D.19992;
  <unnamed-unsigned:6> D.19993;
  int D.19994;
  unsigned char D.19995;
  int D.19996;
  unsigned int D.19997;
  const char * D.19998;
  struct MonoMethodSignature * D.19999;
  struct MonoType * D.20000;
  struct MonoClass * D.20001;
  struct MonoType * D.20002;
  struct MonoArrayType * D.20003;
  struct MonoGenericParam * D.20007;
  int D.20008;
  struct MonoGenericParamInfo * iftmp.58;
  struct MonoGenericContainer * D.20011;
  const char * D.20015;
  char * D.20016;
  short unsigned int D.20017;
  int D.20018;
  int D.20022;
  struct MonoGenericParamInfo * iftmp.59;
  const char * D.20028;
  char * D.20029;
  struct MonoGenericClass * D.20030;
  struct MonoClass * D.20031;
  struct MonoType * D.20032;
  struct MonoType * D.20033;
  int D.20034;
  <unnamed-unsigned:22> D.20035;
  int D.20036;
  char * D.20039;
  unsigned char D.20040;
  unsigned char D.20043;
  char * D.20048;
  const char * iftmp.60;
  const char * pinned;
  const char * byref;
  char * bare;
  char * mods;
  char * result;

  pinned = "";
  byref = "";
  bare = 0B;
  mods = 0B;
  D.19988 = BIT_FIELD_REF <*type, 8, 88>;
  D.19989 = D.19988 & 63;
  if (D.19989 != 0) goto <D.19990>; else goto <D.19991>;
  <D.19990>:
  D.19992 = &type->modifiers;
  D.19993 = type->num_mods;
  D.19994 = (int) D.19993;
  mods = dis_stringify_modifiers (m, D.19994, D.19992);
  <D.19991>:
  D.19995 = type->type;
  D.19996 = (int) D.19995;
  switch (D.19996) <default: <D.18871>, case 1: <D.18859>, case 2: <D.18832>, case 3: <D.18833>, case 4: <D.18834>, case 5: <D.18835>, case 6: <D.18836>, case 7: <D.18837>, case 8: <D.18838>, case 9: <D.18839>, case 10: <D.18840>, case 11: <D.18841>, case 12: <D.18842>, case 13: <D.18843>, case 14: <D.18846>, case 15: <D.18854>, case 17: <D.18850>, case 18: <D.18851>, case 19: <D.18861>, case 20: <D.18858>, case 21: <D.18862>, case 22: <D.18848>, case 24: <D.18844>, case 25: <D.18845>, case 27: <D.18852>, case 28: <D.18847>, case 29: <D.18856>, case 30: <D.18860>>
  <D.18832>:
  <D.18833>:
  <D.18834>:
  <D.18835>:
  <D.18836>:
  <D.18837>:
  <D.18838>:
  <D.18839>:
  <D.18840>:
  <D.18841>:
  <D.18842>:
  <D.18843>:
  <D.18844>:
  <D.18845>:
  <D.18846>:
  <D.18847>:
  <D.18848>:
  D.19995 = type->type;
  D.19997 = (unsigned int) D.19995;
  D.19998 = map (D.19997, &element_type_map);
  bare = monoeg_strdup (D.19998);
  goto <D.18849>;
  <D.18850>:
  <D.18851>:
  bare = dis_stringify_object (m, type, is_def);
  goto <D.18849>;
  <D.18852>:
  {
    char * child_type;

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

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

    D.20001 = type->data.klass;
    D.20002 = &D.20001->byval_arg;
    child_type = dis_stringify_type (m, D.20002, is_def);
    bare = monoeg_g_strdup_printf ("%s[]", child_type);
    monoeg_g_free (child_type);
    goto <D.18849>;
  }
  <D.18858>:
  D.20003 = type->data.array;
  bare = dis_stringify_array (m, D.20003, is_def);
  goto <D.18849>;
  <D.18859>:
  bare = monoeg_strdup ("void");
  goto <D.18849>;
  <D.18860>:
  if (is_def != 0) goto <D.20006>; else goto <D.20004>;
  <D.20006>:
  D.20007 = type->data.generic_param;
  D.20008 = cant_print_generic_param_name (D.20007);
  if (D.20008 == 0) goto <D.20009>; else goto <D.20004>;
  <D.20009>:
  D.20007 = type->data.generic_param;
  D.20011 = D.20007->owner;
  if (D.20011 != 0B) goto <D.20012>; else goto <D.20013>;
  <D.20012>:
  D.20007 = type->data.generic_param;
  iftmp.58 = &MEM[(struct MonoGenericParamFull *)D.20007].info;
  goto <D.20014>;
  <D.20013>:
  iftmp.58 = 0B;
  <D.20014>:
  D.20015 = iftmp.58->name;
  D.20016 = get_escaped_name (D.20015);
  bare = monoeg_g_strdup_printf ("!!%s", D.20016);
  goto <D.20005>;
  <D.20004>:
  D.20007 = type->data.generic_param;
  D.20017 = D.20007->num;
  D.20018 = (int) D.20017;
  bare = monoeg_g_strdup_printf ("!!%d", D.20018);
  <D.20005>:
  goto <D.18849>;
  <D.18861>:
  if (is_def != 0) goto <D.20021>; else goto <D.20019>;
  <D.20021>:
  D.20007 = type->data.generic_param;
  D.20022 = cant_print_generic_param_name (D.20007);
  if (D.20022 == 0) goto <D.20023>; else goto <D.20019>;
  <D.20023>:
  D.20007 = type->data.generic_param;
  D.20011 = D.20007->owner;
  if (D.20011 != 0B) goto <D.20025>; else goto <D.20026>;
  <D.20025>:
  D.20007 = type->data.generic_param;
  iftmp.59 = &MEM[(struct MonoGenericParamFull *)D.20007].info;
  goto <D.20027>;
  <D.20026>:
  iftmp.59 = 0B;
  <D.20027>:
  D.20028 = iftmp.59->name;
  D.20029 = get_escaped_name (D.20028);
  bare = monoeg_g_strdup_printf ("!%s", D.20029);
  goto <D.20020>;
  <D.20019>:
  D.20007 = type->data.generic_param;
  D.20017 = D.20007->num;
  D.20018 = (int) D.20017;
  bare = monoeg_g_strdup_printf ("!%d", D.20018);
  <D.20020>:
  goto <D.18849>;
  <D.18862>:
  {
    struct GString * str;
    struct MonoGenericInst * inst;
    int i;
    char * generic_type;

    str = monoeg_g_string_new ("");
    D.20030 = type->data.generic_class;
    D.20031 = D.20030->container_class;
    D.20032 = &D.20031->byval_arg;
    generic_type = dis_stringify_type (m, D.20032, is_def);
    D.20030 = type->data.generic_class;
    inst = D.20030->context.class_inst;
    i = 0;
    goto <D.18869>;
    <D.18868>:
    {
      char * t;

      D.20033 = inst->type_argv[i];
      t = dis_stringify_type (m, D.20033, is_def);
      monoeg_g_string_append (str, t);
      D.20034 = i + 1;
      D.20035 = inst->type_argc;
      D.20036 = (int) D.20035;
      if (D.20034 != D.20036) goto <D.20037>; else goto <D.20038>;
      <D.20037>:
      monoeg_g_string_append (str, ", ");
      <D.20038>:
      monoeg_g_free (t);
    }
    i = i + 1;
    <D.18869>:
    D.20035 = inst->type_argc;
    D.20036 = (int) D.20035;
    if (D.20036 > i) goto <D.18868>; else goto <D.18870>;
    <D.18870>:
    D.20039 = str->str;
    bare = monoeg_g_strdup_printf ("%s<%s>", generic_type, D.20039);
    monoeg_g_string_free (str, 1);
    goto <D.18849>;
  }
  <D.18871>:
  D.19995 = type->type;
  D.19996 = (int) D.19995;
  monoeg_g_log (0B, 4, "Do not know how to stringify type 0x%x", D.19996);
  <D.18872>:
  goto <D.18872>;
  <D.18849>:
  D.19988 = BIT_FIELD_REF <*type, 8, 88>;
  D.20040 = D.19988 & 128;
  if (D.20040 != 0) goto <D.20041>; else goto <D.20042>;
  <D.20041>:
  pinned = " pinned";
  <D.20042>:
  D.19988 = BIT_FIELD_REF <*type, 8, 88>;
  D.20043 = D.19988 & 64;
  if (D.20043 != 0) goto <D.20044>; else goto <D.20045>;
  <D.20044>:
  byref = "&";
  <D.20045>:
  if (bare == 0B) goto <D.20046>; else goto <D.20047>;
  <D.20046>:
  D.20048 = bare;
  return D.20048;
  <D.20047>:
  if (mods != 0B) goto <D.20050>; else goto <D.20051>;
  <D.20050>:
  iftmp.60 = mods;
  goto <D.20052>;
  <D.20051>:
  iftmp.60 = "";
  <D.20052>:
  result = monoeg_g_strconcat (bare, byref, pinned, iftmp.60, 0B);
  monoeg_g_free (bare);
  D.20048 = result;
  return D.20048;
}


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

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


cant_print_generic_param_name (struct MonoGenericParam * gparam)
{
  _Bool D.20056;
  long int D.20057;
  long int D.20058;
  gboolean D.20061;
  int iftmp.61;
  struct GHashTable * mono_generic_params_with_ambiguous_names.62;
  void * D.20069;
  struct MonoGenericContainer * container;

  D.20056 = gparam == 0B;
  D.20057 = (long int) D.20056;
  D.20058 = __builtin_expect (D.20057, 0);
  if (D.20058 != 0) goto <D.20059>; else goto <D.20060>;
  <D.20059>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "get.c", 3166, "gparam");
  <D.20060>:
  container = gparam->owner;
  check_ambiguous_genparams (container);
  if (container == 0B) goto <D.20063>; else goto <D.20066>;
  <D.20066>:
  mono_generic_params_with_ambiguous_names.62 = mono_generic_params_with_ambiguous_names;
  if (mono_generic_params_with_ambiguous_names.62 != 0B) goto <D.20068>; else goto <D.20064>;
  <D.20068>:
  mono_generic_params_with_ambiguous_names.62 = mono_generic_params_with_ambiguous_names;
  D.20069 = monoeg_g_hash_table_lookup (mono_generic_params_with_ambiguous_names.62, gparam);
  if (D.20069 != 0B) goto <D.20063>; else goto <D.20064>;
  <D.20063>:
  iftmp.61 = 1;
  goto <D.20065>;
  <D.20064>:
  iftmp.61 = 0;
  <D.20065>:
  D.20061 = iftmp.61;
  return D.20061;
}


check_ambiguous_genparams (struct MonoGenericContainer * container)
{
  struct GHashTable * generic_containers.63;
  void * D.20076;
  struct MonoGenericParamFull * D.20079;
  long unsigned int D.20080;
  long unsigned int D.20081;
  struct MonoGenericParamInfo * iftmp.64;
  struct MonoGenericContainer * D.20083;
  const char * D.20087;
  int D.20090;
  long unsigned int D.20091;
  void * D.20092;
  struct GSList * D.20093;
  struct MonoGenericParamInfo * iftmp.65;
  const char * D.20099;
  <unnamed-signed:31> D.20100;
  int D.20101;
  struct GHashTable * mono_generic_params_with_ambiguous_names.66;
  struct GHashTable * mono_generic_params_with_ambiguous_names.67;
  void * D.20108;
  long int D.20109;
  long unsigned int D.20110;
  long unsigned int D.20111;
  sizetype D.20112;
  struct MonoGenericParamFull * D.20113;
  struct GHashTable * generic_containers.68;
  struct GSList * dup_list;
  struct GSList * l;
  struct GHashTable * table;
  void * * p;
  int i;

  dup_list = 0B;
  table = 0B;
  if (container == 0B) goto <D.20071>; else goto <D.20072>;
  <D.20071>:
  return;
  <D.20072>:
  generic_containers.63 = generic_containers;
  if (generic_containers.63 != 0B) goto <D.20074>; else goto <D.20075>;
  <D.20074>:
  generic_containers.63 = generic_containers;
  D.20076 = monoeg_g_hash_table_lookup (generic_containers.63, container);
  if (D.20076 != 0B) goto <D.20077>; else goto <D.20078>;
  <D.20077>:
  return;
  <D.20078>:
  <D.20075>:
  table = monoeg_g_hash_table_new (monoeg_g_str_hash, monoeg_g_str_equal);
  i = 0;
  goto <D.19365>;
  <D.19364>:
  {
    struct MonoGenericParam * param;

    D.20079 = container->type_params;
    D.20080 = (long unsigned int) i;
    D.20081 = D.20080 * 56;
    param = D.20079 + D.20081;
    D.20083 = param->owner;
    if (D.20083 != 0B) goto <D.20084>; else goto <D.20085>;
    <D.20084>:
    iftmp.64 = &MEM[(struct MonoGenericParamFull *)param].info;
    goto <D.20086>;
    <D.20085>:
    iftmp.64 = 0B;
    <D.20086>:
    D.20087 = iftmp.64->name;
    p = monoeg_g_hash_table_lookup (table, D.20087);
    if (p != 0B) goto <D.20088>; else goto <D.20089>;
    <D.20088>:
    D.20090 = i + 1;
    D.20091 = (long unsigned int) D.20090;
    D.20092 = (void *) D.20091;
    D.20093 = monoeg_g_slist_prepend (dup_list, D.20092);
    dup_list = monoeg_g_slist_prepend (D.20093, p);
    goto <D.20094>;
    <D.20089>:
    D.20090 = i + 1;
    D.20091 = (long unsigned int) D.20090;
    D.20092 = (void *) D.20091;
    D.20083 = param->owner;
    if (D.20083 != 0B) goto <D.20096>; else goto <D.20097>;
    <D.20096>:
    iftmp.65 = &MEM[(struct MonoGenericParamFull *)param].info;
    goto <D.20098>;
    <D.20097>:
    iftmp.65 = 0B;
    <D.20098>:
    D.20099 = iftmp.65->name;
    monoeg_g_hash_table_insert_replace (table, D.20099, D.20092, 0);
    <D.20094>:
  }
  i = i + 1;
  <D.19365>:
  D.20100 = container->type_argc;
  D.20101 = (int) D.20100;
  if (D.20101 > i) goto <D.19364>; else goto <D.19366>;
  <D.19366>:
  if (dup_list != 0B) goto <D.20102>; else goto <D.20103>;
  <D.20102>:
  mono_generic_params_with_ambiguous_names.66 = mono_generic_params_with_ambiguous_names;
  if (mono_generic_params_with_ambiguous_names.66 == 0B) goto <D.20105>; else goto <D.20106>;
  <D.20105>:
  mono_generic_params_with_ambiguous_names.67 = monoeg_g_hash_table_new (0B, 0B);
  mono_generic_params_with_ambiguous_names = mono_generic_params_with_ambiguous_names.67;
  <D.20106>:
  l = dup_list;
  goto <D.19369>;
  <D.19368>:
  {
    int param;

    D.20108 = l->data;
    D.20109 = (long int) D.20108;
    param = (int) D.20109;
    D.20079 = container->type_params;
    D.20110 = (long unsigned int) param;
    D.20111 = D.20110 * 56;
    D.20112 = D.20111 + 18446744073709551560;
    D.20113 = D.20079 + D.20112;
    D.20079 = container->type_params;
    D.20110 = (long unsigned int) param;
    D.20111 = D.20110 * 56;
    D.20112 = D.20111 + 18446744073709551560;
    D.20113 = D.20079 + D.20112;
    mono_generic_params_with_ambiguous_names.66 = mono_generic_params_with_ambiguous_names;
    monoeg_g_hash_table_insert_replace (mono_generic_params_with_ambiguous_names.66, D.20113, D.20113, 0);
  }
  l = l->next;
  <D.19369>:
  if (l != 0B) goto <D.19368>; else goto <D.19370>;
  <D.19370>:
  monoeg_g_slist_free (dup_list);
  <D.20103>:
  generic_containers.63 = generic_containers;
  if (generic_containers.63 == 0B) goto <D.20114>; else goto <D.20115>;
  <D.20114>:
  generic_containers.68 = monoeg_g_hash_table_new (0B, 0B);
  generic_containers = generic_containers.68;
  <D.20115>:
  generic_containers.63 = generic_containers;
  monoeg_g_hash_table_insert_replace (generic_containers.63, 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.69;
  char D.20119;
  const char * ptr.70;
  int show_tokens.71;
  gchar * D.20129;
  const char * ptr.72;
  char * temp.73;
  unsigned int D.20133;
  const char * ptr.74;
  char * D.20137;
  char * D.20140;
  gchar * D.20147;
  const char * D.20148;
  const char * start;
  guint32 type;
  struct MonoType * t;

  start = ptr;
  ptr.69 = ptr;
  D.20119 = *ptr.69;
  if (D.20119 == 16) goto <D.20120>; else goto <D.20121>;
  <D.20120>:
  ptr.69 = ptr;
  ptr.70 = ptr.69 + 1;
  ptr = ptr.70;
  <D.20121>:
  ptr.69 = ptr;
  type = mono_metadata_decode_value (ptr.69, &ptr);
  switch (type) <default: <D.18897>, case 17: <D.18883>, case 18: <D.18884>, case 21: <D.18889>>
  <D.18883>:
  <D.18884>:
  {
    guint32 token;
    struct MonoClass * klass;
    char * temp;

    ptr.69 = ptr;
    token = mono_metadata_parse_typedef_or_ref (m, ptr.69, &ptr);
    klass = mono_class_get (m, token);
    if (klass != 0B) goto <D.20123>; else goto <D.20124>;
    <D.20123>:
    temp = dis_stringify_object_with_class (m, klass, 1, 0);
    goto <D.20125>;
    <D.20124>:
    temp = monoeg_g_strdup_printf ("<BROKEN CLASS token_%8x>", token);
    <D.20125>:
    show_tokens.71 = show_tokens;
    if (show_tokens.71 != 0) goto <D.20127>; else goto <D.20128>;
    <D.20127>:
    D.20129 = monoeg_g_strdup_printf ("%s/*%08x*/", temp, token);
    *result = D.20129;
    monoeg_g_free (temp);
    goto <D.20130>;
    <D.20128>:
    *result = temp;
    <D.20130>:
    goto <D.18888>;
  }
  <D.18889>:
  {
    struct GString * str;
    int count;
    int i;
    char * temp;

    try
      {
        str = monoeg_g_string_new ("");
        ptr.69 = ptr;
        ptr.72 = get_type (m, ptr.69, &temp, is_def, container);
        ptr = ptr.72;
        temp.73 = temp;
        monoeg_g_string_append (str, temp.73);
        temp.73 = temp;
        monoeg_g_free (temp.73);
        ptr.69 = ptr;
        D.20133 = mono_metadata_decode_value (ptr.69, &ptr);
        count = (int) D.20133;
        monoeg_g_string_append (str, "<");
        i = 0;
        goto <D.18895>;
        <D.18894>:
        if (i != 0) goto <D.20134>; else goto <D.20135>;
        <D.20134>:
        monoeg_g_string_append (str, ",");
        <D.20135>:
        ptr.69 = ptr;
        ptr.74 = get_type (m, ptr.69, &temp, is_def, container);
        ptr = ptr.74;
        temp.73 = temp;
        monoeg_g_string_append (str, temp.73);
        i = i + 1;
        <D.18895>:
        if (i < count) goto <D.18894>; else goto <D.18896>;
        <D.18896>:
        monoeg_g_string_append (str, ">");
        D.20137 = str->str;
        *result = D.20137;
        monoeg_g_string_free (str, 0);
        goto <D.18888>;
      }
    finally
      {
        temp = {CLOBBER};
      }
  }
  <D.18897>:
  t = mono_metadata_parse_type_full (m, container, 0, 0, start, &ptr);
  if (t != 0B) goto <D.20138>; else goto <D.20139>;
  <D.20138>:
  D.20140 = dis_stringify_type (m, t, is_def);
  *result = D.20140;
  goto <D.20141>;
  <D.20139>:
  {
    struct GString * err;

    err = monoeg_g_string_new ("@!#$<InvalidType>$#!@");
    if (container != 0B) goto <D.20142>; else goto <D.20143>;
    <D.20142>:
    t = mono_metadata_parse_type_full (m, 0B, 0, 0, start, &ptr);
    <D.20143>:
    if (t != 0B) goto <D.20144>; else goto <D.20145>;
    <D.20144>:
    {
      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.20146>;
    <D.20145>:
    monoeg_g_log (0B, 16, "Encountered an invalid type");
    <D.20146>:
    D.20147 = monoeg_g_string_free (err, 0);
    *result = D.20147;
  }
  <D.20141>:
  goto <D.18888>;
  <D.18888>:
  D.20148 = ptr;
  return D.20148;
}


get_field_signature (struct MonoImage * m, guint32 blob_signature, struct MonoGenericContainer * container)
{
  const char * ptr.75;
  const char * ptr.76;
  unsigned int D.20153;
  char D.20154;
  _Bool D.20155;
  long int D.20156;
  long int D.20157;
  const char * ptr.77;
  const char * ptr.78;
  const char * ptr.79;
  const char * iftmp.80;
  char * allocated_modifier_string.81;
  char * allocated_type_string.82;
  char * D.20173;
  char * allocated_modifier_string;
  char * allocated_type_string;
  const char * ptr;
  const char * base;
  char * res;
  int len;

  try
    {
      ptr.75 = mono_metadata_blob_heap (m, blob_signature);
      ptr = ptr.75;
      ptr.76 = ptr;
      D.20153 = mono_metadata_decode_value (ptr.76, &ptr);
      len = (int) D.20153;
      base = ptr;
      ptr.76 = ptr;
      D.20154 = *ptr.76;
      D.20155 = D.20154 != 6;
      D.20156 = (long int) D.20155;
      D.20157 = __builtin_expect (D.20156, 0);
      if (D.20157 != 0) goto <D.20158>; else goto <D.20159>;
      <D.20158>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "get.c", 1361, "*ptr == 0x06");
      <D.20159>:
      ptr.76 = ptr;
      ptr.77 = ptr.76 + 1;
      ptr = ptr.77;
      len = len + -1;
      ptr.76 = ptr;
      ptr.78 = get_custom_mod (m, ptr.76, &allocated_modifier_string);
      ptr = ptr.78;
      ptr.76 = ptr;
      ptr.79 = get_type (m, ptr.76, &allocated_type_string, 0, container);
      ptr = ptr.79;
      allocated_modifier_string.81 = allocated_modifier_string;
      if (allocated_modifier_string.81 != 0B) goto <D.20165>; else goto <D.20166>;
      <D.20165>:
      iftmp.80 = allocated_modifier_string;
      goto <D.20167>;
      <D.20166>:
      iftmp.80 = "";
      <D.20167>:
      allocated_type_string.82 = allocated_type_string;
      res = monoeg_g_strdup_printf ("%s%s", allocated_type_string.82, iftmp.80);
      allocated_modifier_string.81 = allocated_modifier_string;
      if (allocated_modifier_string.81 != 0B) goto <D.20169>; else goto <D.20170>;
      <D.20169>:
      allocated_modifier_string.81 = allocated_modifier_string;
      monoeg_g_free (allocated_modifier_string.81);
      <D.20170>:
      allocated_type_string.82 = allocated_type_string;
      if (allocated_type_string.82 != 0B) goto <D.20171>; else goto <D.20172>;
      <D.20171>:
      allocated_type_string.82 = allocated_type_string;
      monoeg_g_free (allocated_type_string.82);
      <D.20172>:
      D.20173 = res;
      return D.20173;
    }
  finally
    {
      allocated_modifier_string = {CLOBBER};
      allocated_type_string = {CLOBBER};
      ptr = {CLOBBER};
    }
}


get_field_literal_type (struct MonoImage * m, guint32 blob_signature)
{
  const char * ptr.83;
  const char * ptr.84;
  unsigned int D.20178;
  char D.20179;
  _Bool D.20180;
  long int D.20181;
  long int D.20182;
  const char * ptr.85;
  const char * ptr.86;
  char * allocated_modifier_string.87;
  MonoTypeEnum D.20190;
  const char * ptr;
  int len;
  char * allocated_modifier_string;

  try
    {
      ptr.83 = mono_metadata_blob_heap (m, blob_signature);
      ptr = ptr.83;
      ptr.84 = ptr;
      D.20178 = mono_metadata_decode_value (ptr.84, &ptr);
      len = (int) D.20178;
      ptr.84 = ptr;
      D.20179 = *ptr.84;
      D.20180 = D.20179 != 6;
      D.20181 = (long int) D.20180;
      D.20182 = __builtin_expect (D.20181, 0);
      if (D.20182 != 0) goto <D.20183>; else goto <D.20184>;
      <D.20183>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "get.c", 1391, "*ptr == 0x06");
      <D.20184>:
      ptr.84 = ptr;
      ptr.85 = ptr.84 + 1;
      ptr = ptr.85;
      len = len + -1;
      ptr.84 = ptr;
      ptr.86 = get_custom_mod (m, ptr.84, &allocated_modifier_string);
      ptr = ptr.86;
      allocated_modifier_string.87 = allocated_modifier_string;
      if (allocated_modifier_string.87 != 0B) goto <D.20188>; else goto <D.20189>;
      <D.20188>:
      allocated_modifier_string.87 = allocated_modifier_string;
      monoeg_g_free (allocated_modifier_string.87);
      <D.20189>:
      ptr.84 = ptr;
      D.20179 = *ptr.84;
      D.20190 = (MonoTypeEnum) D.20179;
      return D.20190;
    }
  finally
    {
      ptr = {CLOBBER};
      allocated_modifier_string = {CLOBBER};
    }
}


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

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


get_ret_type (struct MonoImage * m, const char * ptr, char * * ret_type, struct MonoGenericContainer * container)
{
  char D.20195;
  char * allocated_type_string.88;
  char * mod.89;
  char * D.20210;
  const char * D.20211;
  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.20195 = *ptr;
      if (D.20195 == 22) goto <D.20196>; else goto <D.20197>;
      <D.20196>:
      monoeg_g_string_append (str, "typedref");
      ptr = ptr + 1;
      goto <D.20198>;
      <D.20197>:
      D.20195 = *ptr;
      if (D.20195 == 1) goto <D.20199>; else goto <D.20200>;
      <D.20199>:
      monoeg_g_string_append (str, "void");
      ptr = ptr + 1;
      goto <D.20201>;
      <D.20200>:
      D.20195 = *ptr;
      if (D.20195 == 16) goto <D.20202>; else goto <D.20203>;
      <D.20202>:
      has_byref = 1;
      ptr = ptr + 1;
      <D.20203>:
      ptr = get_type (m, ptr, &allocated_type_string, 0, container);
      allocated_type_string.88 = allocated_type_string;
      monoeg_g_string_append (str, allocated_type_string.88);
      if (has_byref != 0) goto <D.20205>; else goto <D.20206>;
      <D.20205>:
      monoeg_g_string_append (str, "& ");
      <D.20206>:
      allocated_type_string.88 = allocated_type_string;
      monoeg_g_free (allocated_type_string.88);
      <D.20201>:
      <D.20198>:
      mod.89 = mod;
      if (mod.89 != 0B) goto <D.20208>; else goto <D.20209>;
      <D.20208>:
      mod.89 = mod;
      monoeg_g_string_append (str, mod.89);
      monoeg_g_string_append_c (str, 32);
      mod.89 = mod;
      monoeg_g_free (mod.89);
      <D.20209>:
      D.20210 = str->str;
      *ret_type = D.20210;
      monoeg_g_string_free (str, 0);
      D.20211 = ptr;
      return D.20211;
    }
  finally
    {
      mod = {CLOBBER};
      allocated_type_string = {CLOBBER};
    }
}


get_param (struct MonoImage * m, const char * ptr, char * * retval, struct MonoGenericContainer * container)
{
  char D.20214;
  char * allocated_type_string.90;
  char * allocated_mod_string.91;
  char * D.20226;
  const char * D.20227;
  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.20214 = *ptr;
      if (D.20214 == 22) goto <D.20215>; else goto <D.20216>;
      <D.20215>:
      monoeg_g_string_append (str, " typedref ");
      ptr = ptr + 1;
      goto <D.20217>;
      <D.20216>:
      {
        gboolean by_ref;

        by_ref = 0;
        D.20214 = *ptr;
        if (D.20214 == 16) goto <D.20218>; else goto <D.20219>;
        <D.20218>:
        monoeg_g_string_append (str, "[out] ");
        ptr = ptr + 1;
        by_ref = 1;
        <D.20219>:
        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 (by_ref != 0) goto <D.20221>; else goto <D.20222>;
        <D.20221>:
        monoeg_g_string_append_c (str, 38);
        <D.20222>:
        allocated_type_string.90 = allocated_type_string;
        monoeg_g_free (allocated_type_string.90);
      }
      <D.20217>:
      allocated_mod_string.91 = allocated_mod_string;
      if (allocated_mod_string.91 != 0B) goto <D.20224>; else goto <D.20225>;
      <D.20224>:
      allocated_mod_string.91 = allocated_mod_string;
      monoeg_g_string_append (str, allocated_mod_string.91);
      monoeg_g_string_append_c (str, 32);
      allocated_mod_string.91 = allocated_mod_string;
      monoeg_g_free (allocated_mod_string.91);
      <D.20225>:
      D.20226 = str->str;
      *retval = D.20226;
      monoeg_g_string_free (str, 0);
      D.20227 = ptr;
      return D.20227;
    }
  finally
    {
      allocated_mod_string = {CLOBBER};
      allocated_type_string = {CLOBBER};
    }
}


get_escaped_name (const char * name)
{
  char * D.20232;
  struct GHashTable * key_table.92;
  _Bool D.20234;
  long int D.20235;
  long int D.20236;
  char D.20239;
  char D.20242;
  long int s.93;
  long int name.94;
  long int D.20247;
  long unsigned int D.20248;
  const char * D.20249;
  char * D.20250;
  char * D.20251;
  const short unsigned int * * D.20255;
  const short unsigned int * D.20256;
  long unsigned int D.20257;
  long unsigned int D.20258;
  const short unsigned int * D.20259;
  short unsigned int D.20260;
  int D.20261;
  int D.20262;
  void * D.20271;
  const char * s;
  char * ret;
  char * esc;

  if (name == 0B) goto <D.20230>; else goto <D.20231>;
  <D.20230>:
  D.20232 = 0B;
  return D.20232;
  <D.20231>:
  key_table.92 = key_table;
  D.20234 = key_table.92 == 0B;
  D.20235 = (long int) D.20234;
  D.20236 = __builtin_expect (D.20235, 0);
  if (D.20236 != 0) goto <D.20237>; else goto <D.20238>;
  <D.20237>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "get.c", 1557, "key_table");
  <D.20238>:
  D.20239 = *name;
  if (D.20239 == 0) goto <D.20240>; else goto <D.20241>;
  <D.20240>:
  D.20232 = monoeg_strdup (name);
  return D.20232;
  <D.20241>:
  s = name;
  goto <D.18963>;
  <D.18962>:
  {
    char * first;
    char * result;

    D.20242 = *s;
    if (D.20242 != 47) goto <D.20243>; else goto <D.20244>;
    <D.20243>:
    // predicted unlikely by continue predictor.
    goto <D.18961>;
    <D.20244>:
    s.93 = (long int) s;
    name.94 = (long int) name;
    D.20247 = s.93 - name.94;
    D.20248 = (long unsigned int) D.20247;
    first = monoeg_g_strndup (name, D.20248);
    D.20249 = s + 1;
    D.20250 = get_escaped_name (D.20249);
    D.20251 = get_escaped_name (first);
    result = monoeg_g_strdup_printf ("%s/%s", D.20251, D.20250);
    monoeg_g_free (first);
    D.20232 = result;
    return D.20232;
  }
  <D.18961>:
  s = s + 1;
  <D.18963>:
  D.20242 = *s;
  if (D.20242 != 0) goto <D.18962>; else goto <D.18964>;
  <D.18964>:
  s = name;
  goto <D.18967>;
  <D.18966>:
  D.20255 = __ctype_b_loc ();
  D.20256 = *D.20255;
  D.20242 = *s;
  D.20257 = (long unsigned int) D.20242;
  D.20258 = D.20257 * 2;
  D.20259 = D.20256 + D.20258;
  D.20260 = *D.20259;
  D.20261 = (int) D.20260;
  D.20262 = D.20261 & 8;
  if (D.20262 != 0) goto <D.20252>; else goto <D.20263>;
  <D.20263>:
  D.20242 = *s;
  if (D.20242 == 95) goto <D.20252>; else goto <D.20264>;
  <D.20264>:
  D.20242 = *s;
  if (D.20242 == 36) goto <D.20252>; else goto <D.20265>;
  <D.20265>:
  D.20242 = *s;
  if (D.20242 == 64) goto <D.20252>; else goto <D.20266>;
  <D.20266>:
  D.20242 = *s;
  if (D.20242 == 63) goto <D.20252>; else goto <D.20267>;
  <D.20267>:
  D.20242 = *s;
  if (D.20242 == 46) goto <D.20268>; else goto <D.20253>;
  <D.20268>:
  if (s != name) goto <D.20252>; else goto <D.20253>;
  <D.20253>:
  D.20242 = *s;
  if (D.20242 == 0) goto <D.20252>; else goto <D.20269>;
  <D.20269>:
  D.20242 = *s;
  if (D.20242 == 33) goto <D.20252>; else goto <D.20270>;
  <D.20270>:
  D.20242 = *s;
  if (D.20242 == 96) goto <D.20252>; else goto <D.20254>;
  <D.20252>:
  // predicted unlikely by continue predictor.
  goto <D.18965>;
  <D.20254>:
  esc = str_escape (name, "\'\\");
  ret = monoeg_g_strdup_printf ("\'%s\'", esc);
  monoeg_g_free (esc);
  D.20232 = ret;
  return D.20232;
  <D.18965>:
  s = s + 1;
  <D.18967>:
  D.20242 = *s;
  if (D.20242 != 0) goto <D.18966>; else goto <D.18968>;
  <D.18968>:
  key_table.92 = key_table;
  D.20271 = monoeg_g_hash_table_lookup (key_table.92, name);
  if (D.20271 != 0B) goto <D.20272>; else goto <D.20273>;
  <D.20272>:
  D.20232 = monoeg_g_strdup_printf ("\'%s\'", name);
  return D.20232;
  <D.20273>:
  D.20232 = str_escape (name, "\'\\");
  return D.20232;
}


str_escape (const char * str, const char * list)
{
  long unsigned int D.20275;
  char D.20276;
  int D.20279;
  int D.20280;
  void * D.20283;
  char * D.20284;
  long int p.95;
  long int str.96;
  long int D.20287;
  char * D.20289;
  const char * p;
  struct GString * res;

  p = str;
  D.20275 = strlen (str);
  res = monoeg_g_string_sized_new (D.20275);
  <D.18952>:
  goto <D.18949>;
  <D.18948>:
  p = p + 1;
  <D.18949>:
  D.20276 = *p;
  if (D.20276 != 0) goto <D.20277>; else goto <D.18950>;
  <D.20277>:
  D.20276 = *p;
  D.20279 = (int) D.20276;
  D.20280 = __builtin_constant_p (D.20279);
  if (D.20280 != 0) goto <D.20281>; else goto <D.20278>;
  <D.20281>:
  D.20276 = *p;
  if (D.20276 == 0) goto <D.20282>; else goto <D.20278>;
  <D.20282>:
  D.20276 = *p;
  D.20279 = (int) D.20276;
  D.20283 = __rawmemchr (list, D.20279);
  if (D.20283 == 0B) goto <D.18948>; else goto <D.18950>;
  <D.20278>:
  D.20276 = *p;
  D.20279 = (int) D.20276;
  D.20284 = __builtin_strchr (list, D.20279);
  if (D.20284 == 0B) goto <D.18948>; else goto <D.18950>;
  <D.18950>:
  p.95 = (long int) p;
  str.96 = (long int) str;
  D.20287 = p.95 - str.96;
  monoeg_g_string_append_len (res, str, D.20287);
  D.20276 = *p;
  if (D.20276 == 0) goto <D.18951>; else goto <D.20288>;
  <D.20288>:
  monoeg_g_string_append_c (res, 92);
  str = p;
  p = p + 1;
  goto <D.18952>;
  <D.18951>:
  D.20289 = monoeg_g_string_free (res, 0);
  return D.20289;
}


param_flags (guint32 f)
{
  char * D.20291;
  const char * D.20292;

  D.20292 = flags (f, &param_map);
  D.20291 = monoeg_strdup (D.20292);
  return D.20291;
}


field_flags (guint32 f)
{
  int f.97;
  int D.20295;
  unsigned int D.20296;
  unsigned int D.20297;
  unsigned int access.98;
  const char * D.20299;
  unsigned int rest.99;
  const char * D.20301;
  char * D.20302;
  char buffer[1024];
  int access;
  int rest;

  try
    {
      f.97 = (int) f;
      access = f.97 & 7;
      D.20295 = ~access;
      D.20296 = (unsigned int) D.20295;
      D.20297 = D.20296 & f;
      rest = (int) D.20297;
      buffer[0] = 0;
      access.98 = (unsigned int) access;
      D.20299 = map (access.98, &field_access_map);
      strcat (&buffer, D.20299);
      rest.99 = (unsigned int) rest;
      D.20301 = flags (rest.99, &field_flags_map);
      strcat (&buffer, D.20301);
      D.20302 = monoeg_strdup (&buffer);
      return D.20302;
    }
  finally
    {
      buffer = {CLOBBER};
    }
}


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

  D.20306 = __builtin_object_size (__dest, 1);
  D.20305 = __builtin___strcat_chk (__dest, __src, D.20306);
  return D.20305;
}


get_methodref_signature (struct MonoImage * m, guint32 blob_signature, const char * fancy_name)
{
  const char * ptr.100;
  const char * ptr.101;
  unsigned int D.20310;
  char D.20311;
  int D.20312;
  int D.20313;
  int D.20316;
  int D.20320;
  unsigned int cconv.102;
  int D.19005;
  int iftmp.103;
  int D.19004;
  const char[8] * D.20327;
  unsigned char D.20328;
  int D.20329;
  unsigned char D.20330;
  int D.20331;
  _Bool D.20332;
  _Bool D.20333;
  _Bool D.20334;
  const unsigned char * D.20337;
  unsigned char D.20338;
  int D.20339;
  const unsigned char * D.20340;
  unsigned char D.20341;
  int D.20342;
  _Bool D.20343;
  _Bool D.20344;
  const unsigned char * D.20347;
  unsigned char D.20348;
  int D.20349;
  const unsigned char * D.20350;
  unsigned char D.20351;
  int D.20352;
  _Bool D.20353;
  _Bool D.20354;
  const unsigned char * D.20357;
  unsigned char D.20358;
  int D.20359;
  const unsigned char * D.20360;
  unsigned char D.20361;
  int D.20362;
  const char * ptr.104;
  unsigned int D.20369;
  unsigned int D.20370;
  const char * ptr.105;
  char * allocated_ret_type.106;
  const char * ptr.107;
  char * param.108;
  int D.20383;
  char * D.20386;
  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.100 = mono_metadata_blob_heap (m, blob_signature);
      ptr = ptr.100;
      seen_vararg = 0;
      gen_count = 0;
      ptr.101 = ptr;
      D.20310 = mono_metadata_decode_value (ptr.101, &ptr);
      signature_len = (int) D.20310;
      ptr.101 = ptr;
      D.20311 = *ptr.101;
      D.20312 = (int) D.20311;
      D.20313 = D.20312 & 32;
      if (D.20313 != 0) goto <D.20314>; else goto <D.20315>;
      <D.20314>:
      ptr.101 = ptr;
      D.20311 = *ptr.101;
      D.20312 = (int) D.20311;
      D.20316 = D.20312 & 64;
      if (D.20316 != 0) goto <D.20317>; else goto <D.20318>;
      <D.20317>:
      monoeg_g_string_append (res, "explicit-this ");
      goto <D.20319>;
      <D.20318>:
      monoeg_g_string_append (res, "instance ");
      <D.20319>:
      <D.20315>:
      ptr.101 = ptr;
      D.20311 = *ptr.101;
      D.20312 = (int) D.20311;
      D.20320 = D.20312 & 16;
      if (D.20320 != 0) goto <D.20321>; else goto <D.20322>;
      <D.20321>:
      gen_count = 1;
      <D.20322>:
      ptr.101 = ptr;
      D.20311 = *ptr.101;
      D.20312 = (int) D.20311;
      cconv = D.20312 & 15;
      cconv.102 = (unsigned int) cconv;
      cconv_str = map (cconv.102, &call_conv_type_map);
      {
        size_t __s1_len;
        size_t __s2_len;

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

          __s2 = cconv_str;
          D.20327 = "default";
          D.20328 = MEM[(const unsigned char *)D.20327];
          D.20329 = (int) D.20328;
          D.20330 = *__s2;
          D.20331 = (int) D.20330;
          __result = D.20329 - D.20331;
          {
            D.20332 = __s2_len != 0;
            D.20333 = __result == 0;
            D.20334 = D.20332 & D.20333;
            if (D.20334 != 0) goto <D.20335>; else goto <D.20336>;
            <D.20335>:
            D.20337 = &MEM[(void *)"default" + 1B];
            D.20338 = *D.20337;
            D.20339 = (int) D.20338;
            D.20340 = __s2 + 1;
            D.20341 = *D.20340;
            D.20342 = (int) D.20341;
            __result = D.20339 - D.20342;
            D.20343 = __s2_len > 1;
            D.20333 = __result == 0;
            D.20344 = D.20343 & D.20333;
            if (D.20344 != 0) goto <D.20345>; else goto <D.20346>;
            <D.20345>:
            D.20347 = &MEM[(void *)"default" + 2B];
            D.20348 = *D.20347;
            D.20349 = (int) D.20348;
            D.20350 = __s2 + 2;
            D.20351 = *D.20350;
            D.20352 = (int) D.20351;
            __result = D.20349 - D.20352;
            D.20353 = __s2_len > 2;
            D.20333 = __result == 0;
            D.20354 = D.20353 & D.20333;
            if (D.20354 != 0) goto <D.20355>; else goto <D.20356>;
            <D.20355>:
            D.20357 = &MEM[(void *)"default" + 3B];
            D.20358 = *D.20357;
            D.20359 = (int) D.20358;
            D.20360 = __s2 + 3;
            D.20361 = *D.20360;
            D.20362 = (int) D.20361;
            __result = D.20359 - D.20362;
            <D.20356>:
            <D.20346>:
            <D.20336>:
          }
          D.19004 = __result;
        }
        iftmp.103 = -D.19004;
        goto <D.20363>;
        <D.20326>:
        iftmp.103 = __builtin_strcmp (cconv_str, "default");
        <D.20363>:
        D.19005 = iftmp.103;
      }
      if (D.19005 != 0) goto <D.20364>; else goto <D.20365>;
      <D.20364>:
      monoeg_g_string_append (res, cconv_str);
      monoeg_g_string_append (res, " ");
      <D.20365>:
      ptr.101 = ptr;
      ptr.104 = ptr.101 + 1;
      ptr = ptr.104;
      if (gen_count != 0) goto <D.20367>; else goto <D.20368>;
      <D.20367>:
      ptr.101 = ptr;
      D.20369 = mono_metadata_decode_value (ptr.101, &ptr);
      gen_count = (int) D.20369;
      <D.20368>:
      ptr.101 = ptr;
      D.20370 = mono_metadata_decode_value (ptr.101, &ptr);
      param_count = (int) D.20370;
      if (cconv != 10) goto <D.20371>; else goto <D.20372>;
      <D.20371>:
      ptr.101 = ptr;
      ptr.105 = get_ret_type (m, ptr.101, &allocated_ret_type, 0B);
      ptr = ptr.105;
      allocated_ret_type.106 = allocated_ret_type;
      monoeg_g_string_append (res, allocated_ret_type.106);
      allocated_ret_type.106 = allocated_ret_type;
      monoeg_g_free (allocated_ret_type.106);
      <D.20372>:
      if (fancy_name != 0B) goto <D.20375>; else goto <D.20376>;
      <D.20375>:
      monoeg_g_string_append_c (res, 32);
      monoeg_g_string_append (res, fancy_name);
      <D.20376>:
      monoeg_g_string_append (res, "(");
      i = 0;
      goto <D.19008>;
      <D.19007>:
      {
        char * param;

        try
          {
            param = 0B;
            ptr.101 = ptr;
            D.20311 = *ptr.101;
            if (D.20311 == 65) goto <D.20377>; else goto <D.20378>;
            <D.20377>:
            if (seen_vararg == 0) goto <D.20379>; else goto <D.20380>;
            <D.20379>:
            monoeg_g_string_append (res, "..., ");
            seen_vararg = 1;
            <D.20380>:
            ptr.101 = ptr;
            ptr.104 = ptr.101 + 1;
            ptr = ptr.104;
            <D.20378>:
            ptr.101 = ptr;
            ptr.107 = get_param (m, ptr.101, &param, 0B);
            ptr = ptr.107;
            param.108 = param;
            monoeg_g_string_append (res, param.108);
            D.20383 = i + 1;
            if (D.20383 != param_count) goto <D.20384>; else goto <D.20385>;
            <D.20384>:
            monoeg_g_string_append (res, ", ");
            <D.20385>:
            param.108 = param;
            monoeg_g_free (param.108);
          }
        finally
          {
            param = {CLOBBER};
          }
      }
      i = i + 1;
      <D.19008>:
      if (i < param_count) goto <D.19007>; else goto <D.19009>;
      <D.19009>:
      monoeg_g_string_append (res, ")");
      s = res->str;
      monoeg_g_string_free (res, 0);
      D.20386 = s;
      return D.20386;
    }
  finally
    {
      ptr = {CLOBBER};
      allocated_ret_type = {CLOBBER};
    }
}


get_fieldref_signature (struct MonoImage * m, int idx, struct MonoGenericContainer * container)
{
  int D.20389;
  struct MonoTableInfo * D.20390;
  unsigned int D.20391;
  unsigned int D.20392;
  unsigned int D.20393;
  const char * D.20394;
  const char * iftmp.109;
  const char * iftmp.110;
  char * D.20403;
  guint32 cols[3];
  struct MonoGenericContainer * new_container;
  char * type;
  char * esname;
  char * sig;
  char * full_sig;

  try
    {
      D.20389 = idx + -1;
      D.20390 = &m->tables[10];
      mono_metadata_decode_row (D.20390, D.20389, &cols, 3);
      D.20391 = cols[0];
      new_container = get_memberref_container (m, D.20391, container);
      D.20392 = cols[2];
      sig = get_field_signature (m, D.20392, new_container);
      D.20391 = cols[0];
      type = get_memberref_parent (m, D.20391, container);
      D.20393 = cols[1];
      D.20394 = mono_metadata_string_heap (m, D.20393);
      esname = get_escaped_name (D.20394);
      if (type != 0B) goto <D.20396>; else goto <D.20397>;
      <D.20396>:
      iftmp.109 = "::";
      goto <D.20398>;
      <D.20397>:
      iftmp.109 = "";
      <D.20398>:
      if (type != 0B) goto <D.20400>; else goto <D.20401>;
      <D.20400>:
      iftmp.110 = type;
      goto <D.20402>;
      <D.20401>:
      iftmp.110 = "";
      <D.20402>:
      full_sig = monoeg_g_strdup_printf ("%s %s%s%s", sig, iftmp.110, iftmp.109, esname);
      monoeg_g_free (sig);
      monoeg_g_free (type);
      monoeg_g_free (esname);
      D.20403 = full_sig;
      return D.20403;
    }
  finally
    {
      cols = {CLOBBER};
    }
}


get_memberref_container (struct MonoImage * m, guint32 mrp_token, struct MonoGenericContainer * container)
{
  struct MonoGenericContainer * D.20406;
  unsigned int D.20407;
  unsigned int D.20408;
  _Bool D.20409;
  long int D.20410;
  long int D.20411;
  struct MonoGenericContainer * iftmp.111;
  struct MonoGenericClass * D.20415;
  struct MonoClass * D.20418;
  struct MonoClass * klass;
  guint32 table;
  guint32 idx;

  table = mrp_token & 7;
  idx = mrp_token >> 3;
  switch (table) <default: <D.20420>, case 0: <D.19042>, case 1: <D.19043>, case 4: <D.19044>>
  <D.19042>:
  D.20407 = idx | 33554432;
  D.20406 = mono_metadata_load_generic_params (m, D.20407, 0B);
  return D.20406;
  <D.19043>:
  D.20406 = 0B;
  return D.20406;
  <D.19044>:
  D.20408 = idx | 452984832;
  klass = mono_class_get_full (m, D.20408, container);
  D.20409 = klass == 0B;
  D.20410 = (long int) D.20409;
  D.20411 = __builtin_expect (D.20410, 0);
  if (D.20411 != 0) goto <D.20412>; else goto <D.20413>;
  <D.20412>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "get.c", 1852, "klass");
  <D.20413>:
  D.20415 = klass->generic_class;
  if (D.20415 != 0B) goto <D.20416>; else goto <D.20417>;
  <D.20416>:
  D.20415 = klass->generic_class;
  D.20418 = D.20415->container_class;
  iftmp.111 = D.20418->generic_container;
  goto <D.20419>;
  <D.20417>:
  iftmp.111 = 0B;
  <D.20419>:
  D.20406 = iftmp.111;
  return D.20406;
  <D.20420>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "get.c", 1855);
  D.20406 = 0B;
  return D.20406;
}


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

  table = mrp_token & 7;
  idx = mrp_token >> 3;
  switch (table) <default: <D.20424>, case 0: <D.19052>, case 1: <D.19053>, case 2: <D.19054>, case 3: <D.19055>, case 4: <D.19056>>
  <D.19052>:
  idx.112 = (int) idx;
  D.20422 = get_typedef (m, idx.112);
  return D.20422;
  <D.19053>:
  idx.112 = (int) idx;
  D.20422 = get_typeref (m, idx.112);
  return D.20422;
  <D.19054>:
  D.20422 = monoeg_g_strdup_printf ("TODO:MemberRefParent-ModuleRef");
  return D.20422;
  <D.19055>:
  D.20422 = monoeg_strdup ("TODO:MethodDef");
  return D.20422;
  <D.19056>:
  D.20422 = get_typespec (m, idx, 0, container);
  return D.20422;
  <D.20424>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "get.c", 1884);
  D.20422 = 0B;
  return D.20422;
}


get_field (struct MonoImage * m, guint32 token, struct MonoGenericContainer * container)
{
  int token.113;
  unsigned int D.20427;
  char * D.20430;
  _Bool D.20431;
  long int D.20432;
  long int D.20433;
  int D.20436;
  struct MonoTableInfo * D.20437;
  unsigned int D.20438;
  unsigned int idx.114;
  int type_idx.115;
  unsigned int D.20443;
  const char * D.20444;
  const char * iftmp.116;
  const char * iftmp.117;
  int idx;
  guint32 cols[3];
  char * sig;
  char * res;
  char * type;
  char * estype;
  char * esname;
  guint32 type_idx;

  try
    {
      token.113 = (int) token;
      idx = token.113 & 16777215;
      D.20427 = token & 4278190080;
      if (D.20427 == 167772160) goto <D.20428>; else goto <D.20429>;
      <D.20428>:
      D.20430 = get_fieldref_signature (m, idx, container);
      return D.20430;
      <D.20429>:
      D.20427 = token & 4278190080;
      D.20431 = D.20427 != 67108864;
      D.20432 = (long int) D.20431;
      D.20433 = __builtin_expect (D.20432, 0);
      if (D.20433 != 0) goto <D.20434>; else goto <D.20435>;
      <D.20434>:
      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.20435>:
      D.20436 = idx + -1;
      D.20437 = &m->tables[4];
      mono_metadata_decode_row (D.20437, D.20436, &cols, 3);
      D.20438 = cols[2];
      sig = get_field_signature (m, D.20438, container);
      idx.114 = (unsigned int) idx;
      type_idx = mono_metadata_typedef_from_field (m, idx.114);
      if (type_idx == 0) goto <D.20440>; else goto <D.20441>;
      <D.20440>:
      res = monoeg_g_strdup_printf ("<invalid> %s", sig);
      monoeg_g_free (sig);
      D.20430 = res;
      return D.20430;
      <D.20441>:
      type_idx.115 = (int) type_idx;
      type = get_typedef (m, type_idx.115);
      estype = get_escaped_name (type);
      D.20443 = cols[1];
      D.20444 = mono_metadata_string_heap (m, D.20443);
      esname = get_escaped_name (D.20444);
      if (estype != 0B) goto <D.20446>; else goto <D.20447>;
      <D.20446>:
      iftmp.116 = "::";
      goto <D.20448>;
      <D.20447>:
      iftmp.116 = "";
      <D.20448>:
      if (estype != 0B) goto <D.20450>; else goto <D.20451>;
      <D.20450>:
      iftmp.117 = estype;
      goto <D.20452>;
      <D.20451>:
      iftmp.117 = "";
      <D.20452>:
      res = monoeg_g_strdup_printf ("%s %s%s%s", sig, iftmp.117, iftmp.116, esname);
      monoeg_g_free (type);
      monoeg_g_free (sig);
      monoeg_g_free (estype);
      monoeg_g_free (esname);
      D.20430 = res;
      return D.20430;
    }
  finally
    {
      cols = {CLOBBER};
    }
}


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

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


get_method_core (struct MonoImage * m, guint32 token, gboolean fullsig, struct MonoGenericContainer * container)
{
  int token.118;
  struct MonoMethodSignature * D.20460;
  unsigned char D.20461;
  unsigned char D.20462;
  struct MonoMethod * D.20465;
  const char * D.20466;
  struct MonoClass * D.20467;
  struct MonoType * D.20468;
  int show_tokens.119;
  const char * iftmp.120;
  const char * iftmp.121;
  const char * iftmp.122;
  const char * iftmp.123;
  unsigned int D.20490;
  int D.20491;
  struct MonoTableInfo * D.20492;
  unsigned int D.20493;
  struct MonoTableInfo * D.20494;
  unsigned int D.20497;
  unsigned int D.20498;
  const char * D.20499;
  const char * iftmp.124;
  const char * iftmp.125;
  unsigned char D.20510;
  unsigned char D.20511;
  struct MonoGenericContainer * D.20514;
  <unnamed-signed:31> D.20515;
  unsigned char D.20517;
  unsigned char D.20520;
  unsigned char D.20521;
  struct MonoGenericContainer * D.20524;
  <unnamed-signed:31> D.20525;
  unsigned int D.20528;
  struct MonoTableInfo * D.20529;
  char * D.20533;
  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.118 = (int) token;
      idx = token.118 & 16777215;
      sig = 0B;
      type_container = container;
      mh = mono_get_method_full (m, token, 0B, container);
      if (mh != 0B) goto <D.20458>; else goto <D.20459>;
      <D.20458>:
      D.20460 = mono_method_signature (mh);
      D.20461 = BIT_FIELD_REF <*D.20460, 8, 120>;
      D.20462 = D.20461 & 2;
      if (D.20462 != 0) goto <D.20463>; else goto <D.20464>;
      <D.20463>:
      D.20465 = MEM[(struct MonoMethodInflated *)mh].declaring;
      container = mono_method_get_generic_container (D.20465);
      <D.20464>:
      D.20466 = mh->name;
      esname = get_escaped_name (D.20466);
      D.20467 = mh->klass;
      D.20468 = &D.20467->byval_arg;
      sig = dis_stringify_type (m, D.20468, 1);
      show_tokens.119 = show_tokens;
      if (show_tokens.119 != 0) goto <D.20470>; else goto <D.20471>;
      <D.20470>:
      if (sig != 0B) goto <D.20473>; else goto <D.20474>;
      <D.20473>:
      iftmp.120 = "::";
      goto <D.20475>;
      <D.20474>:
      iftmp.120 = "";
      <D.20475>:
      if (sig != 0B) goto <D.20477>; else goto <D.20478>;
      <D.20477>:
      iftmp.121 = sig;
      goto <D.20479>;
      <D.20478>:
      iftmp.121 = "";
      <D.20479>:
      name = monoeg_g_strdup_printf ("%s/*%08x*/%s%s", iftmp.121, token, iftmp.120, esname);
      goto <D.20480>;
      <D.20471>:
      if (sig != 0B) goto <D.20482>; else goto <D.20483>;
      <D.20482>:
      iftmp.122 = "::";
      goto <D.20484>;
      <D.20483>:
      iftmp.122 = "";
      <D.20484>:
      if (sig != 0B) goto <D.20486>; else goto <D.20487>;
      <D.20486>:
      iftmp.123 = sig;
      goto <D.20488>;
      <D.20487>:
      iftmp.123 = "";
      <D.20488>:
      name = monoeg_g_strdup_printf ("%s%s%s", iftmp.123, iftmp.122, esname);
      <D.20480>:
      monoeg_g_free (sig);
      monoeg_g_free (esname);
      goto <D.20489>;
      <D.20459>:
      name = 0B;
      <D.20489>:
      D.20490 = token & 4278190080;
      switch (D.20490) <default: <D.19078>, case 100663296: <D.19071>, case 167772160: <D.19073>, case 721420288: <D.19077>>
      <D.19071>:
      D.20491 = idx + -1;
      D.20492 = &m->tables[6];
      mono_metadata_decode_row (D.20492, D.20491, &method_cols, 6);
      D.20493 = method_cols[4];
      sig = get_methodref_signature (m, D.20493, name);
      goto <D.19072>;
      <D.19073>:
      D.20491 = idx + -1;
      D.20494 = &m->tables[10];
      mono_metadata_decode_row (D.20494, D.20491, &member_cols, 3);
      if (name == 0B) goto <D.20495>; else goto <D.20496>;
      <D.20495>:
      {
        char * parent;

        D.20497 = member_cols[0];
        parent = get_memberref_parent (m, D.20497, container);
        D.20498 = member_cols[1];
        D.20499 = mono_metadata_string_heap (m, D.20498);
        if (parent != 0B) goto <D.20501>; else goto <D.20502>;
        <D.20501>:
        iftmp.124 = "::";
        goto <D.20503>;
        <D.20502>:
        iftmp.124 = "";
        <D.20503>:
        if (parent != 0B) goto <D.20505>; else goto <D.20506>;
        <D.20505>:
        iftmp.125 = parent;
        goto <D.20507>;
        <D.20506>:
        iftmp.125 = "";
        <D.20507>:
        name = monoeg_g_strdup_printf ("%s%s%s", iftmp.125, iftmp.124, D.20499);
        monoeg_g_free (parent);
      }
      <D.20496>:
      if (mh != 0B) goto <D.20508>; else goto <D.20509>;
      <D.20508>:
      {
        int arity;

        arity = 0;
        D.20510 = BIT_FIELD_REF <*mh, 8, 264>;
        D.20511 = D.20510 & 8;
        if (D.20511 != 0) goto <D.20512>; else goto <D.20513>;
        <D.20512>:
        D.20514 = mono_method_get_generic_container (mh);
        D.20515 = D.20514->type_argc;
        arity = (int) D.20515;
        goto <D.20516>;
        <D.20513>:
        D.20510 = BIT_FIELD_REF <*mh, 8, 264>;
        D.20517 = D.20510 & 16;
        if (D.20517 != 0) goto <D.20518>; else goto <D.20519>;
        <D.20518>:
        D.20465 = MEM[(struct MonoMethodInflated *)mh].declaring;
        D.20520 = BIT_FIELD_REF <*D.20465, 8, 264>;
        D.20521 = D.20520 & 8;
        if (D.20521 != 0) goto <D.20522>; else goto <D.20523>;
        <D.20522>:
        D.20465 = MEM[(struct MonoMethodInflated *)mh].declaring;
        D.20524 = mono_method_get_generic_container (D.20465);
        D.20525 = D.20524->type_argc;
        arity = (int) D.20525;
        <D.20523>:
        <D.20519>:
        <D.20516>:
        if (arity > 0) goto <D.20526>; else goto <D.20527>;
        <D.20526>:
        {
          char * str;

          str = monoeg_g_strdup_printf ("%s <[%d]>", name, arity);
          monoeg_g_free (name);
          name = str;
        }
        <D.20527>:
      }
      <D.20509>:
      D.20528 = member_cols[2];
      sig = get_methodref_signature (m, D.20528, name);
      goto <D.19072>;
      <D.19077>:
      D.20491 = idx + -1;
      D.20529 = &m->tables[43];
      mono_metadata_decode_row (D.20529, D.20491, &member_cols, 2);
      token = member_cols[0];
      sig = get_methodspec (m, idx, token, name, type_container);
      goto <D.19072>;
      <D.19078>:
      monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "get.c", 1971);
      <D.19072>:
      if (fullsig != 0) goto <D.20530>; else goto <D.20531>;
      <D.20530>:
      monoeg_g_free (name);
      goto <D.20532>;
      <D.20531>:
      monoeg_g_free (sig);
      D.20533 = name;
      return D.20533;
      <D.20532>:
      show_tokens.119 = show_tokens;
      if (show_tokens.119 != 0) goto <D.20534>; else goto <D.20535>;
      <D.20534>:
      {
        char * retval;

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


get_methoddef (struct MonoImage * m, guint32 idx)
{
  unsigned int D.20538;
  struct MonoClass * D.20541;
  struct MonoType * D.20542;
  const char * D.20543;
  const char * iftmp.126;
  const char * iftmp.127;
  unsigned int D.20553;
  int D.20554;
  struct MonoTableInfo * D.20555;
  unsigned int D.20556;
  char * D.20557;
  guint32 cols[6];
  char * sig;
  const char * name;
  struct MonoMethod * mh;

  try
    {
      D.20538 = idx | 100663296;
      mh = mono_get_method (m, D.20538, 0B);
      if (mh != 0B) goto <D.20539>; else goto <D.20540>;
      <D.20539>:
      D.20541 = mh->klass;
      D.20542 = &D.20541->byval_arg;
      sig = dis_stringify_type (m, D.20542, 0);
      D.20543 = mh->name;
      if (sig != 0B) goto <D.20545>; else goto <D.20546>;
      <D.20545>:
      iftmp.126 = "::";
      goto <D.20547>;
      <D.20546>:
      iftmp.126 = "";
      <D.20547>:
      if (sig != 0B) goto <D.20549>; else goto <D.20550>;
      <D.20549>:
      iftmp.127 = sig;
      goto <D.20551>;
      <D.20550>:
      iftmp.127 = "";
      <D.20551>:
      name = monoeg_g_strdup_printf ("%s%s%s", iftmp.127, iftmp.126, D.20543);
      monoeg_g_free (sig);
      goto <D.20552>;
      <D.20540>:
      name = 0B;
      <D.20552>:
      D.20553 = idx + 4294967295;
      D.20554 = (int) D.20553;
      D.20555 = &m->tables[6];
      mono_metadata_decode_row (D.20555, D.20554, &cols, 6);
      D.20556 = cols[4];
      sig = get_methodref_signature (m, D.20556, name);
      D.20557 = sig;
      return D.20557;
    }
  finally
    {
      cols = {CLOBBER};
    }
}


get_method_type_param (struct MonoImage * m, guint32 blob_signature, struct MonoGenericContainer * container)
{
  const char * ptr.128;
  const char * ptr.129;
  const char * ptr.130;
  unsigned int D.20563;
  const char * ptr.131;
  char * param.132;
  int D.20566;
  char * D.20569;
  struct GString * res;
  const char * ptr;
  int param_count;
  int i;
  char * s;

  try
    {
      res = monoeg_g_string_new ("");
      ptr.128 = mono_metadata_blob_heap (m, blob_signature);
      ptr = ptr.128;
      i = 0;
      ptr.129 = ptr;
      mono_metadata_decode_value (ptr.129, &ptr);
      ptr.129 = ptr;
      ptr.130 = ptr.129 + 1;
      ptr = ptr.130;
      ptr.129 = ptr;
      D.20563 = mono_metadata_decode_value (ptr.129, &ptr);
      param_count = (int) D.20563;
      monoeg_g_string_append_c (res, 60);
      i = 0;
      goto <D.19105>;
      <D.19104>:
      {
        char * param;

        try
          {
            param = 0B;
            ptr.129 = ptr;
            ptr.131 = get_param (m, ptr.129, &param, container);
            ptr = ptr.131;
            param.132 = param;
            monoeg_g_string_append (res, param.132);
            D.20566 = i + 1;
            if (D.20566 != param_count) goto <D.20567>; else goto <D.20568>;
            <D.20567>:
            monoeg_g_string_append (res, ", ");
            <D.20568>:
            param.132 = param;
            monoeg_g_free (param.132);
          }
        finally
          {
            param = {CLOBBER};
          }
      }
      i = i + 1;
      <D.19105>:
      if (i < param_count) goto <D.19104>; else goto <D.19106>;
      <D.19106>:
      monoeg_g_string_append_c (res, 62);
      s = res->str;
      monoeg_g_string_free (res, 0);
      D.20569 = s;
      return D.20569;
    }
  finally
    {
      ptr = {CLOBBER};
    }
}


get_methodspec (struct MonoImage * m, int idx, guint32 token, const char * fancy_name, struct MonoGenericContainer * type_container)
{
  unsigned int D.20572;
  unsigned int D.20573;
  unsigned int D.20574;
  int D.20575;
  struct MonoTableInfo * D.20576;
  struct MonoTableInfo * D.20577;
  const char * ptr.133;
  const char * ptr.134;
  unsigned int D.20580;
  _Bool D.20581;
  long int D.20582;
  long int D.20583;
  char D.20588;
  int D.20589;
  int D.20590;
  int D.20593;
  int D.20597;
  const char * ptr.135;
  unsigned int D.20603;
  unsigned int D.20604;
  const char * ptr.136;
  char * allocated_ret_type.137;
  int D.20611;
  struct MonoTableInfo * D.20612;
  const char * ptr.138;
  char * param.139;
  int D.20615;
  char * D.20618;
  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.20572 = token & 1;
      switch (D.20572) <default: <D.19130>, case 0: <D.19127>, case 1: <D.19129>>
      <D.19127>:
      D.20573 = token >> 1;
      D.20574 = D.20573 + 4294967295;
      D.20575 = (int) D.20574;
      D.20576 = &m->tables[6];
      mono_metadata_decode_row (D.20576, D.20575, &method_cols, 6);
      sig = method_cols[4];
      goto <D.19128>;
      <D.19129>:
      D.20573 = token >> 1;
      D.20574 = D.20573 + 4294967295;
      D.20575 = (int) D.20574;
      D.20577 = &m->tables[10];
      mono_metadata_decode_row (D.20577, D.20575, &member_cols, 3);
      sig = member_cols[2];
      goto <D.19128>;
      <D.19130>:
      monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "get.c", 2091);
      <D.19128>:
      ptr.133 = mono_metadata_blob_heap (m, sig);
      ptr = ptr.133;
      ptr.134 = ptr;
      mono_metadata_decode_value (ptr.134, &ptr);
      D.20580 = method_dor_to_token (token);
      mh = mono_get_method_full (m, D.20580, 0B, type_container);
      D.20581 = mh == 0B;
      D.20582 = (long int) D.20581;
      D.20583 = __builtin_expect (D.20582, 0);
      if (D.20583 != 0) goto <D.20584>; else goto <D.20585>;
      <D.20584>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "get.c", 2098, "mh");
      <D.20585>:
      container = mono_method_get_generic_container (mh);
      if (container == 0B) goto <D.20586>; else goto <D.20587>;
      <D.20586>:
      container = type_container;
      <D.20587>:
      ptr.134 = ptr;
      D.20588 = *ptr.134;
      D.20589 = (int) D.20588;
      D.20590 = D.20589 & 32;
      if (D.20590 != 0) goto <D.20591>; else goto <D.20592>;
      <D.20591>:
      ptr.134 = ptr;
      D.20588 = *ptr.134;
      D.20589 = (int) D.20588;
      D.20593 = D.20589 & 64;
      if (D.20593 != 0) goto <D.20594>; else goto <D.20595>;
      <D.20594>:
      monoeg_g_string_append (res, "explicit-this ");
      goto <D.20596>;
      <D.20595>:
      monoeg_g_string_append (res, "instance ");
      <D.20596>:
      <D.20592>:
      ptr.134 = ptr;
      D.20588 = *ptr.134;
      D.20589 = (int) D.20588;
      D.20597 = D.20589 & 16;
      if (D.20597 != 0) goto <D.20598>; else goto <D.20599>;
      <D.20598>:
      gen_count = 1;
      <D.20599>:
      ptr.134 = ptr;
      D.20588 = *ptr.134;
      D.20589 = (int) D.20588;
      cconv = D.20589 & 15;
      ptr.134 = ptr;
      ptr.135 = ptr.134 + 1;
      ptr = ptr.135;
      if (gen_count != 0) goto <D.20601>; else goto <D.20602>;
      <D.20601>:
      ptr.134 = ptr;
      D.20603 = mono_metadata_decode_value (ptr.134, &ptr);
      gen_count = (int) D.20603;
      <D.20602>:
      ptr.134 = ptr;
      D.20604 = mono_metadata_decode_value (ptr.134, &ptr);
      param_count = (int) D.20604;
      if (cconv != 10) goto <D.20605>; else goto <D.20606>;
      <D.20605>:
      {
        char * allocated_ret_type;

        try
          {
            ptr.134 = ptr;
            ptr.136 = get_ret_type (m, ptr.134, &allocated_ret_type, container);
            ptr = ptr.136;
            allocated_ret_type.137 = allocated_ret_type;
            monoeg_g_string_append (res, allocated_ret_type.137);
            allocated_ret_type.137 = allocated_ret_type;
            monoeg_g_free (allocated_ret_type.137);
          }
        finally
          {
            allocated_ret_type = {CLOBBER};
          }
      }
      <D.20606>:
      if (fancy_name != 0B) goto <D.20609>; else goto <D.20610>;
      <D.20609>:
      monoeg_g_string_append_c (res, 32);
      monoeg_g_string_append (res, fancy_name);
      <D.20610>:
      D.20611 = idx + -1;
      D.20612 = &m->tables[43];
      mono_metadata_decode_row (D.20612, D.20611, &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.19134>;
      <D.19133>:
      {
        char * param;

        try
          {
            param = 0B;
            ptr.134 = ptr;
            ptr.138 = get_param (m, ptr.134, &param, container);
            ptr = ptr.138;
            param.139 = param;
            monoeg_g_string_append (res, param.139);
            D.20615 = i + 1;
            if (D.20615 != param_count) goto <D.20616>; else goto <D.20617>;
            <D.20616>:
            monoeg_g_string_append (res, ", ");
            <D.20617>:
            param.139 = param;
            monoeg_g_free (param.139);
          }
        finally
          {
            param = {CLOBBER};
          }
      }
      i = i + 1;
      <D.19134>:
      if (i < param_count) goto <D.19133>; else goto <D.19135>;
      <D.19135>:
      monoeg_g_string_append (res, ")");
      s = res->str;
      monoeg_g_string_free (res, 0);
      D.20618 = s;
      return D.20618;
    }
  finally
    {
      member_cols = {CLOBBER};
      method_cols = {CLOBBER};
      ptr = {CLOBBER};
    }
}


get_encoded_user_string_or_bytearray (const unsigned char * ptr, int len)
{
  int D.20621;
  int D.20622;
  long unsigned int D.20623;
  sizetype D.20626;
  sizetype D.20627;
  const unsigned char * D.20628;
  unsigned char D.20629;
  const short unsigned int * * D.20631;
  const short unsigned int * D.20632;
  const unsigned char * D.20633;
  unsigned char D.20634;
  long unsigned int D.20635;
  long unsigned int D.20636;
  const short unsigned int * D.20637;
  short unsigned int D.20638;
  int D.20639;
  int D.20640;
  char * D.20646;
  int D.20647;
  sizetype D.20648;
  char * D.20649;
  char D.20650;
  int D.20651;
  sizetype D.20652;
  char * D.20653;
  char * res;
  char * eres;
  char * result;
  int i;

  D.20621 = len >> 1;
  D.20622 = D.20621 + 1;
  D.20623 = (long unsigned int) D.20622;
  res = monoeg_malloc (D.20623);
  i = 0;
  goto <D.19166>;
  <D.19165>:
  D.20626 = (sizetype) i;
  D.20627 = D.20626 + 1;
  D.20628 = ptr + D.20627;
  D.20629 = *D.20628;
  if (D.20629 != 0) goto <D.20624>; else goto <D.20630>;
  <D.20630>:
  D.20631 = __ctype_b_loc ();
  D.20632 = *D.20631;
  D.20626 = (sizetype) i;
  D.20633 = ptr + D.20626;
  D.20634 = *D.20633;
  D.20635 = (long unsigned int) D.20634;
  D.20636 = D.20635 * 2;
  D.20637 = D.20632 + D.20636;
  D.20638 = *D.20637;
  D.20639 = (int) D.20638;
  D.20640 = D.20639 & 16384;
  if (D.20640 == 0) goto <D.20641>; else goto <D.20625>;
  <D.20641>:
  D.20626 = (sizetype) i;
  D.20633 = ptr + D.20626;
  D.20634 = *D.20633;
  if (D.20634 != 92) goto <D.20642>; else goto <D.20625>;
  <D.20642>:
  D.20626 = (sizetype) i;
  D.20633 = ptr + D.20626;
  D.20634 = *D.20633;
  if (D.20634 != 34) goto <D.20643>; else goto <D.20625>;
  <D.20643>:
  D.20626 = (sizetype) i;
  D.20633 = ptr + D.20626;
  D.20634 = *D.20633;
  if (D.20634 != 13) goto <D.20644>; else goto <D.20625>;
  <D.20644>:
  D.20626 = (sizetype) i;
  D.20633 = ptr + D.20626;
  D.20634 = *D.20633;
  if (D.20634 != 10) goto <D.20645>; else goto <D.20625>;
  <D.20645>:
  D.20626 = (sizetype) i;
  D.20633 = ptr + D.20626;
  D.20634 = *D.20633;
  if (D.20634 != 9) goto <D.20624>; else goto <D.20625>;
  <D.20624>:
  monoeg_g_free (res);
  D.20646 = get_encoded_user_string_bytearray (ptr, len);
  return D.20646;
  <D.20625>:
  D.20647 = i >> 1;
  D.20648 = (sizetype) D.20647;
  D.20649 = res + D.20648;
  D.20626 = (sizetype) i;
  D.20633 = ptr + D.20626;
  D.20634 = *D.20633;
  D.20650 = (char) D.20634;
  *D.20649 = D.20650;
  i = i + 2;
  <D.19166>:
  D.20651 = i + 1;
  if (D.20651 < len) goto <D.19165>; else goto <D.19167>;
  <D.19167>:
  D.20621 = len >> 1;
  D.20652 = (sizetype) D.20621;
  D.20653 = res + D.20652;
  *D.20653 = 0;
  eres = monoeg_g_strescape (res, 0B);
  result = monoeg_g_strdup_printf ("\"%s\"", eres);
  monoeg_g_free (res);
  monoeg_g_free (eres);
  D.20646 = result;
  return D.20646;
}


get_encoded_user_string_bytearray (const unsigned char * ptr, int len)
{
  char * D.20657;
  sizetype D.20658;
  sizetype D.20659;
  const unsigned char * D.20660;
  unsigned char D.20661;
  int D.20662;
  unsigned int i.140;
  unsigned int D.20664;
  int iftmp.141;
  const short unsigned int * * D.20671;
  const short unsigned int * D.20672;
  sizetype D.20673;
  const unsigned char * D.20674;
  unsigned char D.20675;
  long unsigned int D.20676;
  long unsigned int D.20677;
  const short unsigned int * D.20678;
  short unsigned int D.20679;
  int D.20680;
  int D.20681;
  int iftmp.142;
  const unsigned char * D.20688;
  unsigned char D.20689;
  long unsigned int D.20690;
  long unsigned int D.20691;
  const short unsigned int * D.20692;
  short unsigned int D.20693;
  int D.20694;
  int D.20695;
  gchar * str;
  int i;
  int j;
  int tspaces;
  struct GString * res;

  tspaces = len % 16;
  if (len == 0) goto <D.20655>; else goto <D.20656>;
  <D.20655>:
  D.20657 = monoeg_g_strdup_printf ("\"\"");
  return D.20657;
  <D.20656>:
  res = monoeg_g_string_new ("bytearray (\n\t");
  i = 1;
  goto <D.19149>;
  <D.19148>:
  D.20658 = (sizetype) i;
  D.20659 = D.20658 + 18446744073709551615;
  D.20660 = ptr + D.20659;
  D.20661 = *D.20660;
  D.20662 = (int) D.20661;
  monoeg_g_string_append_printf (res, "%02x ", D.20662);
  i.140 = (unsigned int) i;
  D.20664 = i.140 & 15;
  if (D.20664 == 0) goto <D.20665>; else goto <D.20666>;
  <D.20665>:
  if (i == len) goto <D.20667>; else goto <D.20668>;
  <D.20667>:
  monoeg_g_string_append (res, ")// ");
  goto <D.20669>;
  <D.20668>:
  monoeg_g_string_append (res, " // ");
  <D.20669>:
  j = i + -16;
  goto <D.19146>;
  <D.19145>:
  D.20671 = __ctype_b_loc ();
  D.20672 = *D.20671;
  D.20673 = (sizetype) j;
  D.20674 = ptr + D.20673;
  D.20675 = *D.20674;
  D.20676 = (long unsigned int) D.20675;
  D.20677 = D.20676 * 2;
  D.20678 = D.20672 + D.20677;
  D.20679 = *D.20678;
  D.20680 = (int) D.20679;
  D.20681 = D.20680 & 16384;
  if (D.20681 != 0) goto <D.20682>; else goto <D.20683>;
  <D.20682>:
  D.20673 = (sizetype) j;
  D.20674 = ptr + D.20673;
  D.20675 = *D.20674;
  iftmp.141 = (int) D.20675;
  goto <D.20684>;
  <D.20683>:
  iftmp.141 = 46;
  <D.20684>:
  monoeg_g_string_append_printf (res, "%c", iftmp.141);
  j = j + 1;
  <D.19146>:
  if (j < i) goto <D.19145>; else goto <D.19147>;
  <D.19147>:
  monoeg_g_string_append (res, "\n\t");
  <D.20666>:
  i = i + 1;
  <D.19149>:
  if (i <= len) goto <D.19148>; else goto <D.19150>;
  <D.19150>:
  if (tspaces != 0) goto <D.20685>; else goto <D.20686>;
  <D.20685>:
  monoeg_g_string_append (res, ")  ");
  i = tspaces + 1;
  goto <D.19152>;
  <D.19151>:
  monoeg_g_string_append_printf (res, "   ");
  i = i + 1;
  <D.19152>:
  if (i <= 15) goto <D.19151>; else goto <D.19153>;
  <D.19153>:
  monoeg_g_string_append (res, " // ");
  i = len - tspaces;
  goto <D.19155>;
  <D.19154>:
  D.20671 = __ctype_b_loc ();
  D.20672 = *D.20671;
  D.20658 = (sizetype) i;
  D.20688 = ptr + D.20658;
  D.20689 = *D.20688;
  D.20690 = (long unsigned int) D.20689;
  D.20691 = D.20690 * 2;
  D.20692 = D.20672 + D.20691;
  D.20693 = *D.20692;
  D.20694 = (int) D.20693;
  D.20695 = D.20694 & 16384;
  if (D.20695 != 0) goto <D.20696>; else goto <D.20697>;
  <D.20696>:
  D.20658 = (sizetype) i;
  D.20688 = ptr + D.20658;
  D.20689 = *D.20688;
  iftmp.142 = (int) D.20689;
  goto <D.20698>;
  <D.20697>:
  iftmp.142 = 46;
  <D.20698>:
  monoeg_g_string_append_printf (res, "%c", iftmp.142);
  i = i + 1;
  <D.19155>:
  if (i < len) goto <D.19154>; else goto <D.19156>;
  <D.19156>:
  monoeg_g_string_append (res, "\n\t");
  <D.20686>:
  str = res->str;
  monoeg_g_string_free (res, 0);
  D.20657 = str;
  return D.20657;
}


stringify_double (double r)
{
  long unsigned int D.20700;
  sizetype D.20701;
  char * D.19176;
  char * iftmp.143;
  char * iftmp.144;
  int D.20709;
  char * iftmp.145;
  int D.20714;
  char * iftmp.146;
  char D.20717;
  int D.20720;
  char * D.20724;
  char * ret;
  char * ptr;

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

    __a0 = 46;
    if (__a0 == 0) goto <D.20703>; else goto <D.20704>;
    <D.20703>:
    iftmp.143 = 0B;
    goto <D.20705>;
    <D.20704>:
    __a1 = 101;
    if (__a1 == 0) goto <D.20707>; else goto <D.20708>;
    <D.20707>:
    D.20709 = (int) __a0;
    iftmp.144 = __builtin_strchr (ret, D.20709);
    goto <D.20710>;
    <D.20708>:
    __a2 = 69;
    if (__a2 == 0) goto <D.20712>; else goto <D.20713>;
    <D.20712>:
    D.20714 = (int) __a1;
    D.20709 = (int) __a0;
    iftmp.145 = __strpbrk_c2 (ret, D.20709, D.20714);
    goto <D.20715>;
    <D.20713>:
    D.20717 = 0;
    if (D.20717 == 0) goto <D.20718>; else goto <D.20719>;
    <D.20718>:
    D.20720 = (int) __a2;
    D.20714 = (int) __a1;
    D.20709 = (int) __a0;
    iftmp.146 = __strpbrk_c3 (ret, D.20709, D.20714, D.20720);
    goto <D.20721>;
    <D.20719>:
    iftmp.146 = __builtin_strpbrk (ret, ".eE");
    <D.20721>:
    iftmp.145 = iftmp.146;
    <D.20715>:
    iftmp.144 = iftmp.145;
    <D.20710>:
    iftmp.143 = iftmp.144;
    <D.20705>:
    D.19176 = iftmp.143;
  }
  if (D.19176 != ptr) goto <D.20722>; else goto <D.20723>;
  <D.20722>:
  *ptr = 0;
  <D.20723>:
  D.20724 = ret;
  return D.20724;
}


__strpbrk_c2 (const char * __s, int __accept1, int __accept2)
{
  char D.20726;
  int D.20728;
  char * D.20730;
  char * iftmp.147;

  goto <D.3548>;
  <D.3547>:
  __s = __s + 1;
  <D.3548>:
  D.20726 = *__s;
  if (D.20726 != 0) goto <D.20727>; else goto <D.3549>;
  <D.20727>:
  D.20726 = *__s;
  D.20728 = (int) D.20726;
  if (D.20728 != __accept1) goto <D.20729>; else goto <D.3549>;
  <D.20729>:
  D.20726 = *__s;
  D.20728 = (int) D.20726;
  if (D.20728 != __accept2) goto <D.3547>; else goto <D.3549>;
  <D.3549>:
  D.20726 = *__s;
  if (D.20726 != 0) goto <D.20732>; else goto <D.20733>;
  <D.20732>:
  iftmp.147 = __s;
  goto <D.20734>;
  <D.20733>:
  iftmp.147 = 0B;
  <D.20734>:
  D.20730 = iftmp.147;
  return D.20730;
}


__strpbrk_c3 (const char * __s, int __accept1, int __accept2, int __accept3)
{
  char D.20736;
  int D.20738;
  char * D.20741;
  char * iftmp.148;

  goto <D.3562>;
  <D.3561>:
  __s = __s + 1;
  <D.3562>:
  D.20736 = *__s;
  if (D.20736 != 0) goto <D.20737>; else goto <D.3563>;
  <D.20737>:
  D.20736 = *__s;
  D.20738 = (int) D.20736;
  if (D.20738 != __accept1) goto <D.20739>; else goto <D.3563>;
  <D.20739>:
  D.20736 = *__s;
  D.20738 = (int) D.20736;
  if (D.20738 != __accept2) goto <D.20740>; else goto <D.3563>;
  <D.20740>:
  D.20736 = *__s;
  D.20738 = (int) D.20736;
  if (D.20738 != __accept3) goto <D.3561>; else goto <D.3563>;
  <D.3563>:
  D.20736 = *__s;
  if (D.20736 != 0) goto <D.20743>; else goto <D.20744>;
  <D.20743>:
  iftmp.148 = __s;
  goto <D.20745>;
  <D.20744>:
  iftmp.148 = 0B;
  <D.20745>:
  D.20741 = iftmp.148;
  return D.20741;
}


get_constant (struct MonoImage * m, MonoTypeEnum t, guint32 blob_index)
{
  const char * ptr.149;
  const char * ptr.150;
  unsigned int D.20749;
  char * D.20750;
  const char * iftmp.151;
  char D.20752;
  short unsigned int D.20756;
  int D.20757;
  int D.20758;
  int D.20759;
  unsigned int D.20760;
  float r.152;
  float r.153;
  double D.20765;
  long unsigned int D.20766;
  double r.154;
  double r.155;
  const char * ptr;
  int len;

  try
    {
      ptr.149 = mono_metadata_blob_heap (m, blob_index);
      ptr = ptr.149;
      ptr.150 = ptr;
      D.20749 = mono_metadata_decode_value (ptr.150, &ptr);
      len = (int) D.20749;
      switch (t) <default: <D.19212>, case 2: <D.19184>, case 3: <D.19185>, case 4: <D.19187>, case 5: <D.19186>, case 6: <D.19189>, case 7: <D.19188>, case 8: <D.19191>, case 9: <D.19190>, case 10: <D.19193>, case 11: <D.19192>, case 12: <D.19196>, case 13: <D.19202>, case 14: <D.19210>, case 18: <D.19211>>
      <D.19184>:
      ptr.150 = ptr;
      D.20752 = *ptr.150;
      if (D.20752 != 0) goto <D.20753>; else goto <D.20754>;
      <D.20753>:
      iftmp.151 = "bool(true)";
      goto <D.20755>;
      <D.20754>:
      iftmp.151 = "bool(false)";
      <D.20755>:
      D.20750 = monoeg_g_strdup_printf ("%s", iftmp.151);
      return D.20750;
      <D.19185>:
      ptr.150 = ptr;
      D.20756 = MEM[(const guint16 *)ptr.150];
      D.20757 = (int) D.20756;
      D.20750 = monoeg_g_strdup_printf ("char(0x%04x)", D.20757);
      return D.20750;
      <D.19186>:
      <D.19187>:
      ptr.150 = ptr;
      D.20752 = *ptr.150;
      D.20758 = (int) D.20752;
      D.20759 = D.20758 & 255;
      D.20750 = monoeg_g_strdup_printf ("int8(0x%02x)", D.20759);
      return D.20750;
      <D.19188>:
      <D.19189>:
      ptr.150 = ptr;
      D.20756 = MEM[(const guint16 *)ptr.150];
      D.20757 = (int) D.20756;
      D.20750 = monoeg_g_strdup_printf ("int16(0x%08x)", D.20757);
      return D.20750;
      <D.19190>:
      <D.19191>:
      ptr.150 = ptr;
      D.20760 = MEM[(const guint32 *)ptr.150];
      D.20750 = monoeg_g_strdup_printf ("int32(0x%08x)", D.20760);
      return D.20750;
      <D.19192>:
      <D.19193>:
      {
        guint32 low;
        guint32 high;

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

        try
          {
            {
              union mono_rfloat mf;

              try
                {
                  ptr.150 = ptr;
                  D.20760 = MEM[(const guint32 *)ptr.150];
                  mf.ival = D.20760;
                  r.152 = mf.fval;
                  r = r.152;
                }
              finally
                {
                  mf = {CLOBBER};
                }
            }
            r.153 = r;
            normal = __finitef (r.153);
            if (normal == 0) goto <D.20763>; else goto <D.20764>;
            <D.20763>:
            ptr.150 = ptr;
            D.20760 = MEM[(const guint32 *)ptr.150];
            D.20750 = monoeg_g_strdup_printf ("float32(0x%08x)", D.20760);
            return D.20750;
            <D.20764>:
            {
              char * str;
              char * ret;

              r.153 = r;
              D.20765 = (double) r.153;
              str = stringify_double (D.20765);
              ret = monoeg_g_strdup_printf ("float32(%s)", str);
              monoeg_g_free (str);
              D.20750 = ret;
              return D.20750;
            }
          }
        finally
          {
            r = {CLOBBER};
          }
      }
      <D.19202>:
      {
        gboolean normal;
        double r;

        try
          {
            {
              union mono_rdouble mf;

              try
                {
                  ptr.150 = ptr;
                  D.20766 = MEM[(const guint64 *)ptr.150];
                  mf.ival = D.20766;
                  r.154 = mf.fval;
                  r = r.154;
                }
              finally
                {
                  mf = {CLOBBER};
                }
            }
            r.155 = r;
            normal = __finite (r.155);
            if (normal == 0) goto <D.20769>; else goto <D.20770>;
            <D.20769>:
            {
              guint32 low;
              guint32 high;

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

              r.155 = r;
              str = stringify_double (r.155);
              ret = monoeg_g_strdup_printf ("float64(%s)", str);
              monoeg_g_free (str);
              D.20750 = ret;
              return D.20750;
            }
          }
        finally
          {
            r = {CLOBBER};
          }
      }
      <D.19210>:
      ptr.150 = ptr;
      D.20750 = get_encoded_user_string_or_bytearray (ptr.150, len);
      return D.20750;
      <D.19211>:
      D.20750 = monoeg_strdup ("nullref");
      return D.20750;
      <D.19212>:
      ptr.150 = ptr;
      D.20752 = *ptr.150;
      D.20758 = (int) D.20752;
      monoeg_g_log (0B, 4, "Unknown MONO_TYPE (%d) on constant at Blob index (0x%08x)\n", D.20758, blob_index);
      <D.19213>:
      goto <D.19213>;
      D.20750 = monoeg_g_strdup_printf ("Unknown");
      return D.20750;
    }
  finally
    {
      ptr = {CLOBBER};
    }
}


get_token (struct MonoImage * m, guint32 token, struct MonoGenericContainer * container)
{
  unsigned int D.20775;
  char * D.20776;
  int idx.156;
  unsigned int D.20778;
  unsigned int D.20779;
  int D.20780;
  struct MonoTableInfo * D.20781;
  unsigned int D.20782;
  const char * sig.157;
  const char * sig.158;
  char D.20785;
  char * temp;
  char * result;
  guint32 idx;

  idx = token & 16777215;
  D.20775 = token & 4278190080;
  switch (D.20775) <default: <D.19231>, case 16777216: <D.19226>, case 33554432: <D.19225>, case 67108864: <D.19222>, case 100663296: <D.19223>, case 167772160: <D.19228>, case 452984832: <D.19227>, case 721420288: <D.19224>>
  <D.19222>:
  temp = get_field (m, token, container);
  result = monoeg_g_strdup_printf ("field %s", temp);
  monoeg_g_free (temp);
  D.20776 = result;
  return D.20776;
  <D.19223>:
  <D.19224>:
  temp = get_method (m, token, container);
  result = monoeg_g_strdup_printf ("method %s", temp);
  monoeg_g_free (temp);
  D.20776 = result;
  return D.20776;
  <D.19225>:
  idx.156 = (int) idx;
  temp = get_typedef (m, idx.156);
  result = get_escaped_name (temp);
  monoeg_g_free (temp);
  D.20776 = result;
  return D.20776;
  <D.19226>:
  idx.156 = (int) idx;
  D.20776 = get_typeref (m, idx.156);
  return D.20776;
  <D.19227>:
  D.20776 = get_typespec (m, idx, 1, container);
  return D.20776;
  <D.19228>:
  {
    guint32 cols[3];
    const char * sig;

    try
      {
        D.20778 = token & 16777215;
        D.20779 = D.20778 + 4294967295;
        D.20780 = (int) D.20779;
        D.20781 = &m->tables[10];
        mono_metadata_decode_row (D.20781, D.20780, &cols, 3);
        D.20782 = cols[2];
        sig.157 = mono_metadata_blob_heap (m, D.20782);
        sig = sig.157;
        sig.158 = sig;
        mono_metadata_decode_blob_size (sig.158, &sig);
        sig.158 = sig;
        D.20785 = *sig.158;
        if (D.20785 == 6) goto <D.20786>; else goto <D.20787>;
        <D.20786>:
        temp = get_field (m, token, container);
        result = monoeg_g_strdup_printf ("field %s", temp);
        monoeg_g_free (temp);
        D.20776 = result;
        return D.20776;
        <D.20787>:
        temp = get_method (m, token, container);
        result = monoeg_g_strdup_printf ("method %s", temp);
        monoeg_g_free (temp);
        D.20776 = result;
        return D.20776;
      }
    finally
      {
        cols = {CLOBBER};
        sig = {CLOBBER};
      }
  }
  <D.19231>:
  monoeg_g_log (0B, 4, "Do not know how to decode tokens of type 0x%08x", token);
  <D.19232>:
  goto <D.19232>;
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "get.c", 2419);
  D.20776 = monoeg_strdup ("ERROR");
  return D.20776;
}


get_token_type (struct MonoImage * m, guint32 token, struct MonoGenericContainer * container)
{
  int token.159;
  unsigned int D.20791;
  unsigned int idx.160;
  char * D.20795;
  char * temp;
  char * s;
  int idx;

  temp = 0B;
  s = 0B;
  token.159 = (int) token;
  idx = token.159 & 16777215;
  D.20791 = token & 4278190080;
  switch (D.20791) <default: <D.19245>, case 16777216: <D.19243>, case 33554432: <D.19241>, case 452984832: <D.19244>>
  <D.19241>:
  temp = get_typedef (m, idx);
  s = monoeg_g_strdup_printf ("%s", temp);
  goto <D.19242>;
  <D.19243>:
  temp = get_typeref (m, idx);
  s = monoeg_g_strdup_printf ("%s", temp);
  goto <D.19242>;
  <D.19244>:
  idx.160 = (unsigned int) idx;
  s = get_typespec (m, idx.160, 0, container);
  goto <D.19242>;
  <D.19245>:
  monoeg_g_log (0B, 4, "Unhandled encoding for token 0x%08x", token);
  <D.19246>:
  goto <D.19246>;
  <D.19242>:
  if (temp != 0B) goto <D.20793>; else goto <D.20794>;
  <D.20793>:
  monoeg_g_free (temp);
  <D.20794>:
  D.20795 = s;
  return D.20795;
}


get_guid (struct MonoImage * m, guint32 guid_index)
{
  const unsigned char * D.20797;
  unsigned char D.20798;
  int D.20799;
  const unsigned char * D.20800;
  unsigned char D.20801;
  int D.20802;
  const unsigned char * D.20803;
  unsigned char D.20804;
  int D.20805;
  const unsigned char * D.20806;
  unsigned char D.20807;
  int D.20808;
  const unsigned char * D.20809;
  unsigned char D.20810;
  int D.20811;
  const unsigned char * D.20812;
  unsigned char D.20813;
  int D.20814;
  const unsigned char * D.20815;
  unsigned char D.20816;
  int D.20817;
  const unsigned char * D.20818;
  unsigned char D.20819;
  int D.20820;
  const unsigned char * D.20821;
  unsigned char D.20822;
  int D.20823;
  const unsigned char * D.20824;
  unsigned char D.20825;
  int D.20826;
  const unsigned char * D.20827;
  unsigned char D.20828;
  int D.20829;
  const unsigned char * D.20830;
  unsigned char D.20831;
  int D.20832;
  unsigned char D.20833;
  int D.20834;
  const unsigned char * D.20835;
  unsigned char D.20836;
  int D.20837;
  const unsigned char * D.20838;
  unsigned char D.20839;
  int D.20840;
  const unsigned char * D.20841;
  unsigned char D.20842;
  int D.20843;
  char * D.20844;
  const unsigned char * guid;
  char * result;

  guid = mono_metadata_guid_heap (m, guid_index);
  D.20797 = guid + 15;
  D.20798 = *D.20797;
  D.20799 = (int) D.20798;
  D.20800 = guid + 14;
  D.20801 = *D.20800;
  D.20802 = (int) D.20801;
  D.20803 = guid + 13;
  D.20804 = *D.20803;
  D.20805 = (int) D.20804;
  D.20806 = guid + 12;
  D.20807 = *D.20806;
  D.20808 = (int) D.20807;
  D.20809 = guid + 11;
  D.20810 = *D.20809;
  D.20811 = (int) D.20810;
  D.20812 = guid + 10;
  D.20813 = *D.20812;
  D.20814 = (int) D.20813;
  D.20815 = guid + 9;
  D.20816 = *D.20815;
  D.20817 = (int) D.20816;
  D.20818 = guid + 8;
  D.20819 = *D.20818;
  D.20820 = (int) D.20819;
  D.20821 = guid + 6;
  D.20822 = *D.20821;
  D.20823 = (int) D.20822;
  D.20824 = guid + 7;
  D.20825 = *D.20824;
  D.20826 = (int) D.20825;
  D.20827 = guid + 4;
  D.20828 = *D.20827;
  D.20829 = (int) D.20828;
  D.20830 = guid + 5;
  D.20831 = *D.20830;
  D.20832 = (int) D.20831;
  D.20833 = *guid;
  D.20834 = (int) D.20833;
  D.20835 = guid + 1;
  D.20836 = *D.20835;
  D.20837 = (int) D.20836;
  D.20838 = guid + 2;
  D.20839 = *D.20838;
  D.20840 = (int) D.20839;
  D.20841 = guid + 3;
  D.20842 = *D.20841;
  D.20843 = (int) D.20842;
  result = monoeg_g_strdup_printf ("{%02X%02X%02X%02X-%02X%02X-%02X%02X-%02X%02X-%02X%02X%02X%02X%02X%02X}", D.20843, D.20840, D.20837, D.20834, D.20832, D.20829, D.20826, D.20823, D.20820, D.20817, D.20814, D.20811, D.20808, D.20805, D.20802, D.20799);
  D.20844 = result;
  return D.20844;
}


dis_get_custom_attrs (struct MonoImage * m, guint32 token)
{
  unsigned int D.20846;
  struct GList * D.20847;
  int i.161;
  unsigned int D.20849;
  unsigned int D.20852;
  unsigned int D.20853;
  unsigned int D.20854;
  const char * val.162;
  const char * val.163;
  int len.164;
  char * D.20858;
  <unnamed-unsigned:24> D.20859;
  unsigned int D.20860;
  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.20846 = token >> 24;
      switch (D.20846) <default: <D.19278>, case 0: <D.19271>, case 2: <D.19267>, case 4: <D.19274>, case 6: <D.19275>, case 8: <D.19276>, case 20: <D.19273>, case 23: <D.19272>, case 32: <D.19269>, case 35: <D.19270>, case 42: <D.19277>>
      <D.19267>:
      idx = idx | 3;
      goto <D.19268>;
      <D.19269>:
      idx = idx | 14;
      goto <D.19268>;
      <D.19270>:
      idx = idx | 15;
      goto <D.19268>;
      <D.19271>:
      idx = idx | 7;
      goto <D.19268>;
      <D.19272>:
      idx = idx | 9;
      goto <D.19268>;
      <D.19273>:
      idx = idx | 10;
      goto <D.19268>;
      <D.19274>:
      idx = idx | 1;
      goto <D.19268>;
      <D.19275>:
      idx = idx;
      goto <D.19268>;
      <D.19276>:
      idx = idx | 4;
      goto <D.19268>;
      <D.19277>:
      idx = idx | 19;
      goto <D.19268>;
      <D.19278>:
      monoeg_g_print ("Missing custom attr get support for token 0x%08x\n", token);
      D.20847 = 0B;
      return D.20847;
      <D.19268>:
      ca = &m->tables[12];
      i = 0;
      goto <D.19287>;
      <D.19286>:
      {
        char * dump;

        i.161 = (int) i;
        mono_metadata_decode_row (ca, i.161, &cols, 3);
        D.20849 = cols[0];
        if (D.20849 != idx) goto <D.20850>; else goto <D.20851>;
        <D.20850>:
        // predicted unlikely by continue predictor.
        goto <D.19280>;
        <D.20851>:
        D.20852 = cols[1];
        mtoken = D.20852 >> 3;
        D.20852 = cols[1];
        D.20853 = D.20852 & 7;
        switch (D.20853) <default: <D.19284>, case 2: <D.19281>, case 3: <D.19283>>
        <D.19281>:
        mtoken = mtoken | 100663296;
        goto <D.19282>;
        <D.19283>:
        mtoken = mtoken | 167772160;
        goto <D.19282>;
        <D.19284>:
        D.20852 = cols[1];
        monoeg_g_log (0B, 4, "Unknown table for custom attr type %08x", D.20852);
        <D.19285>:
        goto <D.19285>;
        <D.19282>:
        method = get_method (m, mtoken, 0B);
        D.20854 = cols[2];
        val.162 = mono_metadata_blob_heap (m, D.20854);
        val = val.162;
        val.163 = val;
        len = mono_metadata_decode_value (val.163, &val);
        attr = monoeg_g_string_new (".custom ");
        len.164 = (int) len;
        val.163 = val;
        dump = data_dump (val.163, len.164, "\t\t");
        monoeg_g_string_append_printf (attr, "%s = %s", method, dump);
        monoeg_g_free (dump);
        D.20858 = attr->str;
        list = monoeg_g_list_append (list, D.20858);
        monoeg_g_string_free (attr, 0);
        monoeg_g_free (method);
      }
      <D.19280>:
      i = i + 1;
      <D.19287>:
      D.20859 = ca->rows;
      D.20860 = (unsigned int) D.20859;
      if (D.20860 > i) goto <D.19286>; else goto <D.19288>;
      <D.19288>:
      D.20847 = list;
      return D.20847;
    }
  finally
    {
      cols = {CLOBBER};
      val = {CLOBBER};
    }
}


get_marshal_info (struct MonoImage * m, const char * blob)
{
  const char * blob.165;
  unsigned int D.20864;
  char D.20865;
  int D.20866;
  char * D.20867;
  const char * D.20868;
  unsigned int D.20869;
  unsigned int D.20870;
  int len;
  int size;

  size = 0;
  blob.165 = blob;
  D.20864 = mono_metadata_decode_blob_size (blob.165, &blob);
  len = (int) D.20864;
  blob.165 = blob;
  D.20865 = *blob.165;
  D.20866 = (int) D.20865;
  switch (D.20866) <default: <D.19330>, case 2: <D.19295>, case 3: <D.19296>, case 4: <D.19297>, case 5: <D.19298>, case 6: <D.19299>, case 7: <D.19300>, case 8: <D.19301>, case 9: <D.19302>, case 10: <D.19303>, case 11: <D.19304>, case 12: <D.19305>, case 15: <D.19306>, case 19: <D.19307>, case 20: <D.19308>, case 21: <D.19309>, case 22: <D.19310>, case 23: <D.19311>, case 25: <D.19312>, case 26: <D.19313>, case 27: <D.19314>, case 28: <D.19315>, case 29: <D.19316>, case 30: <D.19317>, case 31: <D.19318>, case 32: <D.19319>, case 34: <D.19320>, case 35: <D.19321>, case 36: <D.19322>, case 37: <D.19323>, case 38: <D.19324>, case 40: <D.19325>, case 42: <D.19326>, case 43: <D.19327>, case 44: <D.19328>, case 45: <D.19329>>
  <D.19295>:
  D.20867 = monoeg_strdup ("bool");
  return D.20867;
  <D.19296>:
  D.20867 = monoeg_strdup ("int8");
  return D.20867;
  <D.19297>:
  D.20867 = monoeg_strdup ("unsigned int8");
  return D.20867;
  <D.19298>:
  D.20867 = monoeg_strdup ("int16");
  return D.20867;
  <D.19299>:
  D.20867 = monoeg_strdup ("unsigned int16");
  return D.20867;
  <D.19300>:
  D.20867 = monoeg_strdup ("int32");
  return D.20867;
  <D.19301>:
  D.20867 = monoeg_strdup ("unsigned int32");
  return D.20867;
  <D.19302>:
  D.20867 = monoeg_strdup ("int64");
  return D.20867;
  <D.19303>:
  D.20867 = monoeg_strdup ("unsigned int64");
  return D.20867;
  <D.19304>:
  D.20867 = monoeg_strdup ("float32");
  return D.20867;
  <D.19305>:
  D.20867 = monoeg_strdup ("float64");
  return D.20867;
  <D.19306>:
  D.20867 = monoeg_strdup ("currency");
  return D.20867;
  <D.19307>:
  D.20867 = monoeg_strdup ("bstr");
  return D.20867;
  <D.19308>:
  D.20867 = monoeg_strdup ("lpstr");
  return D.20867;
  <D.19309>:
  D.20867 = monoeg_strdup ("lpwstr");
  return D.20867;
  <D.19310>:
  D.20867 = monoeg_strdup ("lptstr");
  return D.20867;
  <D.19311>:
  blob.165 = blob;
  D.20868 = blob.165 + 1;
  D.20869 = mono_metadata_decode_value (D.20868, &blob);
  size = (int) D.20869;
  D.20867 = monoeg_g_strdup_printf ("fixed sysstring [%d]", size);
  return D.20867;
  <D.19312>:
  D.20867 = monoeg_strdup ("iunknown");
  return D.20867;
  <D.19313>:
  D.20867 = monoeg_strdup ("idispatch");
  return D.20867;
  <D.19314>:
  D.20867 = monoeg_strdup ("struct");
  return D.20867;
  <D.19315>:
  D.20867 = monoeg_strdup ("interface");
  return D.20867;
  <D.19316>:
  D.20867 = monoeg_strdup ("safearray");
  return D.20867;
  <D.19317>:
  blob.165 = blob;
  D.20868 = blob.165 + 1;
  D.20870 = mono_metadata_decode_value (D.20868, &blob);
  size = (int) D.20870;
  D.20867 = monoeg_g_strdup_printf ("fixed array [%d]", size);
  return D.20867;
  <D.19318>:
  D.20867 = monoeg_strdup ("int");
  return D.20867;
  <D.19319>:
  D.20867 = monoeg_strdup ("unsigned int");
  return D.20867;
  <D.19320>:
  D.20867 = monoeg_strdup ("vbbyrefstr");
  return D.20867;
  <D.19321>:
  D.20867 = monoeg_strdup ("ansi bstr");
  return D.20867;
  <D.19322>:
  D.20867 = monoeg_strdup ("tbstr");
  return D.20867;
  <D.19323>:
  D.20867 = monoeg_strdup ("variant bool");
  return D.20867;
  <D.19324>:
  D.20867 = monoeg_strdup ("method");
  return D.20867;
  <D.19325>:
  D.20867 = monoeg_strdup ("as any");
  return D.20867;
  <D.19326>:
  D.20867 = monoeg_strdup ("[]");
  return D.20867;
  <D.19327>:
  D.20867 = monoeg_strdup ("lpstruct");
  return D.20867;
  <D.19328>:
  D.20867 = monoeg_strdup ("custom");
  return D.20867;
  <D.19329>:
  D.20867 = monoeg_strdup ("error");
  return D.20867;
  <D.19330>:
  D.20867 = monoeg_strdup ("unknown");
  return D.20867;
}


init_key_table ()
{
  struct GHashTable * key_table.166;
  struct GHashTable * key_table.167;

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


method_dor_to_token (guint32 idx)
{
  unsigned int D.20874;
  guint32 D.20875;
  unsigned int D.20876;

  D.20874 = idx & 1;
  switch (D.20874) <default: <D.20877>, case 0: <D.19337>, case 1: <D.19338>>
  <D.19337>:
  D.20876 = idx >> 1;
  D.20875 = D.20876 | 100663296;
  return D.20875;
  <D.19338>:
  D.20876 = idx >> 1;
  D.20875 = D.20876 | 167772160;
  return D.20875;
  <D.20877>:
  D.20875 = 4294967295;
  return D.20875;
}


get_method_override (struct MonoImage * m, guint32 token, struct MonoGenericContainer * container)
{
  int D.20879;
  unsigned int D.20880;
  unsigned int D.20881;
  struct MonoClass * D.20887;
  struct MonoGenericClass * D.20889;
  struct MonoGenericContainer * D.20891;
  char * D.20892;
  <unnamed-unsigned:24> D.20893;
  int D.20894;
  struct MonoTableInfo * t;
  int i;

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

    try
      {
        D.20879 = i + -1;
        mono_metadata_decode_row (t, D.20879, &cols, 3);
        D.20880 = cols[1];
        impl = method_dor_to_token (D.20880);
        D.20881 = cols[2];
        decl = method_dor_to_token (D.20881);
        if (token == impl) goto <D.20882>; else goto <D.20883>;
        <D.20882>:
        {
          struct MonoMethod * mh;

          mh = 0B;
          mh = mono_get_method_full (m, decl, 0B, container);
          if (mh != 0B) goto <D.20886>; else goto <D.20884>;
          <D.20886>:
          D.20887 = mh->klass;
          if (D.20887 != 0B) goto <D.20888>; else goto <D.20884>;
          <D.20888>:
          D.20887 = mh->klass;
          D.20889 = D.20887->generic_class;
          if (D.20889 != 0B) goto <D.20885>; else goto <D.20890>;
          <D.20890>:
          D.20887 = mh->klass;
          D.20891 = D.20887->generic_container;
          if (D.20891 != 0B) goto <D.20885>; else goto <D.20884>;
          <D.20885>:
          {
            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.20892 = ret;
            return D.20892;
          }
          <D.20884>:
          D.20892 = get_method_core (m, decl, 0, container);
          return D.20892;
        }
        <D.20883>:
      }
    finally
      {
        cols = {CLOBBER};
      }
  }
  i = i + 1;
  <D.19353>:
  D.20893 = t->rows;
  D.20894 = (int) D.20893;
  if (D.20894 >= i) goto <D.19352>; else goto <D.19354>;
  <D.19354>:
  D.20892 = 0B;
  return D.20892;
}


get_method_impl_flags (guint32 f)
{
  int f.168;
  int D.20899;
  int D.20900;
  unsigned int D.20901;
  unsigned int D.20902;
  unsigned int code_type.169;
  const char * D.20904;
  unsigned int managed_type.170;
  const char * D.20906;
  unsigned int rest.171;
  const char * D.20908;
  char * D.20909;
  struct GString * str;
  char * s;
  int code_type;
  int managed_type;
  int rest;

  str = monoeg_g_string_new ("");
  f.168 = (int) f;
  code_type = f.168 & 3;
  f.168 = (int) f;
  managed_type = f.168 & 4;
  D.20899 = code_type | managed_type;
  D.20900 = ~D.20899;
  D.20901 = (unsigned int) D.20900;
  D.20902 = D.20901 & f;
  rest = (int) D.20902;
  code_type.169 = (unsigned int) code_type;
  D.20904 = map (code_type.169, &method_impl_map);
  monoeg_g_string_append (str, D.20904);
  managed_type.170 = (unsigned int) managed_type;
  D.20906 = map (managed_type.170, &managed_type_map);
  monoeg_g_string_append (str, D.20906);
  rest.171 = (unsigned int) rest;
  D.20908 = flags (rest.171, &managed_impl_flags);
  monoeg_g_string_append (str, D.20908);
  s = str->str;
  monoeg_g_string_free (str, 0);
  D.20909 = s;
  return D.20909;
}