mono_type_get_desc (struct GString * res, struct MonoType * type, gboolean include_namespace)
{
  unsigned char D.16949;
  int D.16950;
  struct MonoType * D.16951;
  struct MonoArrayType * D.16952;
  struct MonoClass * D.16953;
  struct MonoType * D.16954;
  unsigned char D.16955;
  int D.16956;
  struct MonoClass * D.16957;
  struct MonoType * D.16958;
  struct MonoGenericClass * D.16959;
  struct MonoClass * D.16960;
  struct MonoType * D.16961;
  struct MonoGenericInst * D.16962;
  struct MonoType * D.16967;
  <unnamed-unsigned:22> D.16968;
  int D.16969;
  struct MonoGenericInst * D.16970;
  struct MonoType * D.16977;
  <unnamed-unsigned:22> D.16978;
  int D.16979;
  struct MonoGenericParam * D.16980;
  struct MonoGenericParamInfo * iftmp.0;
  struct MonoGenericContainer * D.16984;
  const char * D.16990;
  short unsigned int D.16992;
  int D.16993;
  const char * iftmp.1;
  unsigned char D.16999;
  unsigned char D.17000;
  int i;

  D.16949 = type->type;
  D.16950 = (int) D.16949;
  switch (D.16950) <default: <D.16621>, case 1: <D.16585>, case 2: <D.16588>, case 3: <D.16587>, case 4: <D.16590>, case 5: <D.16589>, case 6: <D.16592>, case 7: <D.16591>, case 8: <D.16594>, case 9: <D.16593>, case 10: <D.16596>, case 11: <D.16595>, case 12: <D.16600>, case 13: <D.16601>, case 14: <D.16602>, case 15: <D.16604>, case 17: <D.16608>, case 18: <D.16607>, case 19: <D.16617>, case 20: <D.16605>, case 21: <D.16609>, case 22: <D.16620>, case 24: <D.16599>, case 25: <D.16598>, case 27: <D.16597>, case 28: <D.16603>, case 29: <D.16606>, case 30: <D.16618>>
  <D.16585>:
  monoeg_g_string_append (res, "void");
  goto <D.16586>;
  <D.16587>:
  monoeg_g_string_append (res, "char");
  goto <D.16586>;
  <D.16588>:
  monoeg_g_string_append (res, "bool");
  goto <D.16586>;
  <D.16589>:
  monoeg_g_string_append (res, "byte");
  goto <D.16586>;
  <D.16590>:
  monoeg_g_string_append (res, "sbyte");
  goto <D.16586>;
  <D.16591>:
  monoeg_g_string_append (res, "uint16");
  goto <D.16586>;
  <D.16592>:
  monoeg_g_string_append (res, "int16");
  goto <D.16586>;
  <D.16593>:
  monoeg_g_string_append (res, "uint");
  goto <D.16586>;
  <D.16594>:
  monoeg_g_string_append (res, "int");
  goto <D.16586>;
  <D.16595>:
  monoeg_g_string_append (res, "ulong");
  goto <D.16586>;
  <D.16596>:
  monoeg_g_string_append (res, "long");
  goto <D.16586>;
  <D.16597>:
  monoeg_g_string_append (res, "*()");
  goto <D.16586>;
  <D.16598>:
  monoeg_g_string_append (res, "uintptr");
  goto <D.16586>;
  <D.16599>:
  monoeg_g_string_append (res, "intptr");
  goto <D.16586>;
  <D.16600>:
  monoeg_g_string_append (res, "single");
  goto <D.16586>;
  <D.16601>:
  monoeg_g_string_append (res, "double");
  goto <D.16586>;
  <D.16602>:
  monoeg_g_string_append (res, "string");
  goto <D.16586>;
  <D.16603>:
  monoeg_g_string_append (res, "object");
  goto <D.16586>;
  <D.16604>:
  D.16951 = type->data.type;
  mono_type_get_desc (res, D.16951, include_namespace);
  monoeg_g_string_append_c (res, 42);
  goto <D.16586>;
  <D.16605>:
  D.16952 = type->data.array;
  D.16953 = D.16952->eklass;
  D.16954 = &D.16953->byval_arg;
  mono_type_get_desc (res, D.16954, include_namespace);
  D.16952 = type->data.array;
  D.16955 = D.16952->rank;
  D.16956 = (int) D.16955;
  monoeg_g_string_append_printf (res, "[%d]", D.16956);
  goto <D.16586>;
  <D.16606>:
  D.16957 = type->data.klass;
  D.16958 = &D.16957->byval_arg;
  mono_type_get_desc (res, D.16958, include_namespace);
  monoeg_g_string_append (res, "[]");
  goto <D.16586>;
  <D.16607>:
  <D.16608>:
  D.16957 = type->data.klass;
  append_class_name (res, D.16957, include_namespace);
  goto <D.16586>;
  <D.16609>:
  {
    struct MonoGenericContext * context;

    D.16959 = type->data.generic_class;
    D.16960 = D.16959->container_class;
    D.16961 = &D.16960->byval_arg;
    mono_type_get_desc (res, D.16961, include_namespace);
    monoeg_g_string_append (res, "<");
    D.16959 = type->data.generic_class;
    context = &D.16959->context;
    D.16962 = context->class_inst;
    if (D.16962 != 0B) goto <D.16963>; else goto <D.16964>;
    <D.16963>:
    i = 0;
    goto <D.16612>;
    <D.16611>:
    if (i > 0) goto <D.16965>; else goto <D.16966>;
    <D.16965>:
    monoeg_g_string_append (res, ", ");
    <D.16966>:
    D.16962 = context->class_inst;
    D.16967 = D.16962->type_argv[i];
    mono_type_get_desc (res, D.16967, include_namespace);
    i = i + 1;
    <D.16612>:
    D.16962 = context->class_inst;
    D.16968 = D.16962->type_argc;
    D.16969 = (int) D.16968;
    if (D.16969 > i) goto <D.16611>; else goto <D.16613>;
    <D.16613>:
    <D.16964>:
    D.16970 = context->method_inst;
    if (D.16970 != 0B) goto <D.16971>; else goto <D.16972>;
    <D.16971>:
    D.16962 = context->class_inst;
    if (D.16962 != 0B) goto <D.16973>; else goto <D.16974>;
    <D.16973>:
    monoeg_g_string_append (res, "; ");
    <D.16974>:
    i = 0;
    goto <D.16615>;
    <D.16614>:
    if (i > 0) goto <D.16975>; else goto <D.16976>;
    <D.16975>:
    monoeg_g_string_append (res, ", ");
    <D.16976>:
    D.16970 = context->method_inst;
    D.16977 = D.16970->type_argv[i];
    mono_type_get_desc (res, D.16977, include_namespace);
    i = i + 1;
    <D.16615>:
    D.16970 = context->method_inst;
    D.16978 = D.16970->type_argc;
    D.16979 = (int) D.16978;
    if (D.16979 > i) goto <D.16614>; else goto <D.16616>;
    <D.16616>:
    <D.16972>:
    monoeg_g_string_append (res, ">");
    goto <D.16586>;
  }
  <D.16617>:
  <D.16618>:
  D.16980 = type->data.generic_param;
  if (D.16980 != 0B) goto <D.16981>; else goto <D.16982>;
  <D.16981>:
  {
    struct MonoGenericParamInfo * info;

    D.16980 = type->data.generic_param;
    D.16984 = D.16980->owner;
    if (D.16984 != 0B) goto <D.16985>; else goto <D.16986>;
    <D.16985>:
    D.16980 = type->data.generic_param;
    iftmp.0 = &MEM[(struct MonoGenericParamFull *)D.16980].info;
    goto <D.16987>;
    <D.16986>:
    iftmp.0 = 0B;
    <D.16987>:
    info = iftmp.0;
    if (info != 0B) goto <D.16988>; else goto <D.16989>;
    <D.16988>:
    D.16990 = info->name;
    monoeg_g_string_append (res, D.16990);
    goto <D.16991>;
    <D.16989>:
    D.16980 = type->data.generic_param;
    D.16992 = D.16980->num;
    D.16993 = (int) D.16992;
    D.16949 = type->type;
    if (D.16949 == 19) goto <D.16995>; else goto <D.16996>;
    <D.16995>:
    iftmp.1 = "!";
    goto <D.16997>;
    <D.16996>:
    iftmp.1 = "!!";
    <D.16997>:
    monoeg_g_string_append_printf (res, "%s%d", iftmp.1, D.16993);
    <D.16991>:
  }
  goto <D.16998>;
  <D.16982>:
  monoeg_g_string_append (res, "<unknown>");
  <D.16998>:
  goto <D.16586>;
  <D.16620>:
  monoeg_g_string_append (res, "typedbyref");
  goto <D.16586>;
  <D.16621>:
  goto <D.16586>;
  <D.16586>:
  D.16999 = BIT_FIELD_REF <*type, 8, 88>;
  D.17000 = D.16999 & 64;
  if (D.17000 != 0) goto <D.17001>; else goto <D.17002>;
  <D.17001>:
  monoeg_g_string_append_c (res, 38);
  <D.17002>:
}


append_class_name (struct GString * res, struct MonoClass * class, gboolean include_namespace)
{
  struct MonoClass * D.17006;
  const char * D.17011;
  char D.17012;
  const char * D.17015;

  if (class == 0B) goto <D.17004>; else goto <D.17005>;
  <D.17004>:
  monoeg_g_string_append (res, "Unknown");
  return;
  <D.17005>:
  D.17006 = class->nested_in;
  if (D.17006 != 0B) goto <D.17007>; else goto <D.17008>;
  <D.17007>:
  D.17006 = class->nested_in;
  append_class_name (res, D.17006, include_namespace);
  monoeg_g_string_append_c (res, 47);
  <D.17008>:
  if (include_namespace != 0) goto <D.17009>; else goto <D.17010>;
  <D.17009>:
  D.17011 = class->name_space;
  D.17012 = *D.17011;
  if (D.17012 != 0) goto <D.17013>; else goto <D.17014>;
  <D.17013>:
  D.17011 = class->name_space;
  monoeg_g_string_append_printf (res, "%s.", D.17011);
  <D.17014>:
  <D.17010>:
  D.17015 = class->name;
  monoeg_g_string_append_printf (res, "%s", D.17015);
}


mono_type_full_name (struct MonoType * type)
{
  char * D.17017;
  struct GString * str;

  str = monoeg_g_string_new ("");
  mono_type_get_desc (str, type, 1);
  D.17017 = monoeg_g_string_free (str, 0);
  return D.17017;
}


mono_signature_get_desc (struct MonoMethodSignature * sig, gboolean include_namespace)
{
  char * D.17021;
  struct MonoType * D.17024;
  short unsigned int D.17025;
  int D.17026;
  int i;
  char * result;
  struct GString * res;

  if (sig == 0B) goto <D.17019>; else goto <D.17020>;
  <D.17019>:
  D.17021 = monoeg_strdup ("<invalid signature>");
  return D.17021;
  <D.17020>:
  res = monoeg_g_string_new ("");
  i = 0;
  goto <D.16634>;
  <D.16633>:
  if (i > 0) goto <D.17022>; else goto <D.17023>;
  <D.17022>:
  monoeg_g_string_append_c (res, 44);
  <D.17023>:
  D.17024 = sig->params[i];
  mono_type_get_desc (res, D.17024, include_namespace);
  i = i + 1;
  <D.16634>:
  D.17025 = sig->param_count;
  D.17026 = (int) D.17025;
  if (D.17026 > i) goto <D.16633>; else goto <D.16635>;
  <D.16635>:
  result = res->str;
  monoeg_g_string_free (res, 0);
  D.17021 = result;
  return D.17021;
}


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

  if (str != 0B) goto <D.17028>; else goto <D.17029>;
  <D.17028>:
  D.17030 = __strdup (str);
  return D.17030;
  <D.17029>:
  D.17030 = 0B;
  return D.17030;
}


mono_context_get_desc (struct MonoGenericContext * context)
{
  struct MonoGenericInst * D.17032;
  struct MonoGenericInst * D.17035;
  char * D.17040;
  char * D.17041;
  struct GString * str;
  char * res;

  str = monoeg_g_string_new ("");
  monoeg_g_string_append (str, "<");
  D.17032 = context->class_inst;
  if (D.17032 != 0B) goto <D.17033>; else goto <D.17034>;
  <D.17033>:
  D.17032 = context->class_inst;
  ginst_get_desc (str, D.17032);
  <D.17034>:
  D.17035 = context->method_inst;
  if (D.17035 != 0B) goto <D.17036>; else goto <D.17037>;
  <D.17036>:
  D.17032 = context->class_inst;
  if (D.17032 != 0B) goto <D.17038>; else goto <D.17039>;
  <D.17038>:
  monoeg_g_string_append (str, "; ");
  <D.17039>:
  D.17035 = context->method_inst;
  ginst_get_desc (str, D.17035);
  <D.17037>:
  monoeg_g_string_append (str, ">");
  D.17040 = str->str;
  res = monoeg_strdup (D.17040);
  monoeg_g_string_free (str, 1);
  D.17041 = res;
  return D.17041;
}


ginst_get_desc (struct GString * str, struct MonoGenericInst * ginst)
{
  struct MonoType * D.17045;
  <unnamed-unsigned:22> D.17046;
  int D.17047;
  int i;

  i = 0;
  goto <D.16642>;
  <D.16641>:
  if (i > 0) goto <D.17043>; else goto <D.17044>;
  <D.17043>:
  monoeg_g_string_append (str, ", ");
  <D.17044>:
  D.17045 = ginst->type_argv[i];
  mono_type_get_desc (str, D.17045, 1);
  i = i + 1;
  <D.16642>:
  D.17046 = ginst->type_argc;
  D.17047 = (int) D.17046;
  if (D.17047 > i) goto <D.16641>; else goto <D.16643>;
  <D.16643>:
}


mono_method_desc_new (const char * name, gboolean include_namespace)
{
  char * D.17052;
  char D.17053;
  char * use_args.2;
  struct MonoMethodDesc * D.17059;
  char * D.17064;
  char D.17065;
  char * method_name.3;
  char * class_name.4;
  char * iftmp.5;
  char * D.17077;
  char * D.17078;
  char * D.17081;
  char * D.17082;
  char D.17087;
  unsigned int D.17092;
  unsigned int D.17093;
  struct MonoMethodDesc * result;
  char * class_name;
  char * class_nspace;
  char * method_name;
  char * use_args;
  char * end;
  int use_namespace;

  class_nspace = monoeg_strdup (name);
  use_args = __builtin_strchr (class_nspace, 40);
  if (use_args != 0B) goto <D.17048>; else goto <D.17049>;
  <D.17048>:
  if (use_args > class_nspace) goto <D.17050>; else goto <D.17051>;
  <D.17050>:
  D.17052 = use_args + 18446744073709551615;
  D.17053 = *D.17052;
  if (D.17053 == 32) goto <D.17054>; else goto <D.17055>;
  <D.17054>:
  D.17052 = use_args + 18446744073709551615;
  *D.17052 = 0;
  <D.17055>:
  <D.17051>:
  use_args.2 = use_args;
  use_args = use_args.2 + 1;
  *use_args.2 = 0;
  end = __builtin_strchr (use_args, 41);
  if (end == 0B) goto <D.17057>; else goto <D.17058>;
  <D.17057>:
  monoeg_g_free (class_nspace);
  D.17059 = 0B;
  return D.17059;
  <D.17058>:
  *end = 0;
  <D.17049>:
  method_name = strrchr (class_nspace, 58);
  if (method_name == 0B) goto <D.17060>; else goto <D.17061>;
  <D.17060>:
  monoeg_g_free (class_nspace);
  D.17059 = 0B;
  return D.17059;
  <D.17061>:
  if (method_name != class_nspace) goto <D.17062>; else goto <D.17063>;
  <D.17062>:
  D.17064 = method_name + 18446744073709551615;
  D.17065 = *D.17064;
  if (D.17065 == 58) goto <D.17066>; else goto <D.17067>;
  <D.17066>:
  D.17064 = method_name + 18446744073709551615;
  *D.17064 = 0;
  <D.17067>:
  <D.17063>:
  method_name.3 = method_name;
  method_name = method_name.3 + 1;
  *method_name.3 = 0;
  class_name = strrchr (class_nspace, 46);
  if (class_name != 0B) goto <D.17069>; else goto <D.17070>;
  <D.17069>:
  class_name.4 = class_name;
  class_name = class_name.4 + 1;
  *class_name.4 = 0;
  use_namespace = 1;
  goto <D.17072>;
  <D.17070>:
  class_name = class_nspace;
  use_namespace = 0;
  <D.17072>:
  result = monoeg_malloc0 (48);
  result->include_namespace = include_namespace;
  result->name = method_name;
  result->klass = class_name;
  if (use_namespace != 0) goto <D.17074>; else goto <D.17075>;
  <D.17074>:
  iftmp.5 = class_nspace;
  goto <D.17076>;
  <D.17075>:
  iftmp.5 = 0B;
  <D.17076>:
  result->namespace = iftmp.5;
  result->args = use_args;
  D.17077 = result->name;
  D.17078 = __builtin_strchr (D.17077, 42);
  if (D.17078 != 0B) goto <D.17079>; else goto <D.17080>;
  <D.17079>:
  result->name_glob = 1;
  <D.17080>:
  D.17081 = result->klass;
  D.17082 = __builtin_strchr (D.17081, 42);
  if (D.17082 != 0B) goto <D.17083>; else goto <D.17084>;
  <D.17083>:
  result->klass_glob = 1;
  <D.17084>:
  if (use_args != 0B) goto <D.17085>; else goto <D.17086>;
  <D.17085>:
  end = use_args;
  D.17087 = *end;
  if (D.17087 != 0) goto <D.17088>; else goto <D.17089>;
  <D.17088>:
  result->num_args = 1;
  <D.17089>:
  goto <D.16661>;
  <D.16660>:
  D.17087 = *end;
  if (D.17087 == 44) goto <D.17090>; else goto <D.17091>;
  <D.17090>:
  D.17092 = result->num_args;
  D.17093 = D.17092 + 1;
  result->num_args = D.17093;
  <D.17091>:
  end = end + 1;
  <D.16661>:
  D.17087 = *end;
  if (D.17087 != 0) goto <D.16660>; else goto <D.16662>;
  <D.16662>:
  <D.17086>:
  D.17059 = result;
  return D.17059;
}


mono_method_desc_from_method (struct MonoMethod * method)
{
  const char * D.17095;
  gchar * D.17096;
  struct MonoClass * D.17097;
  const char * D.17098;
  gchar * D.17099;
  const char * D.17100;
  gchar * D.17101;
  struct MonoMethodDesc * D.17102;
  struct MonoMethodDesc * result;

  result = monoeg_malloc0 (48);
  result->include_namespace = 1;
  D.17095 = method->name;
  D.17096 = monoeg_strdup (D.17095);
  result->name = D.17096;
  D.17097 = method->klass;
  D.17098 = D.17097->name;
  D.17099 = monoeg_strdup (D.17098);
  result->klass = D.17099;
  D.17097 = method->klass;
  D.17100 = D.17097->name_space;
  D.17101 = monoeg_strdup (D.17100);
  result->namespace = D.17101;
  D.17102 = result;
  return D.17102;
}


mono_method_desc_free (struct MonoMethodDesc * desc)
{
  char * D.17104;
  char * D.17108;

  D.17104 = desc->namespace;
  if (D.17104 != 0B) goto <D.17105>; else goto <D.17106>;
  <D.17105>:
  D.17104 = desc->namespace;
  monoeg_g_free (D.17104);
  goto <D.17107>;
  <D.17106>:
  D.17108 = desc->klass;
  if (D.17108 != 0B) goto <D.17109>; else goto <D.17110>;
  <D.17109>:
  D.17108 = desc->klass;
  monoeg_g_free (D.17108);
  <D.17110>:
  <D.17107>:
  monoeg_g_free (desc);
}


mono_method_desc_match (struct MonoMethodDesc * desc, struct MonoMethod * method)
{
  int D.16684;
  const char * D.17111;
  char * D.17112;
  _Bool D.17113;
  mono_bool D.17116;
  char * D.17117;
  unsigned int D.17120;
  struct MonoMethodSignature * D.17121;
  short unsigned int D.17122;
  unsigned int D.17123;
  int D.17126;
  struct MonoMethodSignature * D.17127;
  int D.16693;
  char * sig;
  gboolean name_match;

  {
    size_t __s1_len;
    size_t __s2_len;

    D.17111 = method->name;
    D.17112 = desc->name;
    D.16684 = __builtin_strcmp (D.17112, D.17111);
  }
  D.17113 = D.16684 == 0;
  name_match = (gboolean) D.17113;
  if (name_match == 0) goto <D.17114>; else goto <D.17115>;
  <D.17114>:
  D.17116 = 0;
  return D.17116;
  <D.17115>:
  D.17117 = desc->args;
  if (D.17117 == 0B) goto <D.17118>; else goto <D.17119>;
  <D.17118>:
  D.17116 = 1;
  return D.17116;
  <D.17119>:
  D.17120 = desc->num_args;
  D.17121 = mono_method_signature (method);
  D.17122 = D.17121->param_count;
  D.17123 = (unsigned int) D.17122;
  if (D.17120 != D.17123) goto <D.17124>; else goto <D.17125>;
  <D.17124>:
  D.17116 = 0;
  return D.17116;
  <D.17125>:
  D.17126 = desc->include_namespace;
  D.17127 = mono_method_signature (method);
  sig = mono_signature_get_desc (D.17127, D.17126);
  {
    size_t __s1_len;
    size_t __s2_len;

    D.17117 = desc->args;
    D.16693 = __builtin_strcmp (sig, D.17117);
  }
  if (D.16693 != 0) goto <D.17128>; else goto <D.17129>;
  <D.17128>:
  monoeg_g_free (sig);
  D.17116 = 0;
  return D.17116;
  <D.17129>:
  monoeg_g_free (sig);
  D.17116 = 1;
  return D.17116;
}


mono_method_desc_full_match (struct MonoMethodDesc * desc, struct MonoMethod * method)
{
  char * D.17131;
  mono_bool D.17134;
  struct MonoClass * D.17135;
  long unsigned int D.17136;
  int D.17137;
  int D.17138;

  D.17131 = desc->klass;
  if (D.17131 == 0B) goto <D.17132>; else goto <D.17133>;
  <D.17132>:
  D.17134 = 0;
  return D.17134;
  <D.17133>:
  D.17135 = method->klass;
  D.17131 = desc->klass;
  D.17136 = strlen (D.17131);
  D.17137 = (int) D.17136;
  D.17138 = match_class (desc, D.17137, D.17135);
  if (D.17138 == 0) goto <D.17139>; else goto <D.17140>;
  <D.17139>:
  D.17134 = 0;
  return D.17134;
  <D.17140>:
  D.17134 = mono_method_desc_match (desc, method);
  return D.17134;
}


match_class (struct MonoMethodDesc * desc, int pos, struct MonoClass * klass)
{
  int D.17142;
  int D.16718;
  int iftmp.6;
  int D.16717;
  const char[2] * D.17148;
  unsigned char D.17149;
  int D.17150;
  unsigned char D.17151;
  int D.17152;
  _Bool D.17153;
  _Bool D.17154;
  _Bool D.17155;
  const unsigned char * D.17158;
  unsigned char D.17159;
  int D.17160;
  const unsigned char * D.17161;
  unsigned char D.17162;
  int D.17163;
  _Bool D.17164;
  _Bool D.17165;
  const unsigned char * D.17168;
  unsigned char D.17169;
  int D.17170;
  const unsigned char * D.17171;
  unsigned char D.17172;
  int D.17173;
  _Bool D.17174;
  _Bool D.17175;
  const unsigned char * D.17178;
  unsigned char D.17179;
  int D.17180;
  const unsigned char * D.17181;
  unsigned char D.17182;
  int D.17183;
  char * D.17185;
  gboolean D.17188;
  int pos.7;
  long unsigned int D.17192;
  const char * D.17193;
  int D.17194;
  char * D.17197;
  int D.16736;
  const char * D.17200;
  int D.16745;
  const char * D.17203;
  struct MonoClass * D.17206;
  const char * p;

  D.17142 = desc->klass_glob;
  if (D.17142 != 0) goto <D.17143>; else goto <D.17144>;
  <D.17143>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = desc->klass;
      D.17148 = "*";
      D.17149 = MEM[(const unsigned char *)D.17148];
      D.17150 = (int) D.17149;
      D.17151 = *__s2;
      D.17152 = (int) D.17151;
      __result = D.17150 - D.17152;
      {
        D.17153 = __s2_len != 0;
        D.17154 = __result == 0;
        D.17155 = D.17153 & D.17154;
        if (D.17155 != 0) goto <D.17156>; else goto <D.17157>;
        <D.17156>:
        D.17158 = &MEM[(void *)"*" + 1B];
        D.17159 = *D.17158;
        D.17160 = (int) D.17159;
        D.17161 = __s2 + 1;
        D.17162 = *D.17161;
        D.17163 = (int) D.17162;
        __result = D.17160 - D.17163;
        D.17164 = __s2_len > 1;
        D.17154 = __result == 0;
        D.17165 = D.17164 & D.17154;
        if (D.17165 != 0) goto <D.17166>; else goto <D.17167>;
        <D.17166>:
        D.17168 = &MEM[(void *)"*" + 2B];
        D.17169 = *D.17168;
        D.17170 = (int) D.17169;
        D.17171 = __s2 + 2;
        D.17172 = *D.17171;
        D.17173 = (int) D.17172;
        __result = D.17170 - D.17173;
        D.17174 = __s2_len > 2;
        D.17154 = __result == 0;
        D.17175 = D.17174 & D.17154;
        if (D.17175 != 0) goto <D.17176>; else goto <D.17177>;
        <D.17176>:
        D.17178 = &MEM[(void *)"*" + 3B];
        D.17179 = *D.17178;
        D.17180 = (int) D.17179;
        D.17181 = __s2 + 3;
        D.17182 = *D.17181;
        D.17183 = (int) D.17182;
        __result = D.17180 - D.17183;
        <D.17177>:
        <D.17167>:
        <D.17157>:
      }
      D.16717 = __result;
    }
    iftmp.6 = -D.16717;
    goto <D.17184>;
    <D.17147>:
    D.17185 = desc->klass;
    iftmp.6 = __builtin_strcmp (D.17185, "*");
    <D.17184>:
    D.16718 = iftmp.6;
  }
  if (D.16718 == 0) goto <D.17186>; else goto <D.17187>;
  <D.17186>:
  D.17188 = 1;
  return D.17188;
  <D.17187>:
  <D.17144>:
  D.17185 = desc->klass;
  p = my_strrchr (D.17185, 47, &pos);
  if (p == 0B) goto <D.17189>; else goto <D.17190>;
  <D.17189>:
  pos.7 = pos;
  D.17192 = (long unsigned int) pos.7;
  D.17193 = klass->name;
  D.17185 = desc->klass;
  D.17194 = strncmp (D.17185, D.17193, D.17192);
  if (D.17194 != 0) goto <D.17195>; else goto <D.17196>;
  <D.17195>:
  D.17188 = 0;
  return D.17188;
  <D.17196>:
  D.17197 = desc->namespace;
  if (D.17197 != 0B) goto <D.17198>; else goto <D.17199>;
  <D.17198>:
  {
    size_t __s1_len;
    size_t __s2_len;

    D.17200 = klass->name_space;
    D.17197 = desc->namespace;
    D.16736 = __builtin_strcmp (D.17197, D.17200);
  }
  if (D.16736 != 0) goto <D.17201>; else goto <D.17202>;
  <D.17201>:
  D.17188 = 0;
  return D.17188;
  <D.17202>:
  <D.17199>:
  D.17188 = 1;
  return D.17188;
  <D.17190>:
  {
    size_t __s1_len;
    size_t __s2_len;

    D.17193 = klass->name;
    D.17203 = p + 1;
    D.16745 = __builtin_strcmp (D.17203, D.17193);
  }
  if (D.16745 != 0) goto <D.17204>; else goto <D.17205>;
  <D.17204>:
  D.17188 = 0;
  return D.17188;
  <D.17205>:
  D.17206 = klass->nested_in;
  if (D.17206 == 0B) goto <D.17207>; else goto <D.17208>;
  <D.17207>:
  D.17188 = 0;
  return D.17188;
  <D.17208>:
  D.17206 = klass->nested_in;
  pos.7 = pos;
  D.17188 = match_class (desc, pos.7, D.17206);
  return D.17188;
}


my_strrchr (const char * str, char ch, int * len)
{
  int D.17210;
  sizetype D.17211;
  const char * D.17212;
  char D.17213;
  const char * D.17216;
  int pos;

  D.17210 = *len;
  pos = D.17210 + -1;
  goto <D.16702>;
  <D.16701>:
  D.17211 = (sizetype) pos;
  D.17212 = str + D.17211;
  D.17213 = *D.17212;
  if (D.17213 != ch) goto <D.17214>; else goto <D.17215>;
  <D.17214>:
  // predicted unlikely by continue predictor.
  goto <D.16700>;
  <D.17215>:
  *len = pos;
  D.17211 = (sizetype) pos;
  D.17216 = str + D.17211;
  return D.17216;
  <D.16700>:
  pos = pos + -1;
  <D.16702>:
  if (pos >= 0) goto <D.16701>; else goto <D.16703>;
  <D.16703>:
  D.17216 = 0B;
  return D.17216;
}


mono_method_desc_search_in_class (struct MonoMethodDesc * desc, struct MonoClass * klass)
{
  int D.17218;
  struct MonoMethod * D.17221;
  struct MonoMethod * m;
  void * iter;

  try
    {
      iter = 0B;
      goto <D.16757>;
      <D.16756>:
      D.17218 = mono_method_desc_match (desc, m);
      if (D.17218 != 0) goto <D.17219>; else goto <D.17220>;
      <D.17219>:
      D.17221 = m;
      return D.17221;
      <D.17220>:
      <D.16757>:
      m = mono_class_get_methods (klass, &iter);
      if (m != 0B) goto <D.16756>; else goto <D.16758>;
      <D.16758>:
      D.17221 = 0B;
      return D.17221;
    }
  finally
    {
      iter = {CLOBBER};
    }
}


mono_method_desc_search_in_image (struct MonoMethodDesc * desc, struct MonoImage * image)
{
  char * D.17224;
  struct MonoImage * D.17227;
  char * D.17230;
  struct MonoMethod * D.17233;
  int D.16778;
  char * D.17240;
  int D.17243;
  int D.17244;
  unsigned int D.17245;
  int D.17246;
  int D.17249;
  struct MonoClass * klass;
  const struct MonoTableInfo * tdef;
  const struct MonoTableInfo * methods;
  struct MonoMethod * method;
  int i;

  D.17224 = desc->namespace;
  if (D.17224 == 0B) goto <D.17225>; else goto <D.17226>;
  <D.17225>:
  D.17227 = mono_defaults.corlib;
  if (D.17227 == image) goto <D.17228>; else goto <D.17229>;
  <D.17228>:
  D.17230 = desc->klass;
  klass = find_system_class (D.17230);
  if (klass != 0B) goto <D.17231>; else goto <D.17232>;
  <D.17231>:
  D.17233 = mono_method_desc_search_in_class (desc, klass);
  return D.17233;
  <D.17232>:
  <D.17229>:
  <D.17226>:
  D.17224 = desc->namespace;
  if (D.17224 != 0B) goto <D.17234>; else goto <D.17235>;
  <D.17234>:
  D.17230 = desc->klass;
  if (D.17230 != 0B) goto <D.17236>; else goto <D.17237>;
  <D.17236>:
  D.17230 = desc->klass;
  D.17224 = desc->namespace;
  klass = mono_class_from_name (image, D.17224, D.17230);
  if (klass == 0B) goto <D.17238>; else goto <D.17239>;
  <D.17238>:
  D.17233 = 0B;
  return D.17233;
  <D.17239>:
  D.17233 = mono_method_desc_search_in_class (desc, klass);
  return D.17233;
  <D.17237>:
  <D.17235>:
  tdef = mono_image_get_table_info (image, 2);
  methods = mono_image_get_table_info (image, 6);
  i = 0;
  goto <D.16781>;
  <D.16780>:
  {
    guint32 token;
    const char * n;

    token = mono_metadata_decode_row_col (methods, i, 3);
    n = mono_metadata_string_heap (image, token);
    {
      size_t __s1_len;
      size_t __s2_len;

      D.17240 = desc->name;
      D.16778 = __builtin_strcmp (n, D.17240);
    }
    if (D.16778 != 0) goto <D.17241>; else goto <D.17242>;
    <D.17241>:
    // predicted unlikely by continue predictor.
    goto <D.16779>;
    <D.17242>:
    D.17243 = i + 1;
    D.17244 = D.17243 | 100663296;
    D.17245 = (unsigned int) D.17244;
    method = mono_get_method (image, D.17245, 0B);
    D.17246 = mono_method_desc_full_match (desc, method);
    if (D.17246 != 0) goto <D.17247>; else goto <D.17248>;
    <D.17247>:
    D.17233 = method;
    return D.17233;
    <D.17248>:
  }
  <D.16779>:
  i = i + 1;
  <D.16781>:
  D.17249 = mono_table_info_get_rows (methods);
  if (D.17249 > i) goto <D.16780>; else goto <D.16782>;
  <D.16782>:
  D.17233 = 0B;
  return D.17233;
}


find_system_class (const char * name)
{
  int D.16434;
  int iftmp.8;
  int D.16433;
  const char[5] * D.17254;
  unsigned char D.17255;
  int D.17256;
  unsigned char D.17257;
  int D.17258;
  _Bool D.17259;
  _Bool D.17260;
  _Bool D.17261;
  const unsigned char * D.17264;
  unsigned char D.17265;
  int D.17266;
  const unsigned char * D.17267;
  unsigned char D.17268;
  int D.17269;
  _Bool D.17270;
  _Bool D.17271;
  const unsigned char * D.17274;
  unsigned char D.17275;
  int D.17276;
  const unsigned char * D.17277;
  unsigned char D.17278;
  int D.17279;
  _Bool D.17280;
  _Bool D.17281;
  const unsigned char * D.17284;
  unsigned char D.17285;
  int D.17286;
  const unsigned char * D.17287;
  unsigned char D.17288;
  int D.17289;
  struct MonoClass * D.17293;
  int D.16443;
  int iftmp.9;
  int D.16442;
  const char[5] * D.17297;
  unsigned char D.17298;
  int D.17299;
  unsigned char D.17300;
  int D.17301;
  _Bool D.17302;
  _Bool D.17303;
  _Bool D.17304;
  const unsigned char * D.17307;
  unsigned char D.17308;
  int D.17309;
  const unsigned char * D.17310;
  unsigned char D.17311;
  int D.17312;
  _Bool D.17313;
  _Bool D.17314;
  const unsigned char * D.17317;
  unsigned char D.17318;
  int D.17319;
  const unsigned char * D.17320;
  unsigned char D.17321;
  int D.17322;
  _Bool D.17323;
  _Bool D.17324;
  const unsigned char * D.17327;
  unsigned char D.17328;
  int D.17329;
  const unsigned char * D.17330;
  unsigned char D.17331;
  int D.17332;
  int D.16452;
  int iftmp.10;
  int D.16451;
  const char[5] * D.17339;
  unsigned char D.17340;
  int D.17341;
  unsigned char D.17342;
  int D.17343;
  _Bool D.17344;
  _Bool D.17345;
  _Bool D.17346;
  const unsigned char * D.17349;
  unsigned char D.17350;
  int D.17351;
  const unsigned char * D.17352;
  unsigned char D.17353;
  int D.17354;
  _Bool D.17355;
  _Bool D.17356;
  const unsigned char * D.17359;
  unsigned char D.17360;
  int D.17361;
  const unsigned char * D.17362;
  unsigned char D.17363;
  int D.17364;
  _Bool D.17365;
  _Bool D.17366;
  const unsigned char * D.17369;
  unsigned char D.17370;
  int D.17371;
  const unsigned char * D.17372;
  unsigned char D.17373;
  int D.17374;
  int D.16461;
  int iftmp.11;
  int D.16460;
  const char[5] * D.17381;
  unsigned char D.17382;
  int D.17383;
  unsigned char D.17384;
  int D.17385;
  _Bool D.17386;
  _Bool D.17387;
  _Bool D.17388;
  const unsigned char * D.17391;
  unsigned char D.17392;
  int D.17393;
  const unsigned char * D.17394;
  unsigned char D.17395;
  int D.17396;
  _Bool D.17397;
  _Bool D.17398;
  const unsigned char * D.17401;
  unsigned char D.17402;
  int D.17403;
  const unsigned char * D.17404;
  unsigned char D.17405;
  int D.17406;
  _Bool D.17407;
  _Bool D.17408;
  const unsigned char * D.17411;
  unsigned char D.17412;
  int D.17413;
  const unsigned char * D.17414;
  unsigned char D.17415;
  int D.17416;
  int D.16470;
  int iftmp.12;
  int D.16469;
  const char[6] * D.17423;
  unsigned char D.17424;
  int D.17425;
  unsigned char D.17426;
  int D.17427;
  _Bool D.17428;
  _Bool D.17429;
  _Bool D.17430;
  const unsigned char * D.17433;
  unsigned char D.17434;
  int D.17435;
  const unsigned char * D.17436;
  unsigned char D.17437;
  int D.17438;
  _Bool D.17439;
  _Bool D.17440;
  const unsigned char * D.17443;
  unsigned char D.17444;
  int D.17445;
  const unsigned char * D.17446;
  unsigned char D.17447;
  int D.17448;
  _Bool D.17449;
  _Bool D.17450;
  const unsigned char * D.17453;
  unsigned char D.17454;
  int D.17455;
  const unsigned char * D.17456;
  unsigned char D.17457;
  int D.17458;
  int D.16479;
  int iftmp.13;
  int D.16478;
  const char[7] * D.17465;
  unsigned char D.17466;
  int D.17467;
  unsigned char D.17468;
  int D.17469;
  _Bool D.17470;
  _Bool D.17471;
  _Bool D.17472;
  const unsigned char * D.17475;
  unsigned char D.17476;
  int D.17477;
  const unsigned char * D.17478;
  unsigned char D.17479;
  int D.17480;
  _Bool D.17481;
  _Bool D.17482;
  const unsigned char * D.17485;
  unsigned char D.17486;
  int D.17487;
  const unsigned char * D.17488;
  unsigned char D.17489;
  int D.17490;
  _Bool D.17491;
  _Bool D.17492;
  const unsigned char * D.17495;
  unsigned char D.17496;
  int D.17497;
  const unsigned char * D.17498;
  unsigned char D.17499;
  int D.17500;
  int D.16488;
  int iftmp.14;
  int D.16487;
  const char[6] * D.17507;
  unsigned char D.17508;
  int D.17509;
  unsigned char D.17510;
  int D.17511;
  _Bool D.17512;
  _Bool D.17513;
  _Bool D.17514;
  const unsigned char * D.17517;
  unsigned char D.17518;
  int D.17519;
  const unsigned char * D.17520;
  unsigned char D.17521;
  int D.17522;
  _Bool D.17523;
  _Bool D.17524;
  const unsigned char * D.17527;
  unsigned char D.17528;
  int D.17529;
  const unsigned char * D.17530;
  unsigned char D.17531;
  int D.17532;
  _Bool D.17533;
  _Bool D.17534;
  const unsigned char * D.17537;
  unsigned char D.17538;
  int D.17539;
  const unsigned char * D.17540;
  unsigned char D.17541;
  int D.17542;
  int D.16497;
  int iftmp.15;
  int D.16496;
  const char[5] * D.17549;
  unsigned char D.17550;
  int D.17551;
  unsigned char D.17552;
  int D.17553;
  _Bool D.17554;
  _Bool D.17555;
  _Bool D.17556;
  const unsigned char * D.17559;
  unsigned char D.17560;
  int D.17561;
  const unsigned char * D.17562;
  unsigned char D.17563;
  int D.17564;
  _Bool D.17565;
  _Bool D.17566;
  const unsigned char * D.17569;
  unsigned char D.17570;
  int D.17571;
  const unsigned char * D.17572;
  unsigned char D.17573;
  int D.17574;
  _Bool D.17575;
  _Bool D.17576;
  const unsigned char * D.17579;
  unsigned char D.17580;
  int D.17581;
  const unsigned char * D.17582;
  unsigned char D.17583;
  int D.17584;
  int D.16506;
  int iftmp.16;
  int D.16505;
  const char[4] * D.17591;
  unsigned char D.17592;
  int D.17593;
  unsigned char D.17594;
  int D.17595;
  _Bool D.17596;
  _Bool D.17597;
  _Bool D.17598;
  const unsigned char * D.17601;
  unsigned char D.17602;
  int D.17603;
  const unsigned char * D.17604;
  unsigned char D.17605;
  int D.17606;
  _Bool D.17607;
  _Bool D.17608;
  const unsigned char * D.17611;
  unsigned char D.17612;
  int D.17613;
  const unsigned char * D.17614;
  unsigned char D.17615;
  int D.17616;
  _Bool D.17617;
  _Bool D.17618;
  const unsigned char * D.17621;
  unsigned char D.17622;
  int D.17623;
  const unsigned char * D.17624;
  unsigned char D.17625;
  int D.17626;
  int D.16515;
  int iftmp.17;
  int D.16514;
  const char[6] * D.17633;
  unsigned char D.17634;
  int D.17635;
  unsigned char D.17636;
  int D.17637;
  _Bool D.17638;
  _Bool D.17639;
  _Bool D.17640;
  const unsigned char * D.17643;
  unsigned char D.17644;
  int D.17645;
  const unsigned char * D.17646;
  unsigned char D.17647;
  int D.17648;
  _Bool D.17649;
  _Bool D.17650;
  const unsigned char * D.17653;
  unsigned char D.17654;
  int D.17655;
  const unsigned char * D.17656;
  unsigned char D.17657;
  int D.17658;
  _Bool D.17659;
  _Bool D.17660;
  const unsigned char * D.17663;
  unsigned char D.17664;
  int D.17665;
  const unsigned char * D.17666;
  unsigned char D.17667;
  int D.17668;
  int D.16524;
  int iftmp.18;
  int D.16523;
  const char[5] * D.17675;
  unsigned char D.17676;
  int D.17677;
  unsigned char D.17678;
  int D.17679;
  _Bool D.17680;
  _Bool D.17681;
  _Bool D.17682;
  const unsigned char * D.17685;
  unsigned char D.17686;
  int D.17687;
  const unsigned char * D.17688;
  unsigned char D.17689;
  int D.17690;
  _Bool D.17691;
  _Bool D.17692;
  const unsigned char * D.17695;
  unsigned char D.17696;
  int D.17697;
  const unsigned char * D.17698;
  unsigned char D.17699;
  int D.17700;
  _Bool D.17701;
  _Bool D.17702;
  const unsigned char * D.17705;
  unsigned char D.17706;
  int D.17707;
  const unsigned char * D.17708;
  unsigned char D.17709;
  int D.17710;
  int D.16533;
  int iftmp.19;
  int D.16532;
  const char[8] * D.17717;
  unsigned char D.17718;
  int D.17719;
  unsigned char D.17720;
  int D.17721;
  _Bool D.17722;
  _Bool D.17723;
  _Bool D.17724;
  const unsigned char * D.17727;
  unsigned char D.17728;
  int D.17729;
  const unsigned char * D.17730;
  unsigned char D.17731;
  int D.17732;
  _Bool D.17733;
  _Bool D.17734;
  const unsigned char * D.17737;
  unsigned char D.17738;
  int D.17739;
  const unsigned char * D.17740;
  unsigned char D.17741;
  int D.17742;
  _Bool D.17743;
  _Bool D.17744;
  const unsigned char * D.17747;
  unsigned char D.17748;
  int D.17749;
  const unsigned char * D.17750;
  unsigned char D.17751;
  int D.17752;
  int D.16542;
  int iftmp.20;
  int D.16541;
  const char[7] * D.17759;
  unsigned char D.17760;
  int D.17761;
  unsigned char D.17762;
  int D.17763;
  _Bool D.17764;
  _Bool D.17765;
  _Bool D.17766;
  const unsigned char * D.17769;
  unsigned char D.17770;
  int D.17771;
  const unsigned char * D.17772;
  unsigned char D.17773;
  int D.17774;
  _Bool D.17775;
  _Bool D.17776;
  const unsigned char * D.17779;
  unsigned char D.17780;
  int D.17781;
  const unsigned char * D.17782;
  unsigned char D.17783;
  int D.17784;
  _Bool D.17785;
  _Bool D.17786;
  const unsigned char * D.17789;
  unsigned char D.17790;
  int D.17791;
  const unsigned char * D.17792;
  unsigned char D.17793;
  int D.17794;
  int D.16551;
  int iftmp.21;
  int D.16550;
  const char[7] * D.17801;
  unsigned char D.17802;
  int D.17803;
  unsigned char D.17804;
  int D.17805;
  _Bool D.17806;
  _Bool D.17807;
  _Bool D.17808;
  const unsigned char * D.17811;
  unsigned char D.17812;
  int D.17813;
  const unsigned char * D.17814;
  unsigned char D.17815;
  int D.17816;
  _Bool D.17817;
  _Bool D.17818;
  const unsigned char * D.17821;
  unsigned char D.17822;
  int D.17823;
  const unsigned char * D.17824;
  unsigned char D.17825;
  int D.17826;
  _Bool D.17827;
  _Bool D.17828;
  const unsigned char * D.17831;
  unsigned char D.17832;
  int D.17833;
  const unsigned char * D.17834;
  unsigned char D.17835;
  int D.17836;
  int D.16560;
  int iftmp.22;
  int D.16559;
  const char[7] * D.17843;
  unsigned char D.17844;
  int D.17845;
  unsigned char D.17846;
  int D.17847;
  _Bool D.17848;
  _Bool D.17849;
  _Bool D.17850;
  const unsigned char * D.17853;
  unsigned char D.17854;
  int D.17855;
  const unsigned char * D.17856;
  unsigned char D.17857;
  int D.17858;
  _Bool D.17859;
  _Bool D.17860;
  const unsigned char * D.17863;
  unsigned char D.17864;
  int D.17865;
  const unsigned char * D.17866;
  unsigned char D.17867;
  int D.17868;
  _Bool D.17869;
  _Bool D.17870;
  const unsigned char * D.17873;
  unsigned char D.17874;
  int D.17875;
  const unsigned char * D.17876;
  unsigned char D.17877;
  int D.17878;
  int D.16569;
  int iftmp.23;
  int D.16568;
  const char[7] * D.17885;
  unsigned char D.17886;
  int D.17887;
  unsigned char D.17888;
  int D.17889;
  _Bool D.17890;
  _Bool D.17891;
  _Bool D.17892;
  const unsigned char * D.17895;
  unsigned char D.17896;
  int D.17897;
  const unsigned char * D.17898;
  unsigned char D.17899;
  int D.17900;
  _Bool D.17901;
  _Bool D.17902;
  const unsigned char * D.17905;
  unsigned char D.17906;
  int D.17907;
  const unsigned char * D.17908;
  unsigned char D.17909;
  int D.17910;
  _Bool D.17911;
  _Bool D.17912;
  const unsigned char * D.17915;
  unsigned char D.17916;
  int D.17917;
  const unsigned char * D.17918;
  unsigned char D.17919;
  int D.17920;
  int D.16578;
  int iftmp.24;
  int D.16577;
  const char[7] * D.17927;
  unsigned char D.17928;
  int D.17929;
  unsigned char D.17930;
  int D.17931;
  _Bool D.17932;
  _Bool D.17933;
  _Bool D.17934;
  const unsigned char * D.17937;
  unsigned char D.17938;
  int D.17939;
  const unsigned char * D.17940;
  unsigned char D.17941;
  int D.17942;
  _Bool D.17943;
  _Bool D.17944;
  const unsigned char * D.17947;
  unsigned char D.17948;
  int D.17949;
  const unsigned char * D.17950;
  unsigned char D.17951;
  int D.17952;
  _Bool D.17953;
  _Bool D.17954;
  const unsigned char * D.17957;
  unsigned char D.17958;
  int D.17959;
  const unsigned char * D.17960;
  unsigned char D.17961;
  int D.17962;

  {
    size_t __s1_len;
    size_t __s2_len;

    __s2_len = 4;
    if (__s2_len <= 3) goto <D.17252>; else goto <D.17253>;
    <D.17252>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = name;
      D.17254 = "void";
      D.17255 = MEM[(const unsigned char *)D.17254];
      D.17256 = (int) D.17255;
      D.17257 = *__s2;
      D.17258 = (int) D.17257;
      __result = D.17256 - D.17258;
      {
        D.17259 = __s2_len != 0;
        D.17260 = __result == 0;
        D.17261 = D.17259 & D.17260;
        if (D.17261 != 0) goto <D.17262>; else goto <D.17263>;
        <D.17262>:
        D.17264 = &MEM[(void *)"void" + 1B];
        D.17265 = *D.17264;
        D.17266 = (int) D.17265;
        D.17267 = __s2 + 1;
        D.17268 = *D.17267;
        D.17269 = (int) D.17268;
        __result = D.17266 - D.17269;
        D.17270 = __s2_len > 1;
        D.17260 = __result == 0;
        D.17271 = D.17270 & D.17260;
        if (D.17271 != 0) goto <D.17272>; else goto <D.17273>;
        <D.17272>:
        D.17274 = &MEM[(void *)"void" + 2B];
        D.17275 = *D.17274;
        D.17276 = (int) D.17275;
        D.17277 = __s2 + 2;
        D.17278 = *D.17277;
        D.17279 = (int) D.17278;
        __result = D.17276 - D.17279;
        D.17280 = __s2_len > 2;
        D.17260 = __result == 0;
        D.17281 = D.17280 & D.17260;
        if (D.17281 != 0) goto <D.17282>; else goto <D.17283>;
        <D.17282>:
        D.17284 = &MEM[(void *)"void" + 3B];
        D.17285 = *D.17284;
        D.17286 = (int) D.17285;
        D.17287 = __s2 + 3;
        D.17288 = *D.17287;
        D.17289 = (int) D.17288;
        __result = D.17286 - D.17289;
        <D.17283>:
        <D.17273>:
        <D.17263>:
      }
      D.16433 = __result;
    }
    iftmp.8 = -D.16433;
    goto <D.17290>;
    <D.17253>:
    iftmp.8 = __builtin_strcmp (name, "void");
    <D.17290>:
    D.16434 = iftmp.8;
  }
  if (D.16434 == 0) goto <D.17291>; else goto <D.17292>;
  <D.17291>:
  D.17293 = mono_defaults.void_class;
  return D.17293;
  <D.17292>:
  {
    size_t __s1_len;
    size_t __s2_len;

    __s2_len = 4;
    if (__s2_len <= 3) goto <D.17295>; else goto <D.17296>;
    <D.17295>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = name;
      D.17297 = "char";
      D.17298 = MEM[(const unsigned char *)D.17297];
      D.17299 = (int) D.17298;
      D.17300 = *__s2;
      D.17301 = (int) D.17300;
      __result = D.17299 - D.17301;
      {
        D.17302 = __s2_len != 0;
        D.17303 = __result == 0;
        D.17304 = D.17302 & D.17303;
        if (D.17304 != 0) goto <D.17305>; else goto <D.17306>;
        <D.17305>:
        D.17307 = &MEM[(void *)"char" + 1B];
        D.17308 = *D.17307;
        D.17309 = (int) D.17308;
        D.17310 = __s2 + 1;
        D.17311 = *D.17310;
        D.17312 = (int) D.17311;
        __result = D.17309 - D.17312;
        D.17313 = __s2_len > 1;
        D.17303 = __result == 0;
        D.17314 = D.17313 & D.17303;
        if (D.17314 != 0) goto <D.17315>; else goto <D.17316>;
        <D.17315>:
        D.17317 = &MEM[(void *)"char" + 2B];
        D.17318 = *D.17317;
        D.17319 = (int) D.17318;
        D.17320 = __s2 + 2;
        D.17321 = *D.17320;
        D.17322 = (int) D.17321;
        __result = D.17319 - D.17322;
        D.17323 = __s2_len > 2;
        D.17303 = __result == 0;
        D.17324 = D.17323 & D.17303;
        if (D.17324 != 0) goto <D.17325>; else goto <D.17326>;
        <D.17325>:
        D.17327 = &MEM[(void *)"char" + 3B];
        D.17328 = *D.17327;
        D.17329 = (int) D.17328;
        D.17330 = __s2 + 3;
        D.17331 = *D.17330;
        D.17332 = (int) D.17331;
        __result = D.17329 - D.17332;
        <D.17326>:
        <D.17316>:
        <D.17306>:
      }
      D.16442 = __result;
    }
    iftmp.9 = -D.16442;
    goto <D.17333>;
    <D.17296>:
    iftmp.9 = __builtin_strcmp (name, "char");
    <D.17333>:
    D.16443 = iftmp.9;
  }
  if (D.16443 == 0) goto <D.17334>; else goto <D.17335>;
  <D.17334>:
  D.17293 = mono_defaults.char_class;
  return D.17293;
  <D.17335>:
  {
    size_t __s1_len;
    size_t __s2_len;

    __s2_len = 4;
    if (__s2_len <= 3) goto <D.17337>; else goto <D.17338>;
    <D.17337>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = name;
      D.17339 = "bool";
      D.17340 = MEM[(const unsigned char *)D.17339];
      D.17341 = (int) D.17340;
      D.17342 = *__s2;
      D.17343 = (int) D.17342;
      __result = D.17341 - D.17343;
      {
        D.17344 = __s2_len != 0;
        D.17345 = __result == 0;
        D.17346 = D.17344 & D.17345;
        if (D.17346 != 0) goto <D.17347>; else goto <D.17348>;
        <D.17347>:
        D.17349 = &MEM[(void *)"bool" + 1B];
        D.17350 = *D.17349;
        D.17351 = (int) D.17350;
        D.17352 = __s2 + 1;
        D.17353 = *D.17352;
        D.17354 = (int) D.17353;
        __result = D.17351 - D.17354;
        D.17355 = __s2_len > 1;
        D.17345 = __result == 0;
        D.17356 = D.17355 & D.17345;
        if (D.17356 != 0) goto <D.17357>; else goto <D.17358>;
        <D.17357>:
        D.17359 = &MEM[(void *)"bool" + 2B];
        D.17360 = *D.17359;
        D.17361 = (int) D.17360;
        D.17362 = __s2 + 2;
        D.17363 = *D.17362;
        D.17364 = (int) D.17363;
        __result = D.17361 - D.17364;
        D.17365 = __s2_len > 2;
        D.17345 = __result == 0;
        D.17366 = D.17365 & D.17345;
        if (D.17366 != 0) goto <D.17367>; else goto <D.17368>;
        <D.17367>:
        D.17369 = &MEM[(void *)"bool" + 3B];
        D.17370 = *D.17369;
        D.17371 = (int) D.17370;
        D.17372 = __s2 + 3;
        D.17373 = *D.17372;
        D.17374 = (int) D.17373;
        __result = D.17371 - D.17374;
        <D.17368>:
        <D.17358>:
        <D.17348>:
      }
      D.16451 = __result;
    }
    iftmp.10 = -D.16451;
    goto <D.17375>;
    <D.17338>:
    iftmp.10 = __builtin_strcmp (name, "bool");
    <D.17375>:
    D.16452 = iftmp.10;
  }
  if (D.16452 == 0) goto <D.17376>; else goto <D.17377>;
  <D.17376>:
  D.17293 = mono_defaults.boolean_class;
  return D.17293;
  <D.17377>:
  {
    size_t __s1_len;
    size_t __s2_len;

    __s2_len = 4;
    if (__s2_len <= 3) goto <D.17379>; else goto <D.17380>;
    <D.17379>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = name;
      D.17381 = "byte";
      D.17382 = MEM[(const unsigned char *)D.17381];
      D.17383 = (int) D.17382;
      D.17384 = *__s2;
      D.17385 = (int) D.17384;
      __result = D.17383 - D.17385;
      {
        D.17386 = __s2_len != 0;
        D.17387 = __result == 0;
        D.17388 = D.17386 & D.17387;
        if (D.17388 != 0) goto <D.17389>; else goto <D.17390>;
        <D.17389>:
        D.17391 = &MEM[(void *)"byte" + 1B];
        D.17392 = *D.17391;
        D.17393 = (int) D.17392;
        D.17394 = __s2 + 1;
        D.17395 = *D.17394;
        D.17396 = (int) D.17395;
        __result = D.17393 - D.17396;
        D.17397 = __s2_len > 1;
        D.17387 = __result == 0;
        D.17398 = D.17397 & D.17387;
        if (D.17398 != 0) goto <D.17399>; else goto <D.17400>;
        <D.17399>:
        D.17401 = &MEM[(void *)"byte" + 2B];
        D.17402 = *D.17401;
        D.17403 = (int) D.17402;
        D.17404 = __s2 + 2;
        D.17405 = *D.17404;
        D.17406 = (int) D.17405;
        __result = D.17403 - D.17406;
        D.17407 = __s2_len > 2;
        D.17387 = __result == 0;
        D.17408 = D.17407 & D.17387;
        if (D.17408 != 0) goto <D.17409>; else goto <D.17410>;
        <D.17409>:
        D.17411 = &MEM[(void *)"byte" + 3B];
        D.17412 = *D.17411;
        D.17413 = (int) D.17412;
        D.17414 = __s2 + 3;
        D.17415 = *D.17414;
        D.17416 = (int) D.17415;
        __result = D.17413 - D.17416;
        <D.17410>:
        <D.17400>:
        <D.17390>:
      }
      D.16460 = __result;
    }
    iftmp.11 = -D.16460;
    goto <D.17417>;
    <D.17380>:
    iftmp.11 = __builtin_strcmp (name, "byte");
    <D.17417>:
    D.16461 = iftmp.11;
  }
  if (D.16461 == 0) goto <D.17418>; else goto <D.17419>;
  <D.17418>:
  D.17293 = mono_defaults.byte_class;
  return D.17293;
  <D.17419>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = name;
      D.17423 = "sbyte";
      D.17424 = MEM[(const unsigned char *)D.17423];
      D.17425 = (int) D.17424;
      D.17426 = *__s2;
      D.17427 = (int) D.17426;
      __result = D.17425 - D.17427;
      {
        D.17428 = __s2_len != 0;
        D.17429 = __result == 0;
        D.17430 = D.17428 & D.17429;
        if (D.17430 != 0) goto <D.17431>; else goto <D.17432>;
        <D.17431>:
        D.17433 = &MEM[(void *)"sbyte" + 1B];
        D.17434 = *D.17433;
        D.17435 = (int) D.17434;
        D.17436 = __s2 + 1;
        D.17437 = *D.17436;
        D.17438 = (int) D.17437;
        __result = D.17435 - D.17438;
        D.17439 = __s2_len > 1;
        D.17429 = __result == 0;
        D.17440 = D.17439 & D.17429;
        if (D.17440 != 0) goto <D.17441>; else goto <D.17442>;
        <D.17441>:
        D.17443 = &MEM[(void *)"sbyte" + 2B];
        D.17444 = *D.17443;
        D.17445 = (int) D.17444;
        D.17446 = __s2 + 2;
        D.17447 = *D.17446;
        D.17448 = (int) D.17447;
        __result = D.17445 - D.17448;
        D.17449 = __s2_len > 2;
        D.17429 = __result == 0;
        D.17450 = D.17449 & D.17429;
        if (D.17450 != 0) goto <D.17451>; else goto <D.17452>;
        <D.17451>:
        D.17453 = &MEM[(void *)"sbyte" + 3B];
        D.17454 = *D.17453;
        D.17455 = (int) D.17454;
        D.17456 = __s2 + 3;
        D.17457 = *D.17456;
        D.17458 = (int) D.17457;
        __result = D.17455 - D.17458;
        <D.17452>:
        <D.17442>:
        <D.17432>:
      }
      D.16469 = __result;
    }
    iftmp.12 = -D.16469;
    goto <D.17459>;
    <D.17422>:
    iftmp.12 = __builtin_strcmp (name, "sbyte");
    <D.17459>:
    D.16470 = iftmp.12;
  }
  if (D.16470 == 0) goto <D.17460>; else goto <D.17461>;
  <D.17460>:
  D.17293 = mono_defaults.sbyte_class;
  return D.17293;
  <D.17461>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = name;
      D.17465 = "uint16";
      D.17466 = MEM[(const unsigned char *)D.17465];
      D.17467 = (int) D.17466;
      D.17468 = *__s2;
      D.17469 = (int) D.17468;
      __result = D.17467 - D.17469;
      {
        D.17470 = __s2_len != 0;
        D.17471 = __result == 0;
        D.17472 = D.17470 & D.17471;
        if (D.17472 != 0) goto <D.17473>; else goto <D.17474>;
        <D.17473>:
        D.17475 = &MEM[(void *)"uint16" + 1B];
        D.17476 = *D.17475;
        D.17477 = (int) D.17476;
        D.17478 = __s2 + 1;
        D.17479 = *D.17478;
        D.17480 = (int) D.17479;
        __result = D.17477 - D.17480;
        D.17481 = __s2_len > 1;
        D.17471 = __result == 0;
        D.17482 = D.17481 & D.17471;
        if (D.17482 != 0) goto <D.17483>; else goto <D.17484>;
        <D.17483>:
        D.17485 = &MEM[(void *)"uint16" + 2B];
        D.17486 = *D.17485;
        D.17487 = (int) D.17486;
        D.17488 = __s2 + 2;
        D.17489 = *D.17488;
        D.17490 = (int) D.17489;
        __result = D.17487 - D.17490;
        D.17491 = __s2_len > 2;
        D.17471 = __result == 0;
        D.17492 = D.17491 & D.17471;
        if (D.17492 != 0) goto <D.17493>; else goto <D.17494>;
        <D.17493>:
        D.17495 = &MEM[(void *)"uint16" + 3B];
        D.17496 = *D.17495;
        D.17497 = (int) D.17496;
        D.17498 = __s2 + 3;
        D.17499 = *D.17498;
        D.17500 = (int) D.17499;
        __result = D.17497 - D.17500;
        <D.17494>:
        <D.17484>:
        <D.17474>:
      }
      D.16478 = __result;
    }
    iftmp.13 = -D.16478;
    goto <D.17501>;
    <D.17464>:
    iftmp.13 = __builtin_strcmp (name, "uint16");
    <D.17501>:
    D.16479 = iftmp.13;
  }
  if (D.16479 == 0) goto <D.17502>; else goto <D.17503>;
  <D.17502>:
  D.17293 = mono_defaults.uint16_class;
  return D.17293;
  <D.17503>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = name;
      D.17507 = "int16";
      D.17508 = MEM[(const unsigned char *)D.17507];
      D.17509 = (int) D.17508;
      D.17510 = *__s2;
      D.17511 = (int) D.17510;
      __result = D.17509 - D.17511;
      {
        D.17512 = __s2_len != 0;
        D.17513 = __result == 0;
        D.17514 = D.17512 & D.17513;
        if (D.17514 != 0) goto <D.17515>; else goto <D.17516>;
        <D.17515>:
        D.17517 = &MEM[(void *)"int16" + 1B];
        D.17518 = *D.17517;
        D.17519 = (int) D.17518;
        D.17520 = __s2 + 1;
        D.17521 = *D.17520;
        D.17522 = (int) D.17521;
        __result = D.17519 - D.17522;
        D.17523 = __s2_len > 1;
        D.17513 = __result == 0;
        D.17524 = D.17523 & D.17513;
        if (D.17524 != 0) goto <D.17525>; else goto <D.17526>;
        <D.17525>:
        D.17527 = &MEM[(void *)"int16" + 2B];
        D.17528 = *D.17527;
        D.17529 = (int) D.17528;
        D.17530 = __s2 + 2;
        D.17531 = *D.17530;
        D.17532 = (int) D.17531;
        __result = D.17529 - D.17532;
        D.17533 = __s2_len > 2;
        D.17513 = __result == 0;
        D.17534 = D.17533 & D.17513;
        if (D.17534 != 0) goto <D.17535>; else goto <D.17536>;
        <D.17535>:
        D.17537 = &MEM[(void *)"int16" + 3B];
        D.17538 = *D.17537;
        D.17539 = (int) D.17538;
        D.17540 = __s2 + 3;
        D.17541 = *D.17540;
        D.17542 = (int) D.17541;
        __result = D.17539 - D.17542;
        <D.17536>:
        <D.17526>:
        <D.17516>:
      }
      D.16487 = __result;
    }
    iftmp.14 = -D.16487;
    goto <D.17543>;
    <D.17506>:
    iftmp.14 = __builtin_strcmp (name, "int16");
    <D.17543>:
    D.16488 = iftmp.14;
  }
  if (D.16488 == 0) goto <D.17544>; else goto <D.17545>;
  <D.17544>:
  D.17293 = mono_defaults.int16_class;
  return D.17293;
  <D.17545>:
  {
    size_t __s1_len;
    size_t __s2_len;

    __s2_len = 4;
    if (__s2_len <= 3) goto <D.17547>; else goto <D.17548>;
    <D.17547>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = name;
      D.17549 = "uint";
      D.17550 = MEM[(const unsigned char *)D.17549];
      D.17551 = (int) D.17550;
      D.17552 = *__s2;
      D.17553 = (int) D.17552;
      __result = D.17551 - D.17553;
      {
        D.17554 = __s2_len != 0;
        D.17555 = __result == 0;
        D.17556 = D.17554 & D.17555;
        if (D.17556 != 0) goto <D.17557>; else goto <D.17558>;
        <D.17557>:
        D.17559 = &MEM[(void *)"uint" + 1B];
        D.17560 = *D.17559;
        D.17561 = (int) D.17560;
        D.17562 = __s2 + 1;
        D.17563 = *D.17562;
        D.17564 = (int) D.17563;
        __result = D.17561 - D.17564;
        D.17565 = __s2_len > 1;
        D.17555 = __result == 0;
        D.17566 = D.17565 & D.17555;
        if (D.17566 != 0) goto <D.17567>; else goto <D.17568>;
        <D.17567>:
        D.17569 = &MEM[(void *)"uint" + 2B];
        D.17570 = *D.17569;
        D.17571 = (int) D.17570;
        D.17572 = __s2 + 2;
        D.17573 = *D.17572;
        D.17574 = (int) D.17573;
        __result = D.17571 - D.17574;
        D.17575 = __s2_len > 2;
        D.17555 = __result == 0;
        D.17576 = D.17575 & D.17555;
        if (D.17576 != 0) goto <D.17577>; else goto <D.17578>;
        <D.17577>:
        D.17579 = &MEM[(void *)"uint" + 3B];
        D.17580 = *D.17579;
        D.17581 = (int) D.17580;
        D.17582 = __s2 + 3;
        D.17583 = *D.17582;
        D.17584 = (int) D.17583;
        __result = D.17581 - D.17584;
        <D.17578>:
        <D.17568>:
        <D.17558>:
      }
      D.16496 = __result;
    }
    iftmp.15 = -D.16496;
    goto <D.17585>;
    <D.17548>:
    iftmp.15 = __builtin_strcmp (name, "uint");
    <D.17585>:
    D.16497 = iftmp.15;
  }
  if (D.16497 == 0) goto <D.17586>; else goto <D.17587>;
  <D.17586>:
  D.17293 = mono_defaults.uint32_class;
  return D.17293;
  <D.17587>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = name;
      D.17591 = "int";
      D.17592 = MEM[(const unsigned char *)D.17591];
      D.17593 = (int) D.17592;
      D.17594 = *__s2;
      D.17595 = (int) D.17594;
      __result = D.17593 - D.17595;
      {
        D.17596 = __s2_len != 0;
        D.17597 = __result == 0;
        D.17598 = D.17596 & D.17597;
        if (D.17598 != 0) goto <D.17599>; else goto <D.17600>;
        <D.17599>:
        D.17601 = &MEM[(void *)"int" + 1B];
        D.17602 = *D.17601;
        D.17603 = (int) D.17602;
        D.17604 = __s2 + 1;
        D.17605 = *D.17604;
        D.17606 = (int) D.17605;
        __result = D.17603 - D.17606;
        D.17607 = __s2_len > 1;
        D.17597 = __result == 0;
        D.17608 = D.17607 & D.17597;
        if (D.17608 != 0) goto <D.17609>; else goto <D.17610>;
        <D.17609>:
        D.17611 = &MEM[(void *)"int" + 2B];
        D.17612 = *D.17611;
        D.17613 = (int) D.17612;
        D.17614 = __s2 + 2;
        D.17615 = *D.17614;
        D.17616 = (int) D.17615;
        __result = D.17613 - D.17616;
        D.17617 = __s2_len > 2;
        D.17597 = __result == 0;
        D.17618 = D.17617 & D.17597;
        if (D.17618 != 0) goto <D.17619>; else goto <D.17620>;
        <D.17619>:
        D.17621 = &MEM[(void *)"int" + 3B];
        D.17622 = *D.17621;
        D.17623 = (int) D.17622;
        D.17624 = __s2 + 3;
        D.17625 = *D.17624;
        D.17626 = (int) D.17625;
        __result = D.17623 - D.17626;
        <D.17620>:
        <D.17610>:
        <D.17600>:
      }
      D.16505 = __result;
    }
    iftmp.16 = -D.16505;
    goto <D.17627>;
    <D.17590>:
    iftmp.16 = __builtin_strcmp (name, "int");
    <D.17627>:
    D.16506 = iftmp.16;
  }
  if (D.16506 == 0) goto <D.17628>; else goto <D.17629>;
  <D.17628>:
  D.17293 = mono_defaults.int32_class;
  return D.17293;
  <D.17629>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = name;
      D.17633 = "ulong";
      D.17634 = MEM[(const unsigned char *)D.17633];
      D.17635 = (int) D.17634;
      D.17636 = *__s2;
      D.17637 = (int) D.17636;
      __result = D.17635 - D.17637;
      {
        D.17638 = __s2_len != 0;
        D.17639 = __result == 0;
        D.17640 = D.17638 & D.17639;
        if (D.17640 != 0) goto <D.17641>; else goto <D.17642>;
        <D.17641>:
        D.17643 = &MEM[(void *)"ulong" + 1B];
        D.17644 = *D.17643;
        D.17645 = (int) D.17644;
        D.17646 = __s2 + 1;
        D.17647 = *D.17646;
        D.17648 = (int) D.17647;
        __result = D.17645 - D.17648;
        D.17649 = __s2_len > 1;
        D.17639 = __result == 0;
        D.17650 = D.17649 & D.17639;
        if (D.17650 != 0) goto <D.17651>; else goto <D.17652>;
        <D.17651>:
        D.17653 = &MEM[(void *)"ulong" + 2B];
        D.17654 = *D.17653;
        D.17655 = (int) D.17654;
        D.17656 = __s2 + 2;
        D.17657 = *D.17656;
        D.17658 = (int) D.17657;
        __result = D.17655 - D.17658;
        D.17659 = __s2_len > 2;
        D.17639 = __result == 0;
        D.17660 = D.17659 & D.17639;
        if (D.17660 != 0) goto <D.17661>; else goto <D.17662>;
        <D.17661>:
        D.17663 = &MEM[(void *)"ulong" + 3B];
        D.17664 = *D.17663;
        D.17665 = (int) D.17664;
        D.17666 = __s2 + 3;
        D.17667 = *D.17666;
        D.17668 = (int) D.17667;
        __result = D.17665 - D.17668;
        <D.17662>:
        <D.17652>:
        <D.17642>:
      }
      D.16514 = __result;
    }
    iftmp.17 = -D.16514;
    goto <D.17669>;
    <D.17632>:
    iftmp.17 = __builtin_strcmp (name, "ulong");
    <D.17669>:
    D.16515 = iftmp.17;
  }
  if (D.16515 == 0) goto <D.17670>; else goto <D.17671>;
  <D.17670>:
  D.17293 = mono_defaults.uint64_class;
  return D.17293;
  <D.17671>:
  {
    size_t __s1_len;
    size_t __s2_len;

    __s2_len = 4;
    if (__s2_len <= 3) goto <D.17673>; else goto <D.17674>;
    <D.17673>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = name;
      D.17675 = "long";
      D.17676 = MEM[(const unsigned char *)D.17675];
      D.17677 = (int) D.17676;
      D.17678 = *__s2;
      D.17679 = (int) D.17678;
      __result = D.17677 - D.17679;
      {
        D.17680 = __s2_len != 0;
        D.17681 = __result == 0;
        D.17682 = D.17680 & D.17681;
        if (D.17682 != 0) goto <D.17683>; else goto <D.17684>;
        <D.17683>:
        D.17685 = &MEM[(void *)"long" + 1B];
        D.17686 = *D.17685;
        D.17687 = (int) D.17686;
        D.17688 = __s2 + 1;
        D.17689 = *D.17688;
        D.17690 = (int) D.17689;
        __result = D.17687 - D.17690;
        D.17691 = __s2_len > 1;
        D.17681 = __result == 0;
        D.17692 = D.17691 & D.17681;
        if (D.17692 != 0) goto <D.17693>; else goto <D.17694>;
        <D.17693>:
        D.17695 = &MEM[(void *)"long" + 2B];
        D.17696 = *D.17695;
        D.17697 = (int) D.17696;
        D.17698 = __s2 + 2;
        D.17699 = *D.17698;
        D.17700 = (int) D.17699;
        __result = D.17697 - D.17700;
        D.17701 = __s2_len > 2;
        D.17681 = __result == 0;
        D.17702 = D.17701 & D.17681;
        if (D.17702 != 0) goto <D.17703>; else goto <D.17704>;
        <D.17703>:
        D.17705 = &MEM[(void *)"long" + 3B];
        D.17706 = *D.17705;
        D.17707 = (int) D.17706;
        D.17708 = __s2 + 3;
        D.17709 = *D.17708;
        D.17710 = (int) D.17709;
        __result = D.17707 - D.17710;
        <D.17704>:
        <D.17694>:
        <D.17684>:
      }
      D.16523 = __result;
    }
    iftmp.18 = -D.16523;
    goto <D.17711>;
    <D.17674>:
    iftmp.18 = __builtin_strcmp (name, "long");
    <D.17711>:
    D.16524 = iftmp.18;
  }
  if (D.16524 == 0) goto <D.17712>; else goto <D.17713>;
  <D.17712>:
  D.17293 = mono_defaults.int64_class;
  return D.17293;
  <D.17713>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = name;
      D.17717 = "uintptr";
      D.17718 = MEM[(const unsigned char *)D.17717];
      D.17719 = (int) D.17718;
      D.17720 = *__s2;
      D.17721 = (int) D.17720;
      __result = D.17719 - D.17721;
      {
        D.17722 = __s2_len != 0;
        D.17723 = __result == 0;
        D.17724 = D.17722 & D.17723;
        if (D.17724 != 0) goto <D.17725>; else goto <D.17726>;
        <D.17725>:
        D.17727 = &MEM[(void *)"uintptr" + 1B];
        D.17728 = *D.17727;
        D.17729 = (int) D.17728;
        D.17730 = __s2 + 1;
        D.17731 = *D.17730;
        D.17732 = (int) D.17731;
        __result = D.17729 - D.17732;
        D.17733 = __s2_len > 1;
        D.17723 = __result == 0;
        D.17734 = D.17733 & D.17723;
        if (D.17734 != 0) goto <D.17735>; else goto <D.17736>;
        <D.17735>:
        D.17737 = &MEM[(void *)"uintptr" + 2B];
        D.17738 = *D.17737;
        D.17739 = (int) D.17738;
        D.17740 = __s2 + 2;
        D.17741 = *D.17740;
        D.17742 = (int) D.17741;
        __result = D.17739 - D.17742;
        D.17743 = __s2_len > 2;
        D.17723 = __result == 0;
        D.17744 = D.17743 & D.17723;
        if (D.17744 != 0) goto <D.17745>; else goto <D.17746>;
        <D.17745>:
        D.17747 = &MEM[(void *)"uintptr" + 3B];
        D.17748 = *D.17747;
        D.17749 = (int) D.17748;
        D.17750 = __s2 + 3;
        D.17751 = *D.17750;
        D.17752 = (int) D.17751;
        __result = D.17749 - D.17752;
        <D.17746>:
        <D.17736>:
        <D.17726>:
      }
      D.16532 = __result;
    }
    iftmp.19 = -D.16532;
    goto <D.17753>;
    <D.17716>:
    iftmp.19 = __builtin_strcmp (name, "uintptr");
    <D.17753>:
    D.16533 = iftmp.19;
  }
  if (D.16533 == 0) goto <D.17754>; else goto <D.17755>;
  <D.17754>:
  D.17293 = mono_defaults.uint_class;
  return D.17293;
  <D.17755>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = name;
      D.17759 = "intptr";
      D.17760 = MEM[(const unsigned char *)D.17759];
      D.17761 = (int) D.17760;
      D.17762 = *__s2;
      D.17763 = (int) D.17762;
      __result = D.17761 - D.17763;
      {
        D.17764 = __s2_len != 0;
        D.17765 = __result == 0;
        D.17766 = D.17764 & D.17765;
        if (D.17766 != 0) goto <D.17767>; else goto <D.17768>;
        <D.17767>:
        D.17769 = &MEM[(void *)"intptr" + 1B];
        D.17770 = *D.17769;
        D.17771 = (int) D.17770;
        D.17772 = __s2 + 1;
        D.17773 = *D.17772;
        D.17774 = (int) D.17773;
        __result = D.17771 - D.17774;
        D.17775 = __s2_len > 1;
        D.17765 = __result == 0;
        D.17776 = D.17775 & D.17765;
        if (D.17776 != 0) goto <D.17777>; else goto <D.17778>;
        <D.17777>:
        D.17779 = &MEM[(void *)"intptr" + 2B];
        D.17780 = *D.17779;
        D.17781 = (int) D.17780;
        D.17782 = __s2 + 2;
        D.17783 = *D.17782;
        D.17784 = (int) D.17783;
        __result = D.17781 - D.17784;
        D.17785 = __s2_len > 2;
        D.17765 = __result == 0;
        D.17786 = D.17785 & D.17765;
        if (D.17786 != 0) goto <D.17787>; else goto <D.17788>;
        <D.17787>:
        D.17789 = &MEM[(void *)"intptr" + 3B];
        D.17790 = *D.17789;
        D.17791 = (int) D.17790;
        D.17792 = __s2 + 3;
        D.17793 = *D.17792;
        D.17794 = (int) D.17793;
        __result = D.17791 - D.17794;
        <D.17788>:
        <D.17778>:
        <D.17768>:
      }
      D.16541 = __result;
    }
    iftmp.20 = -D.16541;
    goto <D.17795>;
    <D.17758>:
    iftmp.20 = __builtin_strcmp (name, "intptr");
    <D.17795>:
    D.16542 = iftmp.20;
  }
  if (D.16542 == 0) goto <D.17796>; else goto <D.17797>;
  <D.17796>:
  D.17293 = mono_defaults.int_class;
  return D.17293;
  <D.17797>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = name;
      D.17801 = "single";
      D.17802 = MEM[(const unsigned char *)D.17801];
      D.17803 = (int) D.17802;
      D.17804 = *__s2;
      D.17805 = (int) D.17804;
      __result = D.17803 - D.17805;
      {
        D.17806 = __s2_len != 0;
        D.17807 = __result == 0;
        D.17808 = D.17806 & D.17807;
        if (D.17808 != 0) goto <D.17809>; else goto <D.17810>;
        <D.17809>:
        D.17811 = &MEM[(void *)"single" + 1B];
        D.17812 = *D.17811;
        D.17813 = (int) D.17812;
        D.17814 = __s2 + 1;
        D.17815 = *D.17814;
        D.17816 = (int) D.17815;
        __result = D.17813 - D.17816;
        D.17817 = __s2_len > 1;
        D.17807 = __result == 0;
        D.17818 = D.17817 & D.17807;
        if (D.17818 != 0) goto <D.17819>; else goto <D.17820>;
        <D.17819>:
        D.17821 = &MEM[(void *)"single" + 2B];
        D.17822 = *D.17821;
        D.17823 = (int) D.17822;
        D.17824 = __s2 + 2;
        D.17825 = *D.17824;
        D.17826 = (int) D.17825;
        __result = D.17823 - D.17826;
        D.17827 = __s2_len > 2;
        D.17807 = __result == 0;
        D.17828 = D.17827 & D.17807;
        if (D.17828 != 0) goto <D.17829>; else goto <D.17830>;
        <D.17829>:
        D.17831 = &MEM[(void *)"single" + 3B];
        D.17832 = *D.17831;
        D.17833 = (int) D.17832;
        D.17834 = __s2 + 3;
        D.17835 = *D.17834;
        D.17836 = (int) D.17835;
        __result = D.17833 - D.17836;
        <D.17830>:
        <D.17820>:
        <D.17810>:
      }
      D.16550 = __result;
    }
    iftmp.21 = -D.16550;
    goto <D.17837>;
    <D.17800>:
    iftmp.21 = __builtin_strcmp (name, "single");
    <D.17837>:
    D.16551 = iftmp.21;
  }
  if (D.16551 == 0) goto <D.17838>; else goto <D.17839>;
  <D.17838>:
  D.17293 = mono_defaults.single_class;
  return D.17293;
  <D.17839>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = name;
      D.17843 = "double";
      D.17844 = MEM[(const unsigned char *)D.17843];
      D.17845 = (int) D.17844;
      D.17846 = *__s2;
      D.17847 = (int) D.17846;
      __result = D.17845 - D.17847;
      {
        D.17848 = __s2_len != 0;
        D.17849 = __result == 0;
        D.17850 = D.17848 & D.17849;
        if (D.17850 != 0) goto <D.17851>; else goto <D.17852>;
        <D.17851>:
        D.17853 = &MEM[(void *)"double" + 1B];
        D.17854 = *D.17853;
        D.17855 = (int) D.17854;
        D.17856 = __s2 + 1;
        D.17857 = *D.17856;
        D.17858 = (int) D.17857;
        __result = D.17855 - D.17858;
        D.17859 = __s2_len > 1;
        D.17849 = __result == 0;
        D.17860 = D.17859 & D.17849;
        if (D.17860 != 0) goto <D.17861>; else goto <D.17862>;
        <D.17861>:
        D.17863 = &MEM[(void *)"double" + 2B];
        D.17864 = *D.17863;
        D.17865 = (int) D.17864;
        D.17866 = __s2 + 2;
        D.17867 = *D.17866;
        D.17868 = (int) D.17867;
        __result = D.17865 - D.17868;
        D.17869 = __s2_len > 2;
        D.17849 = __result == 0;
        D.17870 = D.17869 & D.17849;
        if (D.17870 != 0) goto <D.17871>; else goto <D.17872>;
        <D.17871>:
        D.17873 = &MEM[(void *)"double" + 3B];
        D.17874 = *D.17873;
        D.17875 = (int) D.17874;
        D.17876 = __s2 + 3;
        D.17877 = *D.17876;
        D.17878 = (int) D.17877;
        __result = D.17875 - D.17878;
        <D.17872>:
        <D.17862>:
        <D.17852>:
      }
      D.16559 = __result;
    }
    iftmp.22 = -D.16559;
    goto <D.17879>;
    <D.17842>:
    iftmp.22 = __builtin_strcmp (name, "double");
    <D.17879>:
    D.16560 = iftmp.22;
  }
  if (D.16560 == 0) goto <D.17880>; else goto <D.17881>;
  <D.17880>:
  D.17293 = mono_defaults.double_class;
  return D.17293;
  <D.17881>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = name;
      D.17885 = "string";
      D.17886 = MEM[(const unsigned char *)D.17885];
      D.17887 = (int) D.17886;
      D.17888 = *__s2;
      D.17889 = (int) D.17888;
      __result = D.17887 - D.17889;
      {
        D.17890 = __s2_len != 0;
        D.17891 = __result == 0;
        D.17892 = D.17890 & D.17891;
        if (D.17892 != 0) goto <D.17893>; else goto <D.17894>;
        <D.17893>:
        D.17895 = &MEM[(void *)"string" + 1B];
        D.17896 = *D.17895;
        D.17897 = (int) D.17896;
        D.17898 = __s2 + 1;
        D.17899 = *D.17898;
        D.17900 = (int) D.17899;
        __result = D.17897 - D.17900;
        D.17901 = __s2_len > 1;
        D.17891 = __result == 0;
        D.17902 = D.17901 & D.17891;
        if (D.17902 != 0) goto <D.17903>; else goto <D.17904>;
        <D.17903>:
        D.17905 = &MEM[(void *)"string" + 2B];
        D.17906 = *D.17905;
        D.17907 = (int) D.17906;
        D.17908 = __s2 + 2;
        D.17909 = *D.17908;
        D.17910 = (int) D.17909;
        __result = D.17907 - D.17910;
        D.17911 = __s2_len > 2;
        D.17891 = __result == 0;
        D.17912 = D.17911 & D.17891;
        if (D.17912 != 0) goto <D.17913>; else goto <D.17914>;
        <D.17913>:
        D.17915 = &MEM[(void *)"string" + 3B];
        D.17916 = *D.17915;
        D.17917 = (int) D.17916;
        D.17918 = __s2 + 3;
        D.17919 = *D.17918;
        D.17920 = (int) D.17919;
        __result = D.17917 - D.17920;
        <D.17914>:
        <D.17904>:
        <D.17894>:
      }
      D.16568 = __result;
    }
    iftmp.23 = -D.16568;
    goto <D.17921>;
    <D.17884>:
    iftmp.23 = __builtin_strcmp (name, "string");
    <D.17921>:
    D.16569 = iftmp.23;
  }
  if (D.16569 == 0) goto <D.17922>; else goto <D.17923>;
  <D.17922>:
  D.17293 = mono_defaults.string_class;
  return D.17293;
  <D.17923>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = name;
      D.17927 = "object";
      D.17928 = MEM[(const unsigned char *)D.17927];
      D.17929 = (int) D.17928;
      D.17930 = *__s2;
      D.17931 = (int) D.17930;
      __result = D.17929 - D.17931;
      {
        D.17932 = __s2_len != 0;
        D.17933 = __result == 0;
        D.17934 = D.17932 & D.17933;
        if (D.17934 != 0) goto <D.17935>; else goto <D.17936>;
        <D.17935>:
        D.17937 = &MEM[(void *)"object" + 1B];
        D.17938 = *D.17937;
        D.17939 = (int) D.17938;
        D.17940 = __s2 + 1;
        D.17941 = *D.17940;
        D.17942 = (int) D.17941;
        __result = D.17939 - D.17942;
        D.17943 = __s2_len > 1;
        D.17933 = __result == 0;
        D.17944 = D.17943 & D.17933;
        if (D.17944 != 0) goto <D.17945>; else goto <D.17946>;
        <D.17945>:
        D.17947 = &MEM[(void *)"object" + 2B];
        D.17948 = *D.17947;
        D.17949 = (int) D.17948;
        D.17950 = __s2 + 2;
        D.17951 = *D.17950;
        D.17952 = (int) D.17951;
        __result = D.17949 - D.17952;
        D.17953 = __s2_len > 2;
        D.17933 = __result == 0;
        D.17954 = D.17953 & D.17933;
        if (D.17954 != 0) goto <D.17955>; else goto <D.17956>;
        <D.17955>:
        D.17957 = &MEM[(void *)"object" + 3B];
        D.17958 = *D.17957;
        D.17959 = (int) D.17958;
        D.17960 = __s2 + 3;
        D.17961 = *D.17960;
        D.17962 = (int) D.17961;
        __result = D.17959 - D.17962;
        <D.17956>:
        <D.17946>:
        <D.17936>:
      }
      D.16577 = __result;
    }
    iftmp.24 = -D.16577;
    goto <D.17963>;
    <D.17926>:
    iftmp.24 = __builtin_strcmp (name, "object");
    <D.17963>:
    D.16578 = iftmp.24;
  }
  if (D.16578 == 0) goto <D.17964>; else goto <D.17965>;
  <D.17964>:
  D.17293 = mono_defaults.object_class;
  return D.17293;
  <D.17965>:
  D.17293 = 0B;
  return D.17293;
}


mono_disasm_code_one (struct MonoDisHelper * dh, struct MonoMethod * method, const guchar * ip, const guchar * * endp)
{
  const unsigned char * D.17969;
  char * D.17972;
  char * result;
  struct GString * res;

  res = monoeg_g_string_new ("");
  if (dh == 0B) goto <D.17967>; else goto <D.17968>;
  <D.17967>:
  dh = &default_dh;
  <D.17968>:
  D.17969 = ip + 2;
  ip = dis_one (res, dh, method, ip, D.17969);
  if (endp != 0B) goto <D.17970>; else goto <D.17971>;
  <D.17970>:
  *endp = ip;
  <D.17971>:
  result = res->str;
  monoeg_g_string_free (res, 0);
  D.17972 = result;
  return D.17972;
}


dis_one (struct GString * str, struct MonoDisHelper * dh, struct MonoMethod * method, const unsigned char * ip, const unsigned char * end)
{
  const unsigned char * ip.25;
  long int ip.26;
  long int il_code.27;
  long int D.17977;
  char * (*<T2811>) (struct MonoDisHelper *, struct MonoMethod *, uint32_t) D.17978;
  const char * D.17981;
  <unnamed type> D.17984;
  const unsigned char * ip.28;
  const char * D.17986;
  unsigned char D.17987;
  int D.17988;
  char * (*<T2811>) (struct MonoDisHelper *, struct MonoMethod *, uint32_t) D.17989;
  const unsigned char * ip.29;
  struct MonoClass * D.17994;
  struct MonoImage * D.17995;
  unsigned char D.17996;
  unsigned char D.17997;
  unsigned int D.18000;
  const char * blob.30;
  const char * blob.31;
  unsigned int D.18003;
  long int len2.32;
  short unsigned int D.18007;
  int D.18008;
  const unsigned char * ip.33;
  unsigned char D.18010;
  int D.18011;
  unsigned int D.18012;
  const char * D.18013;
  sizetype D.18016;
  const unsigned char * D.18017;
  long int D.18018;
  long int D.18019;
  signed char D.18021;
  int D.18025;
  sizetype D.18026;
  sizetype D.18031;
  const unsigned char * D.18032;
  long int D.18033;
  long int D.18034;
  long unsigned int D.18036;
  double r.34;
  double r.35;
  const unsigned char * ip.36;
  float r.37;
  float r.38;
  double D.18042;
  int D.18043;
  int D.18044;
  const char * D.18045;
  const unsigned char * D.18048;
  struct MonoMethodHeader * header;
  const struct MonoOpcode * opcode;
  guint32 label;
  guint32 token;
  gint32 sval;
  int i;
  char * tmp;
  const unsigned char * il_code;

  header = mono_method_get_header (method);
  il_code = mono_method_header_get_code (header, 0B, 0B);
  ip.25 = ip;
  ip.26 = (long int) ip.25;
  il_code.27 = (long int) il_code;
  D.17977 = ip.26 - il_code.27;
  label = (guint32) D.17977;
  D.17978 = dh->indenter;
  if (D.17978 != 0B) goto <D.17979>; else goto <D.17980>;
  <D.17979>:
  D.17978 = dh->indenter;
  tmp = D.17978 (dh, method, label);
  monoeg_g_string_append (str, tmp);
  monoeg_g_free (tmp);
  <D.17980>:
  D.17981 = dh->label_format;
  if (D.17981 != 0B) goto <D.17982>; else goto <D.17983>;
  <D.17982>:
  D.17981 = dh->label_format;
  monoeg_g_string_append_printf (str, D.17981, label);
  <D.17983>:
  D.17984 = mono_opcode_value (&ip, end);
  i = (int) D.17984;
  ip.25 = ip;
  ip.28 = ip.25 + 1;
  ip = ip.28;
  opcode = &mono_opcodes[i];
  D.17986 = mono_opcode_name (i);
  monoeg_g_string_append_printf (str, "%-10s", D.17986);
  D.17987 = opcode->argument;
  D.17988 = (int) D.17987;
  switch (D.17988) <default: <D.16828>, case 0: <D.16798>, case 1: <D.16800>, case 2: <D.16801>, case 3: <D.16802>, case 4: <D.16803>, case 5: <D.16805>, case 6: <D.16804>, case 7: <D.16810>, case 8: <D.16811>, case 9: <D.16812>, case 10: <D.16813>, case 11: <D.16814>, case 12: <D.16819>, case 13: <D.16822>, case 14: <D.16825>, case 15: <D.16826>, case 16: <D.16827>>
  <D.16798>:
  goto <D.16799>;
  <D.16800>:
  <D.16801>:
  <D.16802>:
  <D.16803>:
  <D.16804>:
  ip.25 = ip;
  token = MEM[(const guint32 *)ip.25];
  D.17989 = dh->tokener;
  if (D.17989 != 0B) goto <D.17990>; else goto <D.17991>;
  <D.17990>:
  D.17989 = dh->tokener;
  tmp = D.17989 (dh, method, token);
  monoeg_g_string_append (str, tmp);
  monoeg_g_free (tmp);
  goto <D.17992>;
  <D.17991>:
  monoeg_g_string_append_printf (str, "0x%08x", token);
  <D.17992>:
  ip.25 = ip;
  ip.29 = ip.25 + 4;
  ip = ip.29;
  goto <D.16799>;
  <D.16805>:
  {
    const char * blob;
    char * s;
    size_t len2;
    char * blob2;

    try
      {
        blob2 = 0B;
        D.17994 = method->klass;
        D.17995 = D.17994->image;
        D.17996 = BIT_FIELD_REF <*D.17995, 8, 224>;
        D.17997 = D.17996 & 8;
        if (D.17997 == 0) goto <D.17998>; else goto <D.17999>;
        <D.17998>:
        ip.25 = ip;
        token = MEM[(const guint32 *)ip.25];
        D.18000 = token & 16777215;
        D.17994 = method->klass;
        D.17995 = D.17994->image;
        blob.30 = mono_metadata_user_string (D.17995, D.18000);
        blob = blob.30;
        blob.31 = blob;
        D.18003 = mono_metadata_decode_blob_size (blob.31, &blob);
        len2 = (size_t) D.18003;
        len2 = len2 >> 1;
        blob2 = blob;
        len2.32 = (long int) len2;
        s = monoeg_g_utf16_to_utf8 (blob2, len2.32, 0B, 0B, 0B);
        monoeg_g_string_append_printf (str, "\"%s\"", s);
        monoeg_g_free (s);
        blob.31 = blob;
        if (blob.31 != blob2) goto <D.18005>; else goto <D.18006>;
        <D.18005>:
        monoeg_g_free (blob2);
        <D.18006>:
        <D.17999>:
        ip.25 = ip;
        ip.29 = ip.25 + 4;
        ip = ip.29;
        goto <D.16799>;
      }
    finally
      {
        blob = {CLOBBER};
      }
  }
  <D.16810>:
  ip.25 = ip;
  D.18007 = MEM[(const guint16 *)ip.25];
  D.18008 = (int) D.18007;
  monoeg_g_string_append_printf (str, "%d", D.18008);
  ip.25 = ip;
  ip.33 = ip.25 + 2;
  ip = ip.33;
  goto <D.16799>;
  <D.16811>:
  ip.25 = ip;
  D.18010 = *ip.25;
  D.18011 = (int) D.18010;
  monoeg_g_string_append_printf (str, "%d", D.18011);
  ip.25 = ip;
  ip.28 = ip.25 + 1;
  ip = ip.28;
  goto <D.16799>;
  <D.16812>:
  ip.25 = ip;
  D.18012 = MEM[(const guint32 *)ip.25];
  sval = (gint32) D.18012;
  ip.25 = ip;
  ip.29 = ip.25 + 4;
  ip = ip.29;
  D.18013 = dh->label_target;
  if (D.18013 != 0B) goto <D.18014>; else goto <D.18015>;
  <D.18014>:
  ip.25 = ip;
  D.18016 = (sizetype) sval;
  D.18017 = ip.25 + D.18016;
  D.18018 = (long int) D.18017;
  il_code.27 = (long int) il_code;
  D.18019 = D.18018 - il_code.27;
  D.18013 = dh->label_target;
  monoeg_g_string_append_printf (str, D.18013, D.18019);
  goto <D.18020>;
  <D.18015>:
  monoeg_g_string_append_printf (str, "%d", sval);
  <D.18020>:
  goto <D.16799>;
  <D.16813>:
  ip.25 = ip;
  D.18021 = MEM[(const signed char *)ip.25];
  sval = (gint32) D.18021;
  ip.25 = ip;
  ip.28 = ip.25 + 1;
  ip = ip.28;
  D.18013 = dh->label_target;
  if (D.18013 != 0B) goto <D.18022>; else goto <D.18023>;
  <D.18022>:
  ip.25 = ip;
  D.18016 = (sizetype) sval;
  D.18017 = ip.25 + D.18016;
  D.18018 = (long int) D.18017;
  il_code.27 = (long int) il_code;
  D.18019 = D.18018 - il_code.27;
  D.18013 = dh->label_target;
  monoeg_g_string_append_printf (str, D.18013, D.18019);
  goto <D.18024>;
  <D.18023>:
  monoeg_g_string_append_printf (str, "%d", sval);
  <D.18024>:
  goto <D.16799>;
  <D.16814>:
  {
    const unsigned char * end;

    ip.25 = ip;
    D.18012 = MEM[(const guint32 *)ip.25];
    sval = (gint32) D.18012;
    ip.25 = ip;
    ip.29 = ip.25 + 4;
    ip = ip.29;
    ip.25 = ip;
    D.18025 = sval * 4;
    D.18026 = (sizetype) D.18025;
    end = ip.25 + D.18026;
    monoeg_g_string_append_c (str, 40);
    i = 0;
    goto <D.16817>;
    <D.16816>:
    if (i > 0) goto <D.18027>; else goto <D.18028>;
    <D.18027>:
    monoeg_g_string_append (str, ", ");
    <D.18028>:
    ip.25 = ip;
    label = MEM[(const guint32 *)ip.25];
    D.18013 = dh->label_target;
    if (D.18013 != 0B) goto <D.18029>; else goto <D.18030>;
    <D.18029>:
    D.18031 = (sizetype) label;
    D.18032 = end + D.18031;
    D.18033 = (long int) D.18032;
    il_code.27 = (long int) il_code;
    D.18034 = D.18033 - il_code.27;
    D.18013 = dh->label_target;
    monoeg_g_string_append_printf (str, D.18013, D.18034);
    goto <D.18035>;
    <D.18030>:
    monoeg_g_string_append_printf (str, "%d", label);
    <D.18035>:
    ip.25 = ip;
    ip.29 = ip.25 + 4;
    ip = ip.29;
    i = i + 1;
    <D.16817>:
    if (i < sval) goto <D.16816>; else goto <D.16818>;
    <D.16818>:
    monoeg_g_string_append_c (str, 41);
    goto <D.16799>;
  }
  <D.16819>:
  {
    double r;

    try
      {
        {
          union mono_rdouble mf;

          try
            {
              ip.25 = ip;
              D.18036 = MEM[(const guint64 *)ip.25];
              mf.ival = D.18036;
              r.34 = mf.fval;
              r = r.34;
            }
          finally
            {
              mf = {CLOBBER};
            }
        }
        r.35 = r;
        monoeg_g_string_append_printf (str, "%g", r.35);
        ip.25 = ip;
        ip.36 = ip.25 + 8;
        ip = ip.36;
        goto <D.16799>;
      }
    finally
      {
        r = {CLOBBER};
      }
  }
  <D.16822>:
  {
    float r;

    try
      {
        {
          union mono_rfloat mf;

          try
            {
              ip.25 = ip;
              D.18012 = MEM[(const guint32 *)ip.25];
              mf.ival = D.18012;
              r.37 = mf.fval;
              r = r.37;
            }
          finally
            {
              mf = {CLOBBER};
            }
        }
        r.38 = r;
        D.18042 = (double) r.38;
        monoeg_g_string_append_printf (str, "%g", D.18042);
        ip.25 = ip;
        ip.29 = ip.25 + 4;
        ip = ip.29;
        goto <D.16799>;
      }
    finally
      {
        r = {CLOBBER};
      }
  }
  <D.16825>:
  ip.25 = ip;
  D.18012 = MEM[(const guint32 *)ip.25];
  D.18043 = (int) D.18012;
  monoeg_g_string_append_printf (str, "%d", D.18043);
  ip.25 = ip;
  ip.29 = ip.25 + 4;
  ip = ip.29;
  goto <D.16799>;
  <D.16826>:
  ip.25 = ip;
  D.18021 = MEM[(const signed char *)ip.25];
  D.18044 = (int) D.18021;
  monoeg_g_string_append_printf (str, "%d", D.18044);
  ip.25 = ip;
  ip.28 = ip.25 + 1;
  ip = ip.28;
  goto <D.16799>;
  <D.16827>:
  ip.25 = ip;
  ip.36 = ip.25 + 8;
  ip = ip.36;
  goto <D.16799>;
  <D.16828>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "debug-helpers.c", 684);
  <D.16799>:
  D.18045 = dh->newline;
  if (D.18045 != 0B) goto <D.18046>; else goto <D.18047>;
  <D.18046>:
  D.18045 = dh->newline;
  monoeg_g_string_append (str, D.18045);
  <D.18047>:
  mono_metadata_free_mh (header);
  D.18048 = ip;
  return D.18048;
}


mono_disasm_code (struct MonoDisHelper * dh, struct MonoMethod * method, const guchar * ip, const guchar * end)
{
  char * D.18056;
  char * result;
  struct GString * res;

  res = monoeg_g_string_new ("");
  if (dh == 0B) goto <D.18054>; else goto <D.18055>;
  <D.18054>:
  dh = &default_dh;
  <D.18055>:
  goto <D.16847>;
  <D.16846>:
  ip = dis_one (res, dh, method, ip, end);
  <D.16847>:
  if (ip < end) goto <D.16846>; else goto <D.16848>;
  <D.16848>:
  result = res->str;
  monoeg_g_string_free (res, 0);
  D.18056 = result;
  return D.18056;
}


mono_field_full_name (struct MonoClassField * field)
{
  struct MonoClass * D.18058;
  const char * D.18059;
  const char * D.18060;
  const char * iftmp.39;
  char D.18062;
  char * D.18066;
  char * res;
  const char * nspace;

  D.18058 = field->parent;
  nspace = D.18058->name_space;
  D.18059 = mono_field_get_name (field);
  D.18058 = field->parent;
  D.18060 = D.18058->name;
  D.18062 = *nspace;
  if (D.18062 != 0) goto <D.18063>; else goto <D.18064>;
  <D.18063>:
  iftmp.39 = ".";
  goto <D.18065>;
  <D.18064>:
  iftmp.39 = "";
  <D.18065>:
  res = monoeg_g_strdup_printf ("%s%s%s:%s", nspace, iftmp.39, D.18060, D.18059);
  D.18066 = res;
  return D.18066;
}


mono_method_full_name (struct MonoMethod * method, gboolean signature)
{
  struct MonoClass * D.18068;
  struct MonoType * D.18069;
  unsigned char D.18072;
  unsigned char D.18073;
  struct MonoGenericInst * D.18075;
  unsigned char D.18077;
  struct MonoGenericInst * D.18080;
  unsigned char D.18081;
  unsigned char D.18082;
  <unnamed-unsigned:5> D.18085;
  unsigned int D.18086;
  const char * D.18087;
  struct MonoMethodSignature * D.18091;
  const char * D.18094;
  const char * iftmp.40;
  const char * D.18100;
  const char * iftmp.41;
  char * D.18106;
  char * res;
  char wrapper[64];
  char * klass_desc;
  char * inst_desc;

  try
    {
      D.18068 = method->klass;
      D.18069 = &D.18068->byval_arg;
      klass_desc = mono_type_full_name (D.18069);
      inst_desc = 0B;
      D.18072 = BIT_FIELD_REF <*method, 8, 264>;
      D.18073 = D.18072 & 16;
      if (D.18073 != 0) goto <D.18074>; else goto <D.18070>;
      <D.18074>:
      D.18075 = MEM[(struct MonoMethodInflated *)method].context.method_inst;
      if (D.18075 != 0B) goto <D.18076>; else goto <D.18070>;
      <D.18076>:
      {
        struct GString * str;

        str = monoeg_g_string_new ("");
        monoeg_g_string_append (str, "<");
        D.18075 = MEM[(struct MonoMethodInflated *)method].context.method_inst;
        ginst_get_desc (str, D.18075);
        monoeg_g_string_append (str, ">");
        inst_desc = str->str;
        monoeg_g_string_free (str, 0);
      }
      goto <D.18071>;
      <D.18070>:
      D.18072 = BIT_FIELD_REF <*method, 8, 264>;
      D.18077 = D.18072 & 8;
      if (D.18077 != 0) goto <D.18078>; else goto <D.18079>;
      <D.18078>:
      {
        struct MonoGenericContainer * container;
        struct GString * str;

        container = mono_method_get_generic_container (method);
        str = monoeg_g_string_new ("");
        monoeg_g_string_append (str, "<");
        D.18080 = container->context.method_inst;
        ginst_get_desc (str, D.18080);
        monoeg_g_string_append (str, ">");
        inst_desc = str->str;
        monoeg_g_string_free (str, 0);
      }
      <D.18079>:
      <D.18071>:
      D.18081 = BIT_FIELD_REF <*method, 8, 256>;
      D.18082 = D.18081 & 124;
      if (D.18082 != 0) goto <D.18083>; else goto <D.18084>;
      <D.18083>:
      D.18085 = method->wrapper_type;
      D.18086 = (unsigned int) D.18085;
      D.18087 = wrapper_type_to_str (D.18086);
      sprintf (&wrapper, "(wrapper %s) ", D.18087);
      goto <D.18088>;
      <D.18084>:
      strcpy (&wrapper, "");
      <D.18088>:
      if (signature != 0) goto <D.18089>; else goto <D.18090>;
      <D.18089>:
      {
        char * tmpsig;

        D.18091 = mono_method_signature (method);
        tmpsig = mono_signature_get_desc (D.18091, 1);
        D.18081 = BIT_FIELD_REF <*method, 8, 256>;
        D.18082 = D.18081 & 124;
        if (D.18082 != 0) goto <D.18092>; else goto <D.18093>;
        <D.18092>:
        D.18085 = method->wrapper_type;
        D.18086 = (unsigned int) D.18085;
        D.18094 = wrapper_type_to_str (D.18086);
        sprintf (&wrapper, "(wrapper %s) ", D.18094);
        goto <D.18095>;
        <D.18093>:
        strcpy (&wrapper, "");
        <D.18095>:
        if (inst_desc != 0B) goto <D.18097>; else goto <D.18098>;
        <D.18097>:
        iftmp.40 = inst_desc;
        goto <D.18099>;
        <D.18098>:
        iftmp.40 = "";
        <D.18099>:
        D.18100 = method->name;
        res = monoeg_g_strdup_printf ("%s%s:%s%s (%s)", &wrapper, klass_desc, D.18100, iftmp.40, tmpsig);
        monoeg_g_free (tmpsig);
      }
      goto <D.18101>;
      <D.18090>:
      if (inst_desc != 0B) goto <D.18103>; else goto <D.18104>;
      <D.18103>:
      iftmp.41 = inst_desc;
      goto <D.18105>;
      <D.18104>:
      iftmp.41 = "";
      <D.18105>:
      D.18100 = method->name;
      res = monoeg_g_strdup_printf ("%s%s:%s%s", &wrapper, klass_desc, D.18100, iftmp.41);
      <D.18101>:
      monoeg_g_free (klass_desc);
      monoeg_g_free (inst_desc);
      D.18106 = res;
      return D.18106;
    }
  finally
    {
      wrapper = {CLOBBER};
    }
}


wrapper_type_to_str (guint32 wrapper_type)
{
  _Bool D.18109;
  long int D.18110;
  long int D.18111;
  const char * D.18114;
  short int D.18115;
  sizetype D.18116;

  D.18109 = wrapper_type > 28;
  D.18110 = (long int) D.18109;
  D.18111 = __builtin_expect (D.18110, 0);
  if (D.18111 != 0) goto <D.18112>; else goto <D.18113>;
  <D.18112>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debug-helpers.c", 51, "wrapper_type < MONO_WRAPPER_NUM");
  <D.18113>:
  D.18115 = opidx[wrapper_type];
  D.18116 = (sizetype) D.18115;
  D.18114 = &opstr + D.18116;
  return D.18114;
}


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

  D.18119 = __builtin_object_size (__s, 1);
  D.18118 = __builtin___sprintf_chk (__s, 1, D.18119, __fmt, __builtin_va_arg_pack ());
  return D.18118;
}


strcpy (char * restrict __dest, const char * restrict __src)
{
  char * D.18121;
  long unsigned int D.18122;

  D.18122 = __builtin_object_size (__dest, 1);
  D.18121 = __builtin___strcpy_chk (__dest, __src, D.18122);
  return D.18121;
}


mono_object_describe (struct MonoObject * obj)
{
  struct MonoVTable * D.18126;
  struct MonoClass * D.18127;
  long unsigned int D.18130;
  char * D.18133;
  char * D.18134;
  char * D.18135;
  char * D.18136;
  int D.18137;
  unsigned char D.18139;
  const char * D.18142;
  long unsigned int D.18143;
  int D.18144;
  int D.18145;
  struct MonoClass * klass;
  const char * sep;

  if (obj == 0B) goto <D.18124>; else goto <D.18125>;
  <D.18124>:
  monoeg_g_print ("(null)\n");
  return;
  <D.18125>:
  D.18126 = obj->vtable;
  klass = D.18126->klass;
  D.18127 = mono_defaults.string_class;
  if (D.18127 == klass) goto <D.18128>; else goto <D.18129>;
  <D.18128>:
  {
    char * utf8;

    utf8 = mono_string_to_utf8 (obj);
    D.18130 = strlen (utf8);
    if (D.18130 > 60) goto <D.18131>; else goto <D.18132>;
    <D.18131>:
    D.18133 = utf8 + 57;
    *D.18133 = 46;
    D.18134 = utf8 + 58;
    *D.18134 = 46;
    D.18135 = utf8 + 59;
    *D.18135 = 46;
    D.18136 = utf8 + 60;
    *D.18136 = 0;
    <D.18132>:
    D.18137 = mono_string_length (obj);
    monoeg_g_print ("String at %p, length: %d, \'%s\'\n", obj, D.18137, utf8);
    monoeg_g_free (utf8);
  }
  goto <D.18138>;
  <D.18129>:
  D.18139 = klass->rank;
  if (D.18139 != 0) goto <D.18140>; else goto <D.18141>;
  <D.18140>:
  {
    struct MonoArray * array;

    array = obj;
    sep = print_name_space (klass);
    D.18142 = klass->name;
    monoeg_g_print ("%s%s", sep, D.18142);
    D.18143 = mono_array_length (array);
    D.18144 = (int) D.18143;
    D.18139 = klass->rank;
    D.18145 = (int) D.18139;
    monoeg_g_print (" at %p, rank: %d, length: %d\n", obj, D.18145, D.18144);
  }
  goto <D.18146>;
  <D.18141>:
  sep = print_name_space (klass);
  D.18142 = klass->name;
  monoeg_g_print ("%s%s", sep, D.18142);
  monoeg_g_print (" object at %p (klass: %p)\n", obj, klass);
  <D.18146>:
  <D.18138>:
}


print_name_space (struct MonoClass * klass)
{
  struct MonoClass * D.18148;
  const char * D.18151;
  const char * D.18152;
  const char * D.18153;
  char D.18154;

  D.18148 = klass->nested_in;
  if (D.18148 != 0B) goto <D.18149>; else goto <D.18150>;
  <D.18149>:
  D.18148 = klass->nested_in;
  print_name_space (D.18148);
  D.18148 = klass->nested_in;
  D.18151 = D.18148->name;
  monoeg_g_print ("%s", D.18151);
  D.18152 = "/";
  return D.18152;
  <D.18150>:
  D.18153 = klass->name_space;
  D.18154 = *D.18153;
  if (D.18154 != 0) goto <D.18155>; else goto <D.18156>;
  <D.18155>:
  D.18153 = klass->name_space;
  monoeg_g_print ("%s", D.18153);
  D.18152 = ".";
  return D.18152;
  <D.18156>:
  D.18152 = "";
  return D.18152;
}


mono_object_describe_fields (struct MonoObject * obj)
{
  struct MonoVTable * D.18158;
  struct MonoClass * class;

  D.18158 = obj->vtable;
  class = D.18158->klass;
  objval_describe (class, obj);
}


objval_describe (struct MonoClass * class, const char * addr)
{
  unsigned char D.18159;
  unsigned char D.18160;
  struct MonoType * D.18163;
  short unsigned int D.18164;
  int D.18165;
  int D.18166;
  _Bool D.18169;
  _Bool D.18170;
  _Bool D.18171;
  const char * D.18174;
  int D.18175;
  sizetype D.18176;
  sizetype type_offset.42;
  sizetype D.18178;
  int D.18179;
  struct MonoClassField * field;
  struct MonoClass * p;
  const char * field_ptr;
  gssize type_offset;

  type_offset = 0;
  D.18159 = BIT_FIELD_REF <*class, 8, 256>;
  D.18160 = D.18159 & 8;
  if (D.18160 != 0) goto <D.18161>; else goto <D.18162>;
  <D.18161>:
  type_offset = -16;
  <D.18162>:
  p = class;
  goto <D.16923>;
  <D.16922>:
  {
    void * iter;
    int printed_header;

    try
      {
        iter = 0B;
        printed_header = 0;
        goto <D.16918>;
        <D.16920>:
        D.18163 = field->type;
        D.18164 = D.18163->attrs;
        D.18165 = (int) D.18164;
        D.18166 = D.18165 & 272;
        if (D.18166 != 0) goto <D.18167>; else goto <D.18168>;
        <D.18167>:
        // predicted unlikely by continue predictor.
        goto <D.16918>;
        <D.18168>:
        D.18169 = p != class;
        D.18170 = printed_header == 0;
        D.18171 = D.18169 & D.18170;
        if (D.18171 != 0) goto <D.18172>; else goto <D.18173>;
        <D.18172>:
        {
          const char * sep;

          monoeg_g_print ("In class ");
          sep = print_name_space (p);
          D.18174 = p->name;
          monoeg_g_print ("%s%s:\n", sep, D.18174);
          printed_header = 1;
        }
        <D.18173>:
        D.18175 = field->offset;
        D.18176 = (sizetype) D.18175;
        type_offset.42 = (sizetype) type_offset;
        D.18178 = D.18176 + type_offset.42;
        field_ptr = addr + D.18178;
        D.18179 = (int) type_offset;
        print_field_value (field_ptr, field, D.18179);
        <D.16918>:
        field = mono_class_get_fields (p, &iter);
        if (field != 0B) goto <D.16920>; else goto <D.16921>;
        <D.16921>:
      }
    finally
      {
        iter = {CLOBBER};
      }
  }
  p = p->parent;
  <D.16923>:
  if (p != 0B) goto <D.16922>; else goto <D.16924>;
  <D.16924>:
}


print_field_value (const char * field_ptr, struct MonoClassField * field, int type_offset)
{
  const char * D.18180;
  int D.18181;
  int D.18182;
  struct MonoType * D.18183;
  unsigned char D.18184;
  int D.18185;
  const void * D.18186;
  struct MonoObject * D.18187;
  int D.18188;
  const char * D.18191;
  signed char D.18192;
  int D.18193;
  unsigned char D.18194;
  int D.18195;
  short int D.18196;
  int D.18197;
  short unsigned int D.18198;
  int D.18199;
  int D.18200;
  unsigned int D.18201;
  long int D.18202;
  long unsigned int D.18203;
  float D.18204;
  double D.18205;
  double D.18206;
  const char * iftmp.43;
  struct MonoType * type;

  D.18180 = mono_field_get_name (field);
  D.18181 = field->offset;
  D.18182 = D.18181 + type_offset;
  monoeg_g_print ("At %p (ofs: %2d) %s: ", field_ptr, D.18182, D.18180);
  D.18183 = field->type;
  type = mono_type_get_underlying_type (D.18183);
  D.18184 = type->type;
  D.18185 = (int) D.18184;
  switch (D.18185) <default: <D.16907>, case 2: <D.16905>, case 3: <D.16906>, case 4: <D.16895>, case 5: <D.16896>, case 6: <D.16897>, case 7: <D.16898>, case 8: <D.16899>, case 9: <D.16900>, case 10: <D.16901>, case 11: <D.16902>, case 12: <D.16903>, case 13: <D.16904>, case 14: <D.16887>, case 15: <D.16884>, case 17: <D.16893>, case 18: <D.16889>, case 20: <D.16891>, case 21: <D.16892>, case 24: <D.16882>, case 25: <D.16883>, case 27: <D.16885>, case 28: <D.16890>, case 29: <D.16888>>
  <D.16882>:
  <D.16883>:
  <D.16884>:
  <D.16885>:
  D.18186 = MEM[(const void * *)field_ptr];
  monoeg_g_print ("%p\n", D.18186);
  goto <D.16886>;
  <D.16887>:
  <D.16888>:
  <D.16889>:
  <D.16890>:
  <D.16891>:
  D.18187 = MEM[(struct MonoObject * *)field_ptr];
  mono_object_describe (D.18187);
  goto <D.16886>;
  <D.16892>:
  D.18188 = mono_type_generic_inst_is_valuetype (type);
  if (D.18188 == 0) goto <D.18189>; else goto <D.18190>;
  <D.18189>:
  D.18187 = MEM[(struct MonoObject * *)field_ptr];
  mono_object_describe (D.18187);
  goto <D.16886>;
  <D.18190>:
  <D.16893>:
  {
    struct MonoClass * k;

    k = mono_class_from_mono_type (type);
    D.18191 = k->name;
    monoeg_g_print ("%s ValueType (type: %p) at %p\n", D.18191, k, field_ptr);
    goto <D.16886>;
  }
  <D.16895>:
  D.18192 = MEM[(gint8 *)field_ptr];
  D.18193 = (int) D.18192;
  monoeg_g_print ("%d\n", D.18193);
  goto <D.16886>;
  <D.16896>:
  D.18194 = MEM[(guint8 *)field_ptr];
  D.18195 = (int) D.18194;
  monoeg_g_print ("%d\n", D.18195);
  goto <D.16886>;
  <D.16897>:
  D.18196 = MEM[(gint16 *)field_ptr];
  D.18197 = (int) D.18196;
  monoeg_g_print ("%d\n", D.18197);
  goto <D.16886>;
  <D.16898>:
  D.18198 = MEM[(guint16 *)field_ptr];
  D.18199 = (int) D.18198;
  monoeg_g_print ("%d\n", D.18199);
  goto <D.16886>;
  <D.16899>:
  D.18200 = MEM[(gint32 *)field_ptr];
  monoeg_g_print ("%d\n", D.18200);
  goto <D.16886>;
  <D.16900>:
  D.18201 = MEM[(guint32 *)field_ptr];
  monoeg_g_print ("%u\n", D.18201);
  goto <D.16886>;
  <D.16901>:
  D.18202 = MEM[(gint64 *)field_ptr];
  monoeg_g_print ("%lld\n", D.18202);
  goto <D.16886>;
  <D.16902>:
  D.18203 = MEM[(guint64 *)field_ptr];
  monoeg_g_print ("%llu\n", D.18203);
  goto <D.16886>;
  <D.16903>:
  D.18204 = MEM[(gfloat *)field_ptr];
  D.18205 = (double) D.18204;
  monoeg_g_print ("%f\n", D.18205);
  goto <D.16886>;
  <D.16904>:
  D.18206 = MEM[(gdouble *)field_ptr];
  monoeg_g_print ("%f\n", D.18206);
  goto <D.16886>;
  <D.16905>:
  D.18194 = MEM[(guint8 *)field_ptr];
  D.18195 = (int) D.18194;
  D.18194 = MEM[(guint8 *)field_ptr];
  if (D.18194 != 0) goto <D.18208>; else goto <D.18209>;
  <D.18208>:
  iftmp.43 = "True";
  goto <D.18210>;
  <D.18209>:
  iftmp.43 = "False";
  <D.18210>:
  monoeg_g_print ("%s (%d)\n", iftmp.43, D.18195);
  goto <D.16886>;
  <D.16906>:
  D.18198 = MEM[(guint16 *)field_ptr];
  D.18199 = (int) D.18198;
  D.18198 = MEM[(guint16 *)field_ptr];
  D.18199 = (int) D.18198;
  D.18198 = MEM[(guint16 *)field_ptr];
  D.18199 = (int) D.18198;
  monoeg_g_print ("\'%c\' (%d 0x%04x)\n", D.18199, D.18199, D.18199);
  goto <D.16886>;
  <D.16907>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "debug-helpers.c", 928);
  <D.16886>:
}


mono_value_describe_fields (struct MonoClass * klass, const char * addr)
{
  objval_describe (klass, addr);
}


mono_class_describe_statics (struct MonoClass * klass)
{
  struct MonoDomain * D.18211;
  struct MonoType * D.18216;
  short unsigned int D.18217;
  int D.18218;
  int D.18219;
  int D.18222;
  int D.18225;
  sizetype D.18226;
  struct MonoClassField * field;
  struct MonoClass * p;
  const char * field_ptr;
  struct MonoVTable * vtable;
  const char * addr;

  D.18211 = mono_domain_get ();
  vtable = mono_class_vtable_full (D.18211, klass, 0);
  if (vtable == 0B) goto <D.18212>; else goto <D.18213>;
  <D.18212>:
  return;
  <D.18213>:
  addr = mono_vtable_get_static_field_data (vtable);
  if (addr == 0B) goto <D.18214>; else goto <D.18215>;
  <D.18214>:
  return;
  <D.18215>:
  p = klass;
  goto <D.16946>;
  <D.16945>:
  {
    void * iter;

    try
      {
        iter = 0B;
        goto <D.16942>;
        <D.16943>:
        D.18216 = field->type;
        D.18217 = D.18216->attrs;
        D.18218 = (int) D.18217;
        D.18219 = D.18218 & 64;
        if (D.18219 != 0) goto <D.18220>; else goto <D.18221>;
        <D.18220>:
        // predicted unlikely by continue predictor.
        goto <D.16942>;
        <D.18221>:
        D.18216 = field->type;
        D.18217 = D.18216->attrs;
        D.18218 = (int) D.18217;
        D.18222 = D.18218 & 272;
        if (D.18222 == 0) goto <D.18223>; else goto <D.18224>;
        <D.18223>:
        // predicted unlikely by continue predictor.
        goto <D.16942>;
        <D.18224>:
        D.18225 = field->offset;
        D.18226 = (sizetype) D.18225;
        field_ptr = addr + D.18226;
        print_field_value (field_ptr, field, 0);
        <D.16942>:
        field = mono_class_get_fields (p, &iter);
        if (field != 0B) goto <D.16943>; else goto <D.16944>;
        <D.16944>:
      }
    finally
      {
        iter = {CLOBBER};
      }
  }
  p = p->parent;
  <D.16946>:
  if (p != 0B) goto <D.16945>; else goto <D.16947>;
  <D.16947>:
}