mono_type_get_desc (struct GString * res, struct MonoType * type, gboolean include_namespace)
{
  unsigned char D.17479;
  int D.17480;
  struct MonoType * D.17481;
  struct MonoArrayType * D.17482;
  struct MonoClass * D.17483;
  struct MonoType * D.17484;
  unsigned char D.17485;
  int D.17486;
  struct MonoClass * D.17487;
  struct MonoType * D.17488;
  struct MonoGenericClass * D.17489;
  struct MonoClass * D.17490;
  struct MonoType * D.17491;
  struct MonoGenericInst * D.17492;
  struct MonoType * D.17497;
  <unnamed-unsigned:22> D.17498;
  int D.17499;
  struct MonoGenericInst * D.17500;
  struct MonoType * D.17507;
  <unnamed-unsigned:22> D.17508;
  int D.17509;
  struct MonoGenericParam * D.17510;
  struct MonoGenericParamInfo * iftmp.0;
  struct MonoGenericContainer * D.17514;
  const char * D.17520;
  const char * iftmp.1;
  short unsigned int D.17526;
  int D.17527;
  long unsigned int D.17529;
  long unsigned int D.17530;
  int i;

  D.17479 = type->type;
  D.17480 = (int) D.17479;
  switch (D.17480) <default: <D.17151>, case 1: <D.17115>, case 2: <D.17118>, case 3: <D.17117>, case 4: <D.17120>, case 5: <D.17119>, case 6: <D.17122>, case 7: <D.17121>, case 8: <D.17124>, case 9: <D.17123>, case 10: <D.17126>, case 11: <D.17125>, case 12: <D.17130>, case 13: <D.17131>, case 14: <D.17132>, case 15: <D.17134>, case 17: <D.17138>, case 18: <D.17137>, case 19: <D.17147>, case 20: <D.17135>, case 21: <D.17139>, case 22: <D.17150>, case 24: <D.17129>, case 25: <D.17128>, case 27: <D.17127>, case 28: <D.17133>, case 29: <D.17136>, case 30: <D.17148>>
  <D.17115>:
  monoeg_g_string_append (res, "void");
  goto <D.17116>;
  <D.17117>:
  monoeg_g_string_append (res, "char");
  goto <D.17116>;
  <D.17118>:
  monoeg_g_string_append (res, "bool");
  goto <D.17116>;
  <D.17119>:
  monoeg_g_string_append (res, "byte");
  goto <D.17116>;
  <D.17120>:
  monoeg_g_string_append (res, "sbyte");
  goto <D.17116>;
  <D.17121>:
  monoeg_g_string_append (res, "uint16");
  goto <D.17116>;
  <D.17122>:
  monoeg_g_string_append (res, "int16");
  goto <D.17116>;
  <D.17123>:
  monoeg_g_string_append (res, "uint");
  goto <D.17116>;
  <D.17124>:
  monoeg_g_string_append (res, "int");
  goto <D.17116>;
  <D.17125>:
  monoeg_g_string_append (res, "ulong");
  goto <D.17116>;
  <D.17126>:
  monoeg_g_string_append (res, "long");
  goto <D.17116>;
  <D.17127>:
  monoeg_g_string_append (res, "*()");
  goto <D.17116>;
  <D.17128>:
  monoeg_g_string_append (res, "uintptr");
  goto <D.17116>;
  <D.17129>:
  monoeg_g_string_append (res, "intptr");
  goto <D.17116>;
  <D.17130>:
  monoeg_g_string_append (res, "single");
  goto <D.17116>;
  <D.17131>:
  monoeg_g_string_append (res, "double");
  goto <D.17116>;
  <D.17132>:
  monoeg_g_string_append (res, "string");
  goto <D.17116>;
  <D.17133>:
  monoeg_g_string_append (res, "object");
  goto <D.17116>;
  <D.17134>:
  D.17481 = type->data.type;
  mono_type_get_desc (res, D.17481, include_namespace);
  monoeg_g_string_append_c (res, 42);
  goto <D.17116>;
  <D.17135>:
  D.17482 = type->data.array;
  D.17483 = D.17482->eklass;
  D.17484 = &D.17483->byval_arg;
  mono_type_get_desc (res, D.17484, include_namespace);
  D.17482 = type->data.array;
  D.17485 = D.17482->rank;
  D.17486 = (int) D.17485;
  monoeg_g_string_append_printf (res, "[%d]", D.17486);
  goto <D.17116>;
  <D.17136>:
  D.17487 = type->data.klass;
  D.17488 = &D.17487->byval_arg;
  mono_type_get_desc (res, D.17488, include_namespace);
  monoeg_g_string_append (res, "[]");
  goto <D.17116>;
  <D.17137>:
  <D.17138>:
  D.17487 = type->data.klass;
  append_class_name (res, D.17487, include_namespace);
  goto <D.17116>;
  <D.17139>:
  {
    struct MonoGenericContext * context;

    D.17489 = type->data.generic_class;
    D.17490 = D.17489->container_class;
    D.17491 = &D.17490->byval_arg;
    mono_type_get_desc (res, D.17491, include_namespace);
    monoeg_g_string_append (res, "<");
    D.17489 = type->data.generic_class;
    context = &D.17489->context;
    D.17492 = context->class_inst;
    if (D.17492 != 0B) goto <D.17493>; else goto <D.17494>;
    <D.17493>:
    i = 0;
    goto <D.17142>;
    <D.17141>:
    if (i > 0) goto <D.17495>; else goto <D.17496>;
    <D.17495>:
    monoeg_g_string_append (res, ", ");
    <D.17496>:
    D.17492 = context->class_inst;
    D.17497 = D.17492->type_argv[i];
    mono_type_get_desc (res, D.17497, include_namespace);
    i = i + 1;
    <D.17142>:
    D.17492 = context->class_inst;
    D.17498 = D.17492->type_argc;
    D.17499 = (int) D.17498;
    if (D.17499 > i) goto <D.17141>; else goto <D.17143>;
    <D.17143>:
    <D.17494>:
    D.17500 = context->method_inst;
    if (D.17500 != 0B) goto <D.17501>; else goto <D.17502>;
    <D.17501>:
    D.17492 = context->class_inst;
    if (D.17492 != 0B) goto <D.17503>; else goto <D.17504>;
    <D.17503>:
    monoeg_g_string_append (res, "; ");
    <D.17504>:
    i = 0;
    goto <D.17145>;
    <D.17144>:
    if (i > 0) goto <D.17505>; else goto <D.17506>;
    <D.17505>:
    monoeg_g_string_append (res, ", ");
    <D.17506>:
    D.17500 = context->method_inst;
    D.17507 = D.17500->type_argv[i];
    mono_type_get_desc (res, D.17507, include_namespace);
    i = i + 1;
    <D.17145>:
    D.17500 = context->method_inst;
    D.17508 = D.17500->type_argc;
    D.17509 = (int) D.17508;
    if (D.17509 > i) goto <D.17144>; else goto <D.17146>;
    <D.17146>:
    <D.17502>:
    monoeg_g_string_append (res, ">");
    goto <D.17116>;
  }
  <D.17147>:
  <D.17148>:
  D.17510 = type->data.generic_param;
  if (D.17510 != 0B) goto <D.17511>; else goto <D.17512>;
  <D.17511>:
  {
    struct MonoGenericParamInfo * info;

    D.17510 = type->data.generic_param;
    D.17514 = D.17510->owner;
    if (D.17514 != 0B) goto <D.17515>; else goto <D.17516>;
    <D.17515>:
    D.17510 = type->data.generic_param;
    iftmp.0 = &MEM[(struct MonoGenericParamFull *)D.17510].info;
    goto <D.17517>;
    <D.17516>:
    iftmp.0 = 0B;
    <D.17517>:
    info = iftmp.0;
    if (info != 0B) goto <D.17518>; else goto <D.17519>;
    <D.17518>:
    D.17520 = info->name;
    monoeg_g_string_append (res, D.17520);
    goto <D.17521>;
    <D.17519>:
    D.17479 = type->type;
    if (D.17479 == 19) goto <D.17523>; else goto <D.17524>;
    <D.17523>:
    iftmp.1 = "!";
    goto <D.17525>;
    <D.17524>:
    iftmp.1 = "!!";
    <D.17525>:
    D.17510 = type->data.generic_param;
    D.17526 = D.17510->num;
    D.17527 = (int) D.17526;
    monoeg_g_string_append_printf (res, "%s%d", iftmp.1, D.17527);
    <D.17521>:
  }
  goto <D.17528>;
  <D.17512>:
  monoeg_g_string_append (res, "<unknown>");
  <D.17528>:
  goto <D.17116>;
  <D.17150>:
  monoeg_g_string_append (res, "typedbyref");
  goto <D.17116>;
  <D.17151>:
  goto <D.17116>;
  <D.17116>:
  D.17529 = BIT_FIELD_REF <*type, 64, 64>;
  D.17530 = D.17529 & 1073741824;
  if (D.17530 != 0) goto <D.17531>; else goto <D.17532>;
  <D.17531>:
  monoeg_g_string_append_c (res, 38);
  <D.17532>:
}


append_class_name (struct GString * res, struct MonoClass * class, gboolean include_namespace)
{
  struct MonoClass * D.17536;
  const char * D.17541;
  char D.17542;
  const char * D.17545;

  if (class == 0B) goto <D.17534>; else goto <D.17535>;
  <D.17534>:
  monoeg_g_string_append (res, "Unknown");
  return;
  <D.17535>:
  D.17536 = class->nested_in;
  if (D.17536 != 0B) goto <D.17537>; else goto <D.17538>;
  <D.17537>:
  D.17536 = class->nested_in;
  append_class_name (res, D.17536, include_namespace);
  monoeg_g_string_append_c (res, 47);
  <D.17538>:
  if (include_namespace != 0) goto <D.17539>; else goto <D.17540>;
  <D.17539>:
  D.17541 = class->name_space;
  D.17542 = *D.17541;
  if (D.17542 != 0) goto <D.17543>; else goto <D.17544>;
  <D.17543>:
  D.17541 = class->name_space;
  monoeg_g_string_append_printf (res, "%s.", D.17541);
  <D.17544>:
  <D.17540>:
  D.17545 = class->name;
  monoeg_g_string_append_printf (res, "%s", D.17545);
}


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

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


mono_signature_get_desc (struct MonoMethodSignature * sig, gboolean include_namespace)
{
  char * D.17551;
  struct MonoType * D.17554;
  short unsigned int D.17555;
  int D.17556;
  int i;
  char * result;
  struct GString * res;

  if (sig == 0B) goto <D.17549>; else goto <D.17550>;
  <D.17549>:
  D.17551 = monoeg_strdup ("<invalid signature>");
  return D.17551;
  <D.17550>:
  res = monoeg_g_string_new ("");
  i = 0;
  goto <D.17164>;
  <D.17163>:
  if (i > 0) goto <D.17552>; else goto <D.17553>;
  <D.17552>:
  monoeg_g_string_append_c (res, 44);
  <D.17553>:
  D.17554 = sig->params[i];
  mono_type_get_desc (res, D.17554, include_namespace);
  i = i + 1;
  <D.17164>:
  D.17555 = sig->param_count;
  D.17556 = (int) D.17555;
  if (D.17556 > i) goto <D.17163>; else goto <D.17165>;
  <D.17165>:
  result = res->str;
  monoeg_g_string_free (res, 0);
  D.17551 = result;
  return D.17551;
}


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

  if (str != 0B) goto <D.17558>; else goto <D.17559>;
  <D.17558>:
  D.17560 = __strdup (str);
  return D.17560;
  <D.17559>:
  D.17560 = 0B;
  return D.17560;
}


mono_context_get_desc (struct MonoGenericContext * context)
{
  struct MonoGenericInst * D.17562;
  struct MonoGenericInst * D.17565;
  char * D.17570;
  char * D.17571;
  struct GString * str;
  char * res;

  str = monoeg_g_string_new ("");
  monoeg_g_string_append (str, "<");
  D.17562 = context->class_inst;
  if (D.17562 != 0B) goto <D.17563>; else goto <D.17564>;
  <D.17563>:
  D.17562 = context->class_inst;
  ginst_get_desc (str, D.17562);
  <D.17564>:
  D.17565 = context->method_inst;
  if (D.17565 != 0B) goto <D.17566>; else goto <D.17567>;
  <D.17566>:
  D.17562 = context->class_inst;
  if (D.17562 != 0B) goto <D.17568>; else goto <D.17569>;
  <D.17568>:
  monoeg_g_string_append (str, "; ");
  <D.17569>:
  D.17565 = context->method_inst;
  ginst_get_desc (str, D.17565);
  <D.17567>:
  monoeg_g_string_append (str, ">");
  D.17570 = str->str;
  res = monoeg_strdup (D.17570);
  monoeg_g_string_free (str, 1);
  D.17571 = res;
  return D.17571;
}


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

  i = 0;
  goto <D.17172>;
  <D.17171>:
  if (i > 0) goto <D.17573>; else goto <D.17574>;
  <D.17573>:
  monoeg_g_string_append (str, ", ");
  <D.17574>:
  D.17575 = ginst->type_argv[i];
  mono_type_get_desc (str, D.17575, 1);
  i = i + 1;
  <D.17172>:
  D.17576 = ginst->type_argc;
  D.17577 = (int) D.17576;
  if (D.17577 > i) goto <D.17171>; else goto <D.17173>;
  <D.17173>:
}


mono_method_desc_new (const char * name, gboolean include_namespace)
{
  char * D.17582;
  char D.17583;
  char * use_args.2;
  struct MonoMethodDesc * D.17589;
  char * D.17594;
  char D.17595;
  char * method_name.3;
  char * class_name.4;
  char * iftmp.5;
  char * D.17607;
  char * D.17608;
  char * D.17611;
  char * D.17612;
  char D.17617;
  unsigned int D.17622;
  unsigned int D.17623;
  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.17578>; else goto <D.17579>;
  <D.17578>:
  if (use_args > class_nspace) goto <D.17580>; else goto <D.17581>;
  <D.17580>:
  D.17582 = use_args + 18446744073709551615;
  D.17583 = *D.17582;
  if (D.17583 == 32) goto <D.17584>; else goto <D.17585>;
  <D.17584>:
  D.17582 = use_args + 18446744073709551615;
  *D.17582 = 0;
  <D.17585>:
  <D.17581>:
  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.17587>; else goto <D.17588>;
  <D.17587>:
  monoeg_g_free (class_nspace);
  D.17589 = 0B;
  return D.17589;
  <D.17588>:
  *end = 0;
  <D.17579>:
  method_name = strrchr (class_nspace, 58);
  if (method_name == 0B) goto <D.17590>; else goto <D.17591>;
  <D.17590>:
  monoeg_g_free (class_nspace);
  D.17589 = 0B;
  return D.17589;
  <D.17591>:
  if (method_name != class_nspace) goto <D.17592>; else goto <D.17593>;
  <D.17592>:
  D.17594 = method_name + 18446744073709551615;
  D.17595 = *D.17594;
  if (D.17595 == 58) goto <D.17596>; else goto <D.17597>;
  <D.17596>:
  D.17594 = method_name + 18446744073709551615;
  *D.17594 = 0;
  <D.17597>:
  <D.17593>:
  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.17599>; else goto <D.17600>;
  <D.17599>:
  class_name.4 = class_name;
  class_name = class_name.4 + 1;
  *class_name.4 = 0;
  use_namespace = 1;
  goto <D.17602>;
  <D.17600>:
  class_name = class_nspace;
  use_namespace = 0;
  <D.17602>:
  result = monoeg_malloc0 (48);
  result->include_namespace = include_namespace;
  result->name = method_name;
  result->klass = class_name;
  if (use_namespace != 0) goto <D.17604>; else goto <D.17605>;
  <D.17604>:
  iftmp.5 = class_nspace;
  goto <D.17606>;
  <D.17605>:
  iftmp.5 = 0B;
  <D.17606>:
  result->namespace = iftmp.5;
  result->args = use_args;
  D.17607 = result->name;
  D.17608 = __builtin_strchr (D.17607, 42);
  if (D.17608 != 0B) goto <D.17609>; else goto <D.17610>;
  <D.17609>:
  result->name_glob = 1;
  <D.17610>:
  D.17611 = result->klass;
  D.17612 = __builtin_strchr (D.17611, 42);
  if (D.17612 != 0B) goto <D.17613>; else goto <D.17614>;
  <D.17613>:
  result->klass_glob = 1;
  <D.17614>:
  if (use_args != 0B) goto <D.17615>; else goto <D.17616>;
  <D.17615>:
  end = use_args;
  D.17617 = *end;
  if (D.17617 != 0) goto <D.17618>; else goto <D.17619>;
  <D.17618>:
  result->num_args = 1;
  <D.17619>:
  goto <D.17191>;
  <D.17190>:
  D.17617 = *end;
  if (D.17617 == 44) goto <D.17620>; else goto <D.17621>;
  <D.17620>:
  D.17622 = result->num_args;
  D.17623 = D.17622 + 1;
  result->num_args = D.17623;
  <D.17621>:
  end = end + 1;
  <D.17191>:
  D.17617 = *end;
  if (D.17617 != 0) goto <D.17190>; else goto <D.17192>;
  <D.17192>:
  <D.17616>:
  D.17589 = result;
  return D.17589;
}


mono_method_desc_from_method (struct MonoMethod * method)
{
  const char * D.17625;
  gchar * D.17626;
  struct MonoClass * D.17627;
  const char * D.17628;
  gchar * D.17629;
  const char * D.17630;
  gchar * D.17631;
  struct MonoMethodDesc * D.17632;
  struct MonoMethodDesc * result;

  result = monoeg_malloc0 (48);
  result->include_namespace = 1;
  D.17625 = method->name;
  D.17626 = monoeg_strdup (D.17625);
  result->name = D.17626;
  D.17627 = method->klass;
  D.17628 = D.17627->name;
  D.17629 = monoeg_strdup (D.17628);
  result->klass = D.17629;
  D.17627 = method->klass;
  D.17630 = D.17627->name_space;
  D.17631 = monoeg_strdup (D.17630);
  result->namespace = D.17631;
  D.17632 = result;
  return D.17632;
}


mono_method_desc_free (struct MonoMethodDesc * desc)
{
  char * D.17634;
  char * D.17638;

  D.17634 = desc->namespace;
  if (D.17634 != 0B) goto <D.17635>; else goto <D.17636>;
  <D.17635>:
  D.17634 = desc->namespace;
  monoeg_g_free (D.17634);
  goto <D.17637>;
  <D.17636>:
  D.17638 = desc->klass;
  if (D.17638 != 0B) goto <D.17639>; else goto <D.17640>;
  <D.17639>:
  D.17638 = desc->klass;
  monoeg_g_free (D.17638);
  <D.17640>:
  <D.17637>:
  monoeg_g_free (desc);
}


mono_method_desc_match (struct MonoMethodDesc * desc, struct MonoMethod * method)
{
  int D.17214;
  char * D.17641;
  const char * D.17642;
  _Bool D.17643;
  mono_bool D.17646;
  char * D.17647;
  unsigned int D.17650;
  struct MonoMethodSignature * D.17651;
  short unsigned int D.17652;
  unsigned int D.17653;
  struct MonoMethodSignature * D.17656;
  int D.17657;
  int D.17223;
  char * sig;
  gboolean name_match;

  {
    size_t __s1_len;
    size_t __s2_len;

    D.17641 = desc->name;
    D.17642 = method->name;
    D.17214 = __builtin_strcmp (D.17641, D.17642);
  }
  D.17643 = D.17214 == 0;
  name_match = (gboolean) D.17643;
  if (name_match == 0) goto <D.17644>; else goto <D.17645>;
  <D.17644>:
  D.17646 = 0;
  return D.17646;
  <D.17645>:
  D.17647 = desc->args;
  if (D.17647 == 0B) goto <D.17648>; else goto <D.17649>;
  <D.17648>:
  D.17646 = 1;
  return D.17646;
  <D.17649>:
  D.17650 = desc->num_args;
  D.17651 = mono_method_signature (method);
  D.17652 = D.17651->param_count;
  D.17653 = (unsigned int) D.17652;
  if (D.17650 != D.17653) goto <D.17654>; else goto <D.17655>;
  <D.17654>:
  D.17646 = 0;
  return D.17646;
  <D.17655>:
  D.17656 = mono_method_signature (method);
  D.17657 = desc->include_namespace;
  sig = mono_signature_get_desc (D.17656, D.17657);
  {
    size_t __s1_len;
    size_t __s2_len;

    D.17647 = desc->args;
    D.17223 = __builtin_strcmp (sig, D.17647);
  }
  if (D.17223 != 0) goto <D.17658>; else goto <D.17659>;
  <D.17658>:
  monoeg_g_free (sig);
  D.17646 = 0;
  return D.17646;
  <D.17659>:
  monoeg_g_free (sig);
  D.17646 = 1;
  return D.17646;
}


mono_method_desc_full_match (struct MonoMethodDesc * desc, struct MonoMethod * method)
{
  char * D.17661;
  mono_bool D.17664;
  long unsigned int D.17665;
  int D.17666;
  struct MonoClass * D.17667;
  int D.17668;

  D.17661 = desc->klass;
  if (D.17661 == 0B) goto <D.17662>; else goto <D.17663>;
  <D.17662>:
  D.17664 = 0;
  return D.17664;
  <D.17663>:
  D.17661 = desc->klass;
  D.17665 = strlen (D.17661);
  D.17666 = (int) D.17665;
  D.17667 = method->klass;
  D.17668 = match_class (desc, D.17666, D.17667);
  if (D.17668 == 0) goto <D.17669>; else goto <D.17670>;
  <D.17669>:
  D.17664 = 0;
  return D.17664;
  <D.17670>:
  D.17664 = mono_method_desc_match (desc, method);
  return D.17664;
}


match_class (struct MonoMethodDesc * desc, int pos, struct MonoClass * klass)
{
  int D.17672;
  int D.17248;
  int iftmp.6;
  int D.17247;
  const char[2] * D.17678;
  unsigned char D.17679;
  int D.17680;
  unsigned char D.17681;
  int D.17682;
  const unsigned char * D.17687;
  unsigned char D.17688;
  int D.17689;
  const unsigned char * D.17690;
  unsigned char D.17691;
  int D.17692;
  const unsigned char * D.17697;
  unsigned char D.17698;
  int D.17699;
  const unsigned char * D.17700;
  unsigned char D.17701;
  int D.17702;
  const unsigned char * D.17707;
  unsigned char D.17708;
  int D.17709;
  const unsigned char * D.17710;
  unsigned char D.17711;
  int D.17712;
  char * D.17714;
  gboolean D.17717;
  const char * D.17720;
  int pos.7;
  long unsigned int D.17722;
  int D.17723;
  char * D.17726;
  int D.17266;
  const char * D.17729;
  int D.17275;
  const char * D.17732;
  struct MonoClass * D.17735;
  const char * p;

  D.17672 = desc->klass_glob;
  if (D.17672 != 0) goto <D.17673>; else goto <D.17674>;
  <D.17673>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = desc->klass;
      D.17678 = "*";
      D.17679 = MEM[(const unsigned char *)D.17678];
      D.17680 = (int) D.17679;
      D.17681 = *__s2;
      D.17682 = (int) D.17681;
      __result = D.17680 - D.17682;
      {
        if (__s2_len != 0) goto <D.17683>; else goto <D.17684>;
        <D.17683>:
        if (__result == 0) goto <D.17685>; else goto <D.17686>;
        <D.17685>:
        D.17687 = &MEM[(void *)"*" + 1B];
        D.17688 = *D.17687;
        D.17689 = (int) D.17688;
        D.17690 = __s2 + 1;
        D.17691 = *D.17690;
        D.17692 = (int) D.17691;
        __result = D.17689 - D.17692;
        if (__s2_len > 1) goto <D.17693>; else goto <D.17694>;
        <D.17693>:
        if (__result == 0) goto <D.17695>; else goto <D.17696>;
        <D.17695>:
        D.17697 = &MEM[(void *)"*" + 2B];
        D.17698 = *D.17697;
        D.17699 = (int) D.17698;
        D.17700 = __s2 + 2;
        D.17701 = *D.17700;
        D.17702 = (int) D.17701;
        __result = D.17699 - D.17702;
        if (__s2_len > 2) goto <D.17703>; else goto <D.17704>;
        <D.17703>:
        if (__result == 0) goto <D.17705>; else goto <D.17706>;
        <D.17705>:
        D.17707 = &MEM[(void *)"*" + 3B];
        D.17708 = *D.17707;
        D.17709 = (int) D.17708;
        D.17710 = __s2 + 3;
        D.17711 = *D.17710;
        D.17712 = (int) D.17711;
        __result = D.17709 - D.17712;
        <D.17706>:
        <D.17704>:
        <D.17696>:
        <D.17694>:
        <D.17686>:
        <D.17684>:
      }
      D.17247 = __result;
    }
    iftmp.6 = -D.17247;
    goto <D.17713>;
    <D.17677>:
    D.17714 = desc->klass;
    iftmp.6 = __builtin_strcmp (D.17714, "*");
    <D.17713>:
    D.17248 = iftmp.6;
  }
  if (D.17248 == 0) goto <D.17715>; else goto <D.17716>;
  <D.17715>:
  D.17717 = 1;
  return D.17717;
  <D.17716>:
  <D.17674>:
  D.17714 = desc->klass;
  p = my_strrchr (D.17714, 47, &pos);
  if (p == 0B) goto <D.17718>; else goto <D.17719>;
  <D.17718>:
  D.17714 = desc->klass;
  D.17720 = klass->name;
  pos.7 = pos;
  D.17722 = (long unsigned int) pos.7;
  D.17723 = strncmp (D.17714, D.17720, D.17722);
  if (D.17723 != 0) goto <D.17724>; else goto <D.17725>;
  <D.17724>:
  D.17717 = 0;
  return D.17717;
  <D.17725>:
  D.17726 = desc->namespace;
  if (D.17726 != 0B) goto <D.17727>; else goto <D.17728>;
  <D.17727>:
  {
    size_t __s1_len;
    size_t __s2_len;

    D.17726 = desc->namespace;
    D.17729 = klass->name_space;
    D.17266 = __builtin_strcmp (D.17726, D.17729);
  }
  if (D.17266 != 0) goto <D.17730>; else goto <D.17731>;
  <D.17730>:
  D.17717 = 0;
  return D.17717;
  <D.17731>:
  <D.17728>:
  D.17717 = 1;
  return D.17717;
  <D.17719>:
  {
    size_t __s1_len;
    size_t __s2_len;

    D.17732 = p + 1;
    D.17720 = klass->name;
    D.17275 = __builtin_strcmp (D.17732, D.17720);
  }
  if (D.17275 != 0) goto <D.17733>; else goto <D.17734>;
  <D.17733>:
  D.17717 = 0;
  return D.17717;
  <D.17734>:
  D.17735 = klass->nested_in;
  if (D.17735 == 0B) goto <D.17736>; else goto <D.17737>;
  <D.17736>:
  D.17717 = 0;
  return D.17717;
  <D.17737>:
  pos.7 = pos;
  D.17735 = klass->nested_in;
  D.17717 = match_class (desc, pos.7, D.17735);
  return D.17717;
}


my_strrchr (const char * str, char ch, int * len)
{
  int D.17739;
  sizetype D.17740;
  const char * D.17741;
  char D.17742;
  const char * D.17745;
  int pos;

  D.17739 = *len;
  pos = D.17739 + -1;
  goto <D.17232>;
  <D.17231>:
  D.17740 = (sizetype) pos;
  D.17741 = str + D.17740;
  D.17742 = *D.17741;
  if (D.17742 != ch) goto <D.17743>; else goto <D.17744>;
  <D.17743>:
  // predicted unlikely by continue predictor.
  goto <D.17230>;
  <D.17744>:
  *len = pos;
  D.17740 = (sizetype) pos;
  D.17745 = str + D.17740;
  return D.17745;
  <D.17230>:
  pos = pos + -1;
  <D.17232>:
  if (pos >= 0) goto <D.17231>; else goto <D.17233>;
  <D.17233>:
  D.17745 = 0B;
  return D.17745;
}


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

  try
    {
      iter = 0B;
      goto <D.17287>;
      <D.17286>:
      D.17747 = mono_method_desc_match (desc, m);
      if (D.17747 != 0) goto <D.17748>; else goto <D.17749>;
      <D.17748>:
      D.17750 = m;
      return D.17750;
      <D.17749>:
      <D.17287>:
      m = mono_class_get_methods (klass, &iter);
      if (m != 0B) goto <D.17286>; else goto <D.17288>;
      <D.17288>:
      D.17750 = 0B;
      return D.17750;
    }
  finally
    {
      iter = {CLOBBER};
    }
}


mono_method_desc_search_in_image (struct MonoMethodDesc * desc, struct MonoImage * image)
{
  char * D.17753;
  struct MonoImage * D.17756;
  char * D.17759;
  struct MonoMethod * D.17762;
  int D.17308;
  char * D.17769;
  int D.17772;
  int D.17773;
  unsigned int D.17774;
  int D.17775;
  int D.17778;
  struct MonoClass * klass;
  const struct MonoTableInfo * tdef;
  const struct MonoTableInfo * methods;
  struct MonoMethod * method;
  int i;

  D.17753 = desc->namespace;
  if (D.17753 == 0B) goto <D.17754>; else goto <D.17755>;
  <D.17754>:
  D.17756 = mono_defaults.corlib;
  if (D.17756 == image) goto <D.17757>; else goto <D.17758>;
  <D.17757>:
  D.17759 = desc->klass;
  klass = find_system_class (D.17759);
  if (klass != 0B) goto <D.17760>; else goto <D.17761>;
  <D.17760>:
  D.17762 = mono_method_desc_search_in_class (desc, klass);
  return D.17762;
  <D.17761>:
  <D.17758>:
  <D.17755>:
  D.17753 = desc->namespace;
  if (D.17753 != 0B) goto <D.17763>; else goto <D.17764>;
  <D.17763>:
  D.17759 = desc->klass;
  if (D.17759 != 0B) goto <D.17765>; else goto <D.17766>;
  <D.17765>:
  D.17753 = desc->namespace;
  D.17759 = desc->klass;
  klass = mono_class_from_name (image, D.17753, D.17759);
  if (klass == 0B) goto <D.17767>; else goto <D.17768>;
  <D.17767>:
  D.17762 = 0B;
  return D.17762;
  <D.17768>:
  D.17762 = mono_method_desc_search_in_class (desc, klass);
  return D.17762;
  <D.17766>:
  <D.17764>:
  tdef = mono_image_get_table_info (image, 2);
  methods = mono_image_get_table_info (image, 6);
  i = 0;
  goto <D.17311>;
  <D.17310>:
  {
    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.17769 = desc->name;
      D.17308 = __builtin_strcmp (n, D.17769);
    }
    if (D.17308 != 0) goto <D.17770>; else goto <D.17771>;
    <D.17770>:
    // predicted unlikely by continue predictor.
    goto <D.17309>;
    <D.17771>:
    D.17772 = i + 1;
    D.17773 = D.17772 | 100663296;
    D.17774 = (unsigned int) D.17773;
    method = mono_get_method (image, D.17774, 0B);
    D.17775 = mono_method_desc_full_match (desc, method);
    if (D.17775 != 0) goto <D.17776>; else goto <D.17777>;
    <D.17776>:
    D.17762 = method;
    return D.17762;
    <D.17777>:
  }
  <D.17309>:
  i = i + 1;
  <D.17311>:
  D.17778 = mono_table_info_get_rows (methods);
  if (D.17778 > i) goto <D.17310>; else goto <D.17312>;
  <D.17312>:
  D.17762 = 0B;
  return D.17762;
}


find_system_class (const char * name)
{
  int D.16964;
  int iftmp.8;
  int D.16963;
  const char[5] * D.17783;
  unsigned char D.17784;
  int D.17785;
  unsigned char D.17786;
  int D.17787;
  const unsigned char * D.17792;
  unsigned char D.17793;
  int D.17794;
  const unsigned char * D.17795;
  unsigned char D.17796;
  int D.17797;
  const unsigned char * D.17802;
  unsigned char D.17803;
  int D.17804;
  const unsigned char * D.17805;
  unsigned char D.17806;
  int D.17807;
  const unsigned char * D.17812;
  unsigned char D.17813;
  int D.17814;
  const unsigned char * D.17815;
  unsigned char D.17816;
  int D.17817;
  struct MonoClass * D.17821;
  int D.16973;
  int iftmp.9;
  int D.16972;
  const char[5] * D.17825;
  unsigned char D.17826;
  int D.17827;
  unsigned char D.17828;
  int D.17829;
  const unsigned char * D.17834;
  unsigned char D.17835;
  int D.17836;
  const unsigned char * D.17837;
  unsigned char D.17838;
  int D.17839;
  const unsigned char * D.17844;
  unsigned char D.17845;
  int D.17846;
  const unsigned char * D.17847;
  unsigned char D.17848;
  int D.17849;
  const unsigned char * D.17854;
  unsigned char D.17855;
  int D.17856;
  const unsigned char * D.17857;
  unsigned char D.17858;
  int D.17859;
  int D.16982;
  int iftmp.10;
  int D.16981;
  const char[5] * D.17866;
  unsigned char D.17867;
  int D.17868;
  unsigned char D.17869;
  int D.17870;
  const unsigned char * D.17875;
  unsigned char D.17876;
  int D.17877;
  const unsigned char * D.17878;
  unsigned char D.17879;
  int D.17880;
  const unsigned char * D.17885;
  unsigned char D.17886;
  int D.17887;
  const unsigned char * D.17888;
  unsigned char D.17889;
  int D.17890;
  const unsigned char * D.17895;
  unsigned char D.17896;
  int D.17897;
  const unsigned char * D.17898;
  unsigned char D.17899;
  int D.17900;
  int D.16991;
  int iftmp.11;
  int D.16990;
  const char[5] * D.17907;
  unsigned char D.17908;
  int D.17909;
  unsigned char D.17910;
  int D.17911;
  const unsigned char * D.17916;
  unsigned char D.17917;
  int D.17918;
  const unsigned char * D.17919;
  unsigned char D.17920;
  int D.17921;
  const unsigned char * D.17926;
  unsigned char D.17927;
  int D.17928;
  const unsigned char * D.17929;
  unsigned char D.17930;
  int D.17931;
  const unsigned char * D.17936;
  unsigned char D.17937;
  int D.17938;
  const unsigned char * D.17939;
  unsigned char D.17940;
  int D.17941;
  int D.17000;
  int iftmp.12;
  int D.16999;
  const char[6] * D.17948;
  unsigned char D.17949;
  int D.17950;
  unsigned char D.17951;
  int D.17952;
  const unsigned char * D.17957;
  unsigned char D.17958;
  int D.17959;
  const unsigned char * D.17960;
  unsigned char D.17961;
  int D.17962;
  const unsigned char * D.17967;
  unsigned char D.17968;
  int D.17969;
  const unsigned char * D.17970;
  unsigned char D.17971;
  int D.17972;
  const unsigned char * D.17977;
  unsigned char D.17978;
  int D.17979;
  const unsigned char * D.17980;
  unsigned char D.17981;
  int D.17982;
  int D.17009;
  int iftmp.13;
  int D.17008;
  const char[7] * D.17989;
  unsigned char D.17990;
  int D.17991;
  unsigned char D.17992;
  int D.17993;
  const unsigned char * D.17998;
  unsigned char D.17999;
  int D.18000;
  const unsigned char * D.18001;
  unsigned char D.18002;
  int D.18003;
  const unsigned char * D.18008;
  unsigned char D.18009;
  int D.18010;
  const unsigned char * D.18011;
  unsigned char D.18012;
  int D.18013;
  const unsigned char * D.18018;
  unsigned char D.18019;
  int D.18020;
  const unsigned char * D.18021;
  unsigned char D.18022;
  int D.18023;
  int D.17018;
  int iftmp.14;
  int D.17017;
  const char[6] * D.18030;
  unsigned char D.18031;
  int D.18032;
  unsigned char D.18033;
  int D.18034;
  const unsigned char * D.18039;
  unsigned char D.18040;
  int D.18041;
  const unsigned char * D.18042;
  unsigned char D.18043;
  int D.18044;
  const unsigned char * D.18049;
  unsigned char D.18050;
  int D.18051;
  const unsigned char * D.18052;
  unsigned char D.18053;
  int D.18054;
  const unsigned char * D.18059;
  unsigned char D.18060;
  int D.18061;
  const unsigned char * D.18062;
  unsigned char D.18063;
  int D.18064;
  int D.17027;
  int iftmp.15;
  int D.17026;
  const char[5] * D.18071;
  unsigned char D.18072;
  int D.18073;
  unsigned char D.18074;
  int D.18075;
  const unsigned char * D.18080;
  unsigned char D.18081;
  int D.18082;
  const unsigned char * D.18083;
  unsigned char D.18084;
  int D.18085;
  const unsigned char * D.18090;
  unsigned char D.18091;
  int D.18092;
  const unsigned char * D.18093;
  unsigned char D.18094;
  int D.18095;
  const unsigned char * D.18100;
  unsigned char D.18101;
  int D.18102;
  const unsigned char * D.18103;
  unsigned char D.18104;
  int D.18105;
  int D.17036;
  int iftmp.16;
  int D.17035;
  const char[4] * D.18112;
  unsigned char D.18113;
  int D.18114;
  unsigned char D.18115;
  int D.18116;
  const unsigned char * D.18121;
  unsigned char D.18122;
  int D.18123;
  const unsigned char * D.18124;
  unsigned char D.18125;
  int D.18126;
  const unsigned char * D.18131;
  unsigned char D.18132;
  int D.18133;
  const unsigned char * D.18134;
  unsigned char D.18135;
  int D.18136;
  const unsigned char * D.18141;
  unsigned char D.18142;
  int D.18143;
  const unsigned char * D.18144;
  unsigned char D.18145;
  int D.18146;
  int D.17045;
  int iftmp.17;
  int D.17044;
  const char[6] * D.18153;
  unsigned char D.18154;
  int D.18155;
  unsigned char D.18156;
  int D.18157;
  const unsigned char * D.18162;
  unsigned char D.18163;
  int D.18164;
  const unsigned char * D.18165;
  unsigned char D.18166;
  int D.18167;
  const unsigned char * D.18172;
  unsigned char D.18173;
  int D.18174;
  const unsigned char * D.18175;
  unsigned char D.18176;
  int D.18177;
  const unsigned char * D.18182;
  unsigned char D.18183;
  int D.18184;
  const unsigned char * D.18185;
  unsigned char D.18186;
  int D.18187;
  int D.17054;
  int iftmp.18;
  int D.17053;
  const char[5] * D.18194;
  unsigned char D.18195;
  int D.18196;
  unsigned char D.18197;
  int D.18198;
  const unsigned char * D.18203;
  unsigned char D.18204;
  int D.18205;
  const unsigned char * D.18206;
  unsigned char D.18207;
  int D.18208;
  const unsigned char * D.18213;
  unsigned char D.18214;
  int D.18215;
  const unsigned char * D.18216;
  unsigned char D.18217;
  int D.18218;
  const unsigned char * D.18223;
  unsigned char D.18224;
  int D.18225;
  const unsigned char * D.18226;
  unsigned char D.18227;
  int D.18228;
  int D.17063;
  int iftmp.19;
  int D.17062;
  const char[8] * D.18235;
  unsigned char D.18236;
  int D.18237;
  unsigned char D.18238;
  int D.18239;
  const unsigned char * D.18244;
  unsigned char D.18245;
  int D.18246;
  const unsigned char * D.18247;
  unsigned char D.18248;
  int D.18249;
  const unsigned char * D.18254;
  unsigned char D.18255;
  int D.18256;
  const unsigned char * D.18257;
  unsigned char D.18258;
  int D.18259;
  const unsigned char * D.18264;
  unsigned char D.18265;
  int D.18266;
  const unsigned char * D.18267;
  unsigned char D.18268;
  int D.18269;
  int D.17072;
  int iftmp.20;
  int D.17071;
  const char[7] * D.18276;
  unsigned char D.18277;
  int D.18278;
  unsigned char D.18279;
  int D.18280;
  const unsigned char * D.18285;
  unsigned char D.18286;
  int D.18287;
  const unsigned char * D.18288;
  unsigned char D.18289;
  int D.18290;
  const unsigned char * D.18295;
  unsigned char D.18296;
  int D.18297;
  const unsigned char * D.18298;
  unsigned char D.18299;
  int D.18300;
  const unsigned char * D.18305;
  unsigned char D.18306;
  int D.18307;
  const unsigned char * D.18308;
  unsigned char D.18309;
  int D.18310;
  int D.17081;
  int iftmp.21;
  int D.17080;
  const char[7] * D.18317;
  unsigned char D.18318;
  int D.18319;
  unsigned char D.18320;
  int D.18321;
  const unsigned char * D.18326;
  unsigned char D.18327;
  int D.18328;
  const unsigned char * D.18329;
  unsigned char D.18330;
  int D.18331;
  const unsigned char * D.18336;
  unsigned char D.18337;
  int D.18338;
  const unsigned char * D.18339;
  unsigned char D.18340;
  int D.18341;
  const unsigned char * D.18346;
  unsigned char D.18347;
  int D.18348;
  const unsigned char * D.18349;
  unsigned char D.18350;
  int D.18351;
  int D.17090;
  int iftmp.22;
  int D.17089;
  const char[7] * D.18358;
  unsigned char D.18359;
  int D.18360;
  unsigned char D.18361;
  int D.18362;
  const unsigned char * D.18367;
  unsigned char D.18368;
  int D.18369;
  const unsigned char * D.18370;
  unsigned char D.18371;
  int D.18372;
  const unsigned char * D.18377;
  unsigned char D.18378;
  int D.18379;
  const unsigned char * D.18380;
  unsigned char D.18381;
  int D.18382;
  const unsigned char * D.18387;
  unsigned char D.18388;
  int D.18389;
  const unsigned char * D.18390;
  unsigned char D.18391;
  int D.18392;
  int D.17099;
  int iftmp.23;
  int D.17098;
  const char[7] * D.18399;
  unsigned char D.18400;
  int D.18401;
  unsigned char D.18402;
  int D.18403;
  const unsigned char * D.18408;
  unsigned char D.18409;
  int D.18410;
  const unsigned char * D.18411;
  unsigned char D.18412;
  int D.18413;
  const unsigned char * D.18418;
  unsigned char D.18419;
  int D.18420;
  const unsigned char * D.18421;
  unsigned char D.18422;
  int D.18423;
  const unsigned char * D.18428;
  unsigned char D.18429;
  int D.18430;
  const unsigned char * D.18431;
  unsigned char D.18432;
  int D.18433;
  int D.17108;
  int iftmp.24;
  int D.17107;
  const char[7] * D.18440;
  unsigned char D.18441;
  int D.18442;
  unsigned char D.18443;
  int D.18444;
  const unsigned char * D.18449;
  unsigned char D.18450;
  int D.18451;
  const unsigned char * D.18452;
  unsigned char D.18453;
  int D.18454;
  const unsigned char * D.18459;
  unsigned char D.18460;
  int D.18461;
  const unsigned char * D.18462;
  unsigned char D.18463;
  int D.18464;
  const unsigned char * D.18469;
  unsigned char D.18470;
  int D.18471;
  const unsigned char * D.18472;
  unsigned char D.18473;
  int D.18474;

  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = name;
      D.17783 = "void";
      D.17784 = MEM[(const unsigned char *)D.17783];
      D.17785 = (int) D.17784;
      D.17786 = *__s2;
      D.17787 = (int) D.17786;
      __result = D.17785 - D.17787;
      {
        if (__s2_len != 0) goto <D.17788>; else goto <D.17789>;
        <D.17788>:
        if (__result == 0) goto <D.17790>; else goto <D.17791>;
        <D.17790>:
        D.17792 = &MEM[(void *)"void" + 1B];
        D.17793 = *D.17792;
        D.17794 = (int) D.17793;
        D.17795 = __s2 + 1;
        D.17796 = *D.17795;
        D.17797 = (int) D.17796;
        __result = D.17794 - D.17797;
        if (__s2_len > 1) goto <D.17798>; else goto <D.17799>;
        <D.17798>:
        if (__result == 0) goto <D.17800>; else goto <D.17801>;
        <D.17800>:
        D.17802 = &MEM[(void *)"void" + 2B];
        D.17803 = *D.17802;
        D.17804 = (int) D.17803;
        D.17805 = __s2 + 2;
        D.17806 = *D.17805;
        D.17807 = (int) D.17806;
        __result = D.17804 - D.17807;
        if (__s2_len > 2) goto <D.17808>; else goto <D.17809>;
        <D.17808>:
        if (__result == 0) goto <D.17810>; else goto <D.17811>;
        <D.17810>:
        D.17812 = &MEM[(void *)"void" + 3B];
        D.17813 = *D.17812;
        D.17814 = (int) D.17813;
        D.17815 = __s2 + 3;
        D.17816 = *D.17815;
        D.17817 = (int) D.17816;
        __result = D.17814 - D.17817;
        <D.17811>:
        <D.17809>:
        <D.17801>:
        <D.17799>:
        <D.17791>:
        <D.17789>:
      }
      D.16963 = __result;
    }
    iftmp.8 = -D.16963;
    goto <D.17818>;
    <D.17782>:
    iftmp.8 = __builtin_strcmp (name, "void");
    <D.17818>:
    D.16964 = iftmp.8;
  }
  if (D.16964 == 0) goto <D.17819>; else goto <D.17820>;
  <D.17819>:
  D.17821 = mono_defaults.void_class;
  return D.17821;
  <D.17820>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = name;
      D.17825 = "char";
      D.17826 = MEM[(const unsigned char *)D.17825];
      D.17827 = (int) D.17826;
      D.17828 = *__s2;
      D.17829 = (int) D.17828;
      __result = D.17827 - D.17829;
      {
        if (__s2_len != 0) goto <D.17830>; else goto <D.17831>;
        <D.17830>:
        if (__result == 0) goto <D.17832>; else goto <D.17833>;
        <D.17832>:
        D.17834 = &MEM[(void *)"char" + 1B];
        D.17835 = *D.17834;
        D.17836 = (int) D.17835;
        D.17837 = __s2 + 1;
        D.17838 = *D.17837;
        D.17839 = (int) D.17838;
        __result = D.17836 - D.17839;
        if (__s2_len > 1) goto <D.17840>; else goto <D.17841>;
        <D.17840>:
        if (__result == 0) goto <D.17842>; else goto <D.17843>;
        <D.17842>:
        D.17844 = &MEM[(void *)"char" + 2B];
        D.17845 = *D.17844;
        D.17846 = (int) D.17845;
        D.17847 = __s2 + 2;
        D.17848 = *D.17847;
        D.17849 = (int) D.17848;
        __result = D.17846 - D.17849;
        if (__s2_len > 2) goto <D.17850>; else goto <D.17851>;
        <D.17850>:
        if (__result == 0) goto <D.17852>; else goto <D.17853>;
        <D.17852>:
        D.17854 = &MEM[(void *)"char" + 3B];
        D.17855 = *D.17854;
        D.17856 = (int) D.17855;
        D.17857 = __s2 + 3;
        D.17858 = *D.17857;
        D.17859 = (int) D.17858;
        __result = D.17856 - D.17859;
        <D.17853>:
        <D.17851>:
        <D.17843>:
        <D.17841>:
        <D.17833>:
        <D.17831>:
      }
      D.16972 = __result;
    }
    iftmp.9 = -D.16972;
    goto <D.17860>;
    <D.17824>:
    iftmp.9 = __builtin_strcmp (name, "char");
    <D.17860>:
    D.16973 = iftmp.9;
  }
  if (D.16973 == 0) goto <D.17861>; else goto <D.17862>;
  <D.17861>:
  D.17821 = mono_defaults.char_class;
  return D.17821;
  <D.17862>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = name;
      D.17866 = "bool";
      D.17867 = MEM[(const unsigned char *)D.17866];
      D.17868 = (int) D.17867;
      D.17869 = *__s2;
      D.17870 = (int) D.17869;
      __result = D.17868 - D.17870;
      {
        if (__s2_len != 0) goto <D.17871>; else goto <D.17872>;
        <D.17871>:
        if (__result == 0) goto <D.17873>; else goto <D.17874>;
        <D.17873>:
        D.17875 = &MEM[(void *)"bool" + 1B];
        D.17876 = *D.17875;
        D.17877 = (int) D.17876;
        D.17878 = __s2 + 1;
        D.17879 = *D.17878;
        D.17880 = (int) D.17879;
        __result = D.17877 - D.17880;
        if (__s2_len > 1) goto <D.17881>; else goto <D.17882>;
        <D.17881>:
        if (__result == 0) goto <D.17883>; else goto <D.17884>;
        <D.17883>:
        D.17885 = &MEM[(void *)"bool" + 2B];
        D.17886 = *D.17885;
        D.17887 = (int) D.17886;
        D.17888 = __s2 + 2;
        D.17889 = *D.17888;
        D.17890 = (int) D.17889;
        __result = D.17887 - D.17890;
        if (__s2_len > 2) goto <D.17891>; else goto <D.17892>;
        <D.17891>:
        if (__result == 0) goto <D.17893>; else goto <D.17894>;
        <D.17893>:
        D.17895 = &MEM[(void *)"bool" + 3B];
        D.17896 = *D.17895;
        D.17897 = (int) D.17896;
        D.17898 = __s2 + 3;
        D.17899 = *D.17898;
        D.17900 = (int) D.17899;
        __result = D.17897 - D.17900;
        <D.17894>:
        <D.17892>:
        <D.17884>:
        <D.17882>:
        <D.17874>:
        <D.17872>:
      }
      D.16981 = __result;
    }
    iftmp.10 = -D.16981;
    goto <D.17901>;
    <D.17865>:
    iftmp.10 = __builtin_strcmp (name, "bool");
    <D.17901>:
    D.16982 = iftmp.10;
  }
  if (D.16982 == 0) goto <D.17902>; else goto <D.17903>;
  <D.17902>:
  D.17821 = mono_defaults.boolean_class;
  return D.17821;
  <D.17903>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = name;
      D.17907 = "byte";
      D.17908 = MEM[(const unsigned char *)D.17907];
      D.17909 = (int) D.17908;
      D.17910 = *__s2;
      D.17911 = (int) D.17910;
      __result = D.17909 - D.17911;
      {
        if (__s2_len != 0) goto <D.17912>; else goto <D.17913>;
        <D.17912>:
        if (__result == 0) goto <D.17914>; else goto <D.17915>;
        <D.17914>:
        D.17916 = &MEM[(void *)"byte" + 1B];
        D.17917 = *D.17916;
        D.17918 = (int) D.17917;
        D.17919 = __s2 + 1;
        D.17920 = *D.17919;
        D.17921 = (int) D.17920;
        __result = D.17918 - D.17921;
        if (__s2_len > 1) goto <D.17922>; else goto <D.17923>;
        <D.17922>:
        if (__result == 0) goto <D.17924>; else goto <D.17925>;
        <D.17924>:
        D.17926 = &MEM[(void *)"byte" + 2B];
        D.17927 = *D.17926;
        D.17928 = (int) D.17927;
        D.17929 = __s2 + 2;
        D.17930 = *D.17929;
        D.17931 = (int) D.17930;
        __result = D.17928 - D.17931;
        if (__s2_len > 2) goto <D.17932>; else goto <D.17933>;
        <D.17932>:
        if (__result == 0) goto <D.17934>; else goto <D.17935>;
        <D.17934>:
        D.17936 = &MEM[(void *)"byte" + 3B];
        D.17937 = *D.17936;
        D.17938 = (int) D.17937;
        D.17939 = __s2 + 3;
        D.17940 = *D.17939;
        D.17941 = (int) D.17940;
        __result = D.17938 - D.17941;
        <D.17935>:
        <D.17933>:
        <D.17925>:
        <D.17923>:
        <D.17915>:
        <D.17913>:
      }
      D.16990 = __result;
    }
    iftmp.11 = -D.16990;
    goto <D.17942>;
    <D.17906>:
    iftmp.11 = __builtin_strcmp (name, "byte");
    <D.17942>:
    D.16991 = iftmp.11;
  }
  if (D.16991 == 0) goto <D.17943>; else goto <D.17944>;
  <D.17943>:
  D.17821 = mono_defaults.byte_class;
  return D.17821;
  <D.17944>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = name;
      D.17948 = "sbyte";
      D.17949 = MEM[(const unsigned char *)D.17948];
      D.17950 = (int) D.17949;
      D.17951 = *__s2;
      D.17952 = (int) D.17951;
      __result = D.17950 - D.17952;
      {
        if (__s2_len != 0) goto <D.17953>; else goto <D.17954>;
        <D.17953>:
        if (__result == 0) goto <D.17955>; else goto <D.17956>;
        <D.17955>:
        D.17957 = &MEM[(void *)"sbyte" + 1B];
        D.17958 = *D.17957;
        D.17959 = (int) D.17958;
        D.17960 = __s2 + 1;
        D.17961 = *D.17960;
        D.17962 = (int) D.17961;
        __result = D.17959 - D.17962;
        if (__s2_len > 1) goto <D.17963>; else goto <D.17964>;
        <D.17963>:
        if (__result == 0) goto <D.17965>; else goto <D.17966>;
        <D.17965>:
        D.17967 = &MEM[(void *)"sbyte" + 2B];
        D.17968 = *D.17967;
        D.17969 = (int) D.17968;
        D.17970 = __s2 + 2;
        D.17971 = *D.17970;
        D.17972 = (int) D.17971;
        __result = D.17969 - D.17972;
        if (__s2_len > 2) goto <D.17973>; else goto <D.17974>;
        <D.17973>:
        if (__result == 0) goto <D.17975>; else goto <D.17976>;
        <D.17975>:
        D.17977 = &MEM[(void *)"sbyte" + 3B];
        D.17978 = *D.17977;
        D.17979 = (int) D.17978;
        D.17980 = __s2 + 3;
        D.17981 = *D.17980;
        D.17982 = (int) D.17981;
        __result = D.17979 - D.17982;
        <D.17976>:
        <D.17974>:
        <D.17966>:
        <D.17964>:
        <D.17956>:
        <D.17954>:
      }
      D.16999 = __result;
    }
    iftmp.12 = -D.16999;
    goto <D.17983>;
    <D.17947>:
    iftmp.12 = __builtin_strcmp (name, "sbyte");
    <D.17983>:
    D.17000 = iftmp.12;
  }
  if (D.17000 == 0) goto <D.17984>; else goto <D.17985>;
  <D.17984>:
  D.17821 = mono_defaults.sbyte_class;
  return D.17821;
  <D.17985>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = name;
      D.17989 = "uint16";
      D.17990 = MEM[(const unsigned char *)D.17989];
      D.17991 = (int) D.17990;
      D.17992 = *__s2;
      D.17993 = (int) D.17992;
      __result = D.17991 - D.17993;
      {
        if (__s2_len != 0) goto <D.17994>; else goto <D.17995>;
        <D.17994>:
        if (__result == 0) goto <D.17996>; else goto <D.17997>;
        <D.17996>:
        D.17998 = &MEM[(void *)"uint16" + 1B];
        D.17999 = *D.17998;
        D.18000 = (int) D.17999;
        D.18001 = __s2 + 1;
        D.18002 = *D.18001;
        D.18003 = (int) D.18002;
        __result = D.18000 - D.18003;
        if (__s2_len > 1) goto <D.18004>; else goto <D.18005>;
        <D.18004>:
        if (__result == 0) goto <D.18006>; else goto <D.18007>;
        <D.18006>:
        D.18008 = &MEM[(void *)"uint16" + 2B];
        D.18009 = *D.18008;
        D.18010 = (int) D.18009;
        D.18011 = __s2 + 2;
        D.18012 = *D.18011;
        D.18013 = (int) D.18012;
        __result = D.18010 - D.18013;
        if (__s2_len > 2) goto <D.18014>; else goto <D.18015>;
        <D.18014>:
        if (__result == 0) goto <D.18016>; else goto <D.18017>;
        <D.18016>:
        D.18018 = &MEM[(void *)"uint16" + 3B];
        D.18019 = *D.18018;
        D.18020 = (int) D.18019;
        D.18021 = __s2 + 3;
        D.18022 = *D.18021;
        D.18023 = (int) D.18022;
        __result = D.18020 - D.18023;
        <D.18017>:
        <D.18015>:
        <D.18007>:
        <D.18005>:
        <D.17997>:
        <D.17995>:
      }
      D.17008 = __result;
    }
    iftmp.13 = -D.17008;
    goto <D.18024>;
    <D.17988>:
    iftmp.13 = __builtin_strcmp (name, "uint16");
    <D.18024>:
    D.17009 = iftmp.13;
  }
  if (D.17009 == 0) goto <D.18025>; else goto <D.18026>;
  <D.18025>:
  D.17821 = mono_defaults.uint16_class;
  return D.17821;
  <D.18026>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = name;
      D.18030 = "int16";
      D.18031 = MEM[(const unsigned char *)D.18030];
      D.18032 = (int) D.18031;
      D.18033 = *__s2;
      D.18034 = (int) D.18033;
      __result = D.18032 - D.18034;
      {
        if (__s2_len != 0) goto <D.18035>; else goto <D.18036>;
        <D.18035>:
        if (__result == 0) goto <D.18037>; else goto <D.18038>;
        <D.18037>:
        D.18039 = &MEM[(void *)"int16" + 1B];
        D.18040 = *D.18039;
        D.18041 = (int) D.18040;
        D.18042 = __s2 + 1;
        D.18043 = *D.18042;
        D.18044 = (int) D.18043;
        __result = D.18041 - D.18044;
        if (__s2_len > 1) goto <D.18045>; else goto <D.18046>;
        <D.18045>:
        if (__result == 0) goto <D.18047>; else goto <D.18048>;
        <D.18047>:
        D.18049 = &MEM[(void *)"int16" + 2B];
        D.18050 = *D.18049;
        D.18051 = (int) D.18050;
        D.18052 = __s2 + 2;
        D.18053 = *D.18052;
        D.18054 = (int) D.18053;
        __result = D.18051 - D.18054;
        if (__s2_len > 2) goto <D.18055>; else goto <D.18056>;
        <D.18055>:
        if (__result == 0) goto <D.18057>; else goto <D.18058>;
        <D.18057>:
        D.18059 = &MEM[(void *)"int16" + 3B];
        D.18060 = *D.18059;
        D.18061 = (int) D.18060;
        D.18062 = __s2 + 3;
        D.18063 = *D.18062;
        D.18064 = (int) D.18063;
        __result = D.18061 - D.18064;
        <D.18058>:
        <D.18056>:
        <D.18048>:
        <D.18046>:
        <D.18038>:
        <D.18036>:
      }
      D.17017 = __result;
    }
    iftmp.14 = -D.17017;
    goto <D.18065>;
    <D.18029>:
    iftmp.14 = __builtin_strcmp (name, "int16");
    <D.18065>:
    D.17018 = iftmp.14;
  }
  if (D.17018 == 0) goto <D.18066>; else goto <D.18067>;
  <D.18066>:
  D.17821 = mono_defaults.int16_class;
  return D.17821;
  <D.18067>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = name;
      D.18071 = "uint";
      D.18072 = MEM[(const unsigned char *)D.18071];
      D.18073 = (int) D.18072;
      D.18074 = *__s2;
      D.18075 = (int) D.18074;
      __result = D.18073 - D.18075;
      {
        if (__s2_len != 0) goto <D.18076>; else goto <D.18077>;
        <D.18076>:
        if (__result == 0) goto <D.18078>; else goto <D.18079>;
        <D.18078>:
        D.18080 = &MEM[(void *)"uint" + 1B];
        D.18081 = *D.18080;
        D.18082 = (int) D.18081;
        D.18083 = __s2 + 1;
        D.18084 = *D.18083;
        D.18085 = (int) D.18084;
        __result = D.18082 - D.18085;
        if (__s2_len > 1) goto <D.18086>; else goto <D.18087>;
        <D.18086>:
        if (__result == 0) goto <D.18088>; else goto <D.18089>;
        <D.18088>:
        D.18090 = &MEM[(void *)"uint" + 2B];
        D.18091 = *D.18090;
        D.18092 = (int) D.18091;
        D.18093 = __s2 + 2;
        D.18094 = *D.18093;
        D.18095 = (int) D.18094;
        __result = D.18092 - D.18095;
        if (__s2_len > 2) goto <D.18096>; else goto <D.18097>;
        <D.18096>:
        if (__result == 0) goto <D.18098>; else goto <D.18099>;
        <D.18098>:
        D.18100 = &MEM[(void *)"uint" + 3B];
        D.18101 = *D.18100;
        D.18102 = (int) D.18101;
        D.18103 = __s2 + 3;
        D.18104 = *D.18103;
        D.18105 = (int) D.18104;
        __result = D.18102 - D.18105;
        <D.18099>:
        <D.18097>:
        <D.18089>:
        <D.18087>:
        <D.18079>:
        <D.18077>:
      }
      D.17026 = __result;
    }
    iftmp.15 = -D.17026;
    goto <D.18106>;
    <D.18070>:
    iftmp.15 = __builtin_strcmp (name, "uint");
    <D.18106>:
    D.17027 = iftmp.15;
  }
  if (D.17027 == 0) goto <D.18107>; else goto <D.18108>;
  <D.18107>:
  D.17821 = mono_defaults.uint32_class;
  return D.17821;
  <D.18108>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = name;
      D.18112 = "int";
      D.18113 = MEM[(const unsigned char *)D.18112];
      D.18114 = (int) D.18113;
      D.18115 = *__s2;
      D.18116 = (int) D.18115;
      __result = D.18114 - D.18116;
      {
        if (__s2_len != 0) goto <D.18117>; else goto <D.18118>;
        <D.18117>:
        if (__result == 0) goto <D.18119>; else goto <D.18120>;
        <D.18119>:
        D.18121 = &MEM[(void *)"int" + 1B];
        D.18122 = *D.18121;
        D.18123 = (int) D.18122;
        D.18124 = __s2 + 1;
        D.18125 = *D.18124;
        D.18126 = (int) D.18125;
        __result = D.18123 - D.18126;
        if (__s2_len > 1) goto <D.18127>; else goto <D.18128>;
        <D.18127>:
        if (__result == 0) goto <D.18129>; else goto <D.18130>;
        <D.18129>:
        D.18131 = &MEM[(void *)"int" + 2B];
        D.18132 = *D.18131;
        D.18133 = (int) D.18132;
        D.18134 = __s2 + 2;
        D.18135 = *D.18134;
        D.18136 = (int) D.18135;
        __result = D.18133 - D.18136;
        if (__s2_len > 2) goto <D.18137>; else goto <D.18138>;
        <D.18137>:
        if (__result == 0) goto <D.18139>; else goto <D.18140>;
        <D.18139>:
        D.18141 = &MEM[(void *)"int" + 3B];
        D.18142 = *D.18141;
        D.18143 = (int) D.18142;
        D.18144 = __s2 + 3;
        D.18145 = *D.18144;
        D.18146 = (int) D.18145;
        __result = D.18143 - D.18146;
        <D.18140>:
        <D.18138>:
        <D.18130>:
        <D.18128>:
        <D.18120>:
        <D.18118>:
      }
      D.17035 = __result;
    }
    iftmp.16 = -D.17035;
    goto <D.18147>;
    <D.18111>:
    iftmp.16 = __builtin_strcmp (name, "int");
    <D.18147>:
    D.17036 = iftmp.16;
  }
  if (D.17036 == 0) goto <D.18148>; else goto <D.18149>;
  <D.18148>:
  D.17821 = mono_defaults.int32_class;
  return D.17821;
  <D.18149>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = name;
      D.18153 = "ulong";
      D.18154 = MEM[(const unsigned char *)D.18153];
      D.18155 = (int) D.18154;
      D.18156 = *__s2;
      D.18157 = (int) D.18156;
      __result = D.18155 - D.18157;
      {
        if (__s2_len != 0) goto <D.18158>; else goto <D.18159>;
        <D.18158>:
        if (__result == 0) goto <D.18160>; else goto <D.18161>;
        <D.18160>:
        D.18162 = &MEM[(void *)"ulong" + 1B];
        D.18163 = *D.18162;
        D.18164 = (int) D.18163;
        D.18165 = __s2 + 1;
        D.18166 = *D.18165;
        D.18167 = (int) D.18166;
        __result = D.18164 - D.18167;
        if (__s2_len > 1) goto <D.18168>; else goto <D.18169>;
        <D.18168>:
        if (__result == 0) goto <D.18170>; else goto <D.18171>;
        <D.18170>:
        D.18172 = &MEM[(void *)"ulong" + 2B];
        D.18173 = *D.18172;
        D.18174 = (int) D.18173;
        D.18175 = __s2 + 2;
        D.18176 = *D.18175;
        D.18177 = (int) D.18176;
        __result = D.18174 - D.18177;
        if (__s2_len > 2) goto <D.18178>; else goto <D.18179>;
        <D.18178>:
        if (__result == 0) goto <D.18180>; else goto <D.18181>;
        <D.18180>:
        D.18182 = &MEM[(void *)"ulong" + 3B];
        D.18183 = *D.18182;
        D.18184 = (int) D.18183;
        D.18185 = __s2 + 3;
        D.18186 = *D.18185;
        D.18187 = (int) D.18186;
        __result = D.18184 - D.18187;
        <D.18181>:
        <D.18179>:
        <D.18171>:
        <D.18169>:
        <D.18161>:
        <D.18159>:
      }
      D.17044 = __result;
    }
    iftmp.17 = -D.17044;
    goto <D.18188>;
    <D.18152>:
    iftmp.17 = __builtin_strcmp (name, "ulong");
    <D.18188>:
    D.17045 = iftmp.17;
  }
  if (D.17045 == 0) goto <D.18189>; else goto <D.18190>;
  <D.18189>:
  D.17821 = mono_defaults.uint64_class;
  return D.17821;
  <D.18190>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = name;
      D.18194 = "long";
      D.18195 = MEM[(const unsigned char *)D.18194];
      D.18196 = (int) D.18195;
      D.18197 = *__s2;
      D.18198 = (int) D.18197;
      __result = D.18196 - D.18198;
      {
        if (__s2_len != 0) goto <D.18199>; else goto <D.18200>;
        <D.18199>:
        if (__result == 0) goto <D.18201>; else goto <D.18202>;
        <D.18201>:
        D.18203 = &MEM[(void *)"long" + 1B];
        D.18204 = *D.18203;
        D.18205 = (int) D.18204;
        D.18206 = __s2 + 1;
        D.18207 = *D.18206;
        D.18208 = (int) D.18207;
        __result = D.18205 - D.18208;
        if (__s2_len > 1) goto <D.18209>; else goto <D.18210>;
        <D.18209>:
        if (__result == 0) goto <D.18211>; else goto <D.18212>;
        <D.18211>:
        D.18213 = &MEM[(void *)"long" + 2B];
        D.18214 = *D.18213;
        D.18215 = (int) D.18214;
        D.18216 = __s2 + 2;
        D.18217 = *D.18216;
        D.18218 = (int) D.18217;
        __result = D.18215 - D.18218;
        if (__s2_len > 2) goto <D.18219>; else goto <D.18220>;
        <D.18219>:
        if (__result == 0) goto <D.18221>; else goto <D.18222>;
        <D.18221>:
        D.18223 = &MEM[(void *)"long" + 3B];
        D.18224 = *D.18223;
        D.18225 = (int) D.18224;
        D.18226 = __s2 + 3;
        D.18227 = *D.18226;
        D.18228 = (int) D.18227;
        __result = D.18225 - D.18228;
        <D.18222>:
        <D.18220>:
        <D.18212>:
        <D.18210>:
        <D.18202>:
        <D.18200>:
      }
      D.17053 = __result;
    }
    iftmp.18 = -D.17053;
    goto <D.18229>;
    <D.18193>:
    iftmp.18 = __builtin_strcmp (name, "long");
    <D.18229>:
    D.17054 = iftmp.18;
  }
  if (D.17054 == 0) goto <D.18230>; else goto <D.18231>;
  <D.18230>:
  D.17821 = mono_defaults.int64_class;
  return D.17821;
  <D.18231>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = name;
      D.18235 = "uintptr";
      D.18236 = MEM[(const unsigned char *)D.18235];
      D.18237 = (int) D.18236;
      D.18238 = *__s2;
      D.18239 = (int) D.18238;
      __result = D.18237 - D.18239;
      {
        if (__s2_len != 0) goto <D.18240>; else goto <D.18241>;
        <D.18240>:
        if (__result == 0) goto <D.18242>; else goto <D.18243>;
        <D.18242>:
        D.18244 = &MEM[(void *)"uintptr" + 1B];
        D.18245 = *D.18244;
        D.18246 = (int) D.18245;
        D.18247 = __s2 + 1;
        D.18248 = *D.18247;
        D.18249 = (int) D.18248;
        __result = D.18246 - D.18249;
        if (__s2_len > 1) goto <D.18250>; else goto <D.18251>;
        <D.18250>:
        if (__result == 0) goto <D.18252>; else goto <D.18253>;
        <D.18252>:
        D.18254 = &MEM[(void *)"uintptr" + 2B];
        D.18255 = *D.18254;
        D.18256 = (int) D.18255;
        D.18257 = __s2 + 2;
        D.18258 = *D.18257;
        D.18259 = (int) D.18258;
        __result = D.18256 - D.18259;
        if (__s2_len > 2) goto <D.18260>; else goto <D.18261>;
        <D.18260>:
        if (__result == 0) goto <D.18262>; else goto <D.18263>;
        <D.18262>:
        D.18264 = &MEM[(void *)"uintptr" + 3B];
        D.18265 = *D.18264;
        D.18266 = (int) D.18265;
        D.18267 = __s2 + 3;
        D.18268 = *D.18267;
        D.18269 = (int) D.18268;
        __result = D.18266 - D.18269;
        <D.18263>:
        <D.18261>:
        <D.18253>:
        <D.18251>:
        <D.18243>:
        <D.18241>:
      }
      D.17062 = __result;
    }
    iftmp.19 = -D.17062;
    goto <D.18270>;
    <D.18234>:
    iftmp.19 = __builtin_strcmp (name, "uintptr");
    <D.18270>:
    D.17063 = iftmp.19;
  }
  if (D.17063 == 0) goto <D.18271>; else goto <D.18272>;
  <D.18271>:
  D.17821 = mono_defaults.uint_class;
  return D.17821;
  <D.18272>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = name;
      D.18276 = "intptr";
      D.18277 = MEM[(const unsigned char *)D.18276];
      D.18278 = (int) D.18277;
      D.18279 = *__s2;
      D.18280 = (int) D.18279;
      __result = D.18278 - D.18280;
      {
        if (__s2_len != 0) goto <D.18281>; else goto <D.18282>;
        <D.18281>:
        if (__result == 0) goto <D.18283>; else goto <D.18284>;
        <D.18283>:
        D.18285 = &MEM[(void *)"intptr" + 1B];
        D.18286 = *D.18285;
        D.18287 = (int) D.18286;
        D.18288 = __s2 + 1;
        D.18289 = *D.18288;
        D.18290 = (int) D.18289;
        __result = D.18287 - D.18290;
        if (__s2_len > 1) goto <D.18291>; else goto <D.18292>;
        <D.18291>:
        if (__result == 0) goto <D.18293>; else goto <D.18294>;
        <D.18293>:
        D.18295 = &MEM[(void *)"intptr" + 2B];
        D.18296 = *D.18295;
        D.18297 = (int) D.18296;
        D.18298 = __s2 + 2;
        D.18299 = *D.18298;
        D.18300 = (int) D.18299;
        __result = D.18297 - D.18300;
        if (__s2_len > 2) goto <D.18301>; else goto <D.18302>;
        <D.18301>:
        if (__result == 0) goto <D.18303>; else goto <D.18304>;
        <D.18303>:
        D.18305 = &MEM[(void *)"intptr" + 3B];
        D.18306 = *D.18305;
        D.18307 = (int) D.18306;
        D.18308 = __s2 + 3;
        D.18309 = *D.18308;
        D.18310 = (int) D.18309;
        __result = D.18307 - D.18310;
        <D.18304>:
        <D.18302>:
        <D.18294>:
        <D.18292>:
        <D.18284>:
        <D.18282>:
      }
      D.17071 = __result;
    }
    iftmp.20 = -D.17071;
    goto <D.18311>;
    <D.18275>:
    iftmp.20 = __builtin_strcmp (name, "intptr");
    <D.18311>:
    D.17072 = iftmp.20;
  }
  if (D.17072 == 0) goto <D.18312>; else goto <D.18313>;
  <D.18312>:
  D.17821 = mono_defaults.int_class;
  return D.17821;
  <D.18313>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = name;
      D.18317 = "single";
      D.18318 = MEM[(const unsigned char *)D.18317];
      D.18319 = (int) D.18318;
      D.18320 = *__s2;
      D.18321 = (int) D.18320;
      __result = D.18319 - D.18321;
      {
        if (__s2_len != 0) goto <D.18322>; else goto <D.18323>;
        <D.18322>:
        if (__result == 0) goto <D.18324>; else goto <D.18325>;
        <D.18324>:
        D.18326 = &MEM[(void *)"single" + 1B];
        D.18327 = *D.18326;
        D.18328 = (int) D.18327;
        D.18329 = __s2 + 1;
        D.18330 = *D.18329;
        D.18331 = (int) D.18330;
        __result = D.18328 - D.18331;
        if (__s2_len > 1) goto <D.18332>; else goto <D.18333>;
        <D.18332>:
        if (__result == 0) goto <D.18334>; else goto <D.18335>;
        <D.18334>:
        D.18336 = &MEM[(void *)"single" + 2B];
        D.18337 = *D.18336;
        D.18338 = (int) D.18337;
        D.18339 = __s2 + 2;
        D.18340 = *D.18339;
        D.18341 = (int) D.18340;
        __result = D.18338 - D.18341;
        if (__s2_len > 2) goto <D.18342>; else goto <D.18343>;
        <D.18342>:
        if (__result == 0) goto <D.18344>; else goto <D.18345>;
        <D.18344>:
        D.18346 = &MEM[(void *)"single" + 3B];
        D.18347 = *D.18346;
        D.18348 = (int) D.18347;
        D.18349 = __s2 + 3;
        D.18350 = *D.18349;
        D.18351 = (int) D.18350;
        __result = D.18348 - D.18351;
        <D.18345>:
        <D.18343>:
        <D.18335>:
        <D.18333>:
        <D.18325>:
        <D.18323>:
      }
      D.17080 = __result;
    }
    iftmp.21 = -D.17080;
    goto <D.18352>;
    <D.18316>:
    iftmp.21 = __builtin_strcmp (name, "single");
    <D.18352>:
    D.17081 = iftmp.21;
  }
  if (D.17081 == 0) goto <D.18353>; else goto <D.18354>;
  <D.18353>:
  D.17821 = mono_defaults.single_class;
  return D.17821;
  <D.18354>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = name;
      D.18358 = "double";
      D.18359 = MEM[(const unsigned char *)D.18358];
      D.18360 = (int) D.18359;
      D.18361 = *__s2;
      D.18362 = (int) D.18361;
      __result = D.18360 - D.18362;
      {
        if (__s2_len != 0) goto <D.18363>; else goto <D.18364>;
        <D.18363>:
        if (__result == 0) goto <D.18365>; else goto <D.18366>;
        <D.18365>:
        D.18367 = &MEM[(void *)"double" + 1B];
        D.18368 = *D.18367;
        D.18369 = (int) D.18368;
        D.18370 = __s2 + 1;
        D.18371 = *D.18370;
        D.18372 = (int) D.18371;
        __result = D.18369 - D.18372;
        if (__s2_len > 1) goto <D.18373>; else goto <D.18374>;
        <D.18373>:
        if (__result == 0) goto <D.18375>; else goto <D.18376>;
        <D.18375>:
        D.18377 = &MEM[(void *)"double" + 2B];
        D.18378 = *D.18377;
        D.18379 = (int) D.18378;
        D.18380 = __s2 + 2;
        D.18381 = *D.18380;
        D.18382 = (int) D.18381;
        __result = D.18379 - D.18382;
        if (__s2_len > 2) goto <D.18383>; else goto <D.18384>;
        <D.18383>:
        if (__result == 0) goto <D.18385>; else goto <D.18386>;
        <D.18385>:
        D.18387 = &MEM[(void *)"double" + 3B];
        D.18388 = *D.18387;
        D.18389 = (int) D.18388;
        D.18390 = __s2 + 3;
        D.18391 = *D.18390;
        D.18392 = (int) D.18391;
        __result = D.18389 - D.18392;
        <D.18386>:
        <D.18384>:
        <D.18376>:
        <D.18374>:
        <D.18366>:
        <D.18364>:
      }
      D.17089 = __result;
    }
    iftmp.22 = -D.17089;
    goto <D.18393>;
    <D.18357>:
    iftmp.22 = __builtin_strcmp (name, "double");
    <D.18393>:
    D.17090 = iftmp.22;
  }
  if (D.17090 == 0) goto <D.18394>; else goto <D.18395>;
  <D.18394>:
  D.17821 = mono_defaults.double_class;
  return D.17821;
  <D.18395>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = name;
      D.18399 = "string";
      D.18400 = MEM[(const unsigned char *)D.18399];
      D.18401 = (int) D.18400;
      D.18402 = *__s2;
      D.18403 = (int) D.18402;
      __result = D.18401 - D.18403;
      {
        if (__s2_len != 0) goto <D.18404>; else goto <D.18405>;
        <D.18404>:
        if (__result == 0) goto <D.18406>; else goto <D.18407>;
        <D.18406>:
        D.18408 = &MEM[(void *)"string" + 1B];
        D.18409 = *D.18408;
        D.18410 = (int) D.18409;
        D.18411 = __s2 + 1;
        D.18412 = *D.18411;
        D.18413 = (int) D.18412;
        __result = D.18410 - D.18413;
        if (__s2_len > 1) goto <D.18414>; else goto <D.18415>;
        <D.18414>:
        if (__result == 0) goto <D.18416>; else goto <D.18417>;
        <D.18416>:
        D.18418 = &MEM[(void *)"string" + 2B];
        D.18419 = *D.18418;
        D.18420 = (int) D.18419;
        D.18421 = __s2 + 2;
        D.18422 = *D.18421;
        D.18423 = (int) D.18422;
        __result = D.18420 - D.18423;
        if (__s2_len > 2) goto <D.18424>; else goto <D.18425>;
        <D.18424>:
        if (__result == 0) goto <D.18426>; else goto <D.18427>;
        <D.18426>:
        D.18428 = &MEM[(void *)"string" + 3B];
        D.18429 = *D.18428;
        D.18430 = (int) D.18429;
        D.18431 = __s2 + 3;
        D.18432 = *D.18431;
        D.18433 = (int) D.18432;
        __result = D.18430 - D.18433;
        <D.18427>:
        <D.18425>:
        <D.18417>:
        <D.18415>:
        <D.18407>:
        <D.18405>:
      }
      D.17098 = __result;
    }
    iftmp.23 = -D.17098;
    goto <D.18434>;
    <D.18398>:
    iftmp.23 = __builtin_strcmp (name, "string");
    <D.18434>:
    D.17099 = iftmp.23;
  }
  if (D.17099 == 0) goto <D.18435>; else goto <D.18436>;
  <D.18435>:
  D.17821 = mono_defaults.string_class;
  return D.17821;
  <D.18436>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = name;
      D.18440 = "object";
      D.18441 = MEM[(const unsigned char *)D.18440];
      D.18442 = (int) D.18441;
      D.18443 = *__s2;
      D.18444 = (int) D.18443;
      __result = D.18442 - D.18444;
      {
        if (__s2_len != 0) goto <D.18445>; else goto <D.18446>;
        <D.18445>:
        if (__result == 0) goto <D.18447>; else goto <D.18448>;
        <D.18447>:
        D.18449 = &MEM[(void *)"object" + 1B];
        D.18450 = *D.18449;
        D.18451 = (int) D.18450;
        D.18452 = __s2 + 1;
        D.18453 = *D.18452;
        D.18454 = (int) D.18453;
        __result = D.18451 - D.18454;
        if (__s2_len > 1) goto <D.18455>; else goto <D.18456>;
        <D.18455>:
        if (__result == 0) goto <D.18457>; else goto <D.18458>;
        <D.18457>:
        D.18459 = &MEM[(void *)"object" + 2B];
        D.18460 = *D.18459;
        D.18461 = (int) D.18460;
        D.18462 = __s2 + 2;
        D.18463 = *D.18462;
        D.18464 = (int) D.18463;
        __result = D.18461 - D.18464;
        if (__s2_len > 2) goto <D.18465>; else goto <D.18466>;
        <D.18465>:
        if (__result == 0) goto <D.18467>; else goto <D.18468>;
        <D.18467>:
        D.18469 = &MEM[(void *)"object" + 3B];
        D.18470 = *D.18469;
        D.18471 = (int) D.18470;
        D.18472 = __s2 + 3;
        D.18473 = *D.18472;
        D.18474 = (int) D.18473;
        __result = D.18471 - D.18474;
        <D.18468>:
        <D.18466>:
        <D.18458>:
        <D.18456>:
        <D.18448>:
        <D.18446>:
      }
      D.17107 = __result;
    }
    iftmp.24 = -D.17107;
    goto <D.18475>;
    <D.18439>:
    iftmp.24 = __builtin_strcmp (name, "object");
    <D.18475>:
    D.17108 = iftmp.24;
  }
  if (D.17108 == 0) goto <D.18476>; else goto <D.18477>;
  <D.18476>:
  D.17821 = mono_defaults.object_class;
  return D.17821;
  <D.18477>:
  D.17821 = 0B;
  return D.17821;
}


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

  res = monoeg_g_string_new ("");
  if (dh == 0B) goto <D.18479>; else goto <D.18480>;
  <D.18479>:
  dh = &default_dh;
  <D.18480>:
  D.18481 = ip + 2;
  ip = dis_one (res, dh, method, ip, D.18481);
  if (endp != 0B) goto <D.18482>; else goto <D.18483>;
  <D.18482>:
  *endp = ip;
  <D.18483>:
  result = res->str;
  monoeg_g_string_free (res, 0);
  D.18484 = result;
  return D.18484;
}


dis_one (struct GString * str, struct MonoDisHelper * dh, struct MonoMethod * method, const unsigned char * ip, const unsigned char * end)
{
  const unsigned char * ip.25;
  long int ip.26;
  long int il_code.27;
  long int D.18489;
  char * (*<T2899>) (struct MonoDisHelper *, struct MonoMethod *, uint32_t) D.18490;
  const char * D.18493;
  <unnamed type> D.18496;
  const unsigned char * ip.28;
  const char * D.18498;
  unsigned char D.18499;
  int D.18500;
  char * (*<T2899>) (struct MonoDisHelper *, struct MonoMethod *, uint32_t) D.18501;
  const unsigned char * ip.29;
  struct MonoClass * D.18506;
  struct MonoImage * D.18507;
  long unsigned int D.18508;
  long unsigned int D.18509;
  unsigned int D.18512;
  const char * blob.30;
  const char * blob.31;
  unsigned int D.18515;
  long int len2.32;
  short unsigned int D.18519;
  int D.18520;
  const unsigned char * ip.33;
  unsigned char D.18522;
  int D.18523;
  unsigned int D.18524;
  const char * D.18525;
  sizetype D.18528;
  const unsigned char * D.18529;
  long int D.18530;
  long int D.18531;
  signed char D.18533;
  int D.18537;
  sizetype D.18538;
  sizetype D.18543;
  const unsigned char * D.18544;
  long int D.18545;
  long int D.18546;
  long unsigned int D.18548;
  double r.34;
  double r.35;
  const unsigned char * ip.36;
  float r.37;
  float r.38;
  double D.18554;
  int D.18555;
  int D.18556;
  const char * D.18557;
  const unsigned char * D.18560;
  struct MonoMethodHeader * header;
  const struct MonoOpcode * opcode;
  guint32 label;
  guint32 token;
  gint32 sval;
  int i;
  char * tmp;
  const unsigned char * il_code;

  header = mono_method_get_header (method);
  il_code = mono_method_header_get_code (header, 0B, 0B);
  ip.25 = ip;
  ip.26 = (long int) ip.25;
  il_code.27 = (long int) il_code;
  D.18489 = ip.26 - il_code.27;
  label = (guint32) D.18489;
  D.18490 = dh->indenter;
  if (D.18490 != 0B) goto <D.18491>; else goto <D.18492>;
  <D.18491>:
  D.18490 = dh->indenter;
  tmp = D.18490 (dh, method, label);
  monoeg_g_string_append (str, tmp);
  monoeg_g_free (tmp);
  <D.18492>:
  D.18493 = dh->label_format;
  if (D.18493 != 0B) goto <D.18494>; else goto <D.18495>;
  <D.18494>:
  D.18493 = dh->label_format;
  monoeg_g_string_append_printf (str, D.18493, label);
  <D.18495>:
  D.18496 = mono_opcode_value (&ip, end);
  i = (int) D.18496;
  ip.25 = ip;
  ip.28 = ip.25 + 1;
  ip = ip.28;
  opcode = &mono_opcodes[i];
  D.18498 = mono_opcode_name (i);
  monoeg_g_string_append_printf (str, "%-10s", D.18498);
  D.18499 = opcode->argument;
  D.18500 = (int) D.18499;
  switch (D.18500) <default: <D.17358>, case 0: <D.17328>, case 1: <D.17330>, case 2: <D.17331>, case 3: <D.17332>, case 4: <D.17333>, case 5: <D.17335>, case 6: <D.17334>, case 7: <D.17340>, case 8: <D.17341>, case 9: <D.17342>, case 10: <D.17343>, case 11: <D.17344>, case 12: <D.17349>, case 13: <D.17352>, case 14: <D.17355>, case 15: <D.17356>, case 16: <D.17357>>
  <D.17328>:
  goto <D.17329>;
  <D.17330>:
  <D.17331>:
  <D.17332>:
  <D.17333>:
  <D.17334>:
  ip.25 = ip;
  token = MEM[(const guint32 *)ip.25];
  D.18501 = dh->tokener;
  if (D.18501 != 0B) goto <D.18502>; else goto <D.18503>;
  <D.18502>:
  D.18501 = dh->tokener;
  tmp = D.18501 (dh, method, token);
  monoeg_g_string_append (str, tmp);
  monoeg_g_free (tmp);
  goto <D.18504>;
  <D.18503>:
  monoeg_g_string_append_printf (str, "0x%08x", token);
  <D.18504>:
  ip.25 = ip;
  ip.29 = ip.25 + 4;
  ip = ip.29;
  goto <D.17329>;
  <D.17335>:
  {
    const char * blob;
    char * s;
    size_t len2;
    char * blob2;

    try
      {
        blob2 = 0B;
        D.18506 = method->klass;
        D.18507 = D.18506->image;
        D.18508 = BIT_FIELD_REF <*D.18507, 64, 192>;
        D.18509 = D.18508 & 34359738368;
        if (D.18509 == 0) goto <D.18510>; else goto <D.18511>;
        <D.18510>:
        ip.25 = ip;
        token = MEM[(const guint32 *)ip.25];
        D.18506 = method->klass;
        D.18507 = D.18506->image;
        D.18512 = token & 16777215;
        blob.30 = mono_metadata_user_string (D.18507, D.18512);
        blob = blob.30;
        blob.31 = blob;
        D.18515 = mono_metadata_decode_blob_size (blob.31, &blob);
        len2 = (size_t) D.18515;
        len2 = len2 >> 1;
        blob2 = blob;
        len2.32 = (long int) len2;
        s = monoeg_g_utf16_to_utf8 (blob2, len2.32, 0B, 0B, 0B);
        monoeg_g_string_append_printf (str, "\"%s\"", s);
        monoeg_g_free (s);
        blob.31 = blob;
        if (blob.31 != blob2) goto <D.18517>; else goto <D.18518>;
        <D.18517>:
        monoeg_g_free (blob2);
        <D.18518>:
        <D.18511>:
        ip.25 = ip;
        ip.29 = ip.25 + 4;
        ip = ip.29;
        goto <D.17329>;
      }
    finally
      {
        blob = {CLOBBER};
      }
  }
  <D.17340>:
  ip.25 = ip;
  D.18519 = MEM[(const guint16 *)ip.25];
  D.18520 = (int) D.18519;
  monoeg_g_string_append_printf (str, "%d", D.18520);
  ip.25 = ip;
  ip.33 = ip.25 + 2;
  ip = ip.33;
  goto <D.17329>;
  <D.17341>:
  ip.25 = ip;
  D.18522 = *ip.25;
  D.18523 = (int) D.18522;
  monoeg_g_string_append_printf (str, "%d", D.18523);
  ip.25 = ip;
  ip.28 = ip.25 + 1;
  ip = ip.28;
  goto <D.17329>;
  <D.17342>:
  ip.25 = ip;
  D.18524 = MEM[(const guint32 *)ip.25];
  sval = (gint32) D.18524;
  ip.25 = ip;
  ip.29 = ip.25 + 4;
  ip = ip.29;
  D.18525 = dh->label_target;
  if (D.18525 != 0B) goto <D.18526>; else goto <D.18527>;
  <D.18526>:
  D.18525 = dh->label_target;
  ip.25 = ip;
  D.18528 = (sizetype) sval;
  D.18529 = ip.25 + D.18528;
  D.18530 = (long int) D.18529;
  il_code.27 = (long int) il_code;
  D.18531 = D.18530 - il_code.27;
  monoeg_g_string_append_printf (str, D.18525, D.18531);
  goto <D.18532>;
  <D.18527>:
  monoeg_g_string_append_printf (str, "%d", sval);
  <D.18532>:
  goto <D.17329>;
  <D.17343>:
  ip.25 = ip;
  D.18533 = MEM[(const signed char *)ip.25];
  sval = (gint32) D.18533;
  ip.25 = ip;
  ip.28 = ip.25 + 1;
  ip = ip.28;
  D.18525 = dh->label_target;
  if (D.18525 != 0B) goto <D.18534>; else goto <D.18535>;
  <D.18534>:
  D.18525 = dh->label_target;
  ip.25 = ip;
  D.18528 = (sizetype) sval;
  D.18529 = ip.25 + D.18528;
  D.18530 = (long int) D.18529;
  il_code.27 = (long int) il_code;
  D.18531 = D.18530 - il_code.27;
  monoeg_g_string_append_printf (str, D.18525, D.18531);
  goto <D.18536>;
  <D.18535>:
  monoeg_g_string_append_printf (str, "%d", sval);
  <D.18536>:
  goto <D.17329>;
  <D.17344>:
  {
    const unsigned char * end;

    ip.25 = ip;
    D.18524 = MEM[(const guint32 *)ip.25];
    sval = (gint32) D.18524;
    ip.25 = ip;
    ip.29 = ip.25 + 4;
    ip = ip.29;
    ip.25 = ip;
    D.18537 = sval * 4;
    D.18538 = (sizetype) D.18537;
    end = ip.25 + D.18538;
    monoeg_g_string_append_c (str, 40);
    i = 0;
    goto <D.17347>;
    <D.17346>:
    if (i > 0) goto <D.18539>; else goto <D.18540>;
    <D.18539>:
    monoeg_g_string_append (str, ", ");
    <D.18540>:
    ip.25 = ip;
    label = MEM[(const guint32 *)ip.25];
    D.18525 = dh->label_target;
    if (D.18525 != 0B) goto <D.18541>; else goto <D.18542>;
    <D.18541>:
    D.18525 = dh->label_target;
    D.18543 = (sizetype) label;
    D.18544 = end + D.18543;
    D.18545 = (long int) D.18544;
    il_code.27 = (long int) il_code;
    D.18546 = D.18545 - il_code.27;
    monoeg_g_string_append_printf (str, D.18525, D.18546);
    goto <D.18547>;
    <D.18542>:
    monoeg_g_string_append_printf (str, "%d", label);
    <D.18547>:
    ip.25 = ip;
    ip.29 = ip.25 + 4;
    ip = ip.29;
    i = i + 1;
    <D.17347>:
    if (i < sval) goto <D.17346>; else goto <D.17348>;
    <D.17348>:
    monoeg_g_string_append_c (str, 41);
    goto <D.17329>;
  }
  <D.17349>:
  {
    double r;

    try
      {
        {
          union mono_rdouble mf;

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

    try
      {
        {
          union mono_rfloat mf;

          try
            {
              ip.25 = ip;
              D.18524 = MEM[(const guint32 *)ip.25];
              mf.ival = D.18524;
              r.37 = mf.fval;
              r = r.37;
            }
          finally
            {
              mf = {CLOBBER};
            }
        }
        r.38 = r;
        D.18554 = (double) r.38;
        monoeg_g_string_append_printf (str, "%g", D.18554);
        ip.25 = ip;
        ip.29 = ip.25 + 4;
        ip = ip.29;
        goto <D.17329>;
      }
    finally
      {
        r = {CLOBBER};
      }
  }
  <D.17355>:
  ip.25 = ip;
  D.18524 = MEM[(const guint32 *)ip.25];
  D.18555 = (int) D.18524;
  monoeg_g_string_append_printf (str, "%d", D.18555);
  ip.25 = ip;
  ip.29 = ip.25 + 4;
  ip = ip.29;
  goto <D.17329>;
  <D.17356>:
  ip.25 = ip;
  D.18533 = MEM[(const signed char *)ip.25];
  D.18556 = (int) D.18533;
  monoeg_g_string_append_printf (str, "%d", D.18556);
  ip.25 = ip;
  ip.28 = ip.25 + 1;
  ip = ip.28;
  goto <D.17329>;
  <D.17357>:
  ip.25 = ip;
  ip.36 = ip.25 + 8;
  ip = ip.36;
  goto <D.17329>;
  <D.17358>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "debug-helpers.c", 684);
  <D.17329>:
  D.18557 = dh->newline;
  if (D.18557 != 0B) goto <D.18558>; else goto <D.18559>;
  <D.18558>:
  D.18557 = dh->newline;
  monoeg_g_string_append (str, D.18557);
  <D.18559>:
  mono_metadata_free_mh (header);
  D.18560 = ip;
  return D.18560;
}


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

  res = monoeg_g_string_new ("");
  if (dh == 0B) goto <D.18566>; else goto <D.18567>;
  <D.18566>:
  dh = &default_dh;
  <D.18567>:
  goto <D.17377>;
  <D.17376>:
  ip = dis_one (res, dh, method, ip, end);
  <D.17377>:
  if (ip < end) goto <D.17376>; else goto <D.17378>;
  <D.17378>:
  result = res->str;
  monoeg_g_string_free (res, 0);
  D.18568 = result;
  return D.18568;
}


mono_field_full_name (struct MonoClassField * field)
{
  struct MonoClass * D.18570;
  const char * iftmp.39;
  char D.18572;
  const char * D.18576;
  const char * D.18577;
  char * D.18578;
  char * res;
  const char * nspace;

  D.18570 = field->parent;
  nspace = D.18570->name_space;
  D.18572 = *nspace;
  if (D.18572 != 0) goto <D.18573>; else goto <D.18574>;
  <D.18573>:
  iftmp.39 = ".";
  goto <D.18575>;
  <D.18574>:
  iftmp.39 = "";
  <D.18575>:
  D.18570 = field->parent;
  D.18576 = D.18570->name;
  D.18577 = mono_field_get_name (field);
  res = monoeg_g_strdup_printf ("%s%s%s:%s", nspace, iftmp.39, D.18576, D.18577);
  D.18578 = res;
  return D.18578;
}


mono_method_full_name (struct MonoMethod * method, gboolean signature)
{
  struct MonoClass * D.18580;
  struct MonoType * D.18581;
  long unsigned int D.18584;
  long unsigned int D.18585;
  struct MonoGenericInst * D.18587;
  long unsigned int D.18589;
  struct MonoGenericInst * D.18592;
  long unsigned int D.18593;
  <unnamed-unsigned:5> D.18596;
  unsigned int D.18597;
  const char * D.18598;
  struct MonoMethodSignature * D.18602;
  const char * D.18605;
  const char * D.18607;
  const char * iftmp.40;
  const char * iftmp.41;
  char * D.18617;
  char * res;
  char wrapper[64];
  char * klass_desc;
  char * inst_desc;

  try
    {
      D.18580 = method->klass;
      D.18581 = &D.18580->byval_arg;
      klass_desc = mono_type_full_name (D.18581);
      inst_desc = 0B;
      D.18584 = BIT_FIELD_REF <*method, 64, 256>;
      D.18585 = D.18584 & 4096;
      if (D.18585 != 0) goto <D.18586>; else goto <D.18582>;
      <D.18586>:
      D.18587 = MEM[(struct MonoMethodInflated *)method].context.method_inst;
      if (D.18587 != 0B) goto <D.18588>; else goto <D.18582>;
      <D.18588>:
      {
        struct GString * str;

        str = monoeg_g_string_new ("");
        monoeg_g_string_append (str, "<");
        D.18587 = MEM[(struct MonoMethodInflated *)method].context.method_inst;
        ginst_get_desc (str, D.18587);
        monoeg_g_string_append (str, ">");
        inst_desc = str->str;
        monoeg_g_string_free (str, 0);
      }
      goto <D.18583>;
      <D.18582>:
      D.18584 = BIT_FIELD_REF <*method, 64, 256>;
      D.18589 = D.18584 & 2048;
      if (D.18589 != 0) goto <D.18590>; else goto <D.18591>;
      <D.18590>:
      {
        struct MonoGenericContainer * container;
        struct GString * str;

        container = mono_method_get_generic_container (method);
        str = monoeg_g_string_new ("");
        monoeg_g_string_append (str, "<");
        D.18592 = container->context.method_inst;
        ginst_get_desc (str, D.18592);
        monoeg_g_string_append (str, ">");
        inst_desc = str->str;
        monoeg_g_string_free (str, 0);
      }
      <D.18591>:
      <D.18583>:
      D.18584 = BIT_FIELD_REF <*method, 64, 256>;
      D.18593 = D.18584 & 124;
      if (D.18593 != 0) goto <D.18594>; else goto <D.18595>;
      <D.18594>:
      D.18596 = method->wrapper_type;
      D.18597 = (unsigned int) D.18596;
      D.18598 = wrapper_type_to_str (D.18597);
      sprintf (&wrapper, "(wrapper %s) ", D.18598);
      goto <D.18599>;
      <D.18595>:
      strcpy (&wrapper, "");
      <D.18599>:
      if (signature != 0) goto <D.18600>; else goto <D.18601>;
      <D.18600>:
      {
        char * tmpsig;

        D.18602 = mono_method_signature (method);
        tmpsig = mono_signature_get_desc (D.18602, 1);
        D.18584 = BIT_FIELD_REF <*method, 64, 256>;
        D.18593 = D.18584 & 124;
        if (D.18593 != 0) goto <D.18603>; else goto <D.18604>;
        <D.18603>:
        D.18596 = method->wrapper_type;
        D.18597 = (unsigned int) D.18596;
        D.18605 = wrapper_type_to_str (D.18597);
        sprintf (&wrapper, "(wrapper %s) ", D.18605);
        goto <D.18606>;
        <D.18604>:
        strcpy (&wrapper, "");
        <D.18606>:
        D.18607 = method->name;
        if (inst_desc != 0B) goto <D.18609>; else goto <D.18610>;
        <D.18609>:
        iftmp.40 = inst_desc;
        goto <D.18611>;
        <D.18610>:
        iftmp.40 = "";
        <D.18611>:
        res = monoeg_g_strdup_printf ("%s%s:%s%s (%s)", &wrapper, klass_desc, D.18607, iftmp.40, tmpsig);
        monoeg_g_free (tmpsig);
      }
      goto <D.18612>;
      <D.18601>:
      D.18607 = method->name;
      if (inst_desc != 0B) goto <D.18614>; else goto <D.18615>;
      <D.18614>:
      iftmp.41 = inst_desc;
      goto <D.18616>;
      <D.18615>:
      iftmp.41 = "";
      <D.18616>:
      res = monoeg_g_strdup_printf ("%s%s:%s%s", &wrapper, klass_desc, D.18607, iftmp.41);
      <D.18612>:
      monoeg_g_free (klass_desc);
      monoeg_g_free (inst_desc);
      D.18617 = res;
      return D.18617;
    }
  finally
    {
      wrapper = {CLOBBER};
    }
}


wrapper_type_to_str (guint32 wrapper_type)
{
  _Bool D.18620;
  long int D.18621;
  long int D.18622;
  const char * D.18625;
  short int D.18626;
  sizetype D.18627;

  D.18620 = wrapper_type > 28;
  D.18621 = (long int) D.18620;
  D.18622 = __builtin_expect (D.18621, 0);
  if (D.18622 != 0) goto <D.18623>; else goto <D.18624>;
  <D.18623>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debug-helpers.c", 51, "wrapper_type < MONO_WRAPPER_NUM");
  <D.18624>:
  D.18626 = opidx[wrapper_type];
  D.18627 = (sizetype) D.18626;
  D.18625 = &opstr + D.18627;
  return D.18625;
}


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

  D.18630 = __builtin_object_size (__s, 1);
  D.18629 = __builtin___sprintf_chk (__s, 1, D.18630, __fmt, __builtin_va_arg_pack ());
  return D.18629;
}


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

  D.18633 = __builtin_object_size (__dest, 1);
  D.18632 = __builtin___strcpy_chk (__dest, __src, D.18633);
  return D.18632;
}


mono_object_describe (struct MonoObject * obj)
{
  struct MonoVTable * D.18637;
  struct MonoClass * D.18638;
  long unsigned int D.18641;
  char * D.18644;
  char * D.18645;
  char * D.18646;
  char * D.18647;
  int D.18648;
  unsigned char D.18650;
  const char * D.18653;
  int D.18654;
  long unsigned int D.18655;
  int D.18656;
  struct MonoClass * klass;
  const char * sep;

  if (obj == 0B) goto <D.18635>; else goto <D.18636>;
  <D.18635>:
  monoeg_g_print ("(null)\n");
  return;
  <D.18636>:
  D.18637 = obj->vtable;
  klass = D.18637->klass;
  D.18638 = mono_defaults.string_class;
  if (D.18638 == klass) goto <D.18639>; else goto <D.18640>;
  <D.18639>:
  {
    char * utf8;

    utf8 = mono_string_to_utf8 (obj);
    D.18641 = strlen (utf8);
    if (D.18641 > 60) goto <D.18642>; else goto <D.18643>;
    <D.18642>:
    D.18644 = utf8 + 57;
    *D.18644 = 46;
    D.18645 = utf8 + 58;
    *D.18645 = 46;
    D.18646 = utf8 + 59;
    *D.18646 = 46;
    D.18647 = utf8 + 60;
    *D.18647 = 0;
    <D.18643>:
    D.18648 = mono_string_length (obj);
    monoeg_g_print ("String at %p, length: %d, \'%s\'\n", obj, D.18648, utf8);
    monoeg_g_free (utf8);
  }
  goto <D.18649>;
  <D.18640>:
  D.18650 = klass->rank;
  if (D.18650 != 0) goto <D.18651>; else goto <D.18652>;
  <D.18651>:
  {
    struct MonoArray * array;

    array = obj;
    sep = print_name_space (klass);
    D.18653 = klass->name;
    monoeg_g_print ("%s%s", sep, D.18653);
    D.18650 = klass->rank;
    D.18654 = (int) D.18650;
    D.18655 = mono_array_length (array);
    D.18656 = (int) D.18655;
    monoeg_g_print (" at %p, rank: %d, length: %d\n", obj, D.18654, D.18656);
  }
  goto <D.18657>;
  <D.18652>:
  sep = print_name_space (klass);
  D.18653 = klass->name;
  monoeg_g_print ("%s%s", sep, D.18653);
  monoeg_g_print (" object at %p (klass: %p)\n", obj, klass);
  <D.18657>:
  <D.18649>:
}


print_name_space (struct MonoClass * klass)
{
  struct MonoClass * D.18659;
  const char * D.18662;
  const char * D.18663;
  const char * D.18664;
  char D.18665;

  D.18659 = klass->nested_in;
  if (D.18659 != 0B) goto <D.18660>; else goto <D.18661>;
  <D.18660>:
  D.18659 = klass->nested_in;
  print_name_space (D.18659);
  D.18659 = klass->nested_in;
  D.18662 = D.18659->name;
  monoeg_g_print ("%s", D.18662);
  D.18663 = "/";
  return D.18663;
  <D.18661>:
  D.18664 = klass->name_space;
  D.18665 = *D.18664;
  if (D.18665 != 0) goto <D.18666>; else goto <D.18667>;
  <D.18666>:
  D.18664 = klass->name_space;
  monoeg_g_print ("%s", D.18664);
  D.18663 = ".";
  return D.18663;
  <D.18667>:
  D.18663 = "";
  return D.18663;
}


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

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


objval_describe (struct MonoClass * class, const char * addr)
{
  long unsigned int D.18670;
  long unsigned int D.18671;
  struct MonoType * D.18674;
  short unsigned int D.18675;
  int D.18676;
  int D.18677;
  const char * D.18684;
  int D.18685;
  sizetype D.18686;
  sizetype type_offset.42;
  sizetype D.18688;
  int D.18689;
  struct MonoClassField * field;
  struct MonoClass * p;
  const char * field_ptr;
  gssize type_offset;

  type_offset = 0;
  D.18670 = BIT_FIELD_REF <*class, 64, 256>;
  D.18671 = D.18670 & 8;
  if (D.18671 != 0) goto <D.18672>; else goto <D.18673>;
  <D.18672>:
  type_offset = -16;
  <D.18673>:
  p = class;
  goto <D.17453>;
  <D.17452>:
  {
    void * iter;
    int printed_header;

    try
      {
        iter = 0B;
        printed_header = 0;
        goto <D.17448>;
        <D.17450>:
        D.18674 = field->type;
        D.18675 = D.18674->attrs;
        D.18676 = (int) D.18675;
        D.18677 = D.18676 & 272;
        if (D.18677 != 0) goto <D.18678>; else goto <D.18679>;
        <D.18678>:
        // predicted unlikely by continue predictor.
        goto <D.17448>;
        <D.18679>:
        if (p != class) goto <D.18680>; else goto <D.18681>;
        <D.18680>:
        if (printed_header == 0) goto <D.18682>; else goto <D.18683>;
        <D.18682>:
        {
          const char * sep;

          monoeg_g_print ("In class ");
          sep = print_name_space (p);
          D.18684 = p->name;
          monoeg_g_print ("%s%s:\n", sep, D.18684);
          printed_header = 1;
        }
        <D.18683>:
        <D.18681>:
        D.18685 = field->offset;
        D.18686 = (sizetype) D.18685;
        type_offset.42 = (sizetype) type_offset;
        D.18688 = D.18686 + type_offset.42;
        field_ptr = addr + D.18688;
        D.18689 = (int) type_offset;
        print_field_value (field_ptr, field, D.18689);
        <D.17448>:
        field = mono_class_get_fields (p, &iter);
        if (field != 0B) goto <D.17450>; else goto <D.17451>;
        <D.17451>:
      }
    finally
      {
        iter = {CLOBBER};
      }
  }
  p = p->parent;
  <D.17453>:
  if (p != 0B) goto <D.17452>; else goto <D.17454>;
  <D.17454>:
}


print_field_value (const char * field_ptr, struct MonoClassField * field, int type_offset)
{
  int D.18690;
  int D.18691;
  const char * D.18692;
  struct MonoType * D.18693;
  unsigned char D.18694;
  int D.18695;
  const void * D.18696;
  struct MonoObject * D.18697;
  int D.18698;
  const char * D.18701;
  signed char D.18702;
  int D.18703;
  unsigned char D.18704;
  int D.18705;
  short int D.18706;
  int D.18707;
  short unsigned int D.18708;
  int D.18709;
  int D.18710;
  unsigned int D.18711;
  long int D.18712;
  long unsigned int D.18713;
  float D.18714;
  double D.18715;
  double D.18716;
  const char * iftmp.43;
  struct MonoType * type;

  D.18690 = field->offset;
  D.18691 = D.18690 + type_offset;
  D.18692 = mono_field_get_name (field);
  monoeg_g_print ("At %p (ofs: %2d) %s: ", field_ptr, D.18691, D.18692);
  D.18693 = field->type;
  type = mono_type_get_underlying_type (D.18693);
  D.18694 = type->type;
  D.18695 = (int) D.18694;
  switch (D.18695) <default: <D.17437>, case 2: <D.17435>, case 3: <D.17436>, case 4: <D.17425>, case 5: <D.17426>, case 6: <D.17427>, case 7: <D.17428>, case 8: <D.17429>, case 9: <D.17430>, case 10: <D.17431>, case 11: <D.17432>, case 12: <D.17433>, case 13: <D.17434>, case 14: <D.17417>, case 15: <D.17414>, case 17: <D.17423>, case 18: <D.17419>, case 20: <D.17421>, case 21: <D.17422>, case 24: <D.17412>, case 25: <D.17413>, case 27: <D.17415>, case 28: <D.17420>, case 29: <D.17418>>
  <D.17412>:
  <D.17413>:
  <D.17414>:
  <D.17415>:
  D.18696 = MEM[(const void * *)field_ptr];
  monoeg_g_print ("%p\n", D.18696);
  goto <D.17416>;
  <D.17417>:
  <D.17418>:
  <D.17419>:
  <D.17420>:
  <D.17421>:
  D.18697 = MEM[(struct MonoObject * *)field_ptr];
  mono_object_describe (D.18697);
  goto <D.17416>;
  <D.17422>:
  D.18698 = mono_type_generic_inst_is_valuetype (type);
  if (D.18698 == 0) goto <D.18699>; else goto <D.18700>;
  <D.18699>:
  D.18697 = MEM[(struct MonoObject * *)field_ptr];
  mono_object_describe (D.18697);
  goto <D.17416>;
  <D.18700>:
  <D.17423>:
  {
    struct MonoClass * k;

    k = mono_class_from_mono_type (type);
    D.18701 = k->name;
    monoeg_g_print ("%s ValueType (type: %p) at %p\n", D.18701, k, field_ptr);
    goto <D.17416>;
  }
  <D.17425>:
  D.18702 = MEM[(gint8 *)field_ptr];
  D.18703 = (int) D.18702;
  monoeg_g_print ("%d\n", D.18703);
  goto <D.17416>;
  <D.17426>:
  D.18704 = MEM[(guint8 *)field_ptr];
  D.18705 = (int) D.18704;
  monoeg_g_print ("%d\n", D.18705);
  goto <D.17416>;
  <D.17427>:
  D.18706 = MEM[(gint16 *)field_ptr];
  D.18707 = (int) D.18706;
  monoeg_g_print ("%d\n", D.18707);
  goto <D.17416>;
  <D.17428>:
  D.18708 = MEM[(guint16 *)field_ptr];
  D.18709 = (int) D.18708;
  monoeg_g_print ("%d\n", D.18709);
  goto <D.17416>;
  <D.17429>:
  D.18710 = MEM[(gint32 *)field_ptr];
  monoeg_g_print ("%d\n", D.18710);
  goto <D.17416>;
  <D.17430>:
  D.18711 = MEM[(guint32 *)field_ptr];
  monoeg_g_print ("%u\n", D.18711);
  goto <D.17416>;
  <D.17431>:
  D.18712 = MEM[(gint64 *)field_ptr];
  monoeg_g_print ("%lld\n", D.18712);
  goto <D.17416>;
  <D.17432>:
  D.18713 = MEM[(guint64 *)field_ptr];
  monoeg_g_print ("%llu\n", D.18713);
  goto <D.17416>;
  <D.17433>:
  D.18714 = MEM[(gfloat *)field_ptr];
  D.18715 = (double) D.18714;
  monoeg_g_print ("%f\n", D.18715);
  goto <D.17416>;
  <D.17434>:
  D.18716 = MEM[(gdouble *)field_ptr];
  monoeg_g_print ("%f\n", D.18716);
  goto <D.17416>;
  <D.17435>:
  D.18704 = MEM[(guint8 *)field_ptr];
  if (D.18704 != 0) goto <D.18718>; else goto <D.18719>;
  <D.18718>:
  iftmp.43 = "True";
  goto <D.18720>;
  <D.18719>:
  iftmp.43 = "False";
  <D.18720>:
  D.18704 = MEM[(guint8 *)field_ptr];
  D.18705 = (int) D.18704;
  monoeg_g_print ("%s (%d)\n", iftmp.43, D.18705);
  goto <D.17416>;
  <D.17436>:
  D.18708 = MEM[(guint16 *)field_ptr];
  D.18709 = (int) D.18708;
  D.18708 = MEM[(guint16 *)field_ptr];
  D.18709 = (int) D.18708;
  D.18708 = MEM[(guint16 *)field_ptr];
  D.18709 = (int) D.18708;
  monoeg_g_print ("\'%c\' (%d 0x%04x)\n", D.18709, D.18709, D.18709);
  goto <D.17416>;
  <D.17437>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "debug-helpers.c", 928);
  <D.17416>:
}


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


mono_class_describe_statics (struct MonoClass * klass)
{
  struct MonoDomain * D.18721;
  struct MonoType * D.18726;
  short unsigned int D.18727;
  int D.18728;
  int D.18729;
  int D.18732;
  int D.18735;
  sizetype D.18736;
  struct MonoClassField * field;
  struct MonoClass * p;
  const char * field_ptr;
  struct MonoVTable * vtable;
  const char * addr;

  D.18721 = mono_domain_get ();
  vtable = mono_class_vtable_full (D.18721, klass, 0);
  if (vtable == 0B) goto <D.18722>; else goto <D.18723>;
  <D.18722>:
  return;
  <D.18723>:
  addr = mono_vtable_get_static_field_data (vtable);
  if (addr == 0B) goto <D.18724>; else goto <D.18725>;
  <D.18724>:
  return;
  <D.18725>:
  p = klass;
  goto <D.17476>;
  <D.17475>:
  {
    void * iter;

    try
      {
        iter = 0B;
        goto <D.17472>;
        <D.17473>:
        D.18726 = field->type;
        D.18727 = D.18726->attrs;
        D.18728 = (int) D.18727;
        D.18729 = D.18728 & 64;
        if (D.18729 != 0) goto <D.18730>; else goto <D.18731>;
        <D.18730>:
        // predicted unlikely by continue predictor.
        goto <D.17472>;
        <D.18731>:
        D.18726 = field->type;
        D.18727 = D.18726->attrs;
        D.18728 = (int) D.18727;
        D.18732 = D.18728 & 272;
        if (D.18732 == 0) goto <D.18733>; else goto <D.18734>;
        <D.18733>:
        // predicted unlikely by continue predictor.
        goto <D.17472>;
        <D.18734>:
        D.18735 = field->offset;
        D.18736 = (sizetype) D.18735;
        field_ptr = addr + D.18736;
        print_field_value (field_ptr, field, 0);
        <D.17472>:
        field = mono_class_get_fields (p, &iter);
        if (field != 0B) goto <D.17473>; else goto <D.17474>;
        <D.17474>:
      }
    finally
      {
        iter = {CLOBBER};
      }
  }
  p = p->parent;
  <D.17476>:
  if (p != 0B) goto <D.17475>; else goto <D.17477>;
  <D.17477>:
}