mono_type_get_desc (struct GString * res, struct MonoType * type, gboolean include_namespace)
{
  unsigned char D.16557;
  int D.16558;
  struct MonoType * D.16559;
  struct MonoArrayType * D.16560;
  struct MonoClass * D.16561;
  struct MonoType * D.16562;
  unsigned char D.16563;
  int D.16564;
  struct MonoClass * D.16565;
  struct MonoType * D.16566;
  struct MonoGenericClass * D.16567;
  struct MonoClass * D.16568;
  struct MonoType * D.16569;
  struct MonoGenericInst * D.16570;
  struct MonoType * D.16575;
  <unnamed-unsigned:22> D.16576;
  int D.16577;
  struct MonoGenericInst * D.16578;
  struct MonoType * D.16585;
  <unnamed-unsigned:22> D.16586;
  int D.16587;
  struct MonoGenericParam * D.16588;
  struct MonoGenericParamInfo * iftmp.0;
  struct MonoGenericContainer * D.16592;
  const char * D.16598;
  const char * iftmp.1;
  short unsigned int D.16604;
  int D.16605;
  unsigned int D.16607;
  unsigned int D.16608;
  int i;

  D.16557 = type->type;
  D.16558 = (int) D.16557;
  switch (D.16558) <default: <D.16229>, case 1: <D.16193>, case 2: <D.16196>, case 3: <D.16195>, case 4: <D.16198>, case 5: <D.16197>, case 6: <D.16200>, case 7: <D.16199>, case 8: <D.16202>, case 9: <D.16201>, case 10: <D.16204>, case 11: <D.16203>, case 12: <D.16208>, case 13: <D.16209>, case 14: <D.16210>, case 15: <D.16212>, case 17: <D.16216>, case 18: <D.16215>, case 19: <D.16225>, case 20: <D.16213>, case 21: <D.16217>, case 22: <D.16228>, case 24: <D.16207>, case 25: <D.16206>, case 27: <D.16205>, case 28: <D.16211>, case 29: <D.16214>, case 30: <D.16226>>
  <D.16193>:
  monoeg_g_string_append (res, "void");
  goto <D.16194>;
  <D.16195>:
  monoeg_g_string_append (res, "char");
  goto <D.16194>;
  <D.16196>:
  monoeg_g_string_append (res, "bool");
  goto <D.16194>;
  <D.16197>:
  monoeg_g_string_append (res, "byte");
  goto <D.16194>;
  <D.16198>:
  monoeg_g_string_append (res, "sbyte");
  goto <D.16194>;
  <D.16199>:
  monoeg_g_string_append (res, "uint16");
  goto <D.16194>;
  <D.16200>:
  monoeg_g_string_append (res, "int16");
  goto <D.16194>;
  <D.16201>:
  monoeg_g_string_append (res, "uint");
  goto <D.16194>;
  <D.16202>:
  monoeg_g_string_append (res, "int");
  goto <D.16194>;
  <D.16203>:
  monoeg_g_string_append (res, "ulong");
  goto <D.16194>;
  <D.16204>:
  monoeg_g_string_append (res, "long");
  goto <D.16194>;
  <D.16205>:
  monoeg_g_string_append (res, "*()");
  goto <D.16194>;
  <D.16206>:
  monoeg_g_string_append (res, "uintptr");
  goto <D.16194>;
  <D.16207>:
  monoeg_g_string_append (res, "intptr");
  goto <D.16194>;
  <D.16208>:
  monoeg_g_string_append (res, "single");
  goto <D.16194>;
  <D.16209>:
  monoeg_g_string_append (res, "double");
  goto <D.16194>;
  <D.16210>:
  monoeg_g_string_append (res, "string");
  goto <D.16194>;
  <D.16211>:
  monoeg_g_string_append (res, "object");
  goto <D.16194>;
  <D.16212>:
  D.16559 = type->data.type;
  mono_type_get_desc (res, D.16559, include_namespace);
  monoeg_g_string_append_c (res, 42);
  goto <D.16194>;
  <D.16213>:
  D.16560 = type->data.array;
  D.16561 = D.16560->eklass;
  D.16562 = &D.16561->byval_arg;
  mono_type_get_desc (res, D.16562, include_namespace);
  D.16560 = type->data.array;
  D.16563 = D.16560->rank;
  D.16564 = (int) D.16563;
  monoeg_g_string_append_printf (res, "[%d]", D.16564);
  goto <D.16194>;
  <D.16214>:
  D.16565 = type->data.klass;
  D.16566 = &D.16565->byval_arg;
  mono_type_get_desc (res, D.16566, include_namespace);
  monoeg_g_string_append (res, "[]");
  goto <D.16194>;
  <D.16215>:
  <D.16216>:
  D.16565 = type->data.klass;
  append_class_name (res, D.16565, include_namespace);
  goto <D.16194>;
  <D.16217>:
  {
    struct MonoGenericContext * context;

    D.16567 = type->data.generic_class;
    D.16568 = D.16567->container_class;
    D.16569 = &D.16568->byval_arg;
    mono_type_get_desc (res, D.16569, include_namespace);
    monoeg_g_string_append (res, "<");
    D.16567 = type->data.generic_class;
    context = &D.16567->context;
    D.16570 = context->class_inst;
    if (D.16570 != 0B) goto <D.16571>; else goto <D.16572>;
    <D.16571>:
    i = 0;
    goto <D.16220>;
    <D.16219>:
    if (i > 0) goto <D.16573>; else goto <D.16574>;
    <D.16573>:
    monoeg_g_string_append (res, ", ");
    <D.16574>:
    D.16570 = context->class_inst;
    D.16575 = D.16570->type_argv[i];
    mono_type_get_desc (res, D.16575, include_namespace);
    i = i + 1;
    <D.16220>:
    D.16570 = context->class_inst;
    D.16576 = D.16570->type_argc;
    D.16577 = (int) D.16576;
    if (D.16577 > i) goto <D.16219>; else goto <D.16221>;
    <D.16221>:
    <D.16572>:
    D.16578 = context->method_inst;
    if (D.16578 != 0B) goto <D.16579>; else goto <D.16580>;
    <D.16579>:
    D.16570 = context->class_inst;
    if (D.16570 != 0B) goto <D.16581>; else goto <D.16582>;
    <D.16581>:
    monoeg_g_string_append (res, "; ");
    <D.16582>:
    i = 0;
    goto <D.16223>;
    <D.16222>:
    if (i > 0) goto <D.16583>; else goto <D.16584>;
    <D.16583>:
    monoeg_g_string_append (res, ", ");
    <D.16584>:
    D.16578 = context->method_inst;
    D.16585 = D.16578->type_argv[i];
    mono_type_get_desc (res, D.16585, include_namespace);
    i = i + 1;
    <D.16223>:
    D.16578 = context->method_inst;
    D.16586 = D.16578->type_argc;
    D.16587 = (int) D.16586;
    if (D.16587 > i) goto <D.16222>; else goto <D.16224>;
    <D.16224>:
    <D.16580>:
    monoeg_g_string_append (res, ">");
    goto <D.16194>;
  }
  <D.16225>:
  <D.16226>:
  D.16588 = type->data.generic_param;
  if (D.16588 != 0B) goto <D.16589>; else goto <D.16590>;
  <D.16589>:
  {
    struct MonoGenericParamInfo * info;

    D.16588 = type->data.generic_param;
    D.16592 = D.16588->owner;
    if (D.16592 != 0B) goto <D.16593>; else goto <D.16594>;
    <D.16593>:
    D.16588 = type->data.generic_param;
    iftmp.0 = &MEM[(struct MonoGenericParamFull *)D.16588].info;
    goto <D.16595>;
    <D.16594>:
    iftmp.0 = 0B;
    <D.16595>:
    info = iftmp.0;
    if (info != 0B) goto <D.16596>; else goto <D.16597>;
    <D.16596>:
    D.16598 = info->name;
    monoeg_g_string_append (res, D.16598);
    goto <D.16599>;
    <D.16597>:
    D.16557 = type->type;
    if (D.16557 == 19) goto <D.16601>; else goto <D.16602>;
    <D.16601>:
    iftmp.1 = "!";
    goto <D.16603>;
    <D.16602>:
    iftmp.1 = "!!";
    <D.16603>:
    D.16588 = type->data.generic_param;
    D.16604 = D.16588->num;
    D.16605 = (int) D.16604;
    monoeg_g_string_append_printf (res, "%s%d", iftmp.1, D.16605);
    <D.16599>:
  }
  goto <D.16606>;
  <D.16590>:
  monoeg_g_string_append (res, "<unknown>");
  <D.16606>:
  goto <D.16194>;
  <D.16228>:
  monoeg_g_string_append (res, "typedbyref");
  goto <D.16194>;
  <D.16229>:
  goto <D.16194>;
  <D.16194>:
  D.16607 = BIT_FIELD_REF <*type, 32, 32>;
  D.16608 = D.16607 & 1073741824;
  if (D.16608 != 0) goto <D.16609>; else goto <D.16610>;
  <D.16609>:
  monoeg_g_string_append_c (res, 38);
  <D.16610>:
}


append_class_name (struct GString * res, struct MonoClass * class, gboolean include_namespace)
{
  struct MonoClass * D.16614;
  const char * D.16619;
  char D.16620;
  const char * D.16623;

  if (class == 0B) goto <D.16612>; else goto <D.16613>;
  <D.16612>:
  monoeg_g_string_append (res, "Unknown");
  return;
  <D.16613>:
  D.16614 = class->nested_in;
  if (D.16614 != 0B) goto <D.16615>; else goto <D.16616>;
  <D.16615>:
  D.16614 = class->nested_in;
  append_class_name (res, D.16614, include_namespace);
  monoeg_g_string_append_c (res, 47);
  <D.16616>:
  if (include_namespace != 0) goto <D.16617>; else goto <D.16618>;
  <D.16617>:
  D.16619 = class->name_space;
  D.16620 = *D.16619;
  if (D.16620 != 0) goto <D.16621>; else goto <D.16622>;
  <D.16621>:
  D.16619 = class->name_space;
  monoeg_g_string_append_printf (res, "%s.", D.16619);
  <D.16622>:
  <D.16618>:
  D.16623 = class->name;
  monoeg_g_string_append_printf (res, "%s", D.16623);
}


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

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


mono_signature_get_desc (struct MonoMethodSignature * sig, gboolean include_namespace)
{
  char * D.16629;
  struct MonoType * D.16632;
  short unsigned int D.16633;
  int D.16634;
  int i;
  char * result;
  struct GString * res;

  if (sig == 0B) goto <D.16627>; else goto <D.16628>;
  <D.16627>:
  D.16629 = monoeg_strdup ("<invalid signature>");
  return D.16629;
  <D.16628>:
  res = monoeg_g_string_new ("");
  i = 0;
  goto <D.16242>;
  <D.16241>:
  if (i > 0) goto <D.16630>; else goto <D.16631>;
  <D.16630>:
  monoeg_g_string_append_c (res, 44);
  <D.16631>:
  D.16632 = sig->params[i];
  mono_type_get_desc (res, D.16632, include_namespace);
  i = i + 1;
  <D.16242>:
  D.16633 = sig->param_count;
  D.16634 = (int) D.16633;
  if (D.16634 > i) goto <D.16241>; else goto <D.16243>;
  <D.16243>:
  result = res->str;
  monoeg_g_string_free (res, 0);
  D.16629 = result;
  return D.16629;
}


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

  if (str != 0B) goto <D.16636>; else goto <D.16637>;
  <D.16636>:
  D.16638 = __strdup (str);
  return D.16638;
  <D.16637>:
  D.16638 = 0B;
  return D.16638;
}


mono_context_get_desc (struct MonoGenericContext * context)
{
  struct MonoGenericInst * D.16640;
  struct MonoGenericInst * D.16643;
  char * D.16648;
  char * D.16649;
  struct GString * str;
  char * res;

  str = monoeg_g_string_new ("");
  monoeg_g_string_append (str, "<");
  D.16640 = context->class_inst;
  if (D.16640 != 0B) goto <D.16641>; else goto <D.16642>;
  <D.16641>:
  D.16640 = context->class_inst;
  ginst_get_desc (str, D.16640);
  <D.16642>:
  D.16643 = context->method_inst;
  if (D.16643 != 0B) goto <D.16644>; else goto <D.16645>;
  <D.16644>:
  D.16640 = context->class_inst;
  if (D.16640 != 0B) goto <D.16646>; else goto <D.16647>;
  <D.16646>:
  monoeg_g_string_append (str, "; ");
  <D.16647>:
  D.16643 = context->method_inst;
  ginst_get_desc (str, D.16643);
  <D.16645>:
  monoeg_g_string_append (str, ">");
  D.16648 = str->str;
  res = monoeg_strdup (D.16648);
  monoeg_g_string_free (str, 1);
  D.16649 = res;
  return D.16649;
}


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

  i = 0;
  goto <D.16250>;
  <D.16249>:
  if (i > 0) goto <D.16651>; else goto <D.16652>;
  <D.16651>:
  monoeg_g_string_append (str, ", ");
  <D.16652>:
  D.16653 = ginst->type_argv[i];
  mono_type_get_desc (str, D.16653, 1);
  i = i + 1;
  <D.16250>:
  D.16654 = ginst->type_argc;
  D.16655 = (int) D.16654;
  if (D.16655 > i) goto <D.16249>; else goto <D.16251>;
  <D.16251>:
}


mono_method_desc_new (const char * name, gboolean include_namespace)
{
  char * D.16660;
  char D.16661;
  char * use_args.2;
  struct MonoMethodDesc * D.16667;
  char * D.16672;
  char D.16673;
  char * method_name.3;
  char * class_name.4;
  char * iftmp.5;
  char * D.16685;
  char * D.16686;
  char * D.16689;
  char * D.16690;
  char D.16695;
  unsigned int D.16700;
  unsigned int D.16701;
  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.16656>; else goto <D.16657>;
  <D.16656>:
  if (use_args > class_nspace) goto <D.16658>; else goto <D.16659>;
  <D.16658>:
  D.16660 = use_args + 4294967295;
  D.16661 = *D.16660;
  if (D.16661 == 32) goto <D.16662>; else goto <D.16663>;
  <D.16662>:
  D.16660 = use_args + 4294967295;
  *D.16660 = 0;
  <D.16663>:
  <D.16659>:
  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.16665>; else goto <D.16666>;
  <D.16665>:
  monoeg_g_free (class_nspace);
  D.16667 = 0B;
  return D.16667;
  <D.16666>:
  *end = 0;
  <D.16657>:
  method_name = strrchr (class_nspace, 58);
  if (method_name == 0B) goto <D.16668>; else goto <D.16669>;
  <D.16668>:
  monoeg_g_free (class_nspace);
  D.16667 = 0B;
  return D.16667;
  <D.16669>:
  if (method_name != class_nspace) goto <D.16670>; else goto <D.16671>;
  <D.16670>:
  D.16672 = method_name + 4294967295;
  D.16673 = *D.16672;
  if (D.16673 == 58) goto <D.16674>; else goto <D.16675>;
  <D.16674>:
  D.16672 = method_name + 4294967295;
  *D.16672 = 0;
  <D.16675>:
  <D.16671>:
  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.16677>; else goto <D.16678>;
  <D.16677>:
  class_name.4 = class_name;
  class_name = class_name.4 + 1;
  *class_name.4 = 0;
  use_namespace = 1;
  goto <D.16680>;
  <D.16678>:
  class_name = class_nspace;
  use_namespace = 0;
  <D.16680>:
  result = monoeg_malloc0 (32);
  result->include_namespace = include_namespace;
  result->name = method_name;
  result->klass = class_name;
  if (use_namespace != 0) goto <D.16682>; else goto <D.16683>;
  <D.16682>:
  iftmp.5 = class_nspace;
  goto <D.16684>;
  <D.16683>:
  iftmp.5 = 0B;
  <D.16684>:
  result->namespace = iftmp.5;
  result->args = use_args;
  D.16685 = result->name;
  D.16686 = __builtin_strchr (D.16685, 42);
  if (D.16686 != 0B) goto <D.16687>; else goto <D.16688>;
  <D.16687>:
  result->name_glob = 1;
  <D.16688>:
  D.16689 = result->klass;
  D.16690 = __builtin_strchr (D.16689, 42);
  if (D.16690 != 0B) goto <D.16691>; else goto <D.16692>;
  <D.16691>:
  result->klass_glob = 1;
  <D.16692>:
  if (use_args != 0B) goto <D.16693>; else goto <D.16694>;
  <D.16693>:
  end = use_args;
  D.16695 = *end;
  if (D.16695 != 0) goto <D.16696>; else goto <D.16697>;
  <D.16696>:
  result->num_args = 1;
  <D.16697>:
  goto <D.16269>;
  <D.16268>:
  D.16695 = *end;
  if (D.16695 == 44) goto <D.16698>; else goto <D.16699>;
  <D.16698>:
  D.16700 = result->num_args;
  D.16701 = D.16700 + 1;
  result->num_args = D.16701;
  <D.16699>:
  end = end + 1;
  <D.16269>:
  D.16695 = *end;
  if (D.16695 != 0) goto <D.16268>; else goto <D.16270>;
  <D.16270>:
  <D.16694>:
  D.16667 = result;
  return D.16667;
}


mono_method_desc_from_method (struct MonoMethod * method)
{
  const char * D.16703;
  gchar * D.16704;
  struct MonoClass * D.16705;
  const char * D.16706;
  gchar * D.16707;
  const char * D.16708;
  gchar * D.16709;
  struct MonoMethodDesc * D.16710;
  struct MonoMethodDesc * result;

  result = monoeg_malloc0 (32);
  result->include_namespace = 1;
  D.16703 = method->name;
  D.16704 = monoeg_strdup (D.16703);
  result->name = D.16704;
  D.16705 = method->klass;
  D.16706 = D.16705->name;
  D.16707 = monoeg_strdup (D.16706);
  result->klass = D.16707;
  D.16705 = method->klass;
  D.16708 = D.16705->name_space;
  D.16709 = monoeg_strdup (D.16708);
  result->namespace = D.16709;
  D.16710 = result;
  return D.16710;
}


mono_method_desc_free (struct MonoMethodDesc * desc)
{
  char * D.16712;
  char * D.16716;

  D.16712 = desc->namespace;
  if (D.16712 != 0B) goto <D.16713>; else goto <D.16714>;
  <D.16713>:
  D.16712 = desc->namespace;
  monoeg_g_free (D.16712);
  goto <D.16715>;
  <D.16714>:
  D.16716 = desc->klass;
  if (D.16716 != 0B) goto <D.16717>; else goto <D.16718>;
  <D.16717>:
  D.16716 = desc->klass;
  monoeg_g_free (D.16716);
  <D.16718>:
  <D.16715>:
  monoeg_g_free (desc);
}


mono_method_desc_match (struct MonoMethodDesc * desc, struct MonoMethod * method)
{
  int D.16292;
  char * D.16719;
  const char * D.16720;
  _Bool D.16721;
  mono_bool D.16724;
  char * D.16725;
  unsigned int D.16728;
  struct MonoMethodSignature * D.16729;
  short unsigned int D.16730;
  unsigned int D.16731;
  struct MonoMethodSignature * D.16734;
  int D.16735;
  int D.16301;
  char * sig;
  gboolean name_match;

  {
    size_t __s1_len;
    size_t __s2_len;

    D.16719 = desc->name;
    D.16720 = method->name;
    D.16292 = __builtin_strcmp (D.16719, D.16720);
  }
  D.16721 = D.16292 == 0;
  name_match = (gboolean) D.16721;
  if (name_match == 0) goto <D.16722>; else goto <D.16723>;
  <D.16722>:
  D.16724 = 0;
  return D.16724;
  <D.16723>:
  D.16725 = desc->args;
  if (D.16725 == 0B) goto <D.16726>; else goto <D.16727>;
  <D.16726>:
  D.16724 = 1;
  return D.16724;
  <D.16727>:
  D.16728 = desc->num_args;
  D.16729 = mono_method_signature (method);
  D.16730 = D.16729->param_count;
  D.16731 = (unsigned int) D.16730;
  if (D.16728 != D.16731) goto <D.16732>; else goto <D.16733>;
  <D.16732>:
  D.16724 = 0;
  return D.16724;
  <D.16733>:
  D.16734 = mono_method_signature (method);
  D.16735 = desc->include_namespace;
  sig = mono_signature_get_desc (D.16734, D.16735);
  {
    size_t __s1_len;
    size_t __s2_len;

    D.16725 = desc->args;
    D.16301 = __builtin_strcmp (sig, D.16725);
  }
  if (D.16301 != 0) goto <D.16736>; else goto <D.16737>;
  <D.16736>:
  monoeg_g_free (sig);
  D.16724 = 0;
  return D.16724;
  <D.16737>:
  monoeg_g_free (sig);
  D.16724 = 1;
  return D.16724;
}


mono_method_desc_full_match (struct MonoMethodDesc * desc, struct MonoMethod * method)
{
  char * D.16739;
  mono_bool D.16742;
  unsigned int D.16743;
  int D.16744;
  struct MonoClass * D.16745;
  int D.16746;

  D.16739 = desc->klass;
  if (D.16739 == 0B) goto <D.16740>; else goto <D.16741>;
  <D.16740>:
  D.16742 = 0;
  return D.16742;
  <D.16741>:
  D.16739 = desc->klass;
  D.16743 = strlen (D.16739);
  D.16744 = (int) D.16743;
  D.16745 = method->klass;
  D.16746 = match_class (desc, D.16744, D.16745);
  if (D.16746 == 0) goto <D.16747>; else goto <D.16748>;
  <D.16747>:
  D.16742 = 0;
  return D.16742;
  <D.16748>:
  D.16742 = mono_method_desc_match (desc, method);
  return D.16742;
}


match_class (struct MonoMethodDesc * desc, int pos, struct MonoClass * klass)
{
  int D.16750;
  int D.16326;
  int iftmp.6;
  int D.16325;
  const char[2] * D.16756;
  unsigned char D.16757;
  int D.16758;
  unsigned char D.16759;
  int D.16760;
  const unsigned char * D.16765;
  unsigned char D.16766;
  int D.16767;
  const unsigned char * D.16768;
  unsigned char D.16769;
  int D.16770;
  const unsigned char * D.16775;
  unsigned char D.16776;
  int D.16777;
  const unsigned char * D.16778;
  unsigned char D.16779;
  int D.16780;
  const unsigned char * D.16785;
  unsigned char D.16786;
  int D.16787;
  const unsigned char * D.16788;
  unsigned char D.16789;
  int D.16790;
  char * D.16792;
  gboolean D.16795;
  const char * D.16798;
  int pos.7;
  unsigned int pos.8;
  int D.16801;
  char * D.16804;
  int D.16344;
  const char * D.16807;
  int D.16353;
  const char * D.16810;
  struct MonoClass * D.16813;
  const char * p;

  D.16750 = desc->klass_glob;
  if (D.16750 != 0) goto <D.16751>; else goto <D.16752>;
  <D.16751>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = desc->klass;
      D.16756 = "*";
      D.16757 = MEM[(const unsigned char *)D.16756];
      D.16758 = (int) D.16757;
      D.16759 = *__s2;
      D.16760 = (int) D.16759;
      __result = D.16758 - D.16760;
      {
        if (__s2_len != 0) goto <D.16761>; else goto <D.16762>;
        <D.16761>:
        if (__result == 0) goto <D.16763>; else goto <D.16764>;
        <D.16763>:
        D.16765 = &MEM[(void *)"*" + 1B];
        D.16766 = *D.16765;
        D.16767 = (int) D.16766;
        D.16768 = __s2 + 1;
        D.16769 = *D.16768;
        D.16770 = (int) D.16769;
        __result = D.16767 - D.16770;
        if (__s2_len > 1) goto <D.16771>; else goto <D.16772>;
        <D.16771>:
        if (__result == 0) goto <D.16773>; else goto <D.16774>;
        <D.16773>:
        D.16775 = &MEM[(void *)"*" + 2B];
        D.16776 = *D.16775;
        D.16777 = (int) D.16776;
        D.16778 = __s2 + 2;
        D.16779 = *D.16778;
        D.16780 = (int) D.16779;
        __result = D.16777 - D.16780;
        if (__s2_len > 2) goto <D.16781>; else goto <D.16782>;
        <D.16781>:
        if (__result == 0) goto <D.16783>; else goto <D.16784>;
        <D.16783>:
        D.16785 = &MEM[(void *)"*" + 3B];
        D.16786 = *D.16785;
        D.16787 = (int) D.16786;
        D.16788 = __s2 + 3;
        D.16789 = *D.16788;
        D.16790 = (int) D.16789;
        __result = D.16787 - D.16790;
        <D.16784>:
        <D.16782>:
        <D.16774>:
        <D.16772>:
        <D.16764>:
        <D.16762>:
      }
      D.16325 = __result;
    }
    iftmp.6 = -D.16325;
    goto <D.16791>;
    <D.16755>:
    D.16792 = desc->klass;
    iftmp.6 = __builtin_strcmp (D.16792, "*");
    <D.16791>:
    D.16326 = iftmp.6;
  }
  if (D.16326 == 0) goto <D.16793>; else goto <D.16794>;
  <D.16793>:
  D.16795 = 1;
  return D.16795;
  <D.16794>:
  <D.16752>:
  D.16792 = desc->klass;
  p = my_strrchr (D.16792, 47, &pos);
  if (p == 0B) goto <D.16796>; else goto <D.16797>;
  <D.16796>:
  D.16792 = desc->klass;
  D.16798 = klass->name;
  pos.7 = pos;
  pos.8 = (unsigned int) pos.7;
  D.16801 = strncmp (D.16792, D.16798, pos.8);
  if (D.16801 != 0) goto <D.16802>; else goto <D.16803>;
  <D.16802>:
  D.16795 = 0;
  return D.16795;
  <D.16803>:
  D.16804 = desc->namespace;
  if (D.16804 != 0B) goto <D.16805>; else goto <D.16806>;
  <D.16805>:
  {
    size_t __s1_len;
    size_t __s2_len;

    D.16804 = desc->namespace;
    D.16807 = klass->name_space;
    D.16344 = __builtin_strcmp (D.16804, D.16807);
  }
  if (D.16344 != 0) goto <D.16808>; else goto <D.16809>;
  <D.16808>:
  D.16795 = 0;
  return D.16795;
  <D.16809>:
  <D.16806>:
  D.16795 = 1;
  return D.16795;
  <D.16797>:
  {
    size_t __s1_len;
    size_t __s2_len;

    D.16810 = p + 1;
    D.16798 = klass->name;
    D.16353 = __builtin_strcmp (D.16810, D.16798);
  }
  if (D.16353 != 0) goto <D.16811>; else goto <D.16812>;
  <D.16811>:
  D.16795 = 0;
  return D.16795;
  <D.16812>:
  D.16813 = klass->nested_in;
  if (D.16813 == 0B) goto <D.16814>; else goto <D.16815>;
  <D.16814>:
  D.16795 = 0;
  return D.16795;
  <D.16815>:
  pos.7 = pos;
  D.16813 = klass->nested_in;
  D.16795 = match_class (desc, pos.7, D.16813);
  return D.16795;
}


my_strrchr (const char * str, char ch, int * len)
{
  int D.16817;
  sizetype pos.9;
  const char * D.16819;
  char D.16820;
  const char * D.16823;
  int pos;

  D.16817 = *len;
  pos = D.16817 + -1;
  goto <D.16310>;
  <D.16309>:
  pos.9 = (sizetype) pos;
  D.16819 = str + pos.9;
  D.16820 = *D.16819;
  if (D.16820 != ch) goto <D.16821>; else goto <D.16822>;
  <D.16821>:
  // predicted unlikely by continue predictor.
  goto <D.16308>;
  <D.16822>:
  *len = pos;
  pos.9 = (sizetype) pos;
  D.16823 = str + pos.9;
  return D.16823;
  <D.16308>:
  pos = pos + -1;
  <D.16310>:
  if (pos >= 0) goto <D.16309>; else goto <D.16311>;
  <D.16311>:
  D.16823 = 0B;
  return D.16823;
}


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

  try
    {
      iter = 0B;
      goto <D.16365>;
      <D.16364>:
      D.16825 = mono_method_desc_match (desc, m);
      if (D.16825 != 0) goto <D.16826>; else goto <D.16827>;
      <D.16826>:
      D.16828 = m;
      return D.16828;
      <D.16827>:
      <D.16365>:
      m = mono_class_get_methods (klass, &iter);
      if (m != 0B) goto <D.16364>; else goto <D.16366>;
      <D.16366>:
      D.16828 = 0B;
      return D.16828;
    }
  finally
    {
      iter = {CLOBBER};
    }
}


mono_method_desc_search_in_image (struct MonoMethodDesc * desc, struct MonoImage * image)
{
  char * D.16831;
  struct MonoImage * D.16834;
  char * D.16837;
  struct MonoMethod * D.16840;
  int D.16386;
  char * D.16847;
  int D.16850;
  int D.16851;
  unsigned int D.16852;
  int D.16853;
  int D.16856;
  struct MonoClass * klass;
  const struct MonoTableInfo * tdef;
  const struct MonoTableInfo * methods;
  struct MonoMethod * method;
  int i;

  D.16831 = desc->namespace;
  if (D.16831 == 0B) goto <D.16832>; else goto <D.16833>;
  <D.16832>:
  D.16834 = mono_defaults.corlib;
  if (D.16834 == image) goto <D.16835>; else goto <D.16836>;
  <D.16835>:
  D.16837 = desc->klass;
  klass = find_system_class (D.16837);
  if (klass != 0B) goto <D.16838>; else goto <D.16839>;
  <D.16838>:
  D.16840 = mono_method_desc_search_in_class (desc, klass);
  return D.16840;
  <D.16839>:
  <D.16836>:
  <D.16833>:
  D.16831 = desc->namespace;
  if (D.16831 != 0B) goto <D.16841>; else goto <D.16842>;
  <D.16841>:
  D.16837 = desc->klass;
  if (D.16837 != 0B) goto <D.16843>; else goto <D.16844>;
  <D.16843>:
  D.16831 = desc->namespace;
  D.16837 = desc->klass;
  klass = mono_class_from_name (image, D.16831, D.16837);
  if (klass == 0B) goto <D.16845>; else goto <D.16846>;
  <D.16845>:
  D.16840 = 0B;
  return D.16840;
  <D.16846>:
  D.16840 = mono_method_desc_search_in_class (desc, klass);
  return D.16840;
  <D.16844>:
  <D.16842>:
  tdef = mono_image_get_table_info (image, 2);
  methods = mono_image_get_table_info (image, 6);
  i = 0;
  goto <D.16389>;
  <D.16388>:
  {
    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.16847 = desc->name;
      D.16386 = __builtin_strcmp (n, D.16847);
    }
    if (D.16386 != 0) goto <D.16848>; else goto <D.16849>;
    <D.16848>:
    // predicted unlikely by continue predictor.
    goto <D.16387>;
    <D.16849>:
    D.16850 = i + 1;
    D.16851 = D.16850 | 100663296;
    D.16852 = (unsigned int) D.16851;
    method = mono_get_method (image, D.16852, 0B);
    D.16853 = mono_method_desc_full_match (desc, method);
    if (D.16853 != 0) goto <D.16854>; else goto <D.16855>;
    <D.16854>:
    D.16840 = method;
    return D.16840;
    <D.16855>:
  }
  <D.16387>:
  i = i + 1;
  <D.16389>:
  D.16856 = mono_table_info_get_rows (methods);
  if (D.16856 > i) goto <D.16388>; else goto <D.16390>;
  <D.16390>:
  D.16840 = 0B;
  return D.16840;
}


find_system_class (const char * name)
{
  int D.16042;
  int iftmp.10;
  int D.16041;
  const char[5] * D.16861;
  unsigned char D.16862;
  int D.16863;
  unsigned char D.16864;
  int D.16865;
  const unsigned char * D.16870;
  unsigned char D.16871;
  int D.16872;
  const unsigned char * D.16873;
  unsigned char D.16874;
  int D.16875;
  const unsigned char * D.16880;
  unsigned char D.16881;
  int D.16882;
  const unsigned char * D.16883;
  unsigned char D.16884;
  int D.16885;
  const unsigned char * D.16890;
  unsigned char D.16891;
  int D.16892;
  const unsigned char * D.16893;
  unsigned char D.16894;
  int D.16895;
  struct MonoClass * D.16899;
  int D.16051;
  int iftmp.11;
  int D.16050;
  const char[5] * D.16903;
  unsigned char D.16904;
  int D.16905;
  unsigned char D.16906;
  int D.16907;
  const unsigned char * D.16912;
  unsigned char D.16913;
  int D.16914;
  const unsigned char * D.16915;
  unsigned char D.16916;
  int D.16917;
  const unsigned char * D.16922;
  unsigned char D.16923;
  int D.16924;
  const unsigned char * D.16925;
  unsigned char D.16926;
  int D.16927;
  const unsigned char * D.16932;
  unsigned char D.16933;
  int D.16934;
  const unsigned char * D.16935;
  unsigned char D.16936;
  int D.16937;
  int D.16060;
  int iftmp.12;
  int D.16059;
  const char[5] * D.16944;
  unsigned char D.16945;
  int D.16946;
  unsigned char D.16947;
  int D.16948;
  const unsigned char * D.16953;
  unsigned char D.16954;
  int D.16955;
  const unsigned char * D.16956;
  unsigned char D.16957;
  int D.16958;
  const unsigned char * D.16963;
  unsigned char D.16964;
  int D.16965;
  const unsigned char * D.16966;
  unsigned char D.16967;
  int D.16968;
  const unsigned char * D.16973;
  unsigned char D.16974;
  int D.16975;
  const unsigned char * D.16976;
  unsigned char D.16977;
  int D.16978;
  int D.16069;
  int iftmp.13;
  int D.16068;
  const char[5] * D.16985;
  unsigned char D.16986;
  int D.16987;
  unsigned char D.16988;
  int D.16989;
  const unsigned char * D.16994;
  unsigned char D.16995;
  int D.16996;
  const unsigned char * D.16997;
  unsigned char D.16998;
  int D.16999;
  const unsigned char * D.17004;
  unsigned char D.17005;
  int D.17006;
  const unsigned char * D.17007;
  unsigned char D.17008;
  int D.17009;
  const unsigned char * D.17014;
  unsigned char D.17015;
  int D.17016;
  const unsigned char * D.17017;
  unsigned char D.17018;
  int D.17019;
  int D.16078;
  int iftmp.14;
  int D.16077;
  const char[6] * D.17026;
  unsigned char D.17027;
  int D.17028;
  unsigned char D.17029;
  int D.17030;
  const unsigned char * D.17035;
  unsigned char D.17036;
  int D.17037;
  const unsigned char * D.17038;
  unsigned char D.17039;
  int D.17040;
  const unsigned char * D.17045;
  unsigned char D.17046;
  int D.17047;
  const unsigned char * D.17048;
  unsigned char D.17049;
  int D.17050;
  const unsigned char * D.17055;
  unsigned char D.17056;
  int D.17057;
  const unsigned char * D.17058;
  unsigned char D.17059;
  int D.17060;
  int D.16087;
  int iftmp.15;
  int D.16086;
  const char[7] * D.17067;
  unsigned char D.17068;
  int D.17069;
  unsigned char D.17070;
  int D.17071;
  const unsigned char * D.17076;
  unsigned char D.17077;
  int D.17078;
  const unsigned char * D.17079;
  unsigned char D.17080;
  int D.17081;
  const unsigned char * D.17086;
  unsigned char D.17087;
  int D.17088;
  const unsigned char * D.17089;
  unsigned char D.17090;
  int D.17091;
  const unsigned char * D.17096;
  unsigned char D.17097;
  int D.17098;
  const unsigned char * D.17099;
  unsigned char D.17100;
  int D.17101;
  int D.16096;
  int iftmp.16;
  int D.16095;
  const char[6] * D.17108;
  unsigned char D.17109;
  int D.17110;
  unsigned char D.17111;
  int D.17112;
  const unsigned char * D.17117;
  unsigned char D.17118;
  int D.17119;
  const unsigned char * D.17120;
  unsigned char D.17121;
  int D.17122;
  const unsigned char * D.17127;
  unsigned char D.17128;
  int D.17129;
  const unsigned char * D.17130;
  unsigned char D.17131;
  int D.17132;
  const unsigned char * D.17137;
  unsigned char D.17138;
  int D.17139;
  const unsigned char * D.17140;
  unsigned char D.17141;
  int D.17142;
  int D.16105;
  int iftmp.17;
  int D.16104;
  const char[5] * D.17149;
  unsigned char D.17150;
  int D.17151;
  unsigned char D.17152;
  int D.17153;
  const unsigned char * D.17158;
  unsigned char D.17159;
  int D.17160;
  const unsigned char * D.17161;
  unsigned char D.17162;
  int D.17163;
  const unsigned char * D.17168;
  unsigned char D.17169;
  int D.17170;
  const unsigned char * D.17171;
  unsigned char D.17172;
  int D.17173;
  const unsigned char * D.17178;
  unsigned char D.17179;
  int D.17180;
  const unsigned char * D.17181;
  unsigned char D.17182;
  int D.17183;
  int D.16114;
  int iftmp.18;
  int D.16113;
  const char[4] * D.17190;
  unsigned char D.17191;
  int D.17192;
  unsigned char D.17193;
  int D.17194;
  const unsigned char * D.17199;
  unsigned char D.17200;
  int D.17201;
  const unsigned char * D.17202;
  unsigned char D.17203;
  int D.17204;
  const unsigned char * D.17209;
  unsigned char D.17210;
  int D.17211;
  const unsigned char * D.17212;
  unsigned char D.17213;
  int D.17214;
  const unsigned char * D.17219;
  unsigned char D.17220;
  int D.17221;
  const unsigned char * D.17222;
  unsigned char D.17223;
  int D.17224;
  int D.16123;
  int iftmp.19;
  int D.16122;
  const char[6] * D.17231;
  unsigned char D.17232;
  int D.17233;
  unsigned char D.17234;
  int D.17235;
  const unsigned char * D.17240;
  unsigned char D.17241;
  int D.17242;
  const unsigned char * D.17243;
  unsigned char D.17244;
  int D.17245;
  const unsigned char * D.17250;
  unsigned char D.17251;
  int D.17252;
  const unsigned char * D.17253;
  unsigned char D.17254;
  int D.17255;
  const unsigned char * D.17260;
  unsigned char D.17261;
  int D.17262;
  const unsigned char * D.17263;
  unsigned char D.17264;
  int D.17265;
  int D.16132;
  int iftmp.20;
  int D.16131;
  const char[5] * D.17272;
  unsigned char D.17273;
  int D.17274;
  unsigned char D.17275;
  int D.17276;
  const unsigned char * D.17281;
  unsigned char D.17282;
  int D.17283;
  const unsigned char * D.17284;
  unsigned char D.17285;
  int D.17286;
  const unsigned char * D.17291;
  unsigned char D.17292;
  int D.17293;
  const unsigned char * D.17294;
  unsigned char D.17295;
  int D.17296;
  const unsigned char * D.17301;
  unsigned char D.17302;
  int D.17303;
  const unsigned char * D.17304;
  unsigned char D.17305;
  int D.17306;
  int D.16141;
  int iftmp.21;
  int D.16140;
  const char[8] * D.17313;
  unsigned char D.17314;
  int D.17315;
  unsigned char D.17316;
  int D.17317;
  const unsigned char * D.17322;
  unsigned char D.17323;
  int D.17324;
  const unsigned char * D.17325;
  unsigned char D.17326;
  int D.17327;
  const unsigned char * D.17332;
  unsigned char D.17333;
  int D.17334;
  const unsigned char * D.17335;
  unsigned char D.17336;
  int D.17337;
  const unsigned char * D.17342;
  unsigned char D.17343;
  int D.17344;
  const unsigned char * D.17345;
  unsigned char D.17346;
  int D.17347;
  int D.16150;
  int iftmp.22;
  int D.16149;
  const char[7] * D.17354;
  unsigned char D.17355;
  int D.17356;
  unsigned char D.17357;
  int D.17358;
  const unsigned char * D.17363;
  unsigned char D.17364;
  int D.17365;
  const unsigned char * D.17366;
  unsigned char D.17367;
  int D.17368;
  const unsigned char * D.17373;
  unsigned char D.17374;
  int D.17375;
  const unsigned char * D.17376;
  unsigned char D.17377;
  int D.17378;
  const unsigned char * D.17383;
  unsigned char D.17384;
  int D.17385;
  const unsigned char * D.17386;
  unsigned char D.17387;
  int D.17388;
  int D.16159;
  int iftmp.23;
  int D.16158;
  const char[7] * D.17395;
  unsigned char D.17396;
  int D.17397;
  unsigned char D.17398;
  int D.17399;
  const unsigned char * D.17404;
  unsigned char D.17405;
  int D.17406;
  const unsigned char * D.17407;
  unsigned char D.17408;
  int D.17409;
  const unsigned char * D.17414;
  unsigned char D.17415;
  int D.17416;
  const unsigned char * D.17417;
  unsigned char D.17418;
  int D.17419;
  const unsigned char * D.17424;
  unsigned char D.17425;
  int D.17426;
  const unsigned char * D.17427;
  unsigned char D.17428;
  int D.17429;
  int D.16168;
  int iftmp.24;
  int D.16167;
  const char[7] * D.17436;
  unsigned char D.17437;
  int D.17438;
  unsigned char D.17439;
  int D.17440;
  const unsigned char * D.17445;
  unsigned char D.17446;
  int D.17447;
  const unsigned char * D.17448;
  unsigned char D.17449;
  int D.17450;
  const unsigned char * D.17455;
  unsigned char D.17456;
  int D.17457;
  const unsigned char * D.17458;
  unsigned char D.17459;
  int D.17460;
  const unsigned char * D.17465;
  unsigned char D.17466;
  int D.17467;
  const unsigned char * D.17468;
  unsigned char D.17469;
  int D.17470;
  int D.16177;
  int iftmp.25;
  int D.16176;
  const char[7] * D.17477;
  unsigned char D.17478;
  int D.17479;
  unsigned char D.17480;
  int D.17481;
  const unsigned char * D.17486;
  unsigned char D.17487;
  int D.17488;
  const unsigned char * D.17489;
  unsigned char D.17490;
  int D.17491;
  const unsigned char * D.17496;
  unsigned char D.17497;
  int D.17498;
  const unsigned char * D.17499;
  unsigned char D.17500;
  int D.17501;
  const unsigned char * D.17506;
  unsigned char D.17507;
  int D.17508;
  const unsigned char * D.17509;
  unsigned char D.17510;
  int D.17511;
  int D.16186;
  int iftmp.26;
  int D.16185;
  const char[7] * D.17518;
  unsigned char D.17519;
  int D.17520;
  unsigned char D.17521;
  int D.17522;
  const unsigned char * D.17527;
  unsigned char D.17528;
  int D.17529;
  const unsigned char * D.17530;
  unsigned char D.17531;
  int D.17532;
  const unsigned char * D.17537;
  unsigned char D.17538;
  int D.17539;
  const unsigned char * D.17540;
  unsigned char D.17541;
  int D.17542;
  const unsigned char * D.17547;
  unsigned char D.17548;
  int D.17549;
  const unsigned char * D.17550;
  unsigned char D.17551;
  int D.17552;

  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = name;
      D.16861 = "void";
      D.16862 = MEM[(const unsigned char *)D.16861];
      D.16863 = (int) D.16862;
      D.16864 = *__s2;
      D.16865 = (int) D.16864;
      __result = D.16863 - D.16865;
      {
        if (__s2_len != 0) goto <D.16866>; else goto <D.16867>;
        <D.16866>:
        if (__result == 0) goto <D.16868>; else goto <D.16869>;
        <D.16868>:
        D.16870 = &MEM[(void *)"void" + 1B];
        D.16871 = *D.16870;
        D.16872 = (int) D.16871;
        D.16873 = __s2 + 1;
        D.16874 = *D.16873;
        D.16875 = (int) D.16874;
        __result = D.16872 - D.16875;
        if (__s2_len > 1) goto <D.16876>; else goto <D.16877>;
        <D.16876>:
        if (__result == 0) goto <D.16878>; else goto <D.16879>;
        <D.16878>:
        D.16880 = &MEM[(void *)"void" + 2B];
        D.16881 = *D.16880;
        D.16882 = (int) D.16881;
        D.16883 = __s2 + 2;
        D.16884 = *D.16883;
        D.16885 = (int) D.16884;
        __result = D.16882 - D.16885;
        if (__s2_len > 2) goto <D.16886>; else goto <D.16887>;
        <D.16886>:
        if (__result == 0) goto <D.16888>; else goto <D.16889>;
        <D.16888>:
        D.16890 = &MEM[(void *)"void" + 3B];
        D.16891 = *D.16890;
        D.16892 = (int) D.16891;
        D.16893 = __s2 + 3;
        D.16894 = *D.16893;
        D.16895 = (int) D.16894;
        __result = D.16892 - D.16895;
        <D.16889>:
        <D.16887>:
        <D.16879>:
        <D.16877>:
        <D.16869>:
        <D.16867>:
      }
      D.16041 = __result;
    }
    iftmp.10 = -D.16041;
    goto <D.16896>;
    <D.16860>:
    iftmp.10 = __builtin_strcmp (name, "void");
    <D.16896>:
    D.16042 = iftmp.10;
  }
  if (D.16042 == 0) goto <D.16897>; else goto <D.16898>;
  <D.16897>:
  D.16899 = mono_defaults.void_class;
  return D.16899;
  <D.16898>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = name;
      D.16903 = "char";
      D.16904 = MEM[(const unsigned char *)D.16903];
      D.16905 = (int) D.16904;
      D.16906 = *__s2;
      D.16907 = (int) D.16906;
      __result = D.16905 - D.16907;
      {
        if (__s2_len != 0) goto <D.16908>; else goto <D.16909>;
        <D.16908>:
        if (__result == 0) goto <D.16910>; else goto <D.16911>;
        <D.16910>:
        D.16912 = &MEM[(void *)"char" + 1B];
        D.16913 = *D.16912;
        D.16914 = (int) D.16913;
        D.16915 = __s2 + 1;
        D.16916 = *D.16915;
        D.16917 = (int) D.16916;
        __result = D.16914 - D.16917;
        if (__s2_len > 1) goto <D.16918>; else goto <D.16919>;
        <D.16918>:
        if (__result == 0) goto <D.16920>; else goto <D.16921>;
        <D.16920>:
        D.16922 = &MEM[(void *)"char" + 2B];
        D.16923 = *D.16922;
        D.16924 = (int) D.16923;
        D.16925 = __s2 + 2;
        D.16926 = *D.16925;
        D.16927 = (int) D.16926;
        __result = D.16924 - D.16927;
        if (__s2_len > 2) goto <D.16928>; else goto <D.16929>;
        <D.16928>:
        if (__result == 0) goto <D.16930>; else goto <D.16931>;
        <D.16930>:
        D.16932 = &MEM[(void *)"char" + 3B];
        D.16933 = *D.16932;
        D.16934 = (int) D.16933;
        D.16935 = __s2 + 3;
        D.16936 = *D.16935;
        D.16937 = (int) D.16936;
        __result = D.16934 - D.16937;
        <D.16931>:
        <D.16929>:
        <D.16921>:
        <D.16919>:
        <D.16911>:
        <D.16909>:
      }
      D.16050 = __result;
    }
    iftmp.11 = -D.16050;
    goto <D.16938>;
    <D.16902>:
    iftmp.11 = __builtin_strcmp (name, "char");
    <D.16938>:
    D.16051 = iftmp.11;
  }
  if (D.16051 == 0) goto <D.16939>; else goto <D.16940>;
  <D.16939>:
  D.16899 = mono_defaults.char_class;
  return D.16899;
  <D.16940>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = name;
      D.16944 = "bool";
      D.16945 = MEM[(const unsigned char *)D.16944];
      D.16946 = (int) D.16945;
      D.16947 = *__s2;
      D.16948 = (int) D.16947;
      __result = D.16946 - D.16948;
      {
        if (__s2_len != 0) goto <D.16949>; else goto <D.16950>;
        <D.16949>:
        if (__result == 0) goto <D.16951>; else goto <D.16952>;
        <D.16951>:
        D.16953 = &MEM[(void *)"bool" + 1B];
        D.16954 = *D.16953;
        D.16955 = (int) D.16954;
        D.16956 = __s2 + 1;
        D.16957 = *D.16956;
        D.16958 = (int) D.16957;
        __result = D.16955 - D.16958;
        if (__s2_len > 1) goto <D.16959>; else goto <D.16960>;
        <D.16959>:
        if (__result == 0) goto <D.16961>; else goto <D.16962>;
        <D.16961>:
        D.16963 = &MEM[(void *)"bool" + 2B];
        D.16964 = *D.16963;
        D.16965 = (int) D.16964;
        D.16966 = __s2 + 2;
        D.16967 = *D.16966;
        D.16968 = (int) D.16967;
        __result = D.16965 - D.16968;
        if (__s2_len > 2) goto <D.16969>; else goto <D.16970>;
        <D.16969>:
        if (__result == 0) goto <D.16971>; else goto <D.16972>;
        <D.16971>:
        D.16973 = &MEM[(void *)"bool" + 3B];
        D.16974 = *D.16973;
        D.16975 = (int) D.16974;
        D.16976 = __s2 + 3;
        D.16977 = *D.16976;
        D.16978 = (int) D.16977;
        __result = D.16975 - D.16978;
        <D.16972>:
        <D.16970>:
        <D.16962>:
        <D.16960>:
        <D.16952>:
        <D.16950>:
      }
      D.16059 = __result;
    }
    iftmp.12 = -D.16059;
    goto <D.16979>;
    <D.16943>:
    iftmp.12 = __builtin_strcmp (name, "bool");
    <D.16979>:
    D.16060 = iftmp.12;
  }
  if (D.16060 == 0) goto <D.16980>; else goto <D.16981>;
  <D.16980>:
  D.16899 = mono_defaults.boolean_class;
  return D.16899;
  <D.16981>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = name;
      D.16985 = "byte";
      D.16986 = MEM[(const unsigned char *)D.16985];
      D.16987 = (int) D.16986;
      D.16988 = *__s2;
      D.16989 = (int) D.16988;
      __result = D.16987 - D.16989;
      {
        if (__s2_len != 0) goto <D.16990>; else goto <D.16991>;
        <D.16990>:
        if (__result == 0) goto <D.16992>; else goto <D.16993>;
        <D.16992>:
        D.16994 = &MEM[(void *)"byte" + 1B];
        D.16995 = *D.16994;
        D.16996 = (int) D.16995;
        D.16997 = __s2 + 1;
        D.16998 = *D.16997;
        D.16999 = (int) D.16998;
        __result = D.16996 - D.16999;
        if (__s2_len > 1) goto <D.17000>; else goto <D.17001>;
        <D.17000>:
        if (__result == 0) goto <D.17002>; else goto <D.17003>;
        <D.17002>:
        D.17004 = &MEM[(void *)"byte" + 2B];
        D.17005 = *D.17004;
        D.17006 = (int) D.17005;
        D.17007 = __s2 + 2;
        D.17008 = *D.17007;
        D.17009 = (int) D.17008;
        __result = D.17006 - D.17009;
        if (__s2_len > 2) goto <D.17010>; else goto <D.17011>;
        <D.17010>:
        if (__result == 0) goto <D.17012>; else goto <D.17013>;
        <D.17012>:
        D.17014 = &MEM[(void *)"byte" + 3B];
        D.17015 = *D.17014;
        D.17016 = (int) D.17015;
        D.17017 = __s2 + 3;
        D.17018 = *D.17017;
        D.17019 = (int) D.17018;
        __result = D.17016 - D.17019;
        <D.17013>:
        <D.17011>:
        <D.17003>:
        <D.17001>:
        <D.16993>:
        <D.16991>:
      }
      D.16068 = __result;
    }
    iftmp.13 = -D.16068;
    goto <D.17020>;
    <D.16984>:
    iftmp.13 = __builtin_strcmp (name, "byte");
    <D.17020>:
    D.16069 = iftmp.13;
  }
  if (D.16069 == 0) goto <D.17021>; else goto <D.17022>;
  <D.17021>:
  D.16899 = mono_defaults.byte_class;
  return D.16899;
  <D.17022>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = name;
      D.17026 = "sbyte";
      D.17027 = MEM[(const unsigned char *)D.17026];
      D.17028 = (int) D.17027;
      D.17029 = *__s2;
      D.17030 = (int) D.17029;
      __result = D.17028 - D.17030;
      {
        if (__s2_len != 0) goto <D.17031>; else goto <D.17032>;
        <D.17031>:
        if (__result == 0) goto <D.17033>; else goto <D.17034>;
        <D.17033>:
        D.17035 = &MEM[(void *)"sbyte" + 1B];
        D.17036 = *D.17035;
        D.17037 = (int) D.17036;
        D.17038 = __s2 + 1;
        D.17039 = *D.17038;
        D.17040 = (int) D.17039;
        __result = D.17037 - D.17040;
        if (__s2_len > 1) goto <D.17041>; else goto <D.17042>;
        <D.17041>:
        if (__result == 0) goto <D.17043>; else goto <D.17044>;
        <D.17043>:
        D.17045 = &MEM[(void *)"sbyte" + 2B];
        D.17046 = *D.17045;
        D.17047 = (int) D.17046;
        D.17048 = __s2 + 2;
        D.17049 = *D.17048;
        D.17050 = (int) D.17049;
        __result = D.17047 - D.17050;
        if (__s2_len > 2) goto <D.17051>; else goto <D.17052>;
        <D.17051>:
        if (__result == 0) goto <D.17053>; else goto <D.17054>;
        <D.17053>:
        D.17055 = &MEM[(void *)"sbyte" + 3B];
        D.17056 = *D.17055;
        D.17057 = (int) D.17056;
        D.17058 = __s2 + 3;
        D.17059 = *D.17058;
        D.17060 = (int) D.17059;
        __result = D.17057 - D.17060;
        <D.17054>:
        <D.17052>:
        <D.17044>:
        <D.17042>:
        <D.17034>:
        <D.17032>:
      }
      D.16077 = __result;
    }
    iftmp.14 = -D.16077;
    goto <D.17061>;
    <D.17025>:
    iftmp.14 = __builtin_strcmp (name, "sbyte");
    <D.17061>:
    D.16078 = iftmp.14;
  }
  if (D.16078 == 0) goto <D.17062>; else goto <D.17063>;
  <D.17062>:
  D.16899 = mono_defaults.sbyte_class;
  return D.16899;
  <D.17063>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = name;
      D.17067 = "uint16";
      D.17068 = MEM[(const unsigned char *)D.17067];
      D.17069 = (int) D.17068;
      D.17070 = *__s2;
      D.17071 = (int) D.17070;
      __result = D.17069 - D.17071;
      {
        if (__s2_len != 0) goto <D.17072>; else goto <D.17073>;
        <D.17072>:
        if (__result == 0) goto <D.17074>; else goto <D.17075>;
        <D.17074>:
        D.17076 = &MEM[(void *)"uint16" + 1B];
        D.17077 = *D.17076;
        D.17078 = (int) D.17077;
        D.17079 = __s2 + 1;
        D.17080 = *D.17079;
        D.17081 = (int) D.17080;
        __result = D.17078 - D.17081;
        if (__s2_len > 1) goto <D.17082>; else goto <D.17083>;
        <D.17082>:
        if (__result == 0) goto <D.17084>; else goto <D.17085>;
        <D.17084>:
        D.17086 = &MEM[(void *)"uint16" + 2B];
        D.17087 = *D.17086;
        D.17088 = (int) D.17087;
        D.17089 = __s2 + 2;
        D.17090 = *D.17089;
        D.17091 = (int) D.17090;
        __result = D.17088 - D.17091;
        if (__s2_len > 2) goto <D.17092>; else goto <D.17093>;
        <D.17092>:
        if (__result == 0) goto <D.17094>; else goto <D.17095>;
        <D.17094>:
        D.17096 = &MEM[(void *)"uint16" + 3B];
        D.17097 = *D.17096;
        D.17098 = (int) D.17097;
        D.17099 = __s2 + 3;
        D.17100 = *D.17099;
        D.17101 = (int) D.17100;
        __result = D.17098 - D.17101;
        <D.17095>:
        <D.17093>:
        <D.17085>:
        <D.17083>:
        <D.17075>:
        <D.17073>:
      }
      D.16086 = __result;
    }
    iftmp.15 = -D.16086;
    goto <D.17102>;
    <D.17066>:
    iftmp.15 = __builtin_strcmp (name, "uint16");
    <D.17102>:
    D.16087 = iftmp.15;
  }
  if (D.16087 == 0) goto <D.17103>; else goto <D.17104>;
  <D.17103>:
  D.16899 = mono_defaults.uint16_class;
  return D.16899;
  <D.17104>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = name;
      D.17108 = "int16";
      D.17109 = MEM[(const unsigned char *)D.17108];
      D.17110 = (int) D.17109;
      D.17111 = *__s2;
      D.17112 = (int) D.17111;
      __result = D.17110 - D.17112;
      {
        if (__s2_len != 0) goto <D.17113>; else goto <D.17114>;
        <D.17113>:
        if (__result == 0) goto <D.17115>; else goto <D.17116>;
        <D.17115>:
        D.17117 = &MEM[(void *)"int16" + 1B];
        D.17118 = *D.17117;
        D.17119 = (int) D.17118;
        D.17120 = __s2 + 1;
        D.17121 = *D.17120;
        D.17122 = (int) D.17121;
        __result = D.17119 - D.17122;
        if (__s2_len > 1) goto <D.17123>; else goto <D.17124>;
        <D.17123>:
        if (__result == 0) goto <D.17125>; else goto <D.17126>;
        <D.17125>:
        D.17127 = &MEM[(void *)"int16" + 2B];
        D.17128 = *D.17127;
        D.17129 = (int) D.17128;
        D.17130 = __s2 + 2;
        D.17131 = *D.17130;
        D.17132 = (int) D.17131;
        __result = D.17129 - D.17132;
        if (__s2_len > 2) goto <D.17133>; else goto <D.17134>;
        <D.17133>:
        if (__result == 0) goto <D.17135>; else goto <D.17136>;
        <D.17135>:
        D.17137 = &MEM[(void *)"int16" + 3B];
        D.17138 = *D.17137;
        D.17139 = (int) D.17138;
        D.17140 = __s2 + 3;
        D.17141 = *D.17140;
        D.17142 = (int) D.17141;
        __result = D.17139 - D.17142;
        <D.17136>:
        <D.17134>:
        <D.17126>:
        <D.17124>:
        <D.17116>:
        <D.17114>:
      }
      D.16095 = __result;
    }
    iftmp.16 = -D.16095;
    goto <D.17143>;
    <D.17107>:
    iftmp.16 = __builtin_strcmp (name, "int16");
    <D.17143>:
    D.16096 = iftmp.16;
  }
  if (D.16096 == 0) goto <D.17144>; else goto <D.17145>;
  <D.17144>:
  D.16899 = mono_defaults.int16_class;
  return D.16899;
  <D.17145>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = name;
      D.17149 = "uint";
      D.17150 = MEM[(const unsigned char *)D.17149];
      D.17151 = (int) D.17150;
      D.17152 = *__s2;
      D.17153 = (int) D.17152;
      __result = D.17151 - D.17153;
      {
        if (__s2_len != 0) goto <D.17154>; else goto <D.17155>;
        <D.17154>:
        if (__result == 0) goto <D.17156>; else goto <D.17157>;
        <D.17156>:
        D.17158 = &MEM[(void *)"uint" + 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;
        if (__s2_len > 1) goto <D.17164>; else goto <D.17165>;
        <D.17164>:
        if (__result == 0) goto <D.17166>; else goto <D.17167>;
        <D.17166>:
        D.17168 = &MEM[(void *)"uint" + 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;
        if (__s2_len > 2) goto <D.17174>; else goto <D.17175>;
        <D.17174>:
        if (__result == 0) goto <D.17176>; else goto <D.17177>;
        <D.17176>:
        D.17178 = &MEM[(void *)"uint" + 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.17175>:
        <D.17167>:
        <D.17165>:
        <D.17157>:
        <D.17155>:
      }
      D.16104 = __result;
    }
    iftmp.17 = -D.16104;
    goto <D.17184>;
    <D.17148>:
    iftmp.17 = __builtin_strcmp (name, "uint");
    <D.17184>:
    D.16105 = iftmp.17;
  }
  if (D.16105 == 0) goto <D.17185>; else goto <D.17186>;
  <D.17185>:
  D.16899 = mono_defaults.uint32_class;
  return D.16899;
  <D.17186>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = name;
      D.17190 = "int";
      D.17191 = MEM[(const unsigned char *)D.17190];
      D.17192 = (int) D.17191;
      D.17193 = *__s2;
      D.17194 = (int) D.17193;
      __result = D.17192 - D.17194;
      {
        if (__s2_len != 0) goto <D.17195>; else goto <D.17196>;
        <D.17195>:
        if (__result == 0) goto <D.17197>; else goto <D.17198>;
        <D.17197>:
        D.17199 = &MEM[(void *)"int" + 1B];
        D.17200 = *D.17199;
        D.17201 = (int) D.17200;
        D.17202 = __s2 + 1;
        D.17203 = *D.17202;
        D.17204 = (int) D.17203;
        __result = D.17201 - D.17204;
        if (__s2_len > 1) goto <D.17205>; else goto <D.17206>;
        <D.17205>:
        if (__result == 0) goto <D.17207>; else goto <D.17208>;
        <D.17207>:
        D.17209 = &MEM[(void *)"int" + 2B];
        D.17210 = *D.17209;
        D.17211 = (int) D.17210;
        D.17212 = __s2 + 2;
        D.17213 = *D.17212;
        D.17214 = (int) D.17213;
        __result = D.17211 - D.17214;
        if (__s2_len > 2) goto <D.17215>; else goto <D.17216>;
        <D.17215>:
        if (__result == 0) goto <D.17217>; else goto <D.17218>;
        <D.17217>:
        D.17219 = &MEM[(void *)"int" + 3B];
        D.17220 = *D.17219;
        D.17221 = (int) D.17220;
        D.17222 = __s2 + 3;
        D.17223 = *D.17222;
        D.17224 = (int) D.17223;
        __result = D.17221 - D.17224;
        <D.17218>:
        <D.17216>:
        <D.17208>:
        <D.17206>:
        <D.17198>:
        <D.17196>:
      }
      D.16113 = __result;
    }
    iftmp.18 = -D.16113;
    goto <D.17225>;
    <D.17189>:
    iftmp.18 = __builtin_strcmp (name, "int");
    <D.17225>:
    D.16114 = iftmp.18;
  }
  if (D.16114 == 0) goto <D.17226>; else goto <D.17227>;
  <D.17226>:
  D.16899 = mono_defaults.int32_class;
  return D.16899;
  <D.17227>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = name;
      D.17231 = "ulong";
      D.17232 = MEM[(const unsigned char *)D.17231];
      D.17233 = (int) D.17232;
      D.17234 = *__s2;
      D.17235 = (int) D.17234;
      __result = D.17233 - D.17235;
      {
        if (__s2_len != 0) goto <D.17236>; else goto <D.17237>;
        <D.17236>:
        if (__result == 0) goto <D.17238>; else goto <D.17239>;
        <D.17238>:
        D.17240 = &MEM[(void *)"ulong" + 1B];
        D.17241 = *D.17240;
        D.17242 = (int) D.17241;
        D.17243 = __s2 + 1;
        D.17244 = *D.17243;
        D.17245 = (int) D.17244;
        __result = D.17242 - D.17245;
        if (__s2_len > 1) goto <D.17246>; else goto <D.17247>;
        <D.17246>:
        if (__result == 0) goto <D.17248>; else goto <D.17249>;
        <D.17248>:
        D.17250 = &MEM[(void *)"ulong" + 2B];
        D.17251 = *D.17250;
        D.17252 = (int) D.17251;
        D.17253 = __s2 + 2;
        D.17254 = *D.17253;
        D.17255 = (int) D.17254;
        __result = D.17252 - D.17255;
        if (__s2_len > 2) goto <D.17256>; else goto <D.17257>;
        <D.17256>:
        if (__result == 0) goto <D.17258>; else goto <D.17259>;
        <D.17258>:
        D.17260 = &MEM[(void *)"ulong" + 3B];
        D.17261 = *D.17260;
        D.17262 = (int) D.17261;
        D.17263 = __s2 + 3;
        D.17264 = *D.17263;
        D.17265 = (int) D.17264;
        __result = D.17262 - D.17265;
        <D.17259>:
        <D.17257>:
        <D.17249>:
        <D.17247>:
        <D.17239>:
        <D.17237>:
      }
      D.16122 = __result;
    }
    iftmp.19 = -D.16122;
    goto <D.17266>;
    <D.17230>:
    iftmp.19 = __builtin_strcmp (name, "ulong");
    <D.17266>:
    D.16123 = iftmp.19;
  }
  if (D.16123 == 0) goto <D.17267>; else goto <D.17268>;
  <D.17267>:
  D.16899 = mono_defaults.uint64_class;
  return D.16899;
  <D.17268>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = name;
      D.17272 = "long";
      D.17273 = MEM[(const unsigned char *)D.17272];
      D.17274 = (int) D.17273;
      D.17275 = *__s2;
      D.17276 = (int) D.17275;
      __result = D.17274 - D.17276;
      {
        if (__s2_len != 0) goto <D.17277>; else goto <D.17278>;
        <D.17277>:
        if (__result == 0) goto <D.17279>; else goto <D.17280>;
        <D.17279>:
        D.17281 = &MEM[(void *)"long" + 1B];
        D.17282 = *D.17281;
        D.17283 = (int) D.17282;
        D.17284 = __s2 + 1;
        D.17285 = *D.17284;
        D.17286 = (int) D.17285;
        __result = D.17283 - D.17286;
        if (__s2_len > 1) goto <D.17287>; else goto <D.17288>;
        <D.17287>:
        if (__result == 0) goto <D.17289>; else goto <D.17290>;
        <D.17289>:
        D.17291 = &MEM[(void *)"long" + 2B];
        D.17292 = *D.17291;
        D.17293 = (int) D.17292;
        D.17294 = __s2 + 2;
        D.17295 = *D.17294;
        D.17296 = (int) D.17295;
        __result = D.17293 - D.17296;
        if (__s2_len > 2) goto <D.17297>; else goto <D.17298>;
        <D.17297>:
        if (__result == 0) goto <D.17299>; else goto <D.17300>;
        <D.17299>:
        D.17301 = &MEM[(void *)"long" + 3B];
        D.17302 = *D.17301;
        D.17303 = (int) D.17302;
        D.17304 = __s2 + 3;
        D.17305 = *D.17304;
        D.17306 = (int) D.17305;
        __result = D.17303 - D.17306;
        <D.17300>:
        <D.17298>:
        <D.17290>:
        <D.17288>:
        <D.17280>:
        <D.17278>:
      }
      D.16131 = __result;
    }
    iftmp.20 = -D.16131;
    goto <D.17307>;
    <D.17271>:
    iftmp.20 = __builtin_strcmp (name, "long");
    <D.17307>:
    D.16132 = iftmp.20;
  }
  if (D.16132 == 0) goto <D.17308>; else goto <D.17309>;
  <D.17308>:
  D.16899 = mono_defaults.int64_class;
  return D.16899;
  <D.17309>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = name;
      D.17313 = "uintptr";
      D.17314 = MEM[(const unsigned char *)D.17313];
      D.17315 = (int) D.17314;
      D.17316 = *__s2;
      D.17317 = (int) D.17316;
      __result = D.17315 - D.17317;
      {
        if (__s2_len != 0) goto <D.17318>; else goto <D.17319>;
        <D.17318>:
        if (__result == 0) goto <D.17320>; else goto <D.17321>;
        <D.17320>:
        D.17322 = &MEM[(void *)"uintptr" + 1B];
        D.17323 = *D.17322;
        D.17324 = (int) D.17323;
        D.17325 = __s2 + 1;
        D.17326 = *D.17325;
        D.17327 = (int) D.17326;
        __result = D.17324 - D.17327;
        if (__s2_len > 1) goto <D.17328>; else goto <D.17329>;
        <D.17328>:
        if (__result == 0) goto <D.17330>; else goto <D.17331>;
        <D.17330>:
        D.17332 = &MEM[(void *)"uintptr" + 2B];
        D.17333 = *D.17332;
        D.17334 = (int) D.17333;
        D.17335 = __s2 + 2;
        D.17336 = *D.17335;
        D.17337 = (int) D.17336;
        __result = D.17334 - D.17337;
        if (__s2_len > 2) goto <D.17338>; else goto <D.17339>;
        <D.17338>:
        if (__result == 0) goto <D.17340>; else goto <D.17341>;
        <D.17340>:
        D.17342 = &MEM[(void *)"uintptr" + 3B];
        D.17343 = *D.17342;
        D.17344 = (int) D.17343;
        D.17345 = __s2 + 3;
        D.17346 = *D.17345;
        D.17347 = (int) D.17346;
        __result = D.17344 - D.17347;
        <D.17341>:
        <D.17339>:
        <D.17331>:
        <D.17329>:
        <D.17321>:
        <D.17319>:
      }
      D.16140 = __result;
    }
    iftmp.21 = -D.16140;
    goto <D.17348>;
    <D.17312>:
    iftmp.21 = __builtin_strcmp (name, "uintptr");
    <D.17348>:
    D.16141 = iftmp.21;
  }
  if (D.16141 == 0) goto <D.17349>; else goto <D.17350>;
  <D.17349>:
  D.16899 = mono_defaults.uint_class;
  return D.16899;
  <D.17350>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = name;
      D.17354 = "intptr";
      D.17355 = MEM[(const unsigned char *)D.17354];
      D.17356 = (int) D.17355;
      D.17357 = *__s2;
      D.17358 = (int) D.17357;
      __result = D.17356 - D.17358;
      {
        if (__s2_len != 0) goto <D.17359>; else goto <D.17360>;
        <D.17359>:
        if (__result == 0) goto <D.17361>; else goto <D.17362>;
        <D.17361>:
        D.17363 = &MEM[(void *)"intptr" + 1B];
        D.17364 = *D.17363;
        D.17365 = (int) D.17364;
        D.17366 = __s2 + 1;
        D.17367 = *D.17366;
        D.17368 = (int) D.17367;
        __result = D.17365 - D.17368;
        if (__s2_len > 1) goto <D.17369>; else goto <D.17370>;
        <D.17369>:
        if (__result == 0) goto <D.17371>; else goto <D.17372>;
        <D.17371>:
        D.17373 = &MEM[(void *)"intptr" + 2B];
        D.17374 = *D.17373;
        D.17375 = (int) D.17374;
        D.17376 = __s2 + 2;
        D.17377 = *D.17376;
        D.17378 = (int) D.17377;
        __result = D.17375 - D.17378;
        if (__s2_len > 2) goto <D.17379>; else goto <D.17380>;
        <D.17379>:
        if (__result == 0) goto <D.17381>; else goto <D.17382>;
        <D.17381>:
        D.17383 = &MEM[(void *)"intptr" + 3B];
        D.17384 = *D.17383;
        D.17385 = (int) D.17384;
        D.17386 = __s2 + 3;
        D.17387 = *D.17386;
        D.17388 = (int) D.17387;
        __result = D.17385 - D.17388;
        <D.17382>:
        <D.17380>:
        <D.17372>:
        <D.17370>:
        <D.17362>:
        <D.17360>:
      }
      D.16149 = __result;
    }
    iftmp.22 = -D.16149;
    goto <D.17389>;
    <D.17353>:
    iftmp.22 = __builtin_strcmp (name, "intptr");
    <D.17389>:
    D.16150 = iftmp.22;
  }
  if (D.16150 == 0) goto <D.17390>; else goto <D.17391>;
  <D.17390>:
  D.16899 = mono_defaults.int_class;
  return D.16899;
  <D.17391>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = name;
      D.17395 = "single";
      D.17396 = MEM[(const unsigned char *)D.17395];
      D.17397 = (int) D.17396;
      D.17398 = *__s2;
      D.17399 = (int) D.17398;
      __result = D.17397 - D.17399;
      {
        if (__s2_len != 0) goto <D.17400>; else goto <D.17401>;
        <D.17400>:
        if (__result == 0) goto <D.17402>; else goto <D.17403>;
        <D.17402>:
        D.17404 = &MEM[(void *)"single" + 1B];
        D.17405 = *D.17404;
        D.17406 = (int) D.17405;
        D.17407 = __s2 + 1;
        D.17408 = *D.17407;
        D.17409 = (int) D.17408;
        __result = D.17406 - D.17409;
        if (__s2_len > 1) goto <D.17410>; else goto <D.17411>;
        <D.17410>:
        if (__result == 0) goto <D.17412>; else goto <D.17413>;
        <D.17412>:
        D.17414 = &MEM[(void *)"single" + 2B];
        D.17415 = *D.17414;
        D.17416 = (int) D.17415;
        D.17417 = __s2 + 2;
        D.17418 = *D.17417;
        D.17419 = (int) D.17418;
        __result = D.17416 - D.17419;
        if (__s2_len > 2) goto <D.17420>; else goto <D.17421>;
        <D.17420>:
        if (__result == 0) goto <D.17422>; else goto <D.17423>;
        <D.17422>:
        D.17424 = &MEM[(void *)"single" + 3B];
        D.17425 = *D.17424;
        D.17426 = (int) D.17425;
        D.17427 = __s2 + 3;
        D.17428 = *D.17427;
        D.17429 = (int) D.17428;
        __result = D.17426 - D.17429;
        <D.17423>:
        <D.17421>:
        <D.17413>:
        <D.17411>:
        <D.17403>:
        <D.17401>:
      }
      D.16158 = __result;
    }
    iftmp.23 = -D.16158;
    goto <D.17430>;
    <D.17394>:
    iftmp.23 = __builtin_strcmp (name, "single");
    <D.17430>:
    D.16159 = iftmp.23;
  }
  if (D.16159 == 0) goto <D.17431>; else goto <D.17432>;
  <D.17431>:
  D.16899 = mono_defaults.single_class;
  return D.16899;
  <D.17432>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = name;
      D.17436 = "double";
      D.17437 = MEM[(const unsigned char *)D.17436];
      D.17438 = (int) D.17437;
      D.17439 = *__s2;
      D.17440 = (int) D.17439;
      __result = D.17438 - D.17440;
      {
        if (__s2_len != 0) goto <D.17441>; else goto <D.17442>;
        <D.17441>:
        if (__result == 0) goto <D.17443>; else goto <D.17444>;
        <D.17443>:
        D.17445 = &MEM[(void *)"double" + 1B];
        D.17446 = *D.17445;
        D.17447 = (int) D.17446;
        D.17448 = __s2 + 1;
        D.17449 = *D.17448;
        D.17450 = (int) D.17449;
        __result = D.17447 - D.17450;
        if (__s2_len > 1) goto <D.17451>; else goto <D.17452>;
        <D.17451>:
        if (__result == 0) goto <D.17453>; else goto <D.17454>;
        <D.17453>:
        D.17455 = &MEM[(void *)"double" + 2B];
        D.17456 = *D.17455;
        D.17457 = (int) D.17456;
        D.17458 = __s2 + 2;
        D.17459 = *D.17458;
        D.17460 = (int) D.17459;
        __result = D.17457 - D.17460;
        if (__s2_len > 2) goto <D.17461>; else goto <D.17462>;
        <D.17461>:
        if (__result == 0) goto <D.17463>; else goto <D.17464>;
        <D.17463>:
        D.17465 = &MEM[(void *)"double" + 3B];
        D.17466 = *D.17465;
        D.17467 = (int) D.17466;
        D.17468 = __s2 + 3;
        D.17469 = *D.17468;
        D.17470 = (int) D.17469;
        __result = D.17467 - D.17470;
        <D.17464>:
        <D.17462>:
        <D.17454>:
        <D.17452>:
        <D.17444>:
        <D.17442>:
      }
      D.16167 = __result;
    }
    iftmp.24 = -D.16167;
    goto <D.17471>;
    <D.17435>:
    iftmp.24 = __builtin_strcmp (name, "double");
    <D.17471>:
    D.16168 = iftmp.24;
  }
  if (D.16168 == 0) goto <D.17472>; else goto <D.17473>;
  <D.17472>:
  D.16899 = mono_defaults.double_class;
  return D.16899;
  <D.17473>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = name;
      D.17477 = "string";
      D.17478 = MEM[(const unsigned char *)D.17477];
      D.17479 = (int) D.17478;
      D.17480 = *__s2;
      D.17481 = (int) D.17480;
      __result = D.17479 - D.17481;
      {
        if (__s2_len != 0) goto <D.17482>; else goto <D.17483>;
        <D.17482>:
        if (__result == 0) goto <D.17484>; else goto <D.17485>;
        <D.17484>:
        D.17486 = &MEM[(void *)"string" + 1B];
        D.17487 = *D.17486;
        D.17488 = (int) D.17487;
        D.17489 = __s2 + 1;
        D.17490 = *D.17489;
        D.17491 = (int) D.17490;
        __result = D.17488 - D.17491;
        if (__s2_len > 1) goto <D.17492>; else goto <D.17493>;
        <D.17492>:
        if (__result == 0) goto <D.17494>; else goto <D.17495>;
        <D.17494>:
        D.17496 = &MEM[(void *)"string" + 2B];
        D.17497 = *D.17496;
        D.17498 = (int) D.17497;
        D.17499 = __s2 + 2;
        D.17500 = *D.17499;
        D.17501 = (int) D.17500;
        __result = D.17498 - D.17501;
        if (__s2_len > 2) goto <D.17502>; else goto <D.17503>;
        <D.17502>:
        if (__result == 0) goto <D.17504>; else goto <D.17505>;
        <D.17504>:
        D.17506 = &MEM[(void *)"string" + 3B];
        D.17507 = *D.17506;
        D.17508 = (int) D.17507;
        D.17509 = __s2 + 3;
        D.17510 = *D.17509;
        D.17511 = (int) D.17510;
        __result = D.17508 - D.17511;
        <D.17505>:
        <D.17503>:
        <D.17495>:
        <D.17493>:
        <D.17485>:
        <D.17483>:
      }
      D.16176 = __result;
    }
    iftmp.25 = -D.16176;
    goto <D.17512>;
    <D.17476>:
    iftmp.25 = __builtin_strcmp (name, "string");
    <D.17512>:
    D.16177 = iftmp.25;
  }
  if (D.16177 == 0) goto <D.17513>; else goto <D.17514>;
  <D.17513>:
  D.16899 = mono_defaults.string_class;
  return D.16899;
  <D.17514>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = name;
      D.17518 = "object";
      D.17519 = MEM[(const unsigned char *)D.17518];
      D.17520 = (int) D.17519;
      D.17521 = *__s2;
      D.17522 = (int) D.17521;
      __result = D.17520 - D.17522;
      {
        if (__s2_len != 0) goto <D.17523>; else goto <D.17524>;
        <D.17523>:
        if (__result == 0) goto <D.17525>; else goto <D.17526>;
        <D.17525>:
        D.17527 = &MEM[(void *)"object" + 1B];
        D.17528 = *D.17527;
        D.17529 = (int) D.17528;
        D.17530 = __s2 + 1;
        D.17531 = *D.17530;
        D.17532 = (int) D.17531;
        __result = D.17529 - D.17532;
        if (__s2_len > 1) goto <D.17533>; else goto <D.17534>;
        <D.17533>:
        if (__result == 0) goto <D.17535>; else goto <D.17536>;
        <D.17535>:
        D.17537 = &MEM[(void *)"object" + 2B];
        D.17538 = *D.17537;
        D.17539 = (int) D.17538;
        D.17540 = __s2 + 2;
        D.17541 = *D.17540;
        D.17542 = (int) D.17541;
        __result = D.17539 - D.17542;
        if (__s2_len > 2) goto <D.17543>; else goto <D.17544>;
        <D.17543>:
        if (__result == 0) goto <D.17545>; else goto <D.17546>;
        <D.17545>:
        D.17547 = &MEM[(void *)"object" + 3B];
        D.17548 = *D.17547;
        D.17549 = (int) D.17548;
        D.17550 = __s2 + 3;
        D.17551 = *D.17550;
        D.17552 = (int) D.17551;
        __result = D.17549 - D.17552;
        <D.17546>:
        <D.17544>:
        <D.17536>:
        <D.17534>:
        <D.17526>:
        <D.17524>:
      }
      D.16185 = __result;
    }
    iftmp.26 = -D.16185;
    goto <D.17553>;
    <D.17517>:
    iftmp.26 = __builtin_strcmp (name, "object");
    <D.17553>:
    D.16186 = iftmp.26;
  }
  if (D.16186 == 0) goto <D.17554>; else goto <D.17555>;
  <D.17554>:
  D.16899 = mono_defaults.object_class;
  return D.16899;
  <D.17555>:
  D.16899 = 0B;
  return D.16899;
}


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

  res = monoeg_g_string_new ("");
  if (dh == 0B) goto <D.17557>; else goto <D.17558>;
  <D.17557>:
  dh = &default_dh;
  <D.17558>:
  D.17559 = ip + 2;
  ip = dis_one (res, dh, method, ip, D.17559);
  if (endp != 0B) goto <D.17560>; else goto <D.17561>;
  <D.17560>:
  *endp = ip;
  <D.17561>:
  result = res->str;
  monoeg_g_string_free (res, 0);
  D.17562 = result;
  return D.17562;
}


dis_one (struct GString * str, struct MonoDisHelper * dh, struct MonoMethod * method, const unsigned char * ip, const unsigned char * end)
{
  const unsigned char * ip.27;
  int ip.28;
  int il_code.29;
  int D.17567;
  char * (*<T2767>) (struct MonoDisHelper *, struct MonoMethod *, uint32_t) D.17568;
  const char * D.17571;
  <unnamed type> D.17574;
  const unsigned char * ip.30;
  const char * D.17576;
  unsigned char D.17577;
  int D.17578;
  char * (*<T2767>) (struct MonoDisHelper *, struct MonoMethod *, uint32_t) D.17579;
  const unsigned char * ip.31;
  struct MonoClass * D.17584;
  struct MonoImage * D.17585;
  unsigned int D.17586;
  unsigned int D.17587;
  unsigned int D.17590;
  const char * blob.32;
  const char * blob.33;
  unsigned int D.17593;
  unsigned int D.17594;
  long int len2.34;
  short unsigned int D.17598;
  int D.17599;
  const unsigned char * ip.35;
  unsigned char D.17601;
  int D.17602;
  unsigned int D.17603;
  const char * D.17604;
  sizetype sval.36;
  const unsigned char * D.17608;
  int D.17609;
  int D.17610;
  signed char D.17612;
  unsigned int D.17616;
  int D.17617;
  sizetype D.17618;
  const unsigned char * D.17623;
  int D.17624;
  int D.17625;
  long long unsigned int D.17627;
  double r.37;
  double r.38;
  const unsigned char * ip.39;
  unsigned int D.17631;
  float r.40;
  float r.41;
  double D.17634;
  unsigned int D.17635;
  int D.17636;
  int D.17637;
  const char * D.17638;
  const unsigned char * D.17641;
  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.27 = ip;
  ip.28 = (int) ip.27;
  il_code.29 = (int) il_code;
  D.17567 = ip.28 - il_code.29;
  label = (guint32) D.17567;
  D.17568 = dh->indenter;
  if (D.17568 != 0B) goto <D.17569>; else goto <D.17570>;
  <D.17569>:
  D.17568 = dh->indenter;
  tmp = D.17568 (dh, method, label);
  monoeg_g_string_append (str, tmp);
  monoeg_g_free (tmp);
  <D.17570>:
  D.17571 = dh->label_format;
  if (D.17571 != 0B) goto <D.17572>; else goto <D.17573>;
  <D.17572>:
  D.17571 = dh->label_format;
  monoeg_g_string_append_printf (str, D.17571, label);
  <D.17573>:
  D.17574 = mono_opcode_value (&ip, end);
  i = (int) D.17574;
  ip.27 = ip;
  ip.30 = ip.27 + 1;
  ip = ip.30;
  opcode = &mono_opcodes[i];
  D.17576 = mono_opcode_name (i);
  monoeg_g_string_append_printf (str, "%-10s", D.17576);
  D.17577 = opcode->argument;
  D.17578 = (int) D.17577;
  switch (D.17578) <default: <D.16436>, case 0: <D.16406>, case 1: <D.16408>, case 2: <D.16409>, case 3: <D.16410>, case 4: <D.16411>, case 5: <D.16413>, case 6: <D.16412>, case 7: <D.16418>, case 8: <D.16419>, case 9: <D.16420>, case 10: <D.16421>, case 11: <D.16422>, case 12: <D.16427>, case 13: <D.16430>, case 14: <D.16433>, case 15: <D.16434>, case 16: <D.16435>>
  <D.16406>:
  goto <D.16407>;
  <D.16408>:
  <D.16409>:
  <D.16410>:
  <D.16411>:
  <D.16412>:
  ip.27 = ip;
  token = mono_read32 (ip.27);
  D.17579 = dh->tokener;
  if (D.17579 != 0B) goto <D.17580>; else goto <D.17581>;
  <D.17580>:
  D.17579 = dh->tokener;
  tmp = D.17579 (dh, method, token);
  monoeg_g_string_append (str, tmp);
  monoeg_g_free (tmp);
  goto <D.17582>;
  <D.17581>:
  monoeg_g_string_append_printf (str, "0x%08x", token);
  <D.17582>:
  ip.27 = ip;
  ip.31 = ip.27 + 4;
  ip = ip.31;
  goto <D.16407>;
  <D.16413>:
  {
    const char * blob;
    char * s;
    size_t len2;
    char * blob2;

    try
      {
        blob2 = 0B;
        D.17584 = method->klass;
        D.17585 = D.17584->image;
        D.17586 = BIT_FIELD_REF <*D.17585, 32, 128>;
        D.17587 = D.17586 & 8;
        if (D.17587 == 0) goto <D.17588>; else goto <D.17589>;
        <D.17588>:
        ip.27 = ip;
        token = mono_read32 (ip.27);
        D.17584 = method->klass;
        D.17585 = D.17584->image;
        D.17590 = token & 16777215;
        blob.32 = mono_metadata_user_string (D.17585, D.17590);
        blob = blob.32;
        blob.33 = blob;
        len2 = mono_metadata_decode_blob_size (blob.33, &blob);
        len2 = len2 >> 1;
        D.17593 = len2 * 2;
        D.17594 = D.17593 + 1;
        blob2 = monoeg_malloc (D.17594);
        blob.33 = blob;
        D.17593 = len2 * 2;
        memcpy (blob2, blob.33, D.17593);
        len2.34 = (long int) len2;
        s = monoeg_g_utf16_to_utf8 (blob2, len2.34, 0B, 0B, 0B);
        monoeg_g_string_append_printf (str, "\"%s\"", s);
        monoeg_g_free (s);
        blob.33 = blob;
        if (blob.33 != blob2) goto <D.17596>; else goto <D.17597>;
        <D.17596>:
        monoeg_g_free (blob2);
        <D.17597>:
        <D.17589>:
        ip.27 = ip;
        ip.31 = ip.27 + 4;
        ip = ip.31;
        goto <D.16407>;
      }
    finally
      {
        blob = {CLOBBER};
      }
  }
  <D.16418>:
  ip.27 = ip;
  D.17598 = mono_read16 (ip.27);
  D.17599 = (int) D.17598;
  monoeg_g_string_append_printf (str, "%d", D.17599);
  ip.27 = ip;
  ip.35 = ip.27 + 2;
  ip = ip.35;
  goto <D.16407>;
  <D.16419>:
  ip.27 = ip;
  D.17601 = *ip.27;
  D.17602 = (int) D.17601;
  monoeg_g_string_append_printf (str, "%d", D.17602);
  ip.27 = ip;
  ip.30 = ip.27 + 1;
  ip = ip.30;
  goto <D.16407>;
  <D.16420>:
  ip.27 = ip;
  D.17603 = mono_read32 (ip.27);
  sval = (gint32) D.17603;
  ip.27 = ip;
  ip.31 = ip.27 + 4;
  ip = ip.31;
  D.17604 = dh->label_target;
  if (D.17604 != 0B) goto <D.17605>; else goto <D.17606>;
  <D.17605>:
  D.17604 = dh->label_target;
  ip.27 = ip;
  sval.36 = (sizetype) sval;
  D.17608 = ip.27 + sval.36;
  D.17609 = (int) D.17608;
  il_code.29 = (int) il_code;
  D.17610 = D.17609 - il_code.29;
  monoeg_g_string_append_printf (str, D.17604, D.17610);
  goto <D.17611>;
  <D.17606>:
  monoeg_g_string_append_printf (str, "%d", sval);
  <D.17611>:
  goto <D.16407>;
  <D.16421>:
  ip.27 = ip;
  D.17612 = MEM[(const signed char *)ip.27];
  sval = (gint32) D.17612;
  ip.27 = ip;
  ip.30 = ip.27 + 1;
  ip = ip.30;
  D.17604 = dh->label_target;
  if (D.17604 != 0B) goto <D.17613>; else goto <D.17614>;
  <D.17613>:
  D.17604 = dh->label_target;
  ip.27 = ip;
  sval.36 = (sizetype) sval;
  D.17608 = ip.27 + sval.36;
  D.17609 = (int) D.17608;
  il_code.29 = (int) il_code;
  D.17610 = D.17609 - il_code.29;
  monoeg_g_string_append_printf (str, D.17604, D.17610);
  goto <D.17615>;
  <D.17614>:
  monoeg_g_string_append_printf (str, "%d", sval);
  <D.17615>:
  goto <D.16407>;
  <D.16422>:
  {
    const unsigned char * end;

    ip.27 = ip;
    D.17616 = mono_read32 (ip.27);
    sval = (gint32) D.17616;
    ip.27 = ip;
    ip.31 = ip.27 + 4;
    ip = ip.31;
    ip.27 = ip;
    D.17617 = sval * 4;
    D.17618 = (sizetype) D.17617;
    end = ip.27 + D.17618;
    monoeg_g_string_append_c (str, 40);
    i = 0;
    goto <D.16425>;
    <D.16424>:
    if (i > 0) goto <D.17619>; else goto <D.17620>;
    <D.17619>:
    monoeg_g_string_append (str, ", ");
    <D.17620>:
    ip.27 = ip;
    label = mono_read32 (ip.27);
    D.17604 = dh->label_target;
    if (D.17604 != 0B) goto <D.17621>; else goto <D.17622>;
    <D.17621>:
    D.17604 = dh->label_target;
    D.17623 = end + label;
    D.17624 = (int) D.17623;
    il_code.29 = (int) il_code;
    D.17625 = D.17624 - il_code.29;
    monoeg_g_string_append_printf (str, D.17604, D.17625);
    goto <D.17626>;
    <D.17622>:
    monoeg_g_string_append_printf (str, "%d", label);
    <D.17626>:
    ip.27 = ip;
    ip.31 = ip.27 + 4;
    ip = ip.31;
    i = i + 1;
    <D.16425>:
    if (i < sval) goto <D.16424>; else goto <D.16426>;
    <D.16426>:
    monoeg_g_string_append_c (str, 41);
    goto <D.16407>;
  }
  <D.16427>:
  {
    double r;

    try
      {
        {
          union mono_rdouble mf;

          try
            {
              ip.27 = ip;
              D.17627 = mono_read64 (ip.27);
              mf.ival = D.17627;
              r.37 = mf.fval;
              r = r.37;
            }
          finally
            {
              mf = {CLOBBER};
            }
        }
        r.38 = r;
        monoeg_g_string_append_printf (str, "%g", r.38);
        ip.27 = ip;
        ip.39 = ip.27 + 8;
        ip = ip.39;
        goto <D.16407>;
      }
    finally
      {
        r = {CLOBBER};
      }
  }
  <D.16430>:
  {
    float r;

    try
      {
        {
          union mono_rfloat mf;

          try
            {
              ip.27 = ip;
              D.17631 = mono_read32 (ip.27);
              mf.ival = D.17631;
              r.40 = mf.fval;
              r = r.40;
            }
          finally
            {
              mf = {CLOBBER};
            }
        }
        r.41 = r;
        D.17634 = (double) r.41;
        monoeg_g_string_append_printf (str, "%g", D.17634);
        ip.27 = ip;
        ip.31 = ip.27 + 4;
        ip = ip.31;
        goto <D.16407>;
      }
    finally
      {
        r = {CLOBBER};
      }
  }
  <D.16433>:
  ip.27 = ip;
  D.17635 = mono_read32 (ip.27);
  D.17636 = (int) D.17635;
  monoeg_g_string_append_printf (str, "%d", D.17636);
  ip.27 = ip;
  ip.31 = ip.27 + 4;
  ip = ip.31;
  goto <D.16407>;
  <D.16434>:
  ip.27 = ip;
  D.17612 = MEM[(const signed char *)ip.27];
  D.17637 = (int) D.17612;
  monoeg_g_string_append_printf (str, "%d", D.17637);
  ip.27 = ip;
  ip.30 = ip.27 + 1;
  ip = ip.30;
  goto <D.16407>;
  <D.16435>:
  ip.27 = ip;
  ip.39 = ip.27 + 8;
  ip = ip.39;
  goto <D.16407>;
  <D.16436>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "debug-helpers.c", 684);
  <D.16407>:
  D.17638 = dh->newline;
  if (D.17638 != 0B) goto <D.17639>; else goto <D.17640>;
  <D.17639>:
  D.17638 = dh->newline;
  monoeg_g_string_append (str, D.17638);
  <D.17640>:
  mono_metadata_free_mh (header);
  D.17641 = ip;
  return D.17641;
}


memcpy (void * restrict __dest, const void * restrict __src, size_t __len)
{
  void * D.17647;
  unsigned int D.17648;

  D.17648 = __builtin_object_size (__dest, 0);
  D.17647 = __builtin___memcpy_chk (__dest, __src, __len, D.17648);
  return D.17647;
}


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

  res = monoeg_g_string_new ("");
  if (dh == 0B) goto <D.17650>; else goto <D.17651>;
  <D.17650>:
  dh = &default_dh;
  <D.17651>:
  goto <D.16455>;
  <D.16454>:
  ip = dis_one (res, dh, method, ip, end);
  <D.16455>:
  if (ip < end) goto <D.16454>; else goto <D.16456>;
  <D.16456>:
  result = res->str;
  monoeg_g_string_free (res, 0);
  D.17652 = result;
  return D.17652;
}


mono_field_full_name (struct MonoClassField * field)
{
  struct MonoClass * D.17654;
  const char * iftmp.42;
  char D.17656;
  const char * D.17660;
  const char * D.17661;
  char * D.17662;
  char * res;
  const char * nspace;

  D.17654 = field->parent;
  nspace = D.17654->name_space;
  D.17656 = *nspace;
  if (D.17656 != 0) goto <D.17657>; else goto <D.17658>;
  <D.17657>:
  iftmp.42 = ".";
  goto <D.17659>;
  <D.17658>:
  iftmp.42 = "";
  <D.17659>:
  D.17654 = field->parent;
  D.17660 = D.17654->name;
  D.17661 = mono_field_get_name (field);
  res = monoeg_g_strdup_printf ("%s%s%s:%s", nspace, iftmp.42, D.17660, D.17661);
  D.17662 = res;
  return D.17662;
}


mono_method_full_name (struct MonoMethod * method, gboolean signature)
{
  struct MonoClass * D.17664;
  struct MonoType * D.17665;
  unsigned int D.17668;
  unsigned int D.17669;
  struct MonoGenericInst * D.17671;
  unsigned int D.17673;
  struct MonoGenericInst * D.17676;
  unsigned int D.17677;
  <unnamed-unsigned:5> D.17680;
  unsigned int D.17681;
  const char * D.17682;
  struct MonoMethodSignature * D.17686;
  const char * D.17689;
  const char * D.17691;
  const char * iftmp.43;
  const char * iftmp.44;
  char * D.17701;
  char * res;
  char wrapper[64];
  char * klass_desc;
  char * inst_desc;

  try
    {
      D.17664 = method->klass;
      D.17665 = &D.17664->byval_arg;
      klass_desc = mono_type_full_name (D.17665);
      inst_desc = 0B;
      D.17668 = BIT_FIELD_REF <*method, 32, 160>;
      D.17669 = D.17668 & 4096;
      if (D.17669 != 0) goto <D.17670>; else goto <D.17666>;
      <D.17670>:
      D.17671 = MEM[(struct MonoMethodInflated *)method].context.method_inst;
      if (D.17671 != 0B) goto <D.17672>; else goto <D.17666>;
      <D.17672>:
      {
        struct GString * str;

        str = monoeg_g_string_new ("");
        monoeg_g_string_append (str, "<");
        D.17671 = MEM[(struct MonoMethodInflated *)method].context.method_inst;
        ginst_get_desc (str, D.17671);
        monoeg_g_string_append (str, ">");
        inst_desc = str->str;
        monoeg_g_string_free (str, 0);
      }
      goto <D.17667>;
      <D.17666>:
      D.17668 = BIT_FIELD_REF <*method, 32, 160>;
      D.17673 = D.17668 & 2048;
      if (D.17673 != 0) goto <D.17674>; else goto <D.17675>;
      <D.17674>:
      {
        struct MonoGenericContainer * container;
        struct GString * str;

        container = mono_method_get_generic_container (method);
        str = monoeg_g_string_new ("");
        monoeg_g_string_append (str, "<");
        D.17676 = container->context.method_inst;
        ginst_get_desc (str, D.17676);
        monoeg_g_string_append (str, ">");
        inst_desc = str->str;
        monoeg_g_string_free (str, 0);
      }
      <D.17675>:
      <D.17667>:
      D.17668 = BIT_FIELD_REF <*method, 32, 160>;
      D.17677 = D.17668 & 124;
      if (D.17677 != 0) goto <D.17678>; else goto <D.17679>;
      <D.17678>:
      D.17680 = method->wrapper_type;
      D.17681 = (unsigned int) D.17680;
      D.17682 = wrapper_type_to_str (D.17681);
      sprintf (&wrapper, "(wrapper %s) ", D.17682);
      goto <D.17683>;
      <D.17679>:
      strcpy (&wrapper, "");
      <D.17683>:
      if (signature != 0) goto <D.17684>; else goto <D.17685>;
      <D.17684>:
      {
        char * tmpsig;

        D.17686 = mono_method_signature (method);
        tmpsig = mono_signature_get_desc (D.17686, 1);
        D.17668 = BIT_FIELD_REF <*method, 32, 160>;
        D.17677 = D.17668 & 124;
        if (D.17677 != 0) goto <D.17687>; else goto <D.17688>;
        <D.17687>:
        D.17680 = method->wrapper_type;
        D.17681 = (unsigned int) D.17680;
        D.17689 = wrapper_type_to_str (D.17681);
        sprintf (&wrapper, "(wrapper %s) ", D.17689);
        goto <D.17690>;
        <D.17688>:
        strcpy (&wrapper, "");
        <D.17690>:
        D.17691 = method->name;
        if (inst_desc != 0B) goto <D.17693>; else goto <D.17694>;
        <D.17693>:
        iftmp.43 = inst_desc;
        goto <D.17695>;
        <D.17694>:
        iftmp.43 = "";
        <D.17695>:
        res = monoeg_g_strdup_printf ("%s%s:%s%s (%s)", &wrapper, klass_desc, D.17691, iftmp.43, tmpsig);
        monoeg_g_free (tmpsig);
      }
      goto <D.17696>;
      <D.17685>:
      D.17691 = method->name;
      if (inst_desc != 0B) goto <D.17698>; else goto <D.17699>;
      <D.17698>:
      iftmp.44 = inst_desc;
      goto <D.17700>;
      <D.17699>:
      iftmp.44 = "";
      <D.17700>:
      res = monoeg_g_strdup_printf ("%s%s:%s%s", &wrapper, klass_desc, D.17691, iftmp.44);
      <D.17696>:
      monoeg_g_free (klass_desc);
      monoeg_g_free (inst_desc);
      D.17701 = res;
      return D.17701;
    }
  finally
    {
      wrapper = {CLOBBER};
    }
}


wrapper_type_to_str (guint32 wrapper_type)
{
  _Bool D.17704;
  long int D.17705;
  long int D.17706;
  const char * D.17709;
  short int D.17710;
  sizetype D.17711;

  D.17704 = wrapper_type > 28;
  D.17705 = (long int) D.17704;
  D.17706 = __builtin_expect (D.17705, 0);
  if (D.17706 != 0) goto <D.17707>; else goto <D.17708>;
  <D.17707>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debug-helpers.c", 51, "wrapper_type < MONO_WRAPPER_NUM");
  <D.17708>:
  D.17710 = opidx[wrapper_type];
  D.17711 = (sizetype) D.17710;
  D.17709 = &opstr + D.17711;
  return D.17709;
}


sprintf (char * restrict __s, const char * restrict __fmt)
{
  int D.17713;
  unsigned int D.17714;

  D.17714 = __builtin_object_size (__s, 1);
  D.17713 = __builtin___sprintf_chk (__s, 1, D.17714, __fmt, __builtin_va_arg_pack ());
  return D.17713;
}


strcpy (char * restrict __dest, const char * restrict __src)
{
  char * D.17716;
  unsigned int D.17717;

  D.17717 = __builtin_object_size (__dest, 1);
  D.17716 = __builtin___strcpy_chk (__dest, __src, D.17717);
  return D.17716;
}


mono_object_describe (struct MonoObject * obj)
{
  struct MonoVTable * D.17721;
  struct MonoClass * D.17722;
  unsigned int D.17725;
  char * D.17728;
  char * D.17729;
  char * D.17730;
  char * D.17731;
  int D.17732;
  unsigned char D.17734;
  const char * D.17737;
  int D.17738;
  unsigned int D.17739;
  int D.17740;
  struct MonoClass * klass;
  const char * sep;

  if (obj == 0B) goto <D.17719>; else goto <D.17720>;
  <D.17719>:
  monoeg_g_print ("(null)\n");
  return;
  <D.17720>:
  D.17721 = obj->vtable;
  klass = D.17721->klass;
  D.17722 = mono_defaults.string_class;
  if (D.17722 == klass) goto <D.17723>; else goto <D.17724>;
  <D.17723>:
  {
    char * utf8;

    utf8 = mono_string_to_utf8 (obj);
    D.17725 = strlen (utf8);
    if (D.17725 > 60) goto <D.17726>; else goto <D.17727>;
    <D.17726>:
    D.17728 = utf8 + 57;
    *D.17728 = 46;
    D.17729 = utf8 + 58;
    *D.17729 = 46;
    D.17730 = utf8 + 59;
    *D.17730 = 46;
    D.17731 = utf8 + 60;
    *D.17731 = 0;
    <D.17727>:
    D.17732 = mono_string_length (obj);
    monoeg_g_print ("String at %p, length: %d, \'%s\'\n", obj, D.17732, utf8);
    monoeg_g_free (utf8);
  }
  goto <D.17733>;
  <D.17724>:
  D.17734 = klass->rank;
  if (D.17734 != 0) goto <D.17735>; else goto <D.17736>;
  <D.17735>:
  {
    struct MonoArray * array;

    array = obj;
    sep = print_name_space (klass);
    D.17737 = klass->name;
    monoeg_g_print ("%s%s", sep, D.17737);
    D.17734 = klass->rank;
    D.17738 = (int) D.17734;
    D.17739 = mono_array_length (array);
    D.17740 = (int) D.17739;
    monoeg_g_print (" at %p, rank: %d, length: %d\n", obj, D.17738, D.17740);
  }
  goto <D.17741>;
  <D.17736>:
  sep = print_name_space (klass);
  D.17737 = klass->name;
  monoeg_g_print ("%s%s", sep, D.17737);
  monoeg_g_print (" object at %p (klass: %p)\n", obj, klass);
  <D.17741>:
  <D.17733>:
}


print_name_space (struct MonoClass * klass)
{
  struct MonoClass * D.17743;
  const char * D.17746;
  const char * D.17747;
  const char * D.17748;
  char D.17749;

  D.17743 = klass->nested_in;
  if (D.17743 != 0B) goto <D.17744>; else goto <D.17745>;
  <D.17744>:
  D.17743 = klass->nested_in;
  print_name_space (D.17743);
  D.17743 = klass->nested_in;
  D.17746 = D.17743->name;
  monoeg_g_print ("%s", D.17746);
  D.17747 = "/";
  return D.17747;
  <D.17745>:
  D.17748 = klass->name_space;
  D.17749 = *D.17748;
  if (D.17749 != 0) goto <D.17750>; else goto <D.17751>;
  <D.17750>:
  D.17748 = klass->name_space;
  monoeg_g_print ("%s", D.17748);
  D.17747 = ".";
  return D.17747;
  <D.17751>:
  D.17747 = "";
  return D.17747;
}


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

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


objval_describe (struct MonoClass * class, const char * addr)
{
  unsigned int D.17754;
  unsigned int D.17755;
  struct MonoType * D.17758;
  short unsigned int D.17759;
  int D.17760;
  int D.17761;
  const char * D.17768;
  int D.17769;
  sizetype D.17770;
  sizetype type_offset.45;
  sizetype D.17772;
  struct MonoClassField * field;
  struct MonoClass * p;
  const char * field_ptr;
  gssize type_offset;

  type_offset = 0;
  D.17754 = BIT_FIELD_REF <*class, 32, 160>;
  D.17755 = D.17754 & 8;
  if (D.17755 != 0) goto <D.17756>; else goto <D.17757>;
  <D.17756>:
  type_offset = -8;
  <D.17757>:
  p = class;
  goto <D.16531>;
  <D.16530>:
  {
    void * iter;
    int printed_header;

    try
      {
        iter = 0B;
        printed_header = 0;
        goto <D.16526>;
        <D.16528>:
        D.17758 = field->type;
        D.17759 = D.17758->attrs;
        D.17760 = (int) D.17759;
        D.17761 = D.17760 & 272;
        if (D.17761 != 0) goto <D.17762>; else goto <D.17763>;
        <D.17762>:
        // predicted unlikely by continue predictor.
        goto <D.16526>;
        <D.17763>:
        if (p != class) goto <D.17764>; else goto <D.17765>;
        <D.17764>:
        if (printed_header == 0) goto <D.17766>; else goto <D.17767>;
        <D.17766>:
        {
          const char * sep;

          monoeg_g_print ("In class ");
          sep = print_name_space (p);
          D.17768 = p->name;
          monoeg_g_print ("%s%s:\n", sep, D.17768);
          printed_header = 1;
        }
        <D.17767>:
        <D.17765>:
        D.17769 = field->offset;
        D.17770 = (sizetype) D.17769;
        type_offset.45 = (sizetype) type_offset;
        D.17772 = D.17770 + type_offset.45;
        field_ptr = addr + D.17772;
        print_field_value (field_ptr, field, type_offset);
        <D.16526>:
        field = mono_class_get_fields (p, &iter);
        if (field != 0B) goto <D.16528>; else goto <D.16529>;
        <D.16529>:
      }
    finally
      {
        iter = {CLOBBER};
      }
  }
  p = p->parent;
  <D.16531>:
  if (p != 0B) goto <D.16530>; else goto <D.16532>;
  <D.16532>:
}


print_field_value (const char * field_ptr, struct MonoClassField * field, int type_offset)
{
  int D.17773;
  int D.17774;
  const char * D.17775;
  struct MonoType * D.17776;
  unsigned char D.17777;
  int D.17778;
  const void * D.17779;
  struct MonoObject * D.17780;
  int D.17781;
  const char * D.17784;
  signed char D.17785;
  int D.17786;
  unsigned char D.17787;
  int D.17788;
  short int D.17789;
  int D.17790;
  short unsigned int D.17791;
  int D.17792;
  int D.17793;
  unsigned int D.17794;
  long long int D.17795;
  long long unsigned int D.17796;
  float D.17797;
  double D.17798;
  double D.17799;
  const char * iftmp.46;
  struct MonoType * type;

  D.17773 = field->offset;
  D.17774 = D.17773 + type_offset;
  D.17775 = mono_field_get_name (field);
  monoeg_g_print ("At %p (ofs: %2d) %s: ", field_ptr, D.17774, D.17775);
  D.17776 = field->type;
  type = mono_type_get_underlying_type (D.17776);
  D.17777 = type->type;
  D.17778 = (int) D.17777;
  switch (D.17778) <default: <D.16515>, case 2: <D.16513>, case 3: <D.16514>, case 4: <D.16503>, case 5: <D.16504>, case 6: <D.16505>, case 7: <D.16506>, case 8: <D.16507>, case 9: <D.16508>, case 10: <D.16509>, case 11: <D.16510>, case 12: <D.16511>, case 13: <D.16512>, case 14: <D.16495>, case 15: <D.16492>, case 17: <D.16501>, case 18: <D.16497>, case 20: <D.16499>, case 21: <D.16500>, case 24: <D.16490>, case 25: <D.16491>, case 27: <D.16493>, case 28: <D.16498>, case 29: <D.16496>>
  <D.16490>:
  <D.16491>:
  <D.16492>:
  <D.16493>:
  D.17779 = MEM[(const void * *)field_ptr];
  monoeg_g_print ("%p\n", D.17779);
  goto <D.16494>;
  <D.16495>:
  <D.16496>:
  <D.16497>:
  <D.16498>:
  <D.16499>:
  D.17780 = MEM[(struct MonoObject * *)field_ptr];
  mono_object_describe (D.17780);
  goto <D.16494>;
  <D.16500>:
  D.17781 = mono_type_generic_inst_is_valuetype (type);
  if (D.17781 == 0) goto <D.17782>; else goto <D.17783>;
  <D.17782>:
  D.17780 = MEM[(struct MonoObject * *)field_ptr];
  mono_object_describe (D.17780);
  goto <D.16494>;
  <D.17783>:
  <D.16501>:
  {
    struct MonoClass * k;

    k = mono_class_from_mono_type (type);
    D.17784 = k->name;
    monoeg_g_print ("%s ValueType (type: %p) at %p\n", D.17784, k, field_ptr);
    goto <D.16494>;
  }
  <D.16503>:
  D.17785 = MEM[(gint8 *)field_ptr];
  D.17786 = (int) D.17785;
  monoeg_g_print ("%d\n", D.17786);
  goto <D.16494>;
  <D.16504>:
  D.17787 = MEM[(guint8 *)field_ptr];
  D.17788 = (int) D.17787;
  monoeg_g_print ("%d\n", D.17788);
  goto <D.16494>;
  <D.16505>:
  D.17789 = MEM[(gint16 *)field_ptr];
  D.17790 = (int) D.17789;
  monoeg_g_print ("%d\n", D.17790);
  goto <D.16494>;
  <D.16506>:
  D.17791 = MEM[(guint16 *)field_ptr];
  D.17792 = (int) D.17791;
  monoeg_g_print ("%d\n", D.17792);
  goto <D.16494>;
  <D.16507>:
  D.17793 = MEM[(gint32 *)field_ptr];
  monoeg_g_print ("%d\n", D.17793);
  goto <D.16494>;
  <D.16508>:
  D.17794 = MEM[(guint32 *)field_ptr];
  monoeg_g_print ("%u\n", D.17794);
  goto <D.16494>;
  <D.16509>:
  D.17795 = MEM[(gint64 *)field_ptr];
  monoeg_g_print ("%lld\n", D.17795);
  goto <D.16494>;
  <D.16510>:
  D.17796 = MEM[(guint64 *)field_ptr];
  monoeg_g_print ("%llu\n", D.17796);
  goto <D.16494>;
  <D.16511>:
  D.17797 = MEM[(gfloat *)field_ptr];
  D.17798 = (double) D.17797;
  monoeg_g_print ("%f\n", D.17798);
  goto <D.16494>;
  <D.16512>:
  D.17799 = MEM[(gdouble *)field_ptr];
  monoeg_g_print ("%f\n", D.17799);
  goto <D.16494>;
  <D.16513>:
  D.17787 = MEM[(guint8 *)field_ptr];
  if (D.17787 != 0) goto <D.17801>; else goto <D.17802>;
  <D.17801>:
  iftmp.46 = "True";
  goto <D.17803>;
  <D.17802>:
  iftmp.46 = "False";
  <D.17803>:
  D.17787 = MEM[(guint8 *)field_ptr];
  D.17788 = (int) D.17787;
  monoeg_g_print ("%s (%d)\n", iftmp.46, D.17788);
  goto <D.16494>;
  <D.16514>:
  D.17791 = MEM[(guint16 *)field_ptr];
  D.17792 = (int) D.17791;
  D.17791 = MEM[(guint16 *)field_ptr];
  D.17792 = (int) D.17791;
  D.17791 = MEM[(guint16 *)field_ptr];
  D.17792 = (int) D.17791;
  monoeg_g_print ("\'%c\' (%d 0x%04x)\n", D.17792, D.17792, D.17792);
  goto <D.16494>;
  <D.16515>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "debug-helpers.c", 928);
  <D.16494>:
}


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


mono_class_describe_statics (struct MonoClass * klass)
{
  struct MonoDomain * D.17804;
  struct MonoType * D.17809;
  short unsigned int D.17810;
  int D.17811;
  int D.17812;
  int D.17815;
  int D.17818;
  sizetype D.17819;
  struct MonoClassField * field;
  struct MonoClass * p;
  const char * field_ptr;
  struct MonoVTable * vtable;
  const char * addr;

  D.17804 = mono_domain_get ();
  vtable = mono_class_vtable_full (D.17804, klass, 0);
  if (vtable == 0B) goto <D.17805>; else goto <D.17806>;
  <D.17805>:
  return;
  <D.17806>:
  addr = mono_vtable_get_static_field_data (vtable);
  if (addr == 0B) goto <D.17807>; else goto <D.17808>;
  <D.17807>:
  return;
  <D.17808>:
  p = klass;
  goto <D.16554>;
  <D.16553>:
  {
    void * iter;

    try
      {
        iter = 0B;
        goto <D.16550>;
        <D.16551>:
        D.17809 = field->type;
        D.17810 = D.17809->attrs;
        D.17811 = (int) D.17810;
        D.17812 = D.17811 & 64;
        if (D.17812 != 0) goto <D.17813>; else goto <D.17814>;
        <D.17813>:
        // predicted unlikely by continue predictor.
        goto <D.16550>;
        <D.17814>:
        D.17809 = field->type;
        D.17810 = D.17809->attrs;
        D.17811 = (int) D.17810;
        D.17815 = D.17811 & 272;
        if (D.17815 == 0) goto <D.17816>; else goto <D.17817>;
        <D.17816>:
        // predicted unlikely by continue predictor.
        goto <D.16550>;
        <D.17817>:
        D.17818 = field->offset;
        D.17819 = (sizetype) D.17818;
        field_ptr = addr + D.17819;
        print_field_value (field_ptr, field, 0);
        <D.16550>:
        field = mono_class_get_fields (p, &iter);
        if (field != 0B) goto <D.16551>; else goto <D.16552>;
        <D.16552>:
      }
    finally
      {
        iter = {CLOBBER};
      }
  }
  p = p->parent;
  <D.16554>:
  if (p != 0B) goto <D.16553>; else goto <D.16555>;
  <D.16555>:
}