mono_type_get_desc (struct GString * res, struct MonoType * type, gboolean include_namespace)
{
  unsigned char D.16585;
  int D.16586;
  struct MonoType * D.16587;
  struct MonoArrayType * D.16588;
  struct MonoClass * D.16589;
  struct MonoType * D.16590;
  unsigned char D.16591;
  int D.16592;
  struct MonoClass * D.16593;
  struct MonoType * D.16594;
  struct MonoGenericClass * D.16595;
  struct MonoClass * D.16596;
  struct MonoType * D.16597;
  struct MonoGenericInst * D.16598;
  struct MonoType * D.16603;
  <unnamed-unsigned:22> D.16604;
  int D.16605;
  struct MonoGenericInst * D.16606;
  struct MonoType * D.16613;
  <unnamed-unsigned:22> D.16614;
  int D.16615;
  struct MonoGenericParam * D.16616;
  struct MonoGenericParamInfo * iftmp.0;
  struct MonoGenericContainer * D.16620;
  const char * D.16626;
  short unsigned int D.16628;
  int D.16629;
  const char * iftmp.1;
  unsigned char D.16635;
  unsigned char D.16636;
  int i;

  D.16585 = type->type;
  D.16586 = (int) D.16585;
  switch (D.16586) <default: <D.16257>, case 1: <D.16221>, case 2: <D.16224>, case 3: <D.16223>, case 4: <D.16226>, case 5: <D.16225>, case 6: <D.16228>, case 7: <D.16227>, case 8: <D.16230>, case 9: <D.16229>, case 10: <D.16232>, case 11: <D.16231>, case 12: <D.16236>, case 13: <D.16237>, case 14: <D.16238>, case 15: <D.16240>, case 17: <D.16244>, case 18: <D.16243>, case 19: <D.16253>, case 20: <D.16241>, case 21: <D.16245>, case 22: <D.16256>, case 24: <D.16235>, case 25: <D.16234>, case 27: <D.16233>, case 28: <D.16239>, case 29: <D.16242>, case 30: <D.16254>>
  <D.16221>:
  monoeg_g_string_append (res, "void");
  goto <D.16222>;
  <D.16223>:
  monoeg_g_string_append (res, "char");
  goto <D.16222>;
  <D.16224>:
  monoeg_g_string_append (res, "bool");
  goto <D.16222>;
  <D.16225>:
  monoeg_g_string_append (res, "byte");
  goto <D.16222>;
  <D.16226>:
  monoeg_g_string_append (res, "sbyte");
  goto <D.16222>;
  <D.16227>:
  monoeg_g_string_append (res, "uint16");
  goto <D.16222>;
  <D.16228>:
  monoeg_g_string_append (res, "int16");
  goto <D.16222>;
  <D.16229>:
  monoeg_g_string_append (res, "uint");
  goto <D.16222>;
  <D.16230>:
  monoeg_g_string_append (res, "int");
  goto <D.16222>;
  <D.16231>:
  monoeg_g_string_append (res, "ulong");
  goto <D.16222>;
  <D.16232>:
  monoeg_g_string_append (res, "long");
  goto <D.16222>;
  <D.16233>:
  monoeg_g_string_append (res, "*()");
  goto <D.16222>;
  <D.16234>:
  monoeg_g_string_append (res, "uintptr");
  goto <D.16222>;
  <D.16235>:
  monoeg_g_string_append (res, "intptr");
  goto <D.16222>;
  <D.16236>:
  monoeg_g_string_append (res, "single");
  goto <D.16222>;
  <D.16237>:
  monoeg_g_string_append (res, "double");
  goto <D.16222>;
  <D.16238>:
  monoeg_g_string_append (res, "string");
  goto <D.16222>;
  <D.16239>:
  monoeg_g_string_append (res, "object");
  goto <D.16222>;
  <D.16240>:
  D.16587 = type->data.type;
  mono_type_get_desc (res, D.16587, include_namespace);
  monoeg_g_string_append_c (res, 42);
  goto <D.16222>;
  <D.16241>:
  D.16588 = type->data.array;
  D.16589 = D.16588->eklass;
  D.16590 = &D.16589->byval_arg;
  mono_type_get_desc (res, D.16590, include_namespace);
  D.16588 = type->data.array;
  D.16591 = D.16588->rank;
  D.16592 = (int) D.16591;
  monoeg_g_string_append_printf (res, "[%d]", D.16592);
  goto <D.16222>;
  <D.16242>:
  D.16593 = type->data.klass;
  D.16594 = &D.16593->byval_arg;
  mono_type_get_desc (res, D.16594, include_namespace);
  monoeg_g_string_append (res, "[]");
  goto <D.16222>;
  <D.16243>:
  <D.16244>:
  D.16593 = type->data.klass;
  append_class_name (res, D.16593, include_namespace);
  goto <D.16222>;
  <D.16245>:
  {
    struct MonoGenericContext * context;

    D.16595 = type->data.generic_class;
    D.16596 = D.16595->container_class;
    D.16597 = &D.16596->byval_arg;
    mono_type_get_desc (res, D.16597, include_namespace);
    monoeg_g_string_append (res, "<");
    D.16595 = type->data.generic_class;
    context = &D.16595->context;
    D.16598 = context->class_inst;
    if (D.16598 != 0B) goto <D.16599>; else goto <D.16600>;
    <D.16599>:
    i = 0;
    goto <D.16248>;
    <D.16247>:
    if (i > 0) goto <D.16601>; else goto <D.16602>;
    <D.16601>:
    monoeg_g_string_append (res, ", ");
    <D.16602>:
    D.16598 = context->class_inst;
    D.16603 = D.16598->type_argv[i];
    mono_type_get_desc (res, D.16603, include_namespace);
    i = i + 1;
    <D.16248>:
    D.16598 = context->class_inst;
    D.16604 = D.16598->type_argc;
    D.16605 = (int) D.16604;
    if (D.16605 > i) goto <D.16247>; else goto <D.16249>;
    <D.16249>:
    <D.16600>:
    D.16606 = context->method_inst;
    if (D.16606 != 0B) goto <D.16607>; else goto <D.16608>;
    <D.16607>:
    D.16598 = context->class_inst;
    if (D.16598 != 0B) goto <D.16609>; else goto <D.16610>;
    <D.16609>:
    monoeg_g_string_append (res, "; ");
    <D.16610>:
    i = 0;
    goto <D.16251>;
    <D.16250>:
    if (i > 0) goto <D.16611>; else goto <D.16612>;
    <D.16611>:
    monoeg_g_string_append (res, ", ");
    <D.16612>:
    D.16606 = context->method_inst;
    D.16613 = D.16606->type_argv[i];
    mono_type_get_desc (res, D.16613, include_namespace);
    i = i + 1;
    <D.16251>:
    D.16606 = context->method_inst;
    D.16614 = D.16606->type_argc;
    D.16615 = (int) D.16614;
    if (D.16615 > i) goto <D.16250>; else goto <D.16252>;
    <D.16252>:
    <D.16608>:
    monoeg_g_string_append (res, ">");
    goto <D.16222>;
  }
  <D.16253>:
  <D.16254>:
  D.16616 = type->data.generic_param;
  if (D.16616 != 0B) goto <D.16617>; else goto <D.16618>;
  <D.16617>:
  {
    struct MonoGenericParamInfo * info;

    D.16616 = type->data.generic_param;
    D.16620 = D.16616->owner;
    if (D.16620 != 0B) goto <D.16621>; else goto <D.16622>;
    <D.16621>:
    D.16616 = type->data.generic_param;
    iftmp.0 = &MEM[(struct MonoGenericParamFull *)D.16616].info;
    goto <D.16623>;
    <D.16622>:
    iftmp.0 = 0B;
    <D.16623>:
    info = iftmp.0;
    if (info != 0B) goto <D.16624>; else goto <D.16625>;
    <D.16624>:
    D.16626 = info->name;
    monoeg_g_string_append (res, D.16626);
    goto <D.16627>;
    <D.16625>:
    D.16616 = type->data.generic_param;
    D.16628 = D.16616->num;
    D.16629 = (int) D.16628;
    D.16585 = type->type;
    if (D.16585 == 19) goto <D.16631>; else goto <D.16632>;
    <D.16631>:
    iftmp.1 = "!";
    goto <D.16633>;
    <D.16632>:
    iftmp.1 = "!!";
    <D.16633>:
    monoeg_g_string_append_printf (res, "%s%d", iftmp.1, D.16629);
    <D.16627>:
  }
  goto <D.16634>;
  <D.16618>:
  monoeg_g_string_append (res, "<unknown>");
  <D.16634>:
  goto <D.16222>;
  <D.16256>:
  monoeg_g_string_append (res, "typedbyref");
  goto <D.16222>;
  <D.16257>:
  goto <D.16222>;
  <D.16222>:
  D.16635 = BIT_FIELD_REF <*type, 8, 56>;
  D.16636 = D.16635 & 64;
  if (D.16636 != 0) goto <D.16637>; else goto <D.16638>;
  <D.16637>:
  monoeg_g_string_append_c (res, 38);
  <D.16638>:
}


append_class_name (struct GString * res, struct MonoClass * class, gboolean include_namespace)
{
  struct MonoClass * D.16642;
  const char * D.16647;
  char D.16648;
  const char * D.16651;

  if (class == 0B) goto <D.16640>; else goto <D.16641>;
  <D.16640>:
  monoeg_g_string_append (res, "Unknown");
  return;
  <D.16641>:
  D.16642 = class->nested_in;
  if (D.16642 != 0B) goto <D.16643>; else goto <D.16644>;
  <D.16643>:
  D.16642 = class->nested_in;
  append_class_name (res, D.16642, include_namespace);
  monoeg_g_string_append_c (res, 47);
  <D.16644>:
  if (include_namespace != 0) goto <D.16645>; else goto <D.16646>;
  <D.16645>:
  D.16647 = class->name_space;
  D.16648 = *D.16647;
  if (D.16648 != 0) goto <D.16649>; else goto <D.16650>;
  <D.16649>:
  D.16647 = class->name_space;
  monoeg_g_string_append_printf (res, "%s.", D.16647);
  <D.16650>:
  <D.16646>:
  D.16651 = class->name;
  monoeg_g_string_append_printf (res, "%s", D.16651);
}


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

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


mono_signature_get_desc (struct MonoMethodSignature * sig, gboolean include_namespace)
{
  char * D.16657;
  struct MonoType * D.16660;
  short unsigned int D.16661;
  int D.16662;
  int i;
  char * result;
  struct GString * res;

  if (sig == 0B) goto <D.16655>; else goto <D.16656>;
  <D.16655>:
  D.16657 = monoeg_strdup ("<invalid signature>");
  return D.16657;
  <D.16656>:
  res = monoeg_g_string_new ("");
  i = 0;
  goto <D.16270>;
  <D.16269>:
  if (i > 0) goto <D.16658>; else goto <D.16659>;
  <D.16658>:
  monoeg_g_string_append_c (res, 44);
  <D.16659>:
  D.16660 = sig->params[i];
  mono_type_get_desc (res, D.16660, include_namespace);
  i = i + 1;
  <D.16270>:
  D.16661 = sig->param_count;
  D.16662 = (int) D.16661;
  if (D.16662 > i) goto <D.16269>; else goto <D.16271>;
  <D.16271>:
  result = res->str;
  monoeg_g_string_free (res, 0);
  D.16657 = result;
  return D.16657;
}


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

  if (str != 0B) goto <D.16664>; else goto <D.16665>;
  <D.16664>:
  D.16666 = __strdup (str);
  return D.16666;
  <D.16665>:
  D.16666 = 0B;
  return D.16666;
}


mono_context_get_desc (struct MonoGenericContext * context)
{
  struct MonoGenericInst * D.16668;
  struct MonoGenericInst * D.16671;
  char * D.16676;
  char * D.16677;
  struct GString * str;
  char * res;

  str = monoeg_g_string_new ("");
  monoeg_g_string_append (str, "<");
  D.16668 = context->class_inst;
  if (D.16668 != 0B) goto <D.16669>; else goto <D.16670>;
  <D.16669>:
  D.16668 = context->class_inst;
  ginst_get_desc (str, D.16668);
  <D.16670>:
  D.16671 = context->method_inst;
  if (D.16671 != 0B) goto <D.16672>; else goto <D.16673>;
  <D.16672>:
  D.16668 = context->class_inst;
  if (D.16668 != 0B) goto <D.16674>; else goto <D.16675>;
  <D.16674>:
  monoeg_g_string_append (str, "; ");
  <D.16675>:
  D.16671 = context->method_inst;
  ginst_get_desc (str, D.16671);
  <D.16673>:
  monoeg_g_string_append (str, ">");
  D.16676 = str->str;
  res = monoeg_strdup (D.16676);
  monoeg_g_string_free (str, 1);
  D.16677 = res;
  return D.16677;
}


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

  i = 0;
  goto <D.16278>;
  <D.16277>:
  if (i > 0) goto <D.16679>; else goto <D.16680>;
  <D.16679>:
  monoeg_g_string_append (str, ", ");
  <D.16680>:
  D.16681 = ginst->type_argv[i];
  mono_type_get_desc (str, D.16681, 1);
  i = i + 1;
  <D.16278>:
  D.16682 = ginst->type_argc;
  D.16683 = (int) D.16682;
  if (D.16683 > i) goto <D.16277>; else goto <D.16279>;
  <D.16279>:
}


mono_method_desc_new (const char * name, gboolean include_namespace)
{
  char * D.16688;
  char D.16689;
  char * use_args.2;
  struct MonoMethodDesc * D.16695;
  char * D.16700;
  char D.16701;
  char * method_name.3;
  char * class_name.4;
  char * iftmp.5;
  char * D.16713;
  char * D.16714;
  char * D.16717;
  char * D.16718;
  char D.16723;
  unsigned int D.16728;
  unsigned int D.16729;
  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.16684>; else goto <D.16685>;
  <D.16684>:
  if (use_args > class_nspace) goto <D.16686>; else goto <D.16687>;
  <D.16686>:
  D.16688 = use_args + 4294967295;
  D.16689 = *D.16688;
  if (D.16689 == 32) goto <D.16690>; else goto <D.16691>;
  <D.16690>:
  D.16688 = use_args + 4294967295;
  *D.16688 = 0;
  <D.16691>:
  <D.16687>:
  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.16693>; else goto <D.16694>;
  <D.16693>:
  monoeg_g_free (class_nspace);
  D.16695 = 0B;
  return D.16695;
  <D.16694>:
  *end = 0;
  <D.16685>:
  method_name = strrchr (class_nspace, 58);
  if (method_name == 0B) goto <D.16696>; else goto <D.16697>;
  <D.16696>:
  monoeg_g_free (class_nspace);
  D.16695 = 0B;
  return D.16695;
  <D.16697>:
  if (method_name != class_nspace) goto <D.16698>; else goto <D.16699>;
  <D.16698>:
  D.16700 = method_name + 4294967295;
  D.16701 = *D.16700;
  if (D.16701 == 58) goto <D.16702>; else goto <D.16703>;
  <D.16702>:
  D.16700 = method_name + 4294967295;
  *D.16700 = 0;
  <D.16703>:
  <D.16699>:
  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.16705>; else goto <D.16706>;
  <D.16705>:
  class_name.4 = class_name;
  class_name = class_name.4 + 1;
  *class_name.4 = 0;
  use_namespace = 1;
  goto <D.16708>;
  <D.16706>:
  class_name = class_nspace;
  use_namespace = 0;
  <D.16708>:
  result = monoeg_malloc0 (32);
  result->include_namespace = include_namespace;
  result->name = method_name;
  result->klass = class_name;
  if (use_namespace != 0) goto <D.16710>; else goto <D.16711>;
  <D.16710>:
  iftmp.5 = class_nspace;
  goto <D.16712>;
  <D.16711>:
  iftmp.5 = 0B;
  <D.16712>:
  result->namespace = iftmp.5;
  result->args = use_args;
  D.16713 = result->name;
  D.16714 = __builtin_strchr (D.16713, 42);
  if (D.16714 != 0B) goto <D.16715>; else goto <D.16716>;
  <D.16715>:
  result->name_glob = 1;
  <D.16716>:
  D.16717 = result->klass;
  D.16718 = __builtin_strchr (D.16717, 42);
  if (D.16718 != 0B) goto <D.16719>; else goto <D.16720>;
  <D.16719>:
  result->klass_glob = 1;
  <D.16720>:
  if (use_args != 0B) goto <D.16721>; else goto <D.16722>;
  <D.16721>:
  end = use_args;
  D.16723 = *end;
  if (D.16723 != 0) goto <D.16724>; else goto <D.16725>;
  <D.16724>:
  result->num_args = 1;
  <D.16725>:
  goto <D.16297>;
  <D.16296>:
  D.16723 = *end;
  if (D.16723 == 44) goto <D.16726>; else goto <D.16727>;
  <D.16726>:
  D.16728 = result->num_args;
  D.16729 = D.16728 + 1;
  result->num_args = D.16729;
  <D.16727>:
  end = end + 1;
  <D.16297>:
  D.16723 = *end;
  if (D.16723 != 0) goto <D.16296>; else goto <D.16298>;
  <D.16298>:
  <D.16722>:
  D.16695 = result;
  return D.16695;
}


mono_method_desc_from_method (struct MonoMethod * method)
{
  const char * D.16731;
  gchar * D.16732;
  struct MonoClass * D.16733;
  const char * D.16734;
  gchar * D.16735;
  const char * D.16736;
  gchar * D.16737;
  struct MonoMethodDesc * D.16738;
  struct MonoMethodDesc * result;

  result = monoeg_malloc0 (32);
  result->include_namespace = 1;
  D.16731 = method->name;
  D.16732 = monoeg_strdup (D.16731);
  result->name = D.16732;
  D.16733 = method->klass;
  D.16734 = D.16733->name;
  D.16735 = monoeg_strdup (D.16734);
  result->klass = D.16735;
  D.16733 = method->klass;
  D.16736 = D.16733->name_space;
  D.16737 = monoeg_strdup (D.16736);
  result->namespace = D.16737;
  D.16738 = result;
  return D.16738;
}


mono_method_desc_free (struct MonoMethodDesc * desc)
{
  char * D.16740;
  char * D.16744;

  D.16740 = desc->namespace;
  if (D.16740 != 0B) goto <D.16741>; else goto <D.16742>;
  <D.16741>:
  D.16740 = desc->namespace;
  monoeg_g_free (D.16740);
  goto <D.16743>;
  <D.16742>:
  D.16744 = desc->klass;
  if (D.16744 != 0B) goto <D.16745>; else goto <D.16746>;
  <D.16745>:
  D.16744 = desc->klass;
  monoeg_g_free (D.16744);
  <D.16746>:
  <D.16743>:
  monoeg_g_free (desc);
}


mono_method_desc_match (struct MonoMethodDesc * desc, struct MonoMethod * method)
{
  int D.16320;
  const char * D.16747;
  char * D.16748;
  _Bool D.16749;
  mono_bool D.16752;
  char * D.16753;
  unsigned int D.16756;
  struct MonoMethodSignature * D.16757;
  short unsigned int D.16758;
  unsigned int D.16759;
  int D.16762;
  struct MonoMethodSignature * D.16763;
  int D.16329;
  char * sig;
  gboolean name_match;

  {
    size_t __s1_len;
    size_t __s2_len;

    D.16747 = method->name;
    D.16748 = desc->name;
    D.16320 = __builtin_strcmp (D.16748, D.16747);
  }
  D.16749 = D.16320 == 0;
  name_match = (gboolean) D.16749;
  if (name_match == 0) goto <D.16750>; else goto <D.16751>;
  <D.16750>:
  D.16752 = 0;
  return D.16752;
  <D.16751>:
  D.16753 = desc->args;
  if (D.16753 == 0B) goto <D.16754>; else goto <D.16755>;
  <D.16754>:
  D.16752 = 1;
  return D.16752;
  <D.16755>:
  D.16756 = desc->num_args;
  D.16757 = mono_method_signature (method);
  D.16758 = D.16757->param_count;
  D.16759 = (unsigned int) D.16758;
  if (D.16756 != D.16759) goto <D.16760>; else goto <D.16761>;
  <D.16760>:
  D.16752 = 0;
  return D.16752;
  <D.16761>:
  D.16762 = desc->include_namespace;
  D.16763 = mono_method_signature (method);
  sig = mono_signature_get_desc (D.16763, D.16762);
  {
    size_t __s1_len;
    size_t __s2_len;

    D.16753 = desc->args;
    D.16329 = __builtin_strcmp (sig, D.16753);
  }
  if (D.16329 != 0) goto <D.16764>; else goto <D.16765>;
  <D.16764>:
  monoeg_g_free (sig);
  D.16752 = 0;
  return D.16752;
  <D.16765>:
  monoeg_g_free (sig);
  D.16752 = 1;
  return D.16752;
}


mono_method_desc_full_match (struct MonoMethodDesc * desc, struct MonoMethod * method)
{
  char * D.16767;
  mono_bool D.16770;
  struct MonoClass * D.16771;
  unsigned int D.16772;
  int D.16773;
  int D.16774;

  D.16767 = desc->klass;
  if (D.16767 == 0B) goto <D.16768>; else goto <D.16769>;
  <D.16768>:
  D.16770 = 0;
  return D.16770;
  <D.16769>:
  D.16771 = method->klass;
  D.16767 = desc->klass;
  D.16772 = strlen (D.16767);
  D.16773 = (int) D.16772;
  D.16774 = match_class (desc, D.16773, D.16771);
  if (D.16774 == 0) goto <D.16775>; else goto <D.16776>;
  <D.16775>:
  D.16770 = 0;
  return D.16770;
  <D.16776>:
  D.16770 = mono_method_desc_match (desc, method);
  return D.16770;
}


match_class (struct MonoMethodDesc * desc, int pos, struct MonoClass * klass)
{
  int D.16778;
  int D.16354;
  int iftmp.6;
  int D.16353;
  const char[2] * D.16784;
  unsigned char D.16785;
  int D.16786;
  unsigned char D.16787;
  int D.16788;
  _Bool D.16789;
  _Bool D.16790;
  _Bool D.16791;
  const unsigned char * D.16794;
  unsigned char D.16795;
  int D.16796;
  const unsigned char * D.16797;
  unsigned char D.16798;
  int D.16799;
  _Bool D.16800;
  _Bool D.16801;
  const unsigned char * D.16804;
  unsigned char D.16805;
  int D.16806;
  const unsigned char * D.16807;
  unsigned char D.16808;
  int D.16809;
  _Bool D.16810;
  _Bool D.16811;
  const unsigned char * D.16814;
  unsigned char D.16815;
  int D.16816;
  const unsigned char * D.16817;
  unsigned char D.16818;
  int D.16819;
  char * D.16821;
  gboolean D.16824;
  int pos.7;
  unsigned int pos.8;
  const char * D.16829;
  int D.16830;
  char * D.16833;
  int D.16372;
  const char * D.16836;
  int D.16381;
  const char * D.16839;
  struct MonoClass * D.16842;
  const char * p;

  D.16778 = desc->klass_glob;
  if (D.16778 != 0) goto <D.16779>; else goto <D.16780>;
  <D.16779>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = desc->klass;
      D.16784 = "*";
      D.16785 = MEM[(const unsigned char *)D.16784];
      D.16786 = (int) D.16785;
      D.16787 = *__s2;
      D.16788 = (int) D.16787;
      __result = D.16786 - D.16788;
      {
        D.16789 = __s2_len != 0;
        D.16790 = __result == 0;
        D.16791 = D.16789 & D.16790;
        if (D.16791 != 0) goto <D.16792>; else goto <D.16793>;
        <D.16792>:
        D.16794 = &MEM[(void *)"*" + 1B];
        D.16795 = *D.16794;
        D.16796 = (int) D.16795;
        D.16797 = __s2 + 1;
        D.16798 = *D.16797;
        D.16799 = (int) D.16798;
        __result = D.16796 - D.16799;
        D.16800 = __s2_len > 1;
        D.16790 = __result == 0;
        D.16801 = D.16800 & D.16790;
        if (D.16801 != 0) goto <D.16802>; else goto <D.16803>;
        <D.16802>:
        D.16804 = &MEM[(void *)"*" + 2B];
        D.16805 = *D.16804;
        D.16806 = (int) D.16805;
        D.16807 = __s2 + 2;
        D.16808 = *D.16807;
        D.16809 = (int) D.16808;
        __result = D.16806 - D.16809;
        D.16810 = __s2_len > 2;
        D.16790 = __result == 0;
        D.16811 = D.16810 & D.16790;
        if (D.16811 != 0) goto <D.16812>; else goto <D.16813>;
        <D.16812>:
        D.16814 = &MEM[(void *)"*" + 3B];
        D.16815 = *D.16814;
        D.16816 = (int) D.16815;
        D.16817 = __s2 + 3;
        D.16818 = *D.16817;
        D.16819 = (int) D.16818;
        __result = D.16816 - D.16819;
        <D.16813>:
        <D.16803>:
        <D.16793>:
      }
      D.16353 = __result;
    }
    iftmp.6 = -D.16353;
    goto <D.16820>;
    <D.16783>:
    D.16821 = desc->klass;
    iftmp.6 = __builtin_strcmp (D.16821, "*");
    <D.16820>:
    D.16354 = iftmp.6;
  }
  if (D.16354 == 0) goto <D.16822>; else goto <D.16823>;
  <D.16822>:
  D.16824 = 1;
  return D.16824;
  <D.16823>:
  <D.16780>:
  D.16821 = desc->klass;
  p = my_strrchr (D.16821, 47, &pos);
  if (p == 0B) goto <D.16825>; else goto <D.16826>;
  <D.16825>:
  pos.7 = pos;
  pos.8 = (unsigned int) pos.7;
  D.16829 = klass->name;
  D.16821 = desc->klass;
  D.16830 = strncmp (D.16821, D.16829, pos.8);
  if (D.16830 != 0) goto <D.16831>; else goto <D.16832>;
  <D.16831>:
  D.16824 = 0;
  return D.16824;
  <D.16832>:
  D.16833 = desc->namespace;
  if (D.16833 != 0B) goto <D.16834>; else goto <D.16835>;
  <D.16834>:
  {
    size_t __s1_len;
    size_t __s2_len;

    D.16836 = klass->name_space;
    D.16833 = desc->namespace;
    D.16372 = __builtin_strcmp (D.16833, D.16836);
  }
  if (D.16372 != 0) goto <D.16837>; else goto <D.16838>;
  <D.16837>:
  D.16824 = 0;
  return D.16824;
  <D.16838>:
  <D.16835>:
  D.16824 = 1;
  return D.16824;
  <D.16826>:
  {
    size_t __s1_len;
    size_t __s2_len;

    D.16829 = klass->name;
    D.16839 = p + 1;
    D.16381 = __builtin_strcmp (D.16839, D.16829);
  }
  if (D.16381 != 0) goto <D.16840>; else goto <D.16841>;
  <D.16840>:
  D.16824 = 0;
  return D.16824;
  <D.16841>:
  D.16842 = klass->nested_in;
  if (D.16842 == 0B) goto <D.16843>; else goto <D.16844>;
  <D.16843>:
  D.16824 = 0;
  return D.16824;
  <D.16844>:
  D.16842 = klass->nested_in;
  pos.7 = pos;
  D.16824 = match_class (desc, pos.7, D.16842);
  return D.16824;
}


my_strrchr (const char * str, char ch, int * len)
{
  int D.16846;
  sizetype pos.9;
  const char * D.16848;
  char D.16849;
  const char * D.16852;
  int pos;

  D.16846 = *len;
  pos = D.16846 + -1;
  goto <D.16338>;
  <D.16337>:
  pos.9 = (sizetype) pos;
  D.16848 = str + pos.9;
  D.16849 = *D.16848;
  if (D.16849 != ch) goto <D.16850>; else goto <D.16851>;
  <D.16850>:
  // predicted unlikely by continue predictor.
  goto <D.16336>;
  <D.16851>:
  *len = pos;
  pos.9 = (sizetype) pos;
  D.16852 = str + pos.9;
  return D.16852;
  <D.16336>:
  pos = pos + -1;
  <D.16338>:
  if (pos >= 0) goto <D.16337>; else goto <D.16339>;
  <D.16339>:
  D.16852 = 0B;
  return D.16852;
}


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

  try
    {
      iter = 0B;
      goto <D.16393>;
      <D.16392>:
      D.16854 = mono_method_desc_match (desc, m);
      if (D.16854 != 0) goto <D.16855>; else goto <D.16856>;
      <D.16855>:
      D.16857 = m;
      return D.16857;
      <D.16856>:
      <D.16393>:
      m = mono_class_get_methods (klass, &iter);
      if (m != 0B) goto <D.16392>; else goto <D.16394>;
      <D.16394>:
      D.16857 = 0B;
      return D.16857;
    }
  finally
    {
      iter = {CLOBBER};
    }
}


mono_method_desc_search_in_image (struct MonoMethodDesc * desc, struct MonoImage * image)
{
  char * D.16860;
  struct MonoImage * D.16863;
  char * D.16866;
  struct MonoMethod * D.16869;
  int D.16414;
  char * D.16876;
  int D.16879;
  int D.16880;
  unsigned int D.16881;
  int D.16882;
  int D.16885;
  struct MonoClass * klass;
  const struct MonoTableInfo * tdef;
  const struct MonoTableInfo * methods;
  struct MonoMethod * method;
  int i;

  D.16860 = desc->namespace;
  if (D.16860 == 0B) goto <D.16861>; else goto <D.16862>;
  <D.16861>:
  D.16863 = mono_defaults.corlib;
  if (D.16863 == image) goto <D.16864>; else goto <D.16865>;
  <D.16864>:
  D.16866 = desc->klass;
  klass = find_system_class (D.16866);
  if (klass != 0B) goto <D.16867>; else goto <D.16868>;
  <D.16867>:
  D.16869 = mono_method_desc_search_in_class (desc, klass);
  return D.16869;
  <D.16868>:
  <D.16865>:
  <D.16862>:
  D.16860 = desc->namespace;
  if (D.16860 != 0B) goto <D.16870>; else goto <D.16871>;
  <D.16870>:
  D.16866 = desc->klass;
  if (D.16866 != 0B) goto <D.16872>; else goto <D.16873>;
  <D.16872>:
  D.16866 = desc->klass;
  D.16860 = desc->namespace;
  klass = mono_class_from_name (image, D.16860, D.16866);
  if (klass == 0B) goto <D.16874>; else goto <D.16875>;
  <D.16874>:
  D.16869 = 0B;
  return D.16869;
  <D.16875>:
  D.16869 = mono_method_desc_search_in_class (desc, klass);
  return D.16869;
  <D.16873>:
  <D.16871>:
  tdef = mono_image_get_table_info (image, 2);
  methods = mono_image_get_table_info (image, 6);
  i = 0;
  goto <D.16417>;
  <D.16416>:
  {
    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.16876 = desc->name;
      D.16414 = __builtin_strcmp (n, D.16876);
    }
    if (D.16414 != 0) goto <D.16877>; else goto <D.16878>;
    <D.16877>:
    // predicted unlikely by continue predictor.
    goto <D.16415>;
    <D.16878>:
    D.16879 = i + 1;
    D.16880 = D.16879 | 100663296;
    D.16881 = (unsigned int) D.16880;
    method = mono_get_method (image, D.16881, 0B);
    D.16882 = mono_method_desc_full_match (desc, method);
    if (D.16882 != 0) goto <D.16883>; else goto <D.16884>;
    <D.16883>:
    D.16869 = method;
    return D.16869;
    <D.16884>:
  }
  <D.16415>:
  i = i + 1;
  <D.16417>:
  D.16885 = mono_table_info_get_rows (methods);
  if (D.16885 > i) goto <D.16416>; else goto <D.16418>;
  <D.16418>:
  D.16869 = 0B;
  return D.16869;
}


find_system_class (const char * name)
{
  int D.16070;
  int iftmp.10;
  int D.16069;
  const char[5] * D.16890;
  unsigned char D.16891;
  int D.16892;
  unsigned char D.16893;
  int D.16894;
  _Bool D.16895;
  _Bool D.16896;
  _Bool D.16897;
  const unsigned char * D.16900;
  unsigned char D.16901;
  int D.16902;
  const unsigned char * D.16903;
  unsigned char D.16904;
  int D.16905;
  _Bool D.16906;
  _Bool D.16907;
  const unsigned char * D.16910;
  unsigned char D.16911;
  int D.16912;
  const unsigned char * D.16913;
  unsigned char D.16914;
  int D.16915;
  _Bool D.16916;
  _Bool D.16917;
  const unsigned char * D.16920;
  unsigned char D.16921;
  int D.16922;
  const unsigned char * D.16923;
  unsigned char D.16924;
  int D.16925;
  struct MonoClass * D.16929;
  int D.16079;
  int iftmp.11;
  int D.16078;
  const char[5] * D.16933;
  unsigned char D.16934;
  int D.16935;
  unsigned char D.16936;
  int D.16937;
  _Bool D.16938;
  _Bool D.16939;
  _Bool D.16940;
  const unsigned char * D.16943;
  unsigned char D.16944;
  int D.16945;
  const unsigned char * D.16946;
  unsigned char D.16947;
  int D.16948;
  _Bool D.16949;
  _Bool D.16950;
  const unsigned char * D.16953;
  unsigned char D.16954;
  int D.16955;
  const unsigned char * D.16956;
  unsigned char D.16957;
  int D.16958;
  _Bool D.16959;
  _Bool D.16960;
  const unsigned char * D.16963;
  unsigned char D.16964;
  int D.16965;
  const unsigned char * D.16966;
  unsigned char D.16967;
  int D.16968;
  int D.16088;
  int iftmp.12;
  int D.16087;
  const char[5] * D.16975;
  unsigned char D.16976;
  int D.16977;
  unsigned char D.16978;
  int D.16979;
  _Bool D.16980;
  _Bool D.16981;
  _Bool D.16982;
  const unsigned char * D.16985;
  unsigned char D.16986;
  int D.16987;
  const unsigned char * D.16988;
  unsigned char D.16989;
  int D.16990;
  _Bool D.16991;
  _Bool D.16992;
  const unsigned char * D.16995;
  unsigned char D.16996;
  int D.16997;
  const unsigned char * D.16998;
  unsigned char D.16999;
  int D.17000;
  _Bool D.17001;
  _Bool D.17002;
  const unsigned char * D.17005;
  unsigned char D.17006;
  int D.17007;
  const unsigned char * D.17008;
  unsigned char D.17009;
  int D.17010;
  int D.16097;
  int iftmp.13;
  int D.16096;
  const char[5] * D.17017;
  unsigned char D.17018;
  int D.17019;
  unsigned char D.17020;
  int D.17021;
  _Bool D.17022;
  _Bool D.17023;
  _Bool D.17024;
  const unsigned char * D.17027;
  unsigned char D.17028;
  int D.17029;
  const unsigned char * D.17030;
  unsigned char D.17031;
  int D.17032;
  _Bool D.17033;
  _Bool D.17034;
  const unsigned char * D.17037;
  unsigned char D.17038;
  int D.17039;
  const unsigned char * D.17040;
  unsigned char D.17041;
  int D.17042;
  _Bool D.17043;
  _Bool D.17044;
  const unsigned char * D.17047;
  unsigned char D.17048;
  int D.17049;
  const unsigned char * D.17050;
  unsigned char D.17051;
  int D.17052;
  int D.16106;
  int iftmp.14;
  int D.16105;
  const char[6] * D.17059;
  unsigned char D.17060;
  int D.17061;
  unsigned char D.17062;
  int D.17063;
  _Bool D.17064;
  _Bool D.17065;
  _Bool D.17066;
  const unsigned char * D.17069;
  unsigned char D.17070;
  int D.17071;
  const unsigned char * D.17072;
  unsigned char D.17073;
  int D.17074;
  _Bool D.17075;
  _Bool D.17076;
  const unsigned char * D.17079;
  unsigned char D.17080;
  int D.17081;
  const unsigned char * D.17082;
  unsigned char D.17083;
  int D.17084;
  _Bool D.17085;
  _Bool D.17086;
  const unsigned char * D.17089;
  unsigned char D.17090;
  int D.17091;
  const unsigned char * D.17092;
  unsigned char D.17093;
  int D.17094;
  int D.16115;
  int iftmp.15;
  int D.16114;
  const char[7] * D.17101;
  unsigned char D.17102;
  int D.17103;
  unsigned char D.17104;
  int D.17105;
  _Bool D.17106;
  _Bool D.17107;
  _Bool D.17108;
  const unsigned char * D.17111;
  unsigned char D.17112;
  int D.17113;
  const unsigned char * D.17114;
  unsigned char D.17115;
  int D.17116;
  _Bool D.17117;
  _Bool D.17118;
  const unsigned char * D.17121;
  unsigned char D.17122;
  int D.17123;
  const unsigned char * D.17124;
  unsigned char D.17125;
  int D.17126;
  _Bool D.17127;
  _Bool D.17128;
  const unsigned char * D.17131;
  unsigned char D.17132;
  int D.17133;
  const unsigned char * D.17134;
  unsigned char D.17135;
  int D.17136;
  int D.16124;
  int iftmp.16;
  int D.16123;
  const char[6] * D.17143;
  unsigned char D.17144;
  int D.17145;
  unsigned char D.17146;
  int D.17147;
  _Bool D.17148;
  _Bool D.17149;
  _Bool D.17150;
  const unsigned char * D.17153;
  unsigned char D.17154;
  int D.17155;
  const unsigned char * D.17156;
  unsigned char D.17157;
  int D.17158;
  _Bool D.17159;
  _Bool D.17160;
  const unsigned char * D.17163;
  unsigned char D.17164;
  int D.17165;
  const unsigned char * D.17166;
  unsigned char D.17167;
  int D.17168;
  _Bool D.17169;
  _Bool D.17170;
  const unsigned char * D.17173;
  unsigned char D.17174;
  int D.17175;
  const unsigned char * D.17176;
  unsigned char D.17177;
  int D.17178;
  int D.16133;
  int iftmp.17;
  int D.16132;
  const char[5] * D.17185;
  unsigned char D.17186;
  int D.17187;
  unsigned char D.17188;
  int D.17189;
  _Bool D.17190;
  _Bool D.17191;
  _Bool D.17192;
  const unsigned char * D.17195;
  unsigned char D.17196;
  int D.17197;
  const unsigned char * D.17198;
  unsigned char D.17199;
  int D.17200;
  _Bool D.17201;
  _Bool D.17202;
  const unsigned char * D.17205;
  unsigned char D.17206;
  int D.17207;
  const unsigned char * D.17208;
  unsigned char D.17209;
  int D.17210;
  _Bool D.17211;
  _Bool D.17212;
  const unsigned char * D.17215;
  unsigned char D.17216;
  int D.17217;
  const unsigned char * D.17218;
  unsigned char D.17219;
  int D.17220;
  int D.16142;
  int iftmp.18;
  int D.16141;
  const char[4] * D.17227;
  unsigned char D.17228;
  int D.17229;
  unsigned char D.17230;
  int D.17231;
  _Bool D.17232;
  _Bool D.17233;
  _Bool D.17234;
  const unsigned char * D.17237;
  unsigned char D.17238;
  int D.17239;
  const unsigned char * D.17240;
  unsigned char D.17241;
  int D.17242;
  _Bool D.17243;
  _Bool D.17244;
  const unsigned char * D.17247;
  unsigned char D.17248;
  int D.17249;
  const unsigned char * D.17250;
  unsigned char D.17251;
  int D.17252;
  _Bool D.17253;
  _Bool D.17254;
  const unsigned char * D.17257;
  unsigned char D.17258;
  int D.17259;
  const unsigned char * D.17260;
  unsigned char D.17261;
  int D.17262;
  int D.16151;
  int iftmp.19;
  int D.16150;
  const char[6] * D.17269;
  unsigned char D.17270;
  int D.17271;
  unsigned char D.17272;
  int D.17273;
  _Bool D.17274;
  _Bool D.17275;
  _Bool D.17276;
  const unsigned char * D.17279;
  unsigned char D.17280;
  int D.17281;
  const unsigned char * D.17282;
  unsigned char D.17283;
  int D.17284;
  _Bool D.17285;
  _Bool D.17286;
  const unsigned char * D.17289;
  unsigned char D.17290;
  int D.17291;
  const unsigned char * D.17292;
  unsigned char D.17293;
  int D.17294;
  _Bool D.17295;
  _Bool D.17296;
  const unsigned char * D.17299;
  unsigned char D.17300;
  int D.17301;
  const unsigned char * D.17302;
  unsigned char D.17303;
  int D.17304;
  int D.16160;
  int iftmp.20;
  int D.16159;
  const char[5] * D.17311;
  unsigned char D.17312;
  int D.17313;
  unsigned char D.17314;
  int D.17315;
  _Bool D.17316;
  _Bool D.17317;
  _Bool D.17318;
  const unsigned char * D.17321;
  unsigned char D.17322;
  int D.17323;
  const unsigned char * D.17324;
  unsigned char D.17325;
  int D.17326;
  _Bool D.17327;
  _Bool D.17328;
  const unsigned char * D.17331;
  unsigned char D.17332;
  int D.17333;
  const unsigned char * D.17334;
  unsigned char D.17335;
  int D.17336;
  _Bool D.17337;
  _Bool D.17338;
  const unsigned char * D.17341;
  unsigned char D.17342;
  int D.17343;
  const unsigned char * D.17344;
  unsigned char D.17345;
  int D.17346;
  int D.16169;
  int iftmp.21;
  int D.16168;
  const char[8] * D.17353;
  unsigned char D.17354;
  int D.17355;
  unsigned char D.17356;
  int D.17357;
  _Bool D.17358;
  _Bool D.17359;
  _Bool D.17360;
  const unsigned char * D.17363;
  unsigned char D.17364;
  int D.17365;
  const unsigned char * D.17366;
  unsigned char D.17367;
  int D.17368;
  _Bool D.17369;
  _Bool D.17370;
  const unsigned char * D.17373;
  unsigned char D.17374;
  int D.17375;
  const unsigned char * D.17376;
  unsigned char D.17377;
  int D.17378;
  _Bool D.17379;
  _Bool D.17380;
  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.16178;
  int iftmp.22;
  int D.16177;
  const char[7] * D.17395;
  unsigned char D.17396;
  int D.17397;
  unsigned char D.17398;
  int D.17399;
  _Bool D.17400;
  _Bool D.17401;
  _Bool D.17402;
  const unsigned char * D.17405;
  unsigned char D.17406;
  int D.17407;
  const unsigned char * D.17408;
  unsigned char D.17409;
  int D.17410;
  _Bool D.17411;
  _Bool D.17412;
  const unsigned char * D.17415;
  unsigned char D.17416;
  int D.17417;
  const unsigned char * D.17418;
  unsigned char D.17419;
  int D.17420;
  _Bool D.17421;
  _Bool D.17422;
  const unsigned char * D.17425;
  unsigned char D.17426;
  int D.17427;
  const unsigned char * D.17428;
  unsigned char D.17429;
  int D.17430;
  int D.16187;
  int iftmp.23;
  int D.16186;
  const char[7] * D.17437;
  unsigned char D.17438;
  int D.17439;
  unsigned char D.17440;
  int D.17441;
  _Bool D.17442;
  _Bool D.17443;
  _Bool D.17444;
  const unsigned char * D.17447;
  unsigned char D.17448;
  int D.17449;
  const unsigned char * D.17450;
  unsigned char D.17451;
  int D.17452;
  _Bool D.17453;
  _Bool D.17454;
  const unsigned char * D.17457;
  unsigned char D.17458;
  int D.17459;
  const unsigned char * D.17460;
  unsigned char D.17461;
  int D.17462;
  _Bool D.17463;
  _Bool D.17464;
  const unsigned char * D.17467;
  unsigned char D.17468;
  int D.17469;
  const unsigned char * D.17470;
  unsigned char D.17471;
  int D.17472;
  int D.16196;
  int iftmp.24;
  int D.16195;
  const char[7] * D.17479;
  unsigned char D.17480;
  int D.17481;
  unsigned char D.17482;
  int D.17483;
  _Bool D.17484;
  _Bool D.17485;
  _Bool D.17486;
  const unsigned char * D.17489;
  unsigned char D.17490;
  int D.17491;
  const unsigned char * D.17492;
  unsigned char D.17493;
  int D.17494;
  _Bool D.17495;
  _Bool D.17496;
  const unsigned char * D.17499;
  unsigned char D.17500;
  int D.17501;
  const unsigned char * D.17502;
  unsigned char D.17503;
  int D.17504;
  _Bool D.17505;
  _Bool D.17506;
  const unsigned char * D.17509;
  unsigned char D.17510;
  int D.17511;
  const unsigned char * D.17512;
  unsigned char D.17513;
  int D.17514;
  int D.16205;
  int iftmp.25;
  int D.16204;
  const char[7] * D.17521;
  unsigned char D.17522;
  int D.17523;
  unsigned char D.17524;
  int D.17525;
  _Bool D.17526;
  _Bool D.17527;
  _Bool D.17528;
  const unsigned char * D.17531;
  unsigned char D.17532;
  int D.17533;
  const unsigned char * D.17534;
  unsigned char D.17535;
  int D.17536;
  _Bool D.17537;
  _Bool D.17538;
  const unsigned char * D.17541;
  unsigned char D.17542;
  int D.17543;
  const unsigned char * D.17544;
  unsigned char D.17545;
  int D.17546;
  _Bool D.17547;
  _Bool D.17548;
  const unsigned char * D.17551;
  unsigned char D.17552;
  int D.17553;
  const unsigned char * D.17554;
  unsigned char D.17555;
  int D.17556;
  int D.16214;
  int iftmp.26;
  int D.16213;
  const char[7] * D.17563;
  unsigned char D.17564;
  int D.17565;
  unsigned char D.17566;
  int D.17567;
  _Bool D.17568;
  _Bool D.17569;
  _Bool D.17570;
  const unsigned char * D.17573;
  unsigned char D.17574;
  int D.17575;
  const unsigned char * D.17576;
  unsigned char D.17577;
  int D.17578;
  _Bool D.17579;
  _Bool D.17580;
  const unsigned char * D.17583;
  unsigned char D.17584;
  int D.17585;
  const unsigned char * D.17586;
  unsigned char D.17587;
  int D.17588;
  _Bool D.17589;
  _Bool D.17590;
  const unsigned char * D.17593;
  unsigned char D.17594;
  int D.17595;
  const unsigned char * D.17596;
  unsigned char D.17597;
  int D.17598;

  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = name;
      D.16890 = "void";
      D.16891 = MEM[(const unsigned char *)D.16890];
      D.16892 = (int) D.16891;
      D.16893 = *__s2;
      D.16894 = (int) D.16893;
      __result = D.16892 - D.16894;
      {
        D.16895 = __s2_len != 0;
        D.16896 = __result == 0;
        D.16897 = D.16895 & D.16896;
        if (D.16897 != 0) goto <D.16898>; else goto <D.16899>;
        <D.16898>:
        D.16900 = &MEM[(void *)"void" + 1B];
        D.16901 = *D.16900;
        D.16902 = (int) D.16901;
        D.16903 = __s2 + 1;
        D.16904 = *D.16903;
        D.16905 = (int) D.16904;
        __result = D.16902 - D.16905;
        D.16906 = __s2_len > 1;
        D.16896 = __result == 0;
        D.16907 = D.16906 & D.16896;
        if (D.16907 != 0) goto <D.16908>; else goto <D.16909>;
        <D.16908>:
        D.16910 = &MEM[(void *)"void" + 2B];
        D.16911 = *D.16910;
        D.16912 = (int) D.16911;
        D.16913 = __s2 + 2;
        D.16914 = *D.16913;
        D.16915 = (int) D.16914;
        __result = D.16912 - D.16915;
        D.16916 = __s2_len > 2;
        D.16896 = __result == 0;
        D.16917 = D.16916 & D.16896;
        if (D.16917 != 0) goto <D.16918>; else goto <D.16919>;
        <D.16918>:
        D.16920 = &MEM[(void *)"void" + 3B];
        D.16921 = *D.16920;
        D.16922 = (int) D.16921;
        D.16923 = __s2 + 3;
        D.16924 = *D.16923;
        D.16925 = (int) D.16924;
        __result = D.16922 - D.16925;
        <D.16919>:
        <D.16909>:
        <D.16899>:
      }
      D.16069 = __result;
    }
    iftmp.10 = -D.16069;
    goto <D.16926>;
    <D.16889>:
    iftmp.10 = __builtin_strcmp (name, "void");
    <D.16926>:
    D.16070 = iftmp.10;
  }
  if (D.16070 == 0) goto <D.16927>; else goto <D.16928>;
  <D.16927>:
  D.16929 = mono_defaults.void_class;
  return D.16929;
  <D.16928>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = name;
      D.16933 = "char";
      D.16934 = MEM[(const unsigned char *)D.16933];
      D.16935 = (int) D.16934;
      D.16936 = *__s2;
      D.16937 = (int) D.16936;
      __result = D.16935 - D.16937;
      {
        D.16938 = __s2_len != 0;
        D.16939 = __result == 0;
        D.16940 = D.16938 & D.16939;
        if (D.16940 != 0) goto <D.16941>; else goto <D.16942>;
        <D.16941>:
        D.16943 = &MEM[(void *)"char" + 1B];
        D.16944 = *D.16943;
        D.16945 = (int) D.16944;
        D.16946 = __s2 + 1;
        D.16947 = *D.16946;
        D.16948 = (int) D.16947;
        __result = D.16945 - D.16948;
        D.16949 = __s2_len > 1;
        D.16939 = __result == 0;
        D.16950 = D.16949 & D.16939;
        if (D.16950 != 0) goto <D.16951>; else goto <D.16952>;
        <D.16951>:
        D.16953 = &MEM[(void *)"char" + 2B];
        D.16954 = *D.16953;
        D.16955 = (int) D.16954;
        D.16956 = __s2 + 2;
        D.16957 = *D.16956;
        D.16958 = (int) D.16957;
        __result = D.16955 - D.16958;
        D.16959 = __s2_len > 2;
        D.16939 = __result == 0;
        D.16960 = D.16959 & D.16939;
        if (D.16960 != 0) goto <D.16961>; else goto <D.16962>;
        <D.16961>:
        D.16963 = &MEM[(void *)"char" + 3B];
        D.16964 = *D.16963;
        D.16965 = (int) D.16964;
        D.16966 = __s2 + 3;
        D.16967 = *D.16966;
        D.16968 = (int) D.16967;
        __result = D.16965 - D.16968;
        <D.16962>:
        <D.16952>:
        <D.16942>:
      }
      D.16078 = __result;
    }
    iftmp.11 = -D.16078;
    goto <D.16969>;
    <D.16932>:
    iftmp.11 = __builtin_strcmp (name, "char");
    <D.16969>:
    D.16079 = iftmp.11;
  }
  if (D.16079 == 0) goto <D.16970>; else goto <D.16971>;
  <D.16970>:
  D.16929 = mono_defaults.char_class;
  return D.16929;
  <D.16971>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = name;
      D.16975 = "bool";
      D.16976 = MEM[(const unsigned char *)D.16975];
      D.16977 = (int) D.16976;
      D.16978 = *__s2;
      D.16979 = (int) D.16978;
      __result = D.16977 - D.16979;
      {
        D.16980 = __s2_len != 0;
        D.16981 = __result == 0;
        D.16982 = D.16980 & D.16981;
        if (D.16982 != 0) goto <D.16983>; else goto <D.16984>;
        <D.16983>:
        D.16985 = &MEM[(void *)"bool" + 1B];
        D.16986 = *D.16985;
        D.16987 = (int) D.16986;
        D.16988 = __s2 + 1;
        D.16989 = *D.16988;
        D.16990 = (int) D.16989;
        __result = D.16987 - D.16990;
        D.16991 = __s2_len > 1;
        D.16981 = __result == 0;
        D.16992 = D.16991 & D.16981;
        if (D.16992 != 0) goto <D.16993>; else goto <D.16994>;
        <D.16993>:
        D.16995 = &MEM[(void *)"bool" + 2B];
        D.16996 = *D.16995;
        D.16997 = (int) D.16996;
        D.16998 = __s2 + 2;
        D.16999 = *D.16998;
        D.17000 = (int) D.16999;
        __result = D.16997 - D.17000;
        D.17001 = __s2_len > 2;
        D.16981 = __result == 0;
        D.17002 = D.17001 & D.16981;
        if (D.17002 != 0) goto <D.17003>; else goto <D.17004>;
        <D.17003>:
        D.17005 = &MEM[(void *)"bool" + 3B];
        D.17006 = *D.17005;
        D.17007 = (int) D.17006;
        D.17008 = __s2 + 3;
        D.17009 = *D.17008;
        D.17010 = (int) D.17009;
        __result = D.17007 - D.17010;
        <D.17004>:
        <D.16994>:
        <D.16984>:
      }
      D.16087 = __result;
    }
    iftmp.12 = -D.16087;
    goto <D.17011>;
    <D.16974>:
    iftmp.12 = __builtin_strcmp (name, "bool");
    <D.17011>:
    D.16088 = iftmp.12;
  }
  if (D.16088 == 0) goto <D.17012>; else goto <D.17013>;
  <D.17012>:
  D.16929 = mono_defaults.boolean_class;
  return D.16929;
  <D.17013>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = name;
      D.17017 = "byte";
      D.17018 = MEM[(const unsigned char *)D.17017];
      D.17019 = (int) D.17018;
      D.17020 = *__s2;
      D.17021 = (int) D.17020;
      __result = D.17019 - D.17021;
      {
        D.17022 = __s2_len != 0;
        D.17023 = __result == 0;
        D.17024 = D.17022 & D.17023;
        if (D.17024 != 0) goto <D.17025>; else goto <D.17026>;
        <D.17025>:
        D.17027 = &MEM[(void *)"byte" + 1B];
        D.17028 = *D.17027;
        D.17029 = (int) D.17028;
        D.17030 = __s2 + 1;
        D.17031 = *D.17030;
        D.17032 = (int) D.17031;
        __result = D.17029 - D.17032;
        D.17033 = __s2_len > 1;
        D.17023 = __result == 0;
        D.17034 = D.17033 & D.17023;
        if (D.17034 != 0) goto <D.17035>; else goto <D.17036>;
        <D.17035>:
        D.17037 = &MEM[(void *)"byte" + 2B];
        D.17038 = *D.17037;
        D.17039 = (int) D.17038;
        D.17040 = __s2 + 2;
        D.17041 = *D.17040;
        D.17042 = (int) D.17041;
        __result = D.17039 - D.17042;
        D.17043 = __s2_len > 2;
        D.17023 = __result == 0;
        D.17044 = D.17043 & D.17023;
        if (D.17044 != 0) goto <D.17045>; else goto <D.17046>;
        <D.17045>:
        D.17047 = &MEM[(void *)"byte" + 3B];
        D.17048 = *D.17047;
        D.17049 = (int) D.17048;
        D.17050 = __s2 + 3;
        D.17051 = *D.17050;
        D.17052 = (int) D.17051;
        __result = D.17049 - D.17052;
        <D.17046>:
        <D.17036>:
        <D.17026>:
      }
      D.16096 = __result;
    }
    iftmp.13 = -D.16096;
    goto <D.17053>;
    <D.17016>:
    iftmp.13 = __builtin_strcmp (name, "byte");
    <D.17053>:
    D.16097 = iftmp.13;
  }
  if (D.16097 == 0) goto <D.17054>; else goto <D.17055>;
  <D.17054>:
  D.16929 = mono_defaults.byte_class;
  return D.16929;
  <D.17055>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = name;
      D.17059 = "sbyte";
      D.17060 = MEM[(const unsigned char *)D.17059];
      D.17061 = (int) D.17060;
      D.17062 = *__s2;
      D.17063 = (int) D.17062;
      __result = D.17061 - D.17063;
      {
        D.17064 = __s2_len != 0;
        D.17065 = __result == 0;
        D.17066 = D.17064 & D.17065;
        if (D.17066 != 0) goto <D.17067>; else goto <D.17068>;
        <D.17067>:
        D.17069 = &MEM[(void *)"sbyte" + 1B];
        D.17070 = *D.17069;
        D.17071 = (int) D.17070;
        D.17072 = __s2 + 1;
        D.17073 = *D.17072;
        D.17074 = (int) D.17073;
        __result = D.17071 - D.17074;
        D.17075 = __s2_len > 1;
        D.17065 = __result == 0;
        D.17076 = D.17075 & D.17065;
        if (D.17076 != 0) goto <D.17077>; else goto <D.17078>;
        <D.17077>:
        D.17079 = &MEM[(void *)"sbyte" + 2B];
        D.17080 = *D.17079;
        D.17081 = (int) D.17080;
        D.17082 = __s2 + 2;
        D.17083 = *D.17082;
        D.17084 = (int) D.17083;
        __result = D.17081 - D.17084;
        D.17085 = __s2_len > 2;
        D.17065 = __result == 0;
        D.17086 = D.17085 & D.17065;
        if (D.17086 != 0) goto <D.17087>; else goto <D.17088>;
        <D.17087>:
        D.17089 = &MEM[(void *)"sbyte" + 3B];
        D.17090 = *D.17089;
        D.17091 = (int) D.17090;
        D.17092 = __s2 + 3;
        D.17093 = *D.17092;
        D.17094 = (int) D.17093;
        __result = D.17091 - D.17094;
        <D.17088>:
        <D.17078>:
        <D.17068>:
      }
      D.16105 = __result;
    }
    iftmp.14 = -D.16105;
    goto <D.17095>;
    <D.17058>:
    iftmp.14 = __builtin_strcmp (name, "sbyte");
    <D.17095>:
    D.16106 = iftmp.14;
  }
  if (D.16106 == 0) goto <D.17096>; else goto <D.17097>;
  <D.17096>:
  D.16929 = mono_defaults.sbyte_class;
  return D.16929;
  <D.17097>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = name;
      D.17101 = "uint16";
      D.17102 = MEM[(const unsigned char *)D.17101];
      D.17103 = (int) D.17102;
      D.17104 = *__s2;
      D.17105 = (int) D.17104;
      __result = D.17103 - D.17105;
      {
        D.17106 = __s2_len != 0;
        D.17107 = __result == 0;
        D.17108 = D.17106 & D.17107;
        if (D.17108 != 0) goto <D.17109>; else goto <D.17110>;
        <D.17109>:
        D.17111 = &MEM[(void *)"uint16" + 1B];
        D.17112 = *D.17111;
        D.17113 = (int) D.17112;
        D.17114 = __s2 + 1;
        D.17115 = *D.17114;
        D.17116 = (int) D.17115;
        __result = D.17113 - D.17116;
        D.17117 = __s2_len > 1;
        D.17107 = __result == 0;
        D.17118 = D.17117 & D.17107;
        if (D.17118 != 0) goto <D.17119>; else goto <D.17120>;
        <D.17119>:
        D.17121 = &MEM[(void *)"uint16" + 2B];
        D.17122 = *D.17121;
        D.17123 = (int) D.17122;
        D.17124 = __s2 + 2;
        D.17125 = *D.17124;
        D.17126 = (int) D.17125;
        __result = D.17123 - D.17126;
        D.17127 = __s2_len > 2;
        D.17107 = __result == 0;
        D.17128 = D.17127 & D.17107;
        if (D.17128 != 0) goto <D.17129>; else goto <D.17130>;
        <D.17129>:
        D.17131 = &MEM[(void *)"uint16" + 3B];
        D.17132 = *D.17131;
        D.17133 = (int) D.17132;
        D.17134 = __s2 + 3;
        D.17135 = *D.17134;
        D.17136 = (int) D.17135;
        __result = D.17133 - D.17136;
        <D.17130>:
        <D.17120>:
        <D.17110>:
      }
      D.16114 = __result;
    }
    iftmp.15 = -D.16114;
    goto <D.17137>;
    <D.17100>:
    iftmp.15 = __builtin_strcmp (name, "uint16");
    <D.17137>:
    D.16115 = iftmp.15;
  }
  if (D.16115 == 0) goto <D.17138>; else goto <D.17139>;
  <D.17138>:
  D.16929 = mono_defaults.uint16_class;
  return D.16929;
  <D.17139>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = name;
      D.17143 = "int16";
      D.17144 = MEM[(const unsigned char *)D.17143];
      D.17145 = (int) D.17144;
      D.17146 = *__s2;
      D.17147 = (int) D.17146;
      __result = D.17145 - D.17147;
      {
        D.17148 = __s2_len != 0;
        D.17149 = __result == 0;
        D.17150 = D.17148 & D.17149;
        if (D.17150 != 0) goto <D.17151>; else goto <D.17152>;
        <D.17151>:
        D.17153 = &MEM[(void *)"int16" + 1B];
        D.17154 = *D.17153;
        D.17155 = (int) D.17154;
        D.17156 = __s2 + 1;
        D.17157 = *D.17156;
        D.17158 = (int) D.17157;
        __result = D.17155 - D.17158;
        D.17159 = __s2_len > 1;
        D.17149 = __result == 0;
        D.17160 = D.17159 & D.17149;
        if (D.17160 != 0) goto <D.17161>; else goto <D.17162>;
        <D.17161>:
        D.17163 = &MEM[(void *)"int16" + 2B];
        D.17164 = *D.17163;
        D.17165 = (int) D.17164;
        D.17166 = __s2 + 2;
        D.17167 = *D.17166;
        D.17168 = (int) D.17167;
        __result = D.17165 - D.17168;
        D.17169 = __s2_len > 2;
        D.17149 = __result == 0;
        D.17170 = D.17169 & D.17149;
        if (D.17170 != 0) goto <D.17171>; else goto <D.17172>;
        <D.17171>:
        D.17173 = &MEM[(void *)"int16" + 3B];
        D.17174 = *D.17173;
        D.17175 = (int) D.17174;
        D.17176 = __s2 + 3;
        D.17177 = *D.17176;
        D.17178 = (int) D.17177;
        __result = D.17175 - D.17178;
        <D.17172>:
        <D.17162>:
        <D.17152>:
      }
      D.16123 = __result;
    }
    iftmp.16 = -D.16123;
    goto <D.17179>;
    <D.17142>:
    iftmp.16 = __builtin_strcmp (name, "int16");
    <D.17179>:
    D.16124 = iftmp.16;
  }
  if (D.16124 == 0) goto <D.17180>; else goto <D.17181>;
  <D.17180>:
  D.16929 = mono_defaults.int16_class;
  return D.16929;
  <D.17181>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = name;
      D.17185 = "uint";
      D.17186 = MEM[(const unsigned char *)D.17185];
      D.17187 = (int) D.17186;
      D.17188 = *__s2;
      D.17189 = (int) D.17188;
      __result = D.17187 - D.17189;
      {
        D.17190 = __s2_len != 0;
        D.17191 = __result == 0;
        D.17192 = D.17190 & D.17191;
        if (D.17192 != 0) goto <D.17193>; else goto <D.17194>;
        <D.17193>:
        D.17195 = &MEM[(void *)"uint" + 1B];
        D.17196 = *D.17195;
        D.17197 = (int) D.17196;
        D.17198 = __s2 + 1;
        D.17199 = *D.17198;
        D.17200 = (int) D.17199;
        __result = D.17197 - D.17200;
        D.17201 = __s2_len > 1;
        D.17191 = __result == 0;
        D.17202 = D.17201 & D.17191;
        if (D.17202 != 0) goto <D.17203>; else goto <D.17204>;
        <D.17203>:
        D.17205 = &MEM[(void *)"uint" + 2B];
        D.17206 = *D.17205;
        D.17207 = (int) D.17206;
        D.17208 = __s2 + 2;
        D.17209 = *D.17208;
        D.17210 = (int) D.17209;
        __result = D.17207 - D.17210;
        D.17211 = __s2_len > 2;
        D.17191 = __result == 0;
        D.17212 = D.17211 & D.17191;
        if (D.17212 != 0) goto <D.17213>; else goto <D.17214>;
        <D.17213>:
        D.17215 = &MEM[(void *)"uint" + 3B];
        D.17216 = *D.17215;
        D.17217 = (int) D.17216;
        D.17218 = __s2 + 3;
        D.17219 = *D.17218;
        D.17220 = (int) D.17219;
        __result = D.17217 - D.17220;
        <D.17214>:
        <D.17204>:
        <D.17194>:
      }
      D.16132 = __result;
    }
    iftmp.17 = -D.16132;
    goto <D.17221>;
    <D.17184>:
    iftmp.17 = __builtin_strcmp (name, "uint");
    <D.17221>:
    D.16133 = iftmp.17;
  }
  if (D.16133 == 0) goto <D.17222>; else goto <D.17223>;
  <D.17222>:
  D.16929 = mono_defaults.uint32_class;
  return D.16929;
  <D.17223>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

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

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

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

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

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

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

      __s2 = name;
      D.17353 = "uintptr";
      D.17354 = MEM[(const unsigned char *)D.17353];
      D.17355 = (int) D.17354;
      D.17356 = *__s2;
      D.17357 = (int) D.17356;
      __result = D.17355 - D.17357;
      {
        D.17358 = __s2_len != 0;
        D.17359 = __result == 0;
        D.17360 = D.17358 & D.17359;
        if (D.17360 != 0) goto <D.17361>; else goto <D.17362>;
        <D.17361>:
        D.17363 = &MEM[(void *)"uintptr" + 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;
        D.17369 = __s2_len > 1;
        D.17359 = __result == 0;
        D.17370 = D.17369 & D.17359;
        if (D.17370 != 0) goto <D.17371>; else goto <D.17372>;
        <D.17371>:
        D.17373 = &MEM[(void *)"uintptr" + 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;
        D.17379 = __s2_len > 2;
        D.17359 = __result == 0;
        D.17380 = D.17379 & D.17359;
        if (D.17380 != 0) goto <D.17381>; else goto <D.17382>;
        <D.17381>:
        D.17383 = &MEM[(void *)"uintptr" + 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.17372>:
        <D.17362>:
      }
      D.16168 = __result;
    }
    iftmp.21 = -D.16168;
    goto <D.17389>;
    <D.17352>:
    iftmp.21 = __builtin_strcmp (name, "uintptr");
    <D.17389>:
    D.16169 = iftmp.21;
  }
  if (D.16169 == 0) goto <D.17390>; else goto <D.17391>;
  <D.17390>:
  D.16929 = mono_defaults.uint_class;
  return D.16929;
  <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 = "intptr";
      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;
      {
        D.17400 = __s2_len != 0;
        D.17401 = __result == 0;
        D.17402 = D.17400 & D.17401;
        if (D.17402 != 0) goto <D.17403>; else goto <D.17404>;
        <D.17403>:
        D.17405 = &MEM[(void *)"intptr" + 1B];
        D.17406 = *D.17405;
        D.17407 = (int) D.17406;
        D.17408 = __s2 + 1;
        D.17409 = *D.17408;
        D.17410 = (int) D.17409;
        __result = D.17407 - D.17410;
        D.17411 = __s2_len > 1;
        D.17401 = __result == 0;
        D.17412 = D.17411 & D.17401;
        if (D.17412 != 0) goto <D.17413>; else goto <D.17414>;
        <D.17413>:
        D.17415 = &MEM[(void *)"intptr" + 2B];
        D.17416 = *D.17415;
        D.17417 = (int) D.17416;
        D.17418 = __s2 + 2;
        D.17419 = *D.17418;
        D.17420 = (int) D.17419;
        __result = D.17417 - D.17420;
        D.17421 = __s2_len > 2;
        D.17401 = __result == 0;
        D.17422 = D.17421 & D.17401;
        if (D.17422 != 0) goto <D.17423>; else goto <D.17424>;
        <D.17423>:
        D.17425 = &MEM[(void *)"intptr" + 3B];
        D.17426 = *D.17425;
        D.17427 = (int) D.17426;
        D.17428 = __s2 + 3;
        D.17429 = *D.17428;
        D.17430 = (int) D.17429;
        __result = D.17427 - D.17430;
        <D.17424>:
        <D.17414>:
        <D.17404>:
      }
      D.16177 = __result;
    }
    iftmp.22 = -D.16177;
    goto <D.17431>;
    <D.17394>:
    iftmp.22 = __builtin_strcmp (name, "intptr");
    <D.17431>:
    D.16178 = iftmp.22;
  }
  if (D.16178 == 0) goto <D.17432>; else goto <D.17433>;
  <D.17432>:
  D.16929 = mono_defaults.int_class;
  return D.16929;
  <D.17433>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

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

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

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

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

      __s2 = name;
      D.17521 = "string";
      D.17522 = MEM[(const unsigned char *)D.17521];
      D.17523 = (int) D.17522;
      D.17524 = *__s2;
      D.17525 = (int) D.17524;
      __result = D.17523 - D.17525;
      {
        D.17526 = __s2_len != 0;
        D.17527 = __result == 0;
        D.17528 = D.17526 & D.17527;
        if (D.17528 != 0) goto <D.17529>; else goto <D.17530>;
        <D.17529>:
        D.17531 = &MEM[(void *)"string" + 1B];
        D.17532 = *D.17531;
        D.17533 = (int) D.17532;
        D.17534 = __s2 + 1;
        D.17535 = *D.17534;
        D.17536 = (int) D.17535;
        __result = D.17533 - D.17536;
        D.17537 = __s2_len > 1;
        D.17527 = __result == 0;
        D.17538 = D.17537 & D.17527;
        if (D.17538 != 0) goto <D.17539>; else goto <D.17540>;
        <D.17539>:
        D.17541 = &MEM[(void *)"string" + 2B];
        D.17542 = *D.17541;
        D.17543 = (int) D.17542;
        D.17544 = __s2 + 2;
        D.17545 = *D.17544;
        D.17546 = (int) D.17545;
        __result = D.17543 - D.17546;
        D.17547 = __s2_len > 2;
        D.17527 = __result == 0;
        D.17548 = D.17547 & D.17527;
        if (D.17548 != 0) goto <D.17549>; else goto <D.17550>;
        <D.17549>:
        D.17551 = &MEM[(void *)"string" + 3B];
        D.17552 = *D.17551;
        D.17553 = (int) D.17552;
        D.17554 = __s2 + 3;
        D.17555 = *D.17554;
        D.17556 = (int) D.17555;
        __result = D.17553 - D.17556;
        <D.17550>:
        <D.17540>:
        <D.17530>:
      }
      D.16204 = __result;
    }
    iftmp.25 = -D.16204;
    goto <D.17557>;
    <D.17520>:
    iftmp.25 = __builtin_strcmp (name, "string");
    <D.17557>:
    D.16205 = iftmp.25;
  }
  if (D.16205 == 0) goto <D.17558>; else goto <D.17559>;
  <D.17558>:
  D.16929 = mono_defaults.string_class;
  return D.16929;
  <D.17559>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = name;
      D.17563 = "object";
      D.17564 = MEM[(const unsigned char *)D.17563];
      D.17565 = (int) D.17564;
      D.17566 = *__s2;
      D.17567 = (int) D.17566;
      __result = D.17565 - D.17567;
      {
        D.17568 = __s2_len != 0;
        D.17569 = __result == 0;
        D.17570 = D.17568 & D.17569;
        if (D.17570 != 0) goto <D.17571>; else goto <D.17572>;
        <D.17571>:
        D.17573 = &MEM[(void *)"object" + 1B];
        D.17574 = *D.17573;
        D.17575 = (int) D.17574;
        D.17576 = __s2 + 1;
        D.17577 = *D.17576;
        D.17578 = (int) D.17577;
        __result = D.17575 - D.17578;
        D.17579 = __s2_len > 1;
        D.17569 = __result == 0;
        D.17580 = D.17579 & D.17569;
        if (D.17580 != 0) goto <D.17581>; else goto <D.17582>;
        <D.17581>:
        D.17583 = &MEM[(void *)"object" + 2B];
        D.17584 = *D.17583;
        D.17585 = (int) D.17584;
        D.17586 = __s2 + 2;
        D.17587 = *D.17586;
        D.17588 = (int) D.17587;
        __result = D.17585 - D.17588;
        D.17589 = __s2_len > 2;
        D.17569 = __result == 0;
        D.17590 = D.17589 & D.17569;
        if (D.17590 != 0) goto <D.17591>; else goto <D.17592>;
        <D.17591>:
        D.17593 = &MEM[(void *)"object" + 3B];
        D.17594 = *D.17593;
        D.17595 = (int) D.17594;
        D.17596 = __s2 + 3;
        D.17597 = *D.17596;
        D.17598 = (int) D.17597;
        __result = D.17595 - D.17598;
        <D.17592>:
        <D.17582>:
        <D.17572>:
      }
      D.16213 = __result;
    }
    iftmp.26 = -D.16213;
    goto <D.17599>;
    <D.17562>:
    iftmp.26 = __builtin_strcmp (name, "object");
    <D.17599>:
    D.16214 = iftmp.26;
  }
  if (D.16214 == 0) goto <D.17600>; else goto <D.17601>;
  <D.17600>:
  D.16929 = mono_defaults.object_class;
  return D.16929;
  <D.17601>:
  D.16929 = 0B;
  return D.16929;
}


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

  res = monoeg_g_string_new ("");
  if (dh == 0B) goto <D.17603>; else goto <D.17604>;
  <D.17603>:
  dh = &default_dh;
  <D.17604>:
  D.17605 = ip + 2;
  ip = dis_one (res, dh, method, ip, D.17605);
  if (endp != 0B) goto <D.17606>; else goto <D.17607>;
  <D.17606>:
  *endp = ip;
  <D.17607>:
  result = res->str;
  monoeg_g_string_free (res, 0);
  D.17608 = result;
  return D.17608;
}


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.17613;
  char * (*<T2765>) (struct MonoDisHelper *, struct MonoMethod *, uint32_t) D.17614;
  const char * D.17617;
  <unnamed type> D.17620;
  const unsigned char * ip.30;
  const char * D.17622;
  unsigned char D.17623;
  int D.17624;
  char * (*<T2765>) (struct MonoDisHelper *, struct MonoMethod *, uint32_t) D.17625;
  const unsigned char * ip.31;
  struct MonoClass * D.17630;
  struct MonoImage * D.17631;
  unsigned char D.17632;
  unsigned char D.17633;
  unsigned int D.17636;
  const char * blob.32;
  const char * blob.33;
  long int len2.34;
  short unsigned int D.17642;
  int D.17643;
  const unsigned char * ip.35;
  unsigned char D.17645;
  int D.17646;
  unsigned int D.17647;
  const char * D.17648;
  sizetype sval.36;
  const unsigned char * D.17652;
  int D.17653;
  int D.17654;
  signed char D.17656;
  int D.17660;
  sizetype D.17661;
  const unsigned char * D.17666;
  int D.17667;
  int D.17668;
  long long unsigned int D.17670;
  double r.37;
  double r.38;
  const unsigned char * ip.39;
  float r.40;
  float r.41;
  double D.17676;
  int D.17677;
  int D.17678;
  const char * D.17679;
  const unsigned char * D.17682;
  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.17613 = ip.28 - il_code.29;
  label = (guint32) D.17613;
  D.17614 = dh->indenter;
  if (D.17614 != 0B) goto <D.17615>; else goto <D.17616>;
  <D.17615>:
  D.17614 = dh->indenter;
  tmp = D.17614 (dh, method, label);
  monoeg_g_string_append (str, tmp);
  monoeg_g_free (tmp);
  <D.17616>:
  D.17617 = dh->label_format;
  if (D.17617 != 0B) goto <D.17618>; else goto <D.17619>;
  <D.17618>:
  D.17617 = dh->label_format;
  monoeg_g_string_append_printf (str, D.17617, label);
  <D.17619>:
  D.17620 = mono_opcode_value (&ip, end);
  i = (int) D.17620;
  ip.27 = ip;
  ip.30 = ip.27 + 1;
  ip = ip.30;
  opcode = &mono_opcodes[i];
  D.17622 = mono_opcode_name (i);
  monoeg_g_string_append_printf (str, "%-10s", D.17622);
  D.17623 = opcode->argument;
  D.17624 = (int) D.17623;
  switch (D.17624) <default: <D.16464>, case 0: <D.16434>, case 1: <D.16436>, case 2: <D.16437>, case 3: <D.16438>, case 4: <D.16439>, case 5: <D.16441>, case 6: <D.16440>, case 7: <D.16446>, case 8: <D.16447>, case 9: <D.16448>, case 10: <D.16449>, case 11: <D.16450>, case 12: <D.16455>, case 13: <D.16458>, case 14: <D.16461>, case 15: <D.16462>, case 16: <D.16463>>
  <D.16434>:
  goto <D.16435>;
  <D.16436>:
  <D.16437>:
  <D.16438>:
  <D.16439>:
  <D.16440>:
  ip.27 = ip;
  token = MEM[(const guint32 *)ip.27];
  D.17625 = dh->tokener;
  if (D.17625 != 0B) goto <D.17626>; else goto <D.17627>;
  <D.17626>:
  D.17625 = dh->tokener;
  tmp = D.17625 (dh, method, token);
  monoeg_g_string_append (str, tmp);
  monoeg_g_free (tmp);
  goto <D.17628>;
  <D.17627>:
  monoeg_g_string_append_printf (str, "0x%08x", token);
  <D.17628>:
  ip.27 = ip;
  ip.31 = ip.27 + 4;
  ip = ip.31;
  goto <D.16435>;
  <D.16441>:
  {
    const char * blob;
    char * s;
    size_t len2;
    char * blob2;

    try
      {
        blob2 = 0B;
        D.17630 = method->klass;
        D.17631 = D.17630->image;
        D.17632 = BIT_FIELD_REF <*D.17631, 8, 128>;
        D.17633 = D.17632 & 8;
        if (D.17633 == 0) goto <D.17634>; else goto <D.17635>;
        <D.17634>:
        ip.27 = ip;
        token = MEM[(const guint32 *)ip.27];
        D.17636 = token & 16777215;
        D.17630 = method->klass;
        D.17631 = D.17630->image;
        blob.32 = mono_metadata_user_string (D.17631, D.17636);
        blob = blob.32;
        blob.33 = blob;
        len2 = mono_metadata_decode_blob_size (blob.33, &blob);
        len2 = len2 >> 1;
        blob2 = blob;
        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.17640>; else goto <D.17641>;
        <D.17640>:
        monoeg_g_free (blob2);
        <D.17641>:
        <D.17635>:
        ip.27 = ip;
        ip.31 = ip.27 + 4;
        ip = ip.31;
        goto <D.16435>;
      }
    finally
      {
        blob = {CLOBBER};
      }
  }
  <D.16446>:
  ip.27 = ip;
  D.17642 = MEM[(const guint16 *)ip.27];
  D.17643 = (int) D.17642;
  monoeg_g_string_append_printf (str, "%d", D.17643);
  ip.27 = ip;
  ip.35 = ip.27 + 2;
  ip = ip.35;
  goto <D.16435>;
  <D.16447>:
  ip.27 = ip;
  D.17645 = *ip.27;
  D.17646 = (int) D.17645;
  monoeg_g_string_append_printf (str, "%d", D.17646);
  ip.27 = ip;
  ip.30 = ip.27 + 1;
  ip = ip.30;
  goto <D.16435>;
  <D.16448>:
  ip.27 = ip;
  D.17647 = MEM[(const guint32 *)ip.27];
  sval = (gint32) D.17647;
  ip.27 = ip;
  ip.31 = ip.27 + 4;
  ip = ip.31;
  D.17648 = dh->label_target;
  if (D.17648 != 0B) goto <D.17649>; else goto <D.17650>;
  <D.17649>:
  ip.27 = ip;
  sval.36 = (sizetype) sval;
  D.17652 = ip.27 + sval.36;
  D.17653 = (int) D.17652;
  il_code.29 = (int) il_code;
  D.17654 = D.17653 - il_code.29;
  D.17648 = dh->label_target;
  monoeg_g_string_append_printf (str, D.17648, D.17654);
  goto <D.17655>;
  <D.17650>:
  monoeg_g_string_append_printf (str, "%d", sval);
  <D.17655>:
  goto <D.16435>;
  <D.16449>:
  ip.27 = ip;
  D.17656 = MEM[(const signed char *)ip.27];
  sval = (gint32) D.17656;
  ip.27 = ip;
  ip.30 = ip.27 + 1;
  ip = ip.30;
  D.17648 = dh->label_target;
  if (D.17648 != 0B) goto <D.17657>; else goto <D.17658>;
  <D.17657>:
  ip.27 = ip;
  sval.36 = (sizetype) sval;
  D.17652 = ip.27 + sval.36;
  D.17653 = (int) D.17652;
  il_code.29 = (int) il_code;
  D.17654 = D.17653 - il_code.29;
  D.17648 = dh->label_target;
  monoeg_g_string_append_printf (str, D.17648, D.17654);
  goto <D.17659>;
  <D.17658>:
  monoeg_g_string_append_printf (str, "%d", sval);
  <D.17659>:
  goto <D.16435>;
  <D.16450>:
  {
    const unsigned char * end;

    ip.27 = ip;
    D.17647 = MEM[(const guint32 *)ip.27];
    sval = (gint32) D.17647;
    ip.27 = ip;
    ip.31 = ip.27 + 4;
    ip = ip.31;
    ip.27 = ip;
    D.17660 = sval * 4;
    D.17661 = (sizetype) D.17660;
    end = ip.27 + D.17661;
    monoeg_g_string_append_c (str, 40);
    i = 0;
    goto <D.16453>;
    <D.16452>:
    if (i > 0) goto <D.17662>; else goto <D.17663>;
    <D.17662>:
    monoeg_g_string_append (str, ", ");
    <D.17663>:
    ip.27 = ip;
    label = MEM[(const guint32 *)ip.27];
    D.17648 = dh->label_target;
    if (D.17648 != 0B) goto <D.17664>; else goto <D.17665>;
    <D.17664>:
    D.17666 = end + label;
    D.17667 = (int) D.17666;
    il_code.29 = (int) il_code;
    D.17668 = D.17667 - il_code.29;
    D.17648 = dh->label_target;
    monoeg_g_string_append_printf (str, D.17648, D.17668);
    goto <D.17669>;
    <D.17665>:
    monoeg_g_string_append_printf (str, "%d", label);
    <D.17669>:
    ip.27 = ip;
    ip.31 = ip.27 + 4;
    ip = ip.31;
    i = i + 1;
    <D.16453>:
    if (i < sval) goto <D.16452>; else goto <D.16454>;
    <D.16454>:
    monoeg_g_string_append_c (str, 41);
    goto <D.16435>;
  }
  <D.16455>:
  {
    double r;

    try
      {
        {
          union mono_rdouble mf;

          try
            {
              ip.27 = ip;
              D.17670 = MEM[(const guint64 *)ip.27];
              mf.ival = D.17670;
              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.16435>;
      }
    finally
      {
        r = {CLOBBER};
      }
  }
  <D.16458>:
  {
    float r;

    try
      {
        {
          union mono_rfloat mf;

          try
            {
              ip.27 = ip;
              D.17647 = MEM[(const guint32 *)ip.27];
              mf.ival = D.17647;
              r.40 = mf.fval;
              r = r.40;
            }
          finally
            {
              mf = {CLOBBER};
            }
        }
        r.41 = r;
        D.17676 = (double) r.41;
        monoeg_g_string_append_printf (str, "%g", D.17676);
        ip.27 = ip;
        ip.31 = ip.27 + 4;
        ip = ip.31;
        goto <D.16435>;
      }
    finally
      {
        r = {CLOBBER};
      }
  }
  <D.16461>:
  ip.27 = ip;
  D.17647 = MEM[(const guint32 *)ip.27];
  D.17677 = (int) D.17647;
  monoeg_g_string_append_printf (str, "%d", D.17677);
  ip.27 = ip;
  ip.31 = ip.27 + 4;
  ip = ip.31;
  goto <D.16435>;
  <D.16462>:
  ip.27 = ip;
  D.17656 = MEM[(const signed char *)ip.27];
  D.17678 = (int) D.17656;
  monoeg_g_string_append_printf (str, "%d", D.17678);
  ip.27 = ip;
  ip.30 = ip.27 + 1;
  ip = ip.30;
  goto <D.16435>;
  <D.16463>:
  ip.27 = ip;
  ip.39 = ip.27 + 8;
  ip = ip.39;
  goto <D.16435>;
  <D.16464>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "debug-helpers.c", 684);
  <D.16435>:
  D.17679 = dh->newline;
  if (D.17679 != 0B) goto <D.17680>; else goto <D.17681>;
  <D.17680>:
  D.17679 = dh->newline;
  monoeg_g_string_append (str, D.17679);
  <D.17681>:
  mono_metadata_free_mh (header);
  D.17682 = ip;
  return D.17682;
}


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

  res = monoeg_g_string_new ("");
  if (dh == 0B) goto <D.17688>; else goto <D.17689>;
  <D.17688>:
  dh = &default_dh;
  <D.17689>:
  goto <D.16483>;
  <D.16482>:
  ip = dis_one (res, dh, method, ip, end);
  <D.16483>:
  if (ip < end) goto <D.16482>; else goto <D.16484>;
  <D.16484>:
  result = res->str;
  monoeg_g_string_free (res, 0);
  D.17690 = result;
  return D.17690;
}


mono_field_full_name (struct MonoClassField * field)
{
  struct MonoClass * D.17692;
  const char * D.17693;
  const char * D.17694;
  const char * iftmp.42;
  char D.17696;
  char * D.17700;
  char * res;
  const char * nspace;

  D.17692 = field->parent;
  nspace = D.17692->name_space;
  D.17693 = mono_field_get_name (field);
  D.17692 = field->parent;
  D.17694 = D.17692->name;
  D.17696 = *nspace;
  if (D.17696 != 0) goto <D.17697>; else goto <D.17698>;
  <D.17697>:
  iftmp.42 = ".";
  goto <D.17699>;
  <D.17698>:
  iftmp.42 = "";
  <D.17699>:
  res = monoeg_g_strdup_printf ("%s%s%s:%s", nspace, iftmp.42, D.17694, D.17693);
  D.17700 = res;
  return D.17700;
}


mono_method_full_name (struct MonoMethod * method, gboolean signature)
{
  struct MonoClass * D.17702;
  struct MonoType * D.17703;
  unsigned char D.17706;
  unsigned char D.17707;
  struct MonoGenericInst * D.17709;
  unsigned char D.17711;
  struct MonoGenericInst * D.17714;
  unsigned char D.17715;
  unsigned char D.17716;
  <unnamed-unsigned:5> D.17719;
  unsigned int D.17720;
  const char * D.17721;
  struct MonoMethodSignature * D.17725;
  const char * D.17728;
  const char * iftmp.43;
  const char * D.17734;
  const char * iftmp.44;
  char * D.17740;
  char * res;
  char wrapper[64];
  char * klass_desc;
  char * inst_desc;

  try
    {
      D.17702 = method->klass;
      D.17703 = &D.17702->byval_arg;
      klass_desc = mono_type_full_name (D.17703);
      inst_desc = 0B;
      D.17706 = BIT_FIELD_REF <*method, 8, 168>;
      D.17707 = D.17706 & 16;
      if (D.17707 != 0) goto <D.17708>; else goto <D.17704>;
      <D.17708>:
      D.17709 = MEM[(struct MonoMethodInflated *)method].context.method_inst;
      if (D.17709 != 0B) goto <D.17710>; else goto <D.17704>;
      <D.17710>:
      {
        struct GString * str;

        str = monoeg_g_string_new ("");
        monoeg_g_string_append (str, "<");
        D.17709 = MEM[(struct MonoMethodInflated *)method].context.method_inst;
        ginst_get_desc (str, D.17709);
        monoeg_g_string_append (str, ">");
        inst_desc = str->str;
        monoeg_g_string_free (str, 0);
      }
      goto <D.17705>;
      <D.17704>:
      D.17706 = BIT_FIELD_REF <*method, 8, 168>;
      D.17711 = D.17706 & 8;
      if (D.17711 != 0) goto <D.17712>; else goto <D.17713>;
      <D.17712>:
      {
        struct MonoGenericContainer * container;
        struct GString * str;

        container = mono_method_get_generic_container (method);
        str = monoeg_g_string_new ("");
        monoeg_g_string_append (str, "<");
        D.17714 = container->context.method_inst;
        ginst_get_desc (str, D.17714);
        monoeg_g_string_append (str, ">");
        inst_desc = str->str;
        monoeg_g_string_free (str, 0);
      }
      <D.17713>:
      <D.17705>:
      D.17715 = BIT_FIELD_REF <*method, 8, 160>;
      D.17716 = D.17715 & 124;
      if (D.17716 != 0) goto <D.17717>; else goto <D.17718>;
      <D.17717>:
      D.17719 = method->wrapper_type;
      D.17720 = (unsigned int) D.17719;
      D.17721 = wrapper_type_to_str (D.17720);
      sprintf (&wrapper, "(wrapper %s) ", D.17721);
      goto <D.17722>;
      <D.17718>:
      strcpy (&wrapper, "");
      <D.17722>:
      if (signature != 0) goto <D.17723>; else goto <D.17724>;
      <D.17723>:
      {
        char * tmpsig;

        D.17725 = mono_method_signature (method);
        tmpsig = mono_signature_get_desc (D.17725, 1);
        D.17715 = BIT_FIELD_REF <*method, 8, 160>;
        D.17716 = D.17715 & 124;
        if (D.17716 != 0) goto <D.17726>; else goto <D.17727>;
        <D.17726>:
        D.17719 = method->wrapper_type;
        D.17720 = (unsigned int) D.17719;
        D.17728 = wrapper_type_to_str (D.17720);
        sprintf (&wrapper, "(wrapper %s) ", D.17728);
        goto <D.17729>;
        <D.17727>:
        strcpy (&wrapper, "");
        <D.17729>:
        if (inst_desc != 0B) goto <D.17731>; else goto <D.17732>;
        <D.17731>:
        iftmp.43 = inst_desc;
        goto <D.17733>;
        <D.17732>:
        iftmp.43 = "";
        <D.17733>:
        D.17734 = method->name;
        res = monoeg_g_strdup_printf ("%s%s:%s%s (%s)", &wrapper, klass_desc, D.17734, iftmp.43, tmpsig);
        monoeg_g_free (tmpsig);
      }
      goto <D.17735>;
      <D.17724>:
      if (inst_desc != 0B) goto <D.17737>; else goto <D.17738>;
      <D.17737>:
      iftmp.44 = inst_desc;
      goto <D.17739>;
      <D.17738>:
      iftmp.44 = "";
      <D.17739>:
      D.17734 = method->name;
      res = monoeg_g_strdup_printf ("%s%s:%s%s", &wrapper, klass_desc, D.17734, iftmp.44);
      <D.17735>:
      monoeg_g_free (klass_desc);
      monoeg_g_free (inst_desc);
      D.17740 = res;
      return D.17740;
    }
  finally
    {
      wrapper = {CLOBBER};
    }
}


wrapper_type_to_str (guint32 wrapper_type)
{
  _Bool D.17743;
  long int D.17744;
  long int D.17745;
  const char * D.17748;
  short int D.17749;
  sizetype D.17750;

  D.17743 = wrapper_type > 28;
  D.17744 = (long int) D.17743;
  D.17745 = __builtin_expect (D.17744, 0);
  if (D.17745 != 0) goto <D.17746>; else goto <D.17747>;
  <D.17746>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debug-helpers.c", 51, "wrapper_type < MONO_WRAPPER_NUM");
  <D.17747>:
  D.17749 = opidx[wrapper_type];
  D.17750 = (sizetype) D.17749;
  D.17748 = &opstr + D.17750;
  return D.17748;
}


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

  D.17753 = __builtin_object_size (__s, 1);
  D.17752 = __builtin___sprintf_chk (__s, 1, D.17753, __fmt, __builtin_va_arg_pack ());
  return D.17752;
}


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

  D.17756 = __builtin_object_size (__dest, 1);
  D.17755 = __builtin___strcpy_chk (__dest, __src, D.17756);
  return D.17755;
}


mono_object_describe (struct MonoObject * obj)
{
  struct MonoVTable * D.17760;
  struct MonoClass * D.17761;
  unsigned int D.17764;
  char * D.17767;
  char * D.17768;
  char * D.17769;
  char * D.17770;
  int D.17771;
  unsigned char D.17773;
  const char * D.17776;
  unsigned int D.17777;
  int D.17778;
  int D.17779;
  struct MonoClass * klass;
  const char * sep;

  if (obj == 0B) goto <D.17758>; else goto <D.17759>;
  <D.17758>:
  monoeg_g_print ("(null)\n");
  return;
  <D.17759>:
  D.17760 = obj->vtable;
  klass = D.17760->klass;
  D.17761 = mono_defaults.string_class;
  if (D.17761 == klass) goto <D.17762>; else goto <D.17763>;
  <D.17762>:
  {
    char * utf8;

    utf8 = mono_string_to_utf8 (obj);
    D.17764 = strlen (utf8);
    if (D.17764 > 60) goto <D.17765>; else goto <D.17766>;
    <D.17765>:
    D.17767 = utf8 + 57;
    *D.17767 = 46;
    D.17768 = utf8 + 58;
    *D.17768 = 46;
    D.17769 = utf8 + 59;
    *D.17769 = 46;
    D.17770 = utf8 + 60;
    *D.17770 = 0;
    <D.17766>:
    D.17771 = mono_string_length (obj);
    monoeg_g_print ("String at %p, length: %d, \'%s\'\n", obj, D.17771, utf8);
    monoeg_g_free (utf8);
  }
  goto <D.17772>;
  <D.17763>:
  D.17773 = klass->rank;
  if (D.17773 != 0) goto <D.17774>; else goto <D.17775>;
  <D.17774>:
  {
    struct MonoArray * array;

    array = obj;
    sep = print_name_space (klass);
    D.17776 = klass->name;
    monoeg_g_print ("%s%s", sep, D.17776);
    D.17777 = mono_array_length (array);
    D.17778 = (int) D.17777;
    D.17773 = klass->rank;
    D.17779 = (int) D.17773;
    monoeg_g_print (" at %p, rank: %d, length: %d\n", obj, D.17779, D.17778);
  }
  goto <D.17780>;
  <D.17775>:
  sep = print_name_space (klass);
  D.17776 = klass->name;
  monoeg_g_print ("%s%s", sep, D.17776);
  monoeg_g_print (" object at %p (klass: %p)\n", obj, klass);
  <D.17780>:
  <D.17772>:
}


print_name_space (struct MonoClass * klass)
{
  struct MonoClass * D.17782;
  const char * D.17785;
  const char * D.17786;
  const char * D.17787;
  char D.17788;

  D.17782 = klass->nested_in;
  if (D.17782 != 0B) goto <D.17783>; else goto <D.17784>;
  <D.17783>:
  D.17782 = klass->nested_in;
  print_name_space (D.17782);
  D.17782 = klass->nested_in;
  D.17785 = D.17782->name;
  monoeg_g_print ("%s", D.17785);
  D.17786 = "/";
  return D.17786;
  <D.17784>:
  D.17787 = klass->name_space;
  D.17788 = *D.17787;
  if (D.17788 != 0) goto <D.17789>; else goto <D.17790>;
  <D.17789>:
  D.17787 = klass->name_space;
  monoeg_g_print ("%s", D.17787);
  D.17786 = ".";
  return D.17786;
  <D.17790>:
  D.17786 = "";
  return D.17786;
}


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

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


objval_describe (struct MonoClass * class, const char * addr)
{
  unsigned char D.17793;
  unsigned char D.17794;
  struct MonoType * D.17797;
  short unsigned int D.17798;
  int D.17799;
  int D.17800;
  _Bool D.17803;
  _Bool D.17804;
  _Bool D.17805;
  const char * D.17808;
  int D.17809;
  sizetype D.17810;
  sizetype type_offset.45;
  sizetype D.17812;
  struct MonoClassField * field;
  struct MonoClass * p;
  const char * field_ptr;
  gssize type_offset;

  type_offset = 0;
  D.17793 = BIT_FIELD_REF <*class, 8, 160>;
  D.17794 = D.17793 & 8;
  if (D.17794 != 0) goto <D.17795>; else goto <D.17796>;
  <D.17795>:
  type_offset = -8;
  <D.17796>:
  p = class;
  goto <D.16559>;
  <D.16558>:
  {
    void * iter;
    int printed_header;

    try
      {
        iter = 0B;
        printed_header = 0;
        goto <D.16554>;
        <D.16556>:
        D.17797 = field->type;
        D.17798 = D.17797->attrs;
        D.17799 = (int) D.17798;
        D.17800 = D.17799 & 272;
        if (D.17800 != 0) goto <D.17801>; else goto <D.17802>;
        <D.17801>:
        // predicted unlikely by continue predictor.
        goto <D.16554>;
        <D.17802>:
        D.17803 = p != class;
        D.17804 = printed_header == 0;
        D.17805 = D.17803 & D.17804;
        if (D.17805 != 0) goto <D.17806>; else goto <D.17807>;
        <D.17806>:
        {
          const char * sep;

          monoeg_g_print ("In class ");
          sep = print_name_space (p);
          D.17808 = p->name;
          monoeg_g_print ("%s%s:\n", sep, D.17808);
          printed_header = 1;
        }
        <D.17807>:
        D.17809 = field->offset;
        D.17810 = (sizetype) D.17809;
        type_offset.45 = (sizetype) type_offset;
        D.17812 = D.17810 + type_offset.45;
        field_ptr = addr + D.17812;
        print_field_value (field_ptr, field, type_offset);
        <D.16554>:
        field = mono_class_get_fields (p, &iter);
        if (field != 0B) goto <D.16556>; else goto <D.16557>;
        <D.16557>:
      }
    finally
      {
        iter = {CLOBBER};
      }
  }
  p = p->parent;
  <D.16559>:
  if (p != 0B) goto <D.16558>; else goto <D.16560>;
  <D.16560>:
}


print_field_value (const char * field_ptr, struct MonoClassField * field, int type_offset)
{
  const char * D.17813;
  int D.17814;
  int D.17815;
  struct MonoType * D.17816;
  unsigned char D.17817;
  int D.17818;
  const void * D.17819;
  struct MonoObject * D.17820;
  int D.17821;
  const char * D.17824;
  signed char D.17825;
  int D.17826;
  unsigned char D.17827;
  int D.17828;
  short int D.17829;
  int D.17830;
  short unsigned int D.17831;
  int D.17832;
  int D.17833;
  unsigned int D.17834;
  long long int D.17835;
  long long unsigned int D.17836;
  float D.17837;
  double D.17838;
  double D.17839;
  const char * iftmp.46;
  struct MonoType * type;

  D.17813 = mono_field_get_name (field);
  D.17814 = field->offset;
  D.17815 = D.17814 + type_offset;
  monoeg_g_print ("At %p (ofs: %2d) %s: ", field_ptr, D.17815, D.17813);
  D.17816 = field->type;
  type = mono_type_get_underlying_type (D.17816);
  D.17817 = type->type;
  D.17818 = (int) D.17817;
  switch (D.17818) <default: <D.16543>, case 2: <D.16541>, case 3: <D.16542>, case 4: <D.16531>, case 5: <D.16532>, case 6: <D.16533>, case 7: <D.16534>, case 8: <D.16535>, case 9: <D.16536>, case 10: <D.16537>, case 11: <D.16538>, case 12: <D.16539>, case 13: <D.16540>, case 14: <D.16523>, case 15: <D.16520>, case 17: <D.16529>, case 18: <D.16525>, case 20: <D.16527>, case 21: <D.16528>, case 24: <D.16518>, case 25: <D.16519>, case 27: <D.16521>, case 28: <D.16526>, case 29: <D.16524>>
  <D.16518>:
  <D.16519>:
  <D.16520>:
  <D.16521>:
  D.17819 = MEM[(const void * *)field_ptr];
  monoeg_g_print ("%p\n", D.17819);
  goto <D.16522>;
  <D.16523>:
  <D.16524>:
  <D.16525>:
  <D.16526>:
  <D.16527>:
  D.17820 = MEM[(struct MonoObject * *)field_ptr];
  mono_object_describe (D.17820);
  goto <D.16522>;
  <D.16528>:
  D.17821 = mono_type_generic_inst_is_valuetype (type);
  if (D.17821 == 0) goto <D.17822>; else goto <D.17823>;
  <D.17822>:
  D.17820 = MEM[(struct MonoObject * *)field_ptr];
  mono_object_describe (D.17820);
  goto <D.16522>;
  <D.17823>:
  <D.16529>:
  {
    struct MonoClass * k;

    k = mono_class_from_mono_type (type);
    D.17824 = k->name;
    monoeg_g_print ("%s ValueType (type: %p) at %p\n", D.17824, k, field_ptr);
    goto <D.16522>;
  }
  <D.16531>:
  D.17825 = MEM[(gint8 *)field_ptr];
  D.17826 = (int) D.17825;
  monoeg_g_print ("%d\n", D.17826);
  goto <D.16522>;
  <D.16532>:
  D.17827 = MEM[(guint8 *)field_ptr];
  D.17828 = (int) D.17827;
  monoeg_g_print ("%d\n", D.17828);
  goto <D.16522>;
  <D.16533>:
  D.17829 = MEM[(gint16 *)field_ptr];
  D.17830 = (int) D.17829;
  monoeg_g_print ("%d\n", D.17830);
  goto <D.16522>;
  <D.16534>:
  D.17831 = MEM[(guint16 *)field_ptr];
  D.17832 = (int) D.17831;
  monoeg_g_print ("%d\n", D.17832);
  goto <D.16522>;
  <D.16535>:
  D.17833 = MEM[(gint32 *)field_ptr];
  monoeg_g_print ("%d\n", D.17833);
  goto <D.16522>;
  <D.16536>:
  D.17834 = MEM[(guint32 *)field_ptr];
  monoeg_g_print ("%u\n", D.17834);
  goto <D.16522>;
  <D.16537>:
  D.17835 = MEM[(gint64 *)field_ptr];
  monoeg_g_print ("%lld\n", D.17835);
  goto <D.16522>;
  <D.16538>:
  D.17836 = MEM[(guint64 *)field_ptr];
  monoeg_g_print ("%llu\n", D.17836);
  goto <D.16522>;
  <D.16539>:
  D.17837 = MEM[(gfloat *)field_ptr];
  D.17838 = (double) D.17837;
  monoeg_g_print ("%f\n", D.17838);
  goto <D.16522>;
  <D.16540>:
  D.17839 = MEM[(gdouble *)field_ptr];
  monoeg_g_print ("%f\n", D.17839);
  goto <D.16522>;
  <D.16541>:
  D.17827 = MEM[(guint8 *)field_ptr];
  D.17828 = (int) D.17827;
  D.17827 = MEM[(guint8 *)field_ptr];
  if (D.17827 != 0) goto <D.17841>; else goto <D.17842>;
  <D.17841>:
  iftmp.46 = "True";
  goto <D.17843>;
  <D.17842>:
  iftmp.46 = "False";
  <D.17843>:
  monoeg_g_print ("%s (%d)\n", iftmp.46, D.17828);
  goto <D.16522>;
  <D.16542>:
  D.17831 = MEM[(guint16 *)field_ptr];
  D.17832 = (int) D.17831;
  D.17831 = MEM[(guint16 *)field_ptr];
  D.17832 = (int) D.17831;
  D.17831 = MEM[(guint16 *)field_ptr];
  D.17832 = (int) D.17831;
  monoeg_g_print ("\'%c\' (%d 0x%04x)\n", D.17832, D.17832, D.17832);
  goto <D.16522>;
  <D.16543>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "debug-helpers.c", 928);
  <D.16522>:
}


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


mono_class_describe_statics (struct MonoClass * klass)
{
  struct MonoDomain * D.17844;
  struct MonoType * D.17849;
  short unsigned int D.17850;
  int D.17851;
  int D.17852;
  int D.17855;
  int D.17858;
  sizetype D.17859;
  struct MonoClassField * field;
  struct MonoClass * p;
  const char * field_ptr;
  struct MonoVTable * vtable;
  const char * addr;

  D.17844 = mono_domain_get ();
  vtable = mono_class_vtable_full (D.17844, klass, 0);
  if (vtable == 0B) goto <D.17845>; else goto <D.17846>;
  <D.17845>:
  return;
  <D.17846>:
  addr = mono_vtable_get_static_field_data (vtable);
  if (addr == 0B) goto <D.17847>; else goto <D.17848>;
  <D.17847>:
  return;
  <D.17848>:
  p = klass;
  goto <D.16582>;
  <D.16581>:
  {
    void * iter;

    try
      {
        iter = 0B;
        goto <D.16578>;
        <D.16579>:
        D.17849 = field->type;
        D.17850 = D.17849->attrs;
        D.17851 = (int) D.17850;
        D.17852 = D.17851 & 64;
        if (D.17852 != 0) goto <D.17853>; else goto <D.17854>;
        <D.17853>:
        // predicted unlikely by continue predictor.
        goto <D.16578>;
        <D.17854>:
        D.17849 = field->type;
        D.17850 = D.17849->attrs;
        D.17851 = (int) D.17850;
        D.17855 = D.17851 & 272;
        if (D.17855 == 0) goto <D.17856>; else goto <D.17857>;
        <D.17856>:
        // predicted unlikely by continue predictor.
        goto <D.16578>;
        <D.17857>:
        D.17858 = field->offset;
        D.17859 = (sizetype) D.17858;
        field_ptr = addr + D.17859;
        print_field_value (field_ptr, field, 0);
        <D.16578>:
        field = mono_class_get_fields (p, &iter);
        if (field != 0B) goto <D.16579>; else goto <D.16580>;
        <D.16580>:
      }
    finally
      {
        iter = {CLOBBER};
      }
  }
  p = p->parent;
  <D.16582>:
  if (p != 0B) goto <D.16581>; else goto <D.16583>;
  <D.16583>:
}