mono_type_get_desc (struct GString * res, struct MonoType * type, gboolean include_namespace)
{
  unsigned char D.16882;
  int D.16883;
  struct MonoType * D.16884;
  struct MonoArrayType * D.16885;
  struct MonoClass * D.16886;
  struct MonoType * D.16887;
  unsigned char D.16888;
  int D.16889;
  struct MonoClass * D.16890;
  struct MonoType * D.16891;
  struct MonoGenericClass * D.16892;
  struct MonoClass * D.16893;
  struct MonoType * D.16894;
  struct MonoGenericInst * D.16895;
  struct MonoType * D.16900;
  <unnamed-unsigned:22> D.16901;
  int D.16902;
  struct MonoGenericInst * D.16903;
  struct MonoType * D.16910;
  <unnamed-unsigned:22> D.16911;
  int D.16912;
  struct MonoGenericParam * D.16913;
  struct MonoGenericParamInfo * iftmp.0;
  struct MonoGenericContainer * D.16917;
  const char * D.16923;
  const char * iftmp.1;
  short unsigned int D.16929;
  int D.16930;
  long unsigned int D.16932;
  long unsigned int D.16933;
  int i;

  D.16882 = type->type;
  D.16883 = (int) D.16882;
  switch (D.16883) <default: <D.16612>, case 1: <D.16576>, case 2: <D.16579>, case 3: <D.16578>, case 4: <D.16581>, case 5: <D.16580>, case 6: <D.16583>, case 7: <D.16582>, case 8: <D.16585>, case 9: <D.16584>, case 10: <D.16587>, case 11: <D.16586>, case 12: <D.16591>, case 13: <D.16592>, case 14: <D.16593>, case 15: <D.16595>, case 17: <D.16599>, case 18: <D.16598>, case 19: <D.16608>, case 20: <D.16596>, case 21: <D.16600>, case 22: <D.16611>, case 24: <D.16590>, case 25: <D.16589>, case 27: <D.16588>, case 28: <D.16594>, case 29: <D.16597>, case 30: <D.16609>>
  <D.16576>:
  monoeg_g_string_append (res, "void");
  goto <D.16577>;
  <D.16578>:
  monoeg_g_string_append (res, "char");
  goto <D.16577>;
  <D.16579>:
  monoeg_g_string_append (res, "bool");
  goto <D.16577>;
  <D.16580>:
  monoeg_g_string_append (res, "byte");
  goto <D.16577>;
  <D.16581>:
  monoeg_g_string_append (res, "sbyte");
  goto <D.16577>;
  <D.16582>:
  monoeg_g_string_append (res, "uint16");
  goto <D.16577>;
  <D.16583>:
  monoeg_g_string_append (res, "int16");
  goto <D.16577>;
  <D.16584>:
  monoeg_g_string_append (res, "uint");
  goto <D.16577>;
  <D.16585>:
  monoeg_g_string_append (res, "int");
  goto <D.16577>;
  <D.16586>:
  monoeg_g_string_append (res, "ulong");
  goto <D.16577>;
  <D.16587>:
  monoeg_g_string_append (res, "long");
  goto <D.16577>;
  <D.16588>:
  monoeg_g_string_append (res, "*()");
  goto <D.16577>;
  <D.16589>:
  monoeg_g_string_append (res, "uintptr");
  goto <D.16577>;
  <D.16590>:
  monoeg_g_string_append (res, "intptr");
  goto <D.16577>;
  <D.16591>:
  monoeg_g_string_append (res, "single");
  goto <D.16577>;
  <D.16592>:
  monoeg_g_string_append (res, "double");
  goto <D.16577>;
  <D.16593>:
  monoeg_g_string_append (res, "string");
  goto <D.16577>;
  <D.16594>:
  monoeg_g_string_append (res, "object");
  goto <D.16577>;
  <D.16595>:
  D.16884 = type->data.type;
  mono_type_get_desc (res, D.16884, include_namespace);
  monoeg_g_string_append_c (res, 42);
  goto <D.16577>;
  <D.16596>:
  D.16885 = type->data.array;
  D.16886 = D.16885->eklass;
  D.16887 = &D.16886->byval_arg;
  mono_type_get_desc (res, D.16887, include_namespace);
  D.16885 = type->data.array;
  D.16888 = D.16885->rank;
  D.16889 = (int) D.16888;
  monoeg_g_string_append_printf (res, "[%d]", D.16889);
  goto <D.16577>;
  <D.16597>:
  D.16890 = type->data.klass;
  D.16891 = &D.16890->byval_arg;
  mono_type_get_desc (res, D.16891, include_namespace);
  monoeg_g_string_append (res, "[]");
  goto <D.16577>;
  <D.16598>:
  <D.16599>:
  D.16890 = type->data.klass;
  append_class_name (res, D.16890, include_namespace);
  goto <D.16577>;
  <D.16600>:
  {
    struct MonoGenericContext * context;

    D.16892 = type->data.generic_class;
    D.16893 = D.16892->container_class;
    D.16894 = &D.16893->byval_arg;
    mono_type_get_desc (res, D.16894, include_namespace);
    monoeg_g_string_append (res, "<");
    D.16892 = type->data.generic_class;
    context = &D.16892->context;
    D.16895 = context->class_inst;
    if (D.16895 != 0B) goto <D.16896>; else goto <D.16897>;
    <D.16896>:
    i = 0;
    goto <D.16603>;
    <D.16602>:
    if (i > 0) goto <D.16898>; else goto <D.16899>;
    <D.16898>:
    monoeg_g_string_append (res, ", ");
    <D.16899>:
    D.16895 = context->class_inst;
    D.16900 = D.16895->type_argv[i];
    mono_type_get_desc (res, D.16900, include_namespace);
    i = i + 1;
    <D.16603>:
    D.16895 = context->class_inst;
    D.16901 = D.16895->type_argc;
    D.16902 = (int) D.16901;
    if (D.16902 > i) goto <D.16602>; else goto <D.16604>;
    <D.16604>:
    <D.16897>:
    D.16903 = context->method_inst;
    if (D.16903 != 0B) goto <D.16904>; else goto <D.16905>;
    <D.16904>:
    D.16895 = context->class_inst;
    if (D.16895 != 0B) goto <D.16906>; else goto <D.16907>;
    <D.16906>:
    monoeg_g_string_append (res, "; ");
    <D.16907>:
    i = 0;
    goto <D.16606>;
    <D.16605>:
    if (i > 0) goto <D.16908>; else goto <D.16909>;
    <D.16908>:
    monoeg_g_string_append (res, ", ");
    <D.16909>:
    D.16903 = context->method_inst;
    D.16910 = D.16903->type_argv[i];
    mono_type_get_desc (res, D.16910, include_namespace);
    i = i + 1;
    <D.16606>:
    D.16903 = context->method_inst;
    D.16911 = D.16903->type_argc;
    D.16912 = (int) D.16911;
    if (D.16912 > i) goto <D.16605>; else goto <D.16607>;
    <D.16607>:
    <D.16905>:
    monoeg_g_string_append (res, ">");
    goto <D.16577>;
  }
  <D.16608>:
  <D.16609>:
  D.16913 = type->data.generic_param;
  if (D.16913 != 0B) goto <D.16914>; else goto <D.16915>;
  <D.16914>:
  {
    struct MonoGenericParamInfo * info;

    D.16913 = type->data.generic_param;
    D.16917 = D.16913->owner;
    if (D.16917 != 0B) goto <D.16918>; else goto <D.16919>;
    <D.16918>:
    D.16913 = type->data.generic_param;
    iftmp.0 = &MEM[(struct MonoGenericParamFull *)D.16913].info;
    goto <D.16920>;
    <D.16919>:
    iftmp.0 = 0B;
    <D.16920>:
    info = iftmp.0;
    if (info != 0B) goto <D.16921>; else goto <D.16922>;
    <D.16921>:
    D.16923 = info->name;
    monoeg_g_string_append (res, D.16923);
    goto <D.16924>;
    <D.16922>:
    D.16882 = type->type;
    if (D.16882 == 19) goto <D.16926>; else goto <D.16927>;
    <D.16926>:
    iftmp.1 = "!";
    goto <D.16928>;
    <D.16927>:
    iftmp.1 = "!!";
    <D.16928>:
    D.16913 = type->data.generic_param;
    D.16929 = D.16913->num;
    D.16930 = (int) D.16929;
    monoeg_g_string_append_printf (res, "%s%d", iftmp.1, D.16930);
    <D.16924>:
  }
  goto <D.16931>;
  <D.16915>:
  monoeg_g_string_append (res, "<unknown>");
  <D.16931>:
  goto <D.16577>;
  <D.16611>:
  monoeg_g_string_append (res, "typedbyref");
  goto <D.16577>;
  <D.16612>:
  goto <D.16577>;
  <D.16577>:
  D.16932 = BIT_FIELD_REF <*type, 64, 64>;
  D.16933 = D.16932 & 8589934592;
  if (D.16933 != 0) goto <D.16934>; else goto <D.16935>;
  <D.16934>:
  monoeg_g_string_append_c (res, 38);
  <D.16935>:
}


append_class_name (struct GString * res, struct MonoClass * class, gboolean include_namespace)
{
  struct MonoClass * D.16939;
  const char * D.16944;
  char D.16945;
  const char * D.16948;

  if (class == 0B) goto <D.16937>; else goto <D.16938>;
  <D.16937>:
  monoeg_g_string_append (res, "Unknown");
  return;
  <D.16938>:
  D.16939 = class->nested_in;
  if (D.16939 != 0B) goto <D.16940>; else goto <D.16941>;
  <D.16940>:
  D.16939 = class->nested_in;
  append_class_name (res, D.16939, include_namespace);
  monoeg_g_string_append_c (res, 47);
  <D.16941>:
  if (include_namespace != 0) goto <D.16942>; else goto <D.16943>;
  <D.16942>:
  D.16944 = class->name_space;
  D.16945 = *D.16944;
  if (D.16945 != 0) goto <D.16946>; else goto <D.16947>;
  <D.16946>:
  D.16944 = class->name_space;
  monoeg_g_string_append_printf (res, "%s.", D.16944);
  <D.16947>:
  <D.16943>:
  D.16948 = class->name;
  monoeg_g_string_append_printf (res, "%s", D.16948);
}


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

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


mono_signature_get_desc (struct MonoMethodSignature * sig, gboolean include_namespace)
{
  char * D.16954;
  struct MonoType * D.16957;
  short unsigned int D.16958;
  int D.16959;
  int i;
  char * result;
  struct GString * res;

  if (sig == 0B) goto <D.16952>; else goto <D.16953>;
  <D.16952>:
  D.16954 = monoeg_strdup ("<invalid signature>");
  return D.16954;
  <D.16953>:
  res = monoeg_g_string_new ("");
  i = 0;
  goto <D.16625>;
  <D.16624>:
  if (i > 0) goto <D.16955>; else goto <D.16956>;
  <D.16955>:
  monoeg_g_string_append_c (res, 44);
  <D.16956>:
  D.16957 = sig->params[i];
  mono_type_get_desc (res, D.16957, include_namespace);
  i = i + 1;
  <D.16625>:
  D.16958 = sig->param_count;
  D.16959 = (int) D.16958;
  if (D.16959 > i) goto <D.16624>; else goto <D.16626>;
  <D.16626>:
  result = res->str;
  monoeg_g_string_free (res, 0);
  D.16954 = result;
  return D.16954;
}


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

  if (str != 0B) goto <D.16961>; else goto <D.16962>;
  <D.16961>:
  D.16963 = __strdup (str);
  return D.16963;
  <D.16962>:
  D.16963 = 0B;
  return D.16963;
}


mono_context_get_desc (struct MonoGenericContext * context)
{
  struct MonoGenericInst * D.16965;
  struct MonoGenericInst * D.16968;
  char * D.16973;
  char * D.16974;
  struct GString * str;
  char * res;

  str = monoeg_g_string_new ("");
  monoeg_g_string_append (str, "<");
  D.16965 = context->class_inst;
  if (D.16965 != 0B) goto <D.16966>; else goto <D.16967>;
  <D.16966>:
  D.16965 = context->class_inst;
  ginst_get_desc (str, D.16965);
  <D.16967>:
  D.16968 = context->method_inst;
  if (D.16968 != 0B) goto <D.16969>; else goto <D.16970>;
  <D.16969>:
  D.16965 = context->class_inst;
  if (D.16965 != 0B) goto <D.16971>; else goto <D.16972>;
  <D.16971>:
  monoeg_g_string_append (str, "; ");
  <D.16972>:
  D.16968 = context->method_inst;
  ginst_get_desc (str, D.16968);
  <D.16970>:
  monoeg_g_string_append (str, ">");
  D.16973 = str->str;
  res = monoeg_strdup (D.16973);
  monoeg_g_string_free (str, 1);
  D.16974 = res;
  return D.16974;
}


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

  i = 0;
  goto <D.16633>;
  <D.16632>:
  if (i > 0) goto <D.16976>; else goto <D.16977>;
  <D.16976>:
  monoeg_g_string_append (str, ", ");
  <D.16977>:
  D.16978 = ginst->type_argv[i];
  mono_type_get_desc (str, D.16978, 1);
  i = i + 1;
  <D.16633>:
  D.16979 = ginst->type_argc;
  D.16980 = (int) D.16979;
  if (D.16980 > i) goto <D.16632>; else goto <D.16634>;
  <D.16634>:
}


mono_method_desc_new (const char * name, gboolean include_namespace)
{
  char * D.16985;
  char D.16986;
  char * use_args.2;
  struct MonoMethodDesc * D.16992;
  char * D.16997;
  char D.16998;
  char * method_name.3;
  char * class_name.4;
  char * iftmp.5;
  char * D.17010;
  char * D.17011;
  char * D.17014;
  char * D.17015;
  char D.17020;
  unsigned int D.17025;
  unsigned int D.17026;
  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.16981>; else goto <D.16982>;
  <D.16981>:
  if (use_args > class_nspace) goto <D.16983>; else goto <D.16984>;
  <D.16983>:
  D.16985 = use_args + 18446744073709551615;
  D.16986 = *D.16985;
  if (D.16986 == 32) goto <D.16987>; else goto <D.16988>;
  <D.16987>:
  D.16985 = use_args + 18446744073709551615;
  *D.16985 = 0;
  <D.16988>:
  <D.16984>:
  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.16990>; else goto <D.16991>;
  <D.16990>:
  monoeg_g_free (class_nspace);
  D.16992 = 0B;
  return D.16992;
  <D.16991>:
  *end = 0;
  <D.16982>:
  method_name = strrchr (class_nspace, 58);
  if (method_name == 0B) goto <D.16993>; else goto <D.16994>;
  <D.16993>:
  monoeg_g_free (class_nspace);
  D.16992 = 0B;
  return D.16992;
  <D.16994>:
  if (method_name != class_nspace) goto <D.16995>; else goto <D.16996>;
  <D.16995>:
  D.16997 = method_name + 18446744073709551615;
  D.16998 = *D.16997;
  if (D.16998 == 58) goto <D.16999>; else goto <D.17000>;
  <D.16999>:
  D.16997 = method_name + 18446744073709551615;
  *D.16997 = 0;
  <D.17000>:
  <D.16996>:
  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.17002>; else goto <D.17003>;
  <D.17002>:
  class_name.4 = class_name;
  class_name = class_name.4 + 1;
  *class_name.4 = 0;
  use_namespace = 1;
  goto <D.17005>;
  <D.17003>:
  class_name = class_nspace;
  use_namespace = 0;
  <D.17005>:
  result = monoeg_malloc0 (48);
  result->include_namespace = include_namespace;
  result->name = method_name;
  result->klass = class_name;
  if (use_namespace != 0) goto <D.17007>; else goto <D.17008>;
  <D.17007>:
  iftmp.5 = class_nspace;
  goto <D.17009>;
  <D.17008>:
  iftmp.5 = 0B;
  <D.17009>:
  result->namespace = iftmp.5;
  result->args = use_args;
  D.17010 = result->name;
  D.17011 = __builtin_strchr (D.17010, 42);
  if (D.17011 != 0B) goto <D.17012>; else goto <D.17013>;
  <D.17012>:
  result->name_glob = 1;
  <D.17013>:
  D.17014 = result->klass;
  D.17015 = __builtin_strchr (D.17014, 42);
  if (D.17015 != 0B) goto <D.17016>; else goto <D.17017>;
  <D.17016>:
  result->klass_glob = 1;
  <D.17017>:
  if (use_args != 0B) goto <D.17018>; else goto <D.17019>;
  <D.17018>:
  end = use_args;
  D.17020 = *end;
  if (D.17020 != 0) goto <D.17021>; else goto <D.17022>;
  <D.17021>:
  result->num_args = 1;
  <D.17022>:
  goto <D.16652>;
  <D.16651>:
  D.17020 = *end;
  if (D.17020 == 44) goto <D.17023>; else goto <D.17024>;
  <D.17023>:
  D.17025 = result->num_args;
  D.17026 = D.17025 + 1;
  result->num_args = D.17026;
  <D.17024>:
  end = end + 1;
  <D.16652>:
  D.17020 = *end;
  if (D.17020 != 0) goto <D.16651>; else goto <D.16653>;
  <D.16653>:
  <D.17019>:
  D.16992 = result;
  return D.16992;
}


mono_method_desc_from_method (struct MonoMethod * method)
{
  const char * D.17028;
  gchar * D.17029;
  struct MonoClass * D.17030;
  const char * D.17031;
  gchar * D.17032;
  const char * D.17033;
  gchar * D.17034;
  struct MonoMethodDesc * D.17035;
  struct MonoMethodDesc * result;

  result = monoeg_malloc0 (48);
  result->include_namespace = 1;
  D.17028 = method->name;
  D.17029 = monoeg_strdup (D.17028);
  result->name = D.17029;
  D.17030 = method->klass;
  D.17031 = D.17030->name;
  D.17032 = monoeg_strdup (D.17031);
  result->klass = D.17032;
  D.17030 = method->klass;
  D.17033 = D.17030->name_space;
  D.17034 = monoeg_strdup (D.17033);
  result->namespace = D.17034;
  D.17035 = result;
  return D.17035;
}


mono_method_desc_free (struct MonoMethodDesc * desc)
{
  char * D.17037;
  char * D.17041;

  D.17037 = desc->namespace;
  if (D.17037 != 0B) goto <D.17038>; else goto <D.17039>;
  <D.17038>:
  D.17037 = desc->namespace;
  monoeg_g_free (D.17037);
  goto <D.17040>;
  <D.17039>:
  D.17041 = desc->klass;
  if (D.17041 != 0B) goto <D.17042>; else goto <D.17043>;
  <D.17042>:
  D.17041 = desc->klass;
  monoeg_g_free (D.17041);
  <D.17043>:
  <D.17040>:
  monoeg_g_free (desc);
}


mono_method_desc_match (struct MonoMethodDesc * desc, struct MonoMethod * method)
{
  char * D.17044;
  const char * D.17045;
  int D.17046;
  _Bool D.17047;
  mono_bool D.17050;
  char * D.17051;
  unsigned int D.17054;
  struct MonoMethodSignature * D.17055;
  short unsigned int D.17056;
  unsigned int D.17057;
  struct MonoMethodSignature * D.17060;
  int D.17061;
  int D.17062;
  char * sig;
  gboolean name_match;

  D.17044 = desc->name;
  D.17045 = method->name;
  D.17046 = strcmp (D.17044, D.17045);
  D.17047 = D.17046 == 0;
  name_match = (gboolean) D.17047;
  if (name_match == 0) goto <D.17048>; else goto <D.17049>;
  <D.17048>:
  D.17050 = 0;
  return D.17050;
  <D.17049>:
  D.17051 = desc->args;
  if (D.17051 == 0B) goto <D.17052>; else goto <D.17053>;
  <D.17052>:
  D.17050 = 1;
  return D.17050;
  <D.17053>:
  D.17054 = desc->num_args;
  D.17055 = mono_method_signature (method);
  D.17056 = D.17055->param_count;
  D.17057 = (unsigned int) D.17056;
  if (D.17054 != D.17057) goto <D.17058>; else goto <D.17059>;
  <D.17058>:
  D.17050 = 0;
  return D.17050;
  <D.17059>:
  D.17060 = mono_method_signature (method);
  D.17061 = desc->include_namespace;
  sig = mono_signature_get_desc (D.17060, D.17061);
  D.17051 = desc->args;
  D.17062 = strcmp (sig, D.17051);
  if (D.17062 != 0) goto <D.17063>; else goto <D.17064>;
  <D.17063>:
  monoeg_g_free (sig);
  D.17050 = 0;
  return D.17050;
  <D.17064>:
  monoeg_g_free (sig);
  D.17050 = 1;
  return D.17050;
}


__attribute__((__gnu_inline__, nothrow, leaf, pure))
strcmp (const char * __s1, const char * __s2)
{
  int iftmp.6;
  int iftmp.7;
  int D.17074;
  char * __p1;
  char * __p2;
  int __ret;

  __p1 = __s1;
  __p2 = __s2;
  __asm__ __volatile__("   slr   0,0
0: clst  %1,%2
   jo    0b
   ipm   %0
   srl   %0,28" : "=d" __ret, "=&a" __p1, "=&a" __p2 : "1" __p1, "2" __p2 : "0", "memory", "cc");
  if (__ret != 0) goto <D.17067>; else goto <D.17068>;
  <D.17067>:
  if (__ret == 1) goto <D.17070>; else goto <D.17071>;
  <D.17070>:
  iftmp.7 = -1;
  goto <D.17072>;
  <D.17071>:
  iftmp.7 = 1;
  <D.17072>:
  iftmp.6 = iftmp.7;
  goto <D.17073>;
  <D.17068>:
  iftmp.6 = 0;
  <D.17073>:
  __ret = iftmp.6;
  D.17074 = __ret;
  return D.17074;
}


mono_method_desc_full_match (struct MonoMethodDesc * desc, struct MonoMethod * method)
{
  char * D.17076;
  mono_bool D.17079;
  long unsigned int D.17080;
  int D.17081;
  struct MonoClass * D.17082;
  int D.17083;

  D.17076 = desc->klass;
  if (D.17076 == 0B) goto <D.17077>; else goto <D.17078>;
  <D.17077>:
  D.17079 = 0;
  return D.17079;
  <D.17078>:
  D.17076 = desc->klass;
  D.17080 = __strlen_g (D.17076);
  D.17081 = (int) D.17080;
  D.17082 = method->klass;
  D.17083 = match_class (desc, D.17081, D.17082);
  if (D.17083 == 0) goto <D.17084>; else goto <D.17085>;
  <D.17084>:
  D.17079 = 0;
  return D.17079;
  <D.17085>:
  D.17079 = mono_method_desc_match (desc, method);
  return D.17079;
}


__attribute__((__gnu_inline__))
__strlen_g (const char * __str)
{
  size_t D.17087;
  long int __ptr.8;
  long int __str.9;
  long int D.17090;
  char * __ptr;
  char * __tmp;

  __ptr = 0B;
  __tmp = __str;
  __asm__ __volatile__("   la    0,0
0: srst  %0,%1
   jo    0b
" : "=&a" __ptr, "=&a" __tmp : "0" __ptr, "1" __tmp : "0", "memory", "cc");
  __ptr.8 = (long int) __ptr;
  __str.9 = (long int) __str;
  D.17090 = __ptr.8 - __str.9;
  D.17087 = (size_t) D.17090;
  return D.17087;
}


match_class (struct MonoMethodDesc * desc, int pos, struct MonoClass * klass)
{
  int D.17092;
  char * D.17095;
  int D.17096;
  gboolean D.17099;
  const char * D.17102;
  int pos.10;
  long unsigned int D.17104;
  int D.17105;
  char * D.17108;
  const char * D.17111;
  int D.17112;
  const char * D.17115;
  int D.17116;
  struct MonoClass * D.17119;
  const char * p;

  D.17092 = desc->klass_glob;
  if (D.17092 != 0) goto <D.17093>; else goto <D.17094>;
  <D.17093>:
  D.17095 = desc->klass;
  D.17096 = strcmp (D.17095, "*");
  if (D.17096 == 0) goto <D.17097>; else goto <D.17098>;
  <D.17097>:
  D.17099 = 1;
  return D.17099;
  <D.17098>:
  <D.17094>:
  D.17095 = desc->klass;
  p = my_strrchr (D.17095, 47, &pos);
  if (p == 0B) goto <D.17100>; else goto <D.17101>;
  <D.17100>:
  D.17095 = desc->klass;
  D.17102 = klass->name;
  pos.10 = pos;
  D.17104 = (long unsigned int) pos.10;
  D.17105 = strncmp (D.17095, D.17102, D.17104);
  if (D.17105 != 0) goto <D.17106>; else goto <D.17107>;
  <D.17106>:
  D.17099 = 0;
  return D.17099;
  <D.17107>:
  D.17108 = desc->namespace;
  if (D.17108 != 0B) goto <D.17109>; else goto <D.17110>;
  <D.17109>:
  D.17108 = desc->namespace;
  D.17111 = klass->name_space;
  D.17112 = strcmp (D.17108, D.17111);
  if (D.17112 != 0) goto <D.17113>; else goto <D.17114>;
  <D.17113>:
  D.17099 = 0;
  return D.17099;
  <D.17114>:
  <D.17110>:
  D.17099 = 1;
  return D.17099;
  <D.17101>:
  D.17115 = p + 1;
  D.17102 = klass->name;
  D.17116 = strcmp (D.17115, D.17102);
  if (D.17116 != 0) goto <D.17117>; else goto <D.17118>;
  <D.17117>:
  D.17099 = 0;
  return D.17099;
  <D.17118>:
  D.17119 = klass->nested_in;
  if (D.17119 == 0B) goto <D.17120>; else goto <D.17121>;
  <D.17120>:
  D.17099 = 0;
  return D.17099;
  <D.17121>:
  pos.10 = pos;
  D.17119 = klass->nested_in;
  D.17099 = match_class (desc, pos.10, D.17119);
  return D.17099;
}


my_strrchr (const char * str, char ch, int * len)
{
  int D.17123;
  sizetype D.17124;
  const char * D.17125;
  char D.17126;
  const char * D.17129;
  int pos;

  D.17123 = *len;
  pos = D.17123 + -1;
  goto <D.16675>;
  <D.16674>:
  D.17124 = (sizetype) pos;
  D.17125 = str + D.17124;
  D.17126 = *D.17125;
  if (D.17126 != ch) goto <D.17127>; else goto <D.17128>;
  <D.17127>:
  // predicted unlikely by continue predictor.
  goto <D.16673>;
  <D.17128>:
  *len = pos;
  D.17124 = (sizetype) pos;
  D.17129 = str + D.17124;
  return D.17129;
  <D.16673>:
  pos = pos + -1;
  <D.16675>:
  if (pos >= 0) goto <D.16674>; else goto <D.16676>;
  <D.16676>:
  D.17129 = 0B;
  return D.17129;
}


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

  try
    {
      iter = 0B;
      goto <D.16694>;
      <D.16693>:
      D.17131 = mono_method_desc_match (desc, m);
      if (D.17131 != 0) goto <D.17132>; else goto <D.17133>;
      <D.17132>:
      D.17134 = m;
      return D.17134;
      <D.17133>:
      <D.16694>:
      m = mono_class_get_methods (klass, &iter);
      if (m != 0B) goto <D.16693>; else goto <D.16695>;
      <D.16695>:
      D.17134 = 0B;
      return D.17134;
    }
  finally
    {
      iter = {CLOBBER};
    }
}


mono_method_desc_search_in_image (struct MonoMethodDesc * desc, struct MonoImage * image)
{
  char * D.17137;
  struct MonoImage * D.17140;
  char * D.17143;
  struct MonoMethod * D.17146;
  char * D.17153;
  int D.17154;
  int D.17157;
  int D.17158;
  unsigned int D.17159;
  int D.17160;
  int D.17163;
  struct MonoClass * klass;
  const struct MonoTableInfo * tdef;
  const struct MonoTableInfo * methods;
  struct MonoMethod * method;
  int i;

  D.17137 = desc->namespace;
  if (D.17137 == 0B) goto <D.17138>; else goto <D.17139>;
  <D.17138>:
  D.17140 = mono_defaults.corlib;
  if (D.17140 == image) goto <D.17141>; else goto <D.17142>;
  <D.17141>:
  D.17143 = desc->klass;
  klass = find_system_class (D.17143);
  if (klass != 0B) goto <D.17144>; else goto <D.17145>;
  <D.17144>:
  D.17146 = mono_method_desc_search_in_class (desc, klass);
  return D.17146;
  <D.17145>:
  <D.17142>:
  <D.17139>:
  D.17137 = desc->namespace;
  if (D.17137 != 0B) goto <D.17147>; else goto <D.17148>;
  <D.17147>:
  D.17143 = desc->klass;
  if (D.17143 != 0B) goto <D.17149>; else goto <D.17150>;
  <D.17149>:
  D.17137 = desc->namespace;
  D.17143 = desc->klass;
  klass = mono_class_from_name (image, D.17137, D.17143);
  if (klass == 0B) goto <D.17151>; else goto <D.17152>;
  <D.17151>:
  D.17146 = 0B;
  return D.17146;
  <D.17152>:
  D.17146 = mono_method_desc_search_in_class (desc, klass);
  return D.17146;
  <D.17150>:
  <D.17148>:
  tdef = mono_image_get_table_info (image, 2);
  methods = mono_image_get_table_info (image, 6);
  i = 0;
  goto <D.16709>;
  <D.16708>:
  {
    guint32 token;
    const char * n;

    token = mono_metadata_decode_row_col (methods, i, 3);
    n = mono_metadata_string_heap (image, token);
    D.17153 = desc->name;
    D.17154 = strcmp (n, D.17153);
    if (D.17154 != 0) goto <D.17155>; else goto <D.17156>;
    <D.17155>:
    // predicted unlikely by continue predictor.
    goto <D.16707>;
    <D.17156>:
    D.17157 = i + 1;
    D.17158 = D.17157 | 100663296;
    D.17159 = (unsigned int) D.17158;
    method = mono_get_method (image, D.17159, 0B);
    D.17160 = mono_method_desc_full_match (desc, method);
    if (D.17160 != 0) goto <D.17161>; else goto <D.17162>;
    <D.17161>:
    D.17146 = method;
    return D.17146;
    <D.17162>:
  }
  <D.16707>:
  i = i + 1;
  <D.16709>:
  D.17163 = mono_table_info_get_rows (methods);
  if (D.17163 > i) goto <D.16708>; else goto <D.16710>;
  <D.16710>:
  D.17146 = 0B;
  return D.17146;
}


find_system_class (const char * name)
{
  int D.17165;
  struct MonoClass * D.17168;
  int D.17169;
  int D.17172;
  int D.17175;
  int D.17178;
  int D.17181;
  int D.17184;
  int D.17187;
  int D.17190;
  int D.17193;
  int D.17196;
  int D.17199;
  int D.17202;
  int D.17205;
  int D.17208;
  int D.17211;
  int D.17214;

  D.17165 = strcmp (name, "void");
  if (D.17165 == 0) goto <D.17166>; else goto <D.17167>;
  <D.17166>:
  D.17168 = mono_defaults.void_class;
  return D.17168;
  <D.17167>:
  D.17169 = strcmp (name, "char");
  if (D.17169 == 0) goto <D.17170>; else goto <D.17171>;
  <D.17170>:
  D.17168 = mono_defaults.char_class;
  return D.17168;
  <D.17171>:
  D.17172 = strcmp (name, "bool");
  if (D.17172 == 0) goto <D.17173>; else goto <D.17174>;
  <D.17173>:
  D.17168 = mono_defaults.boolean_class;
  return D.17168;
  <D.17174>:
  D.17175 = strcmp (name, "byte");
  if (D.17175 == 0) goto <D.17176>; else goto <D.17177>;
  <D.17176>:
  D.17168 = mono_defaults.byte_class;
  return D.17168;
  <D.17177>:
  D.17178 = strcmp (name, "sbyte");
  if (D.17178 == 0) goto <D.17179>; else goto <D.17180>;
  <D.17179>:
  D.17168 = mono_defaults.sbyte_class;
  return D.17168;
  <D.17180>:
  D.17181 = strcmp (name, "uint16");
  if (D.17181 == 0) goto <D.17182>; else goto <D.17183>;
  <D.17182>:
  D.17168 = mono_defaults.uint16_class;
  return D.17168;
  <D.17183>:
  D.17184 = strcmp (name, "int16");
  if (D.17184 == 0) goto <D.17185>; else goto <D.17186>;
  <D.17185>:
  D.17168 = mono_defaults.int16_class;
  return D.17168;
  <D.17186>:
  D.17187 = strcmp (name, "uint");
  if (D.17187 == 0) goto <D.17188>; else goto <D.17189>;
  <D.17188>:
  D.17168 = mono_defaults.uint32_class;
  return D.17168;
  <D.17189>:
  D.17190 = strcmp (name, "int");
  if (D.17190 == 0) goto <D.17191>; else goto <D.17192>;
  <D.17191>:
  D.17168 = mono_defaults.int32_class;
  return D.17168;
  <D.17192>:
  D.17193 = strcmp (name, "ulong");
  if (D.17193 == 0) goto <D.17194>; else goto <D.17195>;
  <D.17194>:
  D.17168 = mono_defaults.uint64_class;
  return D.17168;
  <D.17195>:
  D.17196 = strcmp (name, "long");
  if (D.17196 == 0) goto <D.17197>; else goto <D.17198>;
  <D.17197>:
  D.17168 = mono_defaults.int64_class;
  return D.17168;
  <D.17198>:
  D.17199 = strcmp (name, "uintptr");
  if (D.17199 == 0) goto <D.17200>; else goto <D.17201>;
  <D.17200>:
  D.17168 = mono_defaults.uint_class;
  return D.17168;
  <D.17201>:
  D.17202 = strcmp (name, "intptr");
  if (D.17202 == 0) goto <D.17203>; else goto <D.17204>;
  <D.17203>:
  D.17168 = mono_defaults.int_class;
  return D.17168;
  <D.17204>:
  D.17205 = strcmp (name, "single");
  if (D.17205 == 0) goto <D.17206>; else goto <D.17207>;
  <D.17206>:
  D.17168 = mono_defaults.single_class;
  return D.17168;
  <D.17207>:
  D.17208 = strcmp (name, "double");
  if (D.17208 == 0) goto <D.17209>; else goto <D.17210>;
  <D.17209>:
  D.17168 = mono_defaults.double_class;
  return D.17168;
  <D.17210>:
  D.17211 = strcmp (name, "string");
  if (D.17211 == 0) goto <D.17212>; else goto <D.17213>;
  <D.17212>:
  D.17168 = mono_defaults.string_class;
  return D.17168;
  <D.17213>:
  D.17214 = strcmp (name, "object");
  if (D.17214 == 0) goto <D.17215>; else goto <D.17216>;
  <D.17215>:
  D.17168 = mono_defaults.object_class;
  return D.17168;
  <D.17216>:
  D.17168 = 0B;
  return D.17168;
}


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

  res = monoeg_g_string_new ("");
  if (dh == 0B) goto <D.17218>; else goto <D.17219>;
  <D.17218>:
  dh = &default_dh;
  <D.17219>:
  D.17220 = ip + 2;
  ip = dis_one (res, dh, method, ip, D.17220);
  if (endp != 0B) goto <D.17221>; else goto <D.17222>;
  <D.17221>:
  *endp = ip;
  <D.17222>:
  result = res->str;
  monoeg_g_string_free (res, 0);
  D.17223 = result;
  return D.17223;
}


dis_one (struct GString * str, struct MonoDisHelper * dh, struct MonoMethod * method, const unsigned char * ip, const unsigned char * end)
{
  const unsigned char * ip.11;
  long int ip.12;
  long int il_code.13;
  long int D.17228;
  char * (*<T2956>) (struct MonoDisHelper *, struct MonoMethod *, uint32_t) D.17229;
  const char * D.17232;
  <unnamed type> D.17235;
  const unsigned char * ip.14;
  const char * D.17237;
  unsigned char D.17238;
  int D.17239;
  unsigned int D.17240;
  unsigned int D.17241;
  unsigned int D.17242;
  unsigned int D.17243;
  unsigned int D.17244;
  unsigned int D.17245;
  unsigned int D.17246;
  unsigned int D.17247;
  unsigned int D.17248;
  char * (*<T2956>) (struct MonoDisHelper *, struct MonoMethod *, uint32_t) D.17249;
  const unsigned char * ip.15;
  struct MonoClass * D.17254;
  struct MonoImage * D.17255;
  long unsigned int D.17256;
  long unsigned int D.17257;
  unsigned int D.17260;
  const char * blob.16;
  const char * blob.17;
  unsigned int D.17263;
  long unsigned int D.17264;
  long unsigned int D.17265;
  long unsigned int D.17266;
  long unsigned int D.17267;
  guint16 * D.17268;
  guint16 * D.17269;
  short unsigned int D.17270;
  short unsigned int D.17271;
  signed short D.17272;
  int D.17273;
  int D.17274;
  signed short D.17275;
  signed short D.17276;
  short unsigned int D.17277;
  long unsigned int D.17278;
  long int len2.18;
  short unsigned int D.17282;
  short unsigned int D.17283;
  int D.17284;
  int D.17285;
  int D.17286;
  int D.17287;
  int D.17288;
  const unsigned char * ip.19;
  unsigned char D.17290;
  int D.17291;
  unsigned int D.17292;
  const char * D.17293;
  sizetype D.17296;
  const unsigned char * D.17297;
  long int D.17298;
  long int D.17299;
  signed char D.17301;
  int D.17305;
  sizetype D.17306;
  sizetype D.17311;
  const unsigned char * D.17312;
  long int D.17313;
  long int D.17314;
  long unsigned int D.17316;
  unsigned int D.17317;
  unsigned int D.17318;
  unsigned int D.17319;
  unsigned int D.17320;
  unsigned int D.17321;
  unsigned int D.17322;
  unsigned int D.17323;
  unsigned int D.17324;
  unsigned int D.17325;
  unsigned int D.17326;
  long unsigned int D.17327;
  long unsigned int D.17328;
  long unsigned int D.17329;
  unsigned int D.17330;
  unsigned int D.17331;
  unsigned int D.17332;
  unsigned int D.17333;
  unsigned int D.17334;
  unsigned int D.17335;
  unsigned int D.17336;
  unsigned int D.17337;
  unsigned int D.17338;
  unsigned int D.17339;
  long unsigned int D.17340;
  long unsigned int D.17341;
  double r.20;
  double r.21;
  const unsigned char * ip.22;
  float r.23;
  float r.24;
  double D.17347;
  int D.17348;
  int D.17349;
  const char * D.17350;
  const unsigned char * D.17353;
  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.11 = ip;
  ip.12 = (long int) ip.11;
  il_code.13 = (long int) il_code;
  D.17228 = ip.12 - il_code.13;
  label = (guint32) D.17228;
  D.17229 = dh->indenter;
  if (D.17229 != 0B) goto <D.17230>; else goto <D.17231>;
  <D.17230>:
  D.17229 = dh->indenter;
  tmp = D.17229 (dh, method, label);
  monoeg_g_string_append (str, tmp);
  monoeg_g_free (tmp);
  <D.17231>:
  D.17232 = dh->label_format;
  if (D.17232 != 0B) goto <D.17233>; else goto <D.17234>;
  <D.17233>:
  D.17232 = dh->label_format;
  monoeg_g_string_append_printf (str, D.17232, label);
  <D.17234>:
  D.17235 = mono_opcode_value (&ip, end);
  i = (int) D.17235;
  ip.11 = ip;
  ip.14 = ip.11 + 1;
  ip = ip.14;
  opcode = &mono_opcodes[i];
  D.17237 = mono_opcode_name (i);
  monoeg_g_string_append_printf (str, "%-10s", D.17237);
  D.17238 = opcode->argument;
  D.17239 = (int) D.17238;
  switch (D.17239) <default: <D.16761>, case 0: <D.16726>, case 1: <D.16728>, case 2: <D.16729>, case 3: <D.16730>, case 4: <D.16731>, case 5: <D.16733>, case 6: <D.16732>, case 7: <D.16743>, case 8: <D.16744>, case 9: <D.16745>, case 10: <D.16746>, case 11: <D.16747>, case 12: <D.16752>, case 13: <D.16755>, case 14: <D.16758>, case 15: <D.16759>, case 16: <D.16760>>
  <D.16726>:
  goto <D.16727>;
  <D.16728>:
  <D.16729>:
  <D.16730>:
  <D.16731>:
  <D.16732>:
  ip.11 = ip;
  D.17240 = MEM[(const guint32 *)ip.11];
  D.17241 = D.17240 << 24;
  ip.11 = ip;
  D.17240 = MEM[(const guint32 *)ip.11];
  D.17242 = D.17240 >> 8;
  D.17243 = D.17242 & 65280;
  D.17244 = D.17241 | D.17243;
  ip.11 = ip;
  D.17240 = MEM[(const guint32 *)ip.11];
  D.17245 = D.17240 << 8;
  D.17246 = D.17245 & 16711680;
  D.17247 = D.17244 | D.17246;
  ip.11 = ip;
  D.17240 = MEM[(const guint32 *)ip.11];
  D.17248 = D.17240 >> 24;
  token = D.17247 | D.17248;
  D.17249 = dh->tokener;
  if (D.17249 != 0B) goto <D.17250>; else goto <D.17251>;
  <D.17250>:
  D.17249 = dh->tokener;
  tmp = D.17249 (dh, method, token);
  monoeg_g_string_append (str, tmp);
  monoeg_g_free (tmp);
  goto <D.17252>;
  <D.17251>:
  monoeg_g_string_append_printf (str, "0x%08x", token);
  <D.17252>:
  ip.11 = ip;
  ip.15 = ip.11 + 4;
  ip = ip.15;
  goto <D.16727>;
  <D.16733>:
  {
    const char * blob;
    char * s;
    size_t len2;
    char * blob2;

    try
      {
        blob2 = 0B;
        D.17254 = method->klass;
        D.17255 = D.17254->image;
        D.17256 = BIT_FIELD_REF <*D.17255, 64, 192>;
        D.17257 = D.17256 & 268435456;
        if (D.17257 == 0) goto <D.17258>; else goto <D.17259>;
        <D.17258>:
        ip.11 = ip;
        D.17240 = MEM[(const guint32 *)ip.11];
        D.17241 = D.17240 << 24;
        ip.11 = ip;
        D.17240 = MEM[(const guint32 *)ip.11];
        D.17242 = D.17240 >> 8;
        D.17243 = D.17242 & 65280;
        D.17244 = D.17241 | D.17243;
        ip.11 = ip;
        D.17240 = MEM[(const guint32 *)ip.11];
        D.17245 = D.17240 << 8;
        D.17246 = D.17245 & 16711680;
        D.17247 = D.17244 | D.17246;
        ip.11 = ip;
        D.17240 = MEM[(const guint32 *)ip.11];
        D.17248 = D.17240 >> 24;
        token = D.17247 | D.17248;
        D.17254 = method->klass;
        D.17255 = D.17254->image;
        D.17260 = token & 16777215;
        blob.16 = mono_metadata_user_string (D.17255, D.17260);
        blob = blob.16;
        blob.17 = blob;
        D.17263 = mono_metadata_decode_blob_size (blob.17, &blob);
        len2 = (size_t) D.17263;
        len2 = len2 >> 1;
        blob2 = blob;
        {
          guint16 * buf;
          int i;

          D.17264 = len2 + 1;
          D.17265 = D.17264 * 2;
          buf = monoeg_malloc (D.17265);
          i = 0;
          goto <D.16741>;
          <D.16740>:
          D.17266 = (long unsigned int) i;
          D.17267 = D.17266 * 2;
          D.17268 = buf + D.17267;
          D.17266 = (long unsigned int) i;
          D.17267 = D.17266 * 2;
          D.17269 = blob2 + D.17267;
          D.17270 = *D.17269;
          D.17271 = D.17270 >> 8;
          D.17272 = (signed short) D.17271;
          D.17266 = (long unsigned int) i;
          D.17267 = D.17266 * 2;
          D.17269 = blob2 + D.17267;
          D.17270 = *D.17269;
          D.17273 = (int) D.17270;
          D.17274 = D.17273 << 8;
          D.17275 = (signed short) D.17274;
          D.17276 = D.17272 | D.17275;
          D.17277 = (short unsigned int) D.17276;
          *D.17268 = D.17277;
          i = i + 1;
          <D.16741>:
          D.17278 = (long unsigned int) i;
          if (D.17278 < len2) goto <D.16740>; else goto <D.16742>;
          <D.16742>:
          len2.18 = (long int) len2;
          s = monoeg_g_utf16_to_utf8 (buf, len2.18, 0B, 0B, 0B);
          monoeg_g_free (buf);
        }
        monoeg_g_string_append_printf (str, "\"%s\"", s);
        monoeg_g_free (s);
        blob.17 = blob;
        if (blob.17 != blob2) goto <D.17280>; else goto <D.17281>;
        <D.17280>:
        monoeg_g_free (blob2);
        <D.17281>:
        <D.17259>:
        ip.11 = ip;
        ip.15 = ip.11 + 4;
        ip = ip.15;
        goto <D.16727>;
      }
    finally
      {
        blob = {CLOBBER};
      }
  }
  <D.16743>:
  ip.11 = ip;
  D.17282 = MEM[(const guint16 *)ip.11];
  D.17283 = D.17282 >> 8;
  D.17284 = (int) D.17283;
  ip.11 = ip;
  D.17282 = MEM[(const guint16 *)ip.11];
  D.17285 = (int) D.17282;
  D.17286 = D.17285 << 8;
  D.17287 = D.17286 & 65535;
  D.17288 = D.17284 | D.17287;
  monoeg_g_string_append_printf (str, "%d", D.17288);
  ip.11 = ip;
  ip.19 = ip.11 + 2;
  ip = ip.19;
  goto <D.16727>;
  <D.16744>:
  ip.11 = ip;
  D.17290 = *ip.11;
  D.17291 = (int) D.17290;
  monoeg_g_string_append_printf (str, "%d", D.17291);
  ip.11 = ip;
  ip.14 = ip.11 + 1;
  ip = ip.14;
  goto <D.16727>;
  <D.16745>:
  ip.11 = ip;
  D.17240 = MEM[(const guint32 *)ip.11];
  D.17241 = D.17240 << 24;
  ip.11 = ip;
  D.17240 = MEM[(const guint32 *)ip.11];
  D.17242 = D.17240 >> 8;
  D.17243 = D.17242 & 65280;
  D.17244 = D.17241 | D.17243;
  ip.11 = ip;
  D.17240 = MEM[(const guint32 *)ip.11];
  D.17245 = D.17240 << 8;
  D.17246 = D.17245 & 16711680;
  D.17247 = D.17244 | D.17246;
  ip.11 = ip;
  D.17240 = MEM[(const guint32 *)ip.11];
  D.17248 = D.17240 >> 24;
  D.17292 = D.17247 | D.17248;
  sval = (gint32) D.17292;
  ip.11 = ip;
  ip.15 = ip.11 + 4;
  ip = ip.15;
  D.17293 = dh->label_target;
  if (D.17293 != 0B) goto <D.17294>; else goto <D.17295>;
  <D.17294>:
  D.17293 = dh->label_target;
  ip.11 = ip;
  D.17296 = (sizetype) sval;
  D.17297 = ip.11 + D.17296;
  D.17298 = (long int) D.17297;
  il_code.13 = (long int) il_code;
  D.17299 = D.17298 - il_code.13;
  monoeg_g_string_append_printf (str, D.17293, D.17299);
  goto <D.17300>;
  <D.17295>:
  monoeg_g_string_append_printf (str, "%d", sval);
  <D.17300>:
  goto <D.16727>;
  <D.16746>:
  ip.11 = ip;
  D.17301 = MEM[(const signed char *)ip.11];
  sval = (gint32) D.17301;
  ip.11 = ip;
  ip.14 = ip.11 + 1;
  ip = ip.14;
  D.17293 = dh->label_target;
  if (D.17293 != 0B) goto <D.17302>; else goto <D.17303>;
  <D.17302>:
  D.17293 = dh->label_target;
  ip.11 = ip;
  D.17296 = (sizetype) sval;
  D.17297 = ip.11 + D.17296;
  D.17298 = (long int) D.17297;
  il_code.13 = (long int) il_code;
  D.17299 = D.17298 - il_code.13;
  monoeg_g_string_append_printf (str, D.17293, D.17299);
  goto <D.17304>;
  <D.17303>:
  monoeg_g_string_append_printf (str, "%d", sval);
  <D.17304>:
  goto <D.16727>;
  <D.16747>:
  {
    const unsigned char * end;

    ip.11 = ip;
    D.17240 = MEM[(const guint32 *)ip.11];
    D.17241 = D.17240 << 24;
    ip.11 = ip;
    D.17240 = MEM[(const guint32 *)ip.11];
    D.17242 = D.17240 >> 8;
    D.17243 = D.17242 & 65280;
    D.17244 = D.17241 | D.17243;
    ip.11 = ip;
    D.17240 = MEM[(const guint32 *)ip.11];
    D.17245 = D.17240 << 8;
    D.17246 = D.17245 & 16711680;
    D.17247 = D.17244 | D.17246;
    ip.11 = ip;
    D.17240 = MEM[(const guint32 *)ip.11];
    D.17248 = D.17240 >> 24;
    D.17292 = D.17247 | D.17248;
    sval = (gint32) D.17292;
    ip.11 = ip;
    ip.15 = ip.11 + 4;
    ip = ip.15;
    ip.11 = ip;
    D.17305 = sval * 4;
    D.17306 = (sizetype) D.17305;
    end = ip.11 + D.17306;
    monoeg_g_string_append_c (str, 40);
    i = 0;
    goto <D.16750>;
    <D.16749>:
    if (i > 0) goto <D.17307>; else goto <D.17308>;
    <D.17307>:
    monoeg_g_string_append (str, ", ");
    <D.17308>:
    ip.11 = ip;
    D.17240 = MEM[(const guint32 *)ip.11];
    D.17241 = D.17240 << 24;
    ip.11 = ip;
    D.17240 = MEM[(const guint32 *)ip.11];
    D.17242 = D.17240 >> 8;
    D.17243 = D.17242 & 65280;
    D.17244 = D.17241 | D.17243;
    ip.11 = ip;
    D.17240 = MEM[(const guint32 *)ip.11];
    D.17245 = D.17240 << 8;
    D.17246 = D.17245 & 16711680;
    D.17247 = D.17244 | D.17246;
    ip.11 = ip;
    D.17240 = MEM[(const guint32 *)ip.11];
    D.17248 = D.17240 >> 24;
    label = D.17247 | D.17248;
    D.17293 = dh->label_target;
    if (D.17293 != 0B) goto <D.17309>; else goto <D.17310>;
    <D.17309>:
    D.17293 = dh->label_target;
    D.17311 = (sizetype) label;
    D.17312 = end + D.17311;
    D.17313 = (long int) D.17312;
    il_code.13 = (long int) il_code;
    D.17314 = D.17313 - il_code.13;
    monoeg_g_string_append_printf (str, D.17293, D.17314);
    goto <D.17315>;
    <D.17310>:
    monoeg_g_string_append_printf (str, "%d", label);
    <D.17315>:
    ip.11 = ip;
    ip.15 = ip.11 + 4;
    ip = ip.15;
    i = i + 1;
    <D.16750>:
    if (i < sval) goto <D.16749>; else goto <D.16751>;
    <D.16751>:
    monoeg_g_string_append_c (str, 41);
    goto <D.16727>;
  }
  <D.16752>:
  {
    double r;

    try
      {
        {
          union mono_rdouble mf;

          try
            {
              ip.11 = ip;
              D.17316 = MEM[(const guint64 *)ip.11];
              D.17317 = (unsigned int) D.17316;
              D.17318 = D.17317 << 24;
              ip.11 = ip;
              D.17316 = MEM[(const guint64 *)ip.11];
              D.17317 = (unsigned int) D.17316;
              D.17319 = D.17317 >> 8;
              D.17320 = D.17319 & 65280;
              D.17321 = D.17318 | D.17320;
              ip.11 = ip;
              D.17316 = MEM[(const guint64 *)ip.11];
              D.17317 = (unsigned int) D.17316;
              D.17322 = D.17317 << 8;
              D.17323 = D.17322 & 16711680;
              D.17324 = D.17321 | D.17323;
              ip.11 = ip;
              D.17316 = MEM[(const guint64 *)ip.11];
              D.17317 = (unsigned int) D.17316;
              D.17325 = D.17317 >> 24;
              D.17326 = D.17324 | D.17325;
              D.17327 = (long unsigned int) D.17326;
              D.17328 = D.17327 << 32;
              ip.11 = ip;
              D.17316 = MEM[(const guint64 *)ip.11];
              D.17329 = D.17316 >> 32;
              D.17330 = (unsigned int) D.17329;
              D.17331 = D.17330 << 24;
              ip.11 = ip;
              D.17316 = MEM[(const guint64 *)ip.11];
              D.17329 = D.17316 >> 32;
              D.17330 = (unsigned int) D.17329;
              D.17332 = D.17330 >> 8;
              D.17333 = D.17332 & 65280;
              D.17334 = D.17331 | D.17333;
              ip.11 = ip;
              D.17316 = MEM[(const guint64 *)ip.11];
              D.17329 = D.17316 >> 32;
              D.17330 = (unsigned int) D.17329;
              D.17335 = D.17330 << 8;
              D.17336 = D.17335 & 16711680;
              D.17337 = D.17334 | D.17336;
              ip.11 = ip;
              D.17316 = MEM[(const guint64 *)ip.11];
              D.17329 = D.17316 >> 32;
              D.17330 = (unsigned int) D.17329;
              D.17338 = D.17330 >> 24;
              D.17339 = D.17337 | D.17338;
              D.17340 = (long unsigned int) D.17339;
              D.17341 = D.17328 | D.17340;
              mf.ival = D.17341;
              r.20 = mf.fval;
              r = r.20;
            }
          finally
            {
              mf = {CLOBBER};
            }
        }
        r.21 = r;
        monoeg_g_string_append_printf (str, "%g", r.21);
        ip.11 = ip;
        ip.22 = ip.11 + 8;
        ip = ip.22;
        goto <D.16727>;
      }
    finally
      {
        r = {CLOBBER};
      }
  }
  <D.16755>:
  {
    float r;

    try
      {
        {
          union mono_rfloat mf;

          try
            {
              ip.11 = ip;
              D.17240 = MEM[(const guint32 *)ip.11];
              D.17241 = D.17240 << 24;
              ip.11 = ip;
              D.17240 = MEM[(const guint32 *)ip.11];
              D.17242 = D.17240 >> 8;
              D.17243 = D.17242 & 65280;
              D.17244 = D.17241 | D.17243;
              ip.11 = ip;
              D.17240 = MEM[(const guint32 *)ip.11];
              D.17245 = D.17240 << 8;
              D.17246 = D.17245 & 16711680;
              D.17247 = D.17244 | D.17246;
              ip.11 = ip;
              D.17240 = MEM[(const guint32 *)ip.11];
              D.17248 = D.17240 >> 24;
              D.17292 = D.17247 | D.17248;
              mf.ival = D.17292;
              r.23 = mf.fval;
              r = r.23;
            }
          finally
            {
              mf = {CLOBBER};
            }
        }
        r.24 = r;
        D.17347 = (double) r.24;
        monoeg_g_string_append_printf (str, "%g", D.17347);
        ip.11 = ip;
        ip.15 = ip.11 + 4;
        ip = ip.15;
        goto <D.16727>;
      }
    finally
      {
        r = {CLOBBER};
      }
  }
  <D.16758>:
  ip.11 = ip;
  D.17240 = MEM[(const guint32 *)ip.11];
  D.17241 = D.17240 << 24;
  ip.11 = ip;
  D.17240 = MEM[(const guint32 *)ip.11];
  D.17242 = D.17240 >> 8;
  D.17243 = D.17242 & 65280;
  D.17244 = D.17241 | D.17243;
  ip.11 = ip;
  D.17240 = MEM[(const guint32 *)ip.11];
  D.17245 = D.17240 << 8;
  D.17246 = D.17245 & 16711680;
  D.17247 = D.17244 | D.17246;
  ip.11 = ip;
  D.17240 = MEM[(const guint32 *)ip.11];
  D.17248 = D.17240 >> 24;
  D.17292 = D.17247 | D.17248;
  D.17348 = (int) D.17292;
  monoeg_g_string_append_printf (str, "%d", D.17348);
  ip.11 = ip;
  ip.15 = ip.11 + 4;
  ip = ip.15;
  goto <D.16727>;
  <D.16759>:
  ip.11 = ip;
  D.17301 = MEM[(const signed char *)ip.11];
  D.17349 = (int) D.17301;
  monoeg_g_string_append_printf (str, "%d", D.17349);
  ip.11 = ip;
  ip.14 = ip.11 + 1;
  ip = ip.14;
  goto <D.16727>;
  <D.16760>:
  ip.11 = ip;
  ip.22 = ip.11 + 8;
  ip = ip.22;
  goto <D.16727>;
  <D.16761>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "debug-helpers.c", 684);
  <D.16727>:
  D.17350 = dh->newline;
  if (D.17350 != 0B) goto <D.17351>; else goto <D.17352>;
  <D.17351>:
  D.17350 = dh->newline;
  monoeg_g_string_append (str, D.17350);
  <D.17352>:
  mono_metadata_free_mh (header);
  D.17353 = ip;
  return D.17353;
}


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

  res = monoeg_g_string_new ("");
  if (dh == 0B) goto <D.17359>; else goto <D.17360>;
  <D.17359>:
  dh = &default_dh;
  <D.17360>:
  goto <D.16780>;
  <D.16779>:
  ip = dis_one (res, dh, method, ip, end);
  <D.16780>:
  if (ip < end) goto <D.16779>; else goto <D.16781>;
  <D.16781>:
  result = res->str;
  monoeg_g_string_free (res, 0);
  D.17361 = result;
  return D.17361;
}


mono_field_full_name (struct MonoClassField * field)
{
  struct MonoClass * D.17363;
  const char * iftmp.25;
  char D.17365;
  const char * D.17369;
  const char * D.17370;
  char * D.17371;
  char * res;
  const char * nspace;

  D.17363 = field->parent;
  nspace = D.17363->name_space;
  D.17365 = *nspace;
  if (D.17365 != 0) goto <D.17366>; else goto <D.17367>;
  <D.17366>:
  iftmp.25 = ".";
  goto <D.17368>;
  <D.17367>:
  iftmp.25 = "";
  <D.17368>:
  D.17363 = field->parent;
  D.17369 = D.17363->name;
  D.17370 = mono_field_get_name (field);
  res = monoeg_g_strdup_printf ("%s%s%s:%s", nspace, iftmp.25, D.17369, D.17370);
  D.17371 = res;
  return D.17371;
}


mono_method_full_name (struct MonoMethod * method, gboolean signature)
{
  struct MonoClass * D.17373;
  struct MonoType * D.17374;
  long unsigned int D.17377;
  long unsigned int D.17378;
  struct MonoGenericInst * D.17380;
  long unsigned int D.17382;
  struct MonoGenericInst * D.17385;
  long unsigned int D.17386;
  <unnamed-unsigned:5> D.17389;
  unsigned int D.17390;
  const char * D.17391;
  struct MonoMethodSignature * D.17395;
  const char * D.17398;
  const char * D.17400;
  const char * iftmp.26;
  const char * iftmp.27;
  char * D.17410;
  char * res;
  char wrapper[64];
  char * klass_desc;
  char * inst_desc;

  try
    {
      D.17373 = method->klass;
      D.17374 = &D.17373->byval_arg;
      klass_desc = mono_type_full_name (D.17374);
      inst_desc = 0B;
      D.17377 = BIT_FIELD_REF <*method, 64, 256>;
      D.17378 = D.17377 & 2251799813685248;
      if (D.17378 != 0) goto <D.17379>; else goto <D.17375>;
      <D.17379>:
      D.17380 = MEM[(struct MonoMethodInflated *)method].context.method_inst;
      if (D.17380 != 0B) goto <D.17381>; else goto <D.17375>;
      <D.17381>:
      {
        struct GString * str;

        str = monoeg_g_string_new ("");
        monoeg_g_string_append (str, "<");
        D.17380 = MEM[(struct MonoMethodInflated *)method].context.method_inst;
        ginst_get_desc (str, D.17380);
        monoeg_g_string_append (str, ">");
        inst_desc = str->str;
        monoeg_g_string_free (str, 0);
      }
      goto <D.17376>;
      <D.17375>:
      D.17377 = BIT_FIELD_REF <*method, 64, 256>;
      D.17382 = D.17377 & 4503599627370496;
      if (D.17382 != 0) goto <D.17383>; else goto <D.17384>;
      <D.17383>:
      {
        struct MonoGenericContainer * container;
        struct GString * str;

        container = mono_method_get_generic_container (method);
        str = monoeg_g_string_new ("");
        monoeg_g_string_append (str, "<");
        D.17385 = container->context.method_inst;
        ginst_get_desc (str, D.17385);
        monoeg_g_string_append (str, ">");
        inst_desc = str->str;
        monoeg_g_string_free (str, 0);
      }
      <D.17384>:
      <D.17376>:
      D.17377 = BIT_FIELD_REF <*method, 64, 256>;
      D.17386 = D.17377 & 4467570830351532032;
      if (D.17386 != 0) goto <D.17387>; else goto <D.17388>;
      <D.17387>:
      D.17389 = method->wrapper_type;
      D.17390 = (unsigned int) D.17389;
      D.17391 = wrapper_type_to_str (D.17390);
      sprintf (&wrapper, "(wrapper %s) ", D.17391);
      goto <D.17392>;
      <D.17388>:
      strcpy (&wrapper, "");
      <D.17392>:
      if (signature != 0) goto <D.17393>; else goto <D.17394>;
      <D.17393>:
      {
        char * tmpsig;

        D.17395 = mono_method_signature (method);
        tmpsig = mono_signature_get_desc (D.17395, 1);
        D.17377 = BIT_FIELD_REF <*method, 64, 256>;
        D.17386 = D.17377 & 4467570830351532032;
        if (D.17386 != 0) goto <D.17396>; else goto <D.17397>;
        <D.17396>:
        D.17389 = method->wrapper_type;
        D.17390 = (unsigned int) D.17389;
        D.17398 = wrapper_type_to_str (D.17390);
        sprintf (&wrapper, "(wrapper %s) ", D.17398);
        goto <D.17399>;
        <D.17397>:
        strcpy (&wrapper, "");
        <D.17399>:
        D.17400 = method->name;
        if (inst_desc != 0B) goto <D.17402>; else goto <D.17403>;
        <D.17402>:
        iftmp.26 = inst_desc;
        goto <D.17404>;
        <D.17403>:
        iftmp.26 = "";
        <D.17404>:
        res = monoeg_g_strdup_printf ("%s%s:%s%s (%s)", &wrapper, klass_desc, D.17400, iftmp.26, tmpsig);
        monoeg_g_free (tmpsig);
      }
      goto <D.17405>;
      <D.17394>:
      D.17400 = method->name;
      if (inst_desc != 0B) goto <D.17407>; else goto <D.17408>;
      <D.17407>:
      iftmp.27 = inst_desc;
      goto <D.17409>;
      <D.17408>:
      iftmp.27 = "";
      <D.17409>:
      res = monoeg_g_strdup_printf ("%s%s:%s%s", &wrapper, klass_desc, D.17400, iftmp.27);
      <D.17405>:
      monoeg_g_free (klass_desc);
      monoeg_g_free (inst_desc);
      D.17410 = res;
      return D.17410;
    }
  finally
    {
      wrapper = {CLOBBER};
    }
}


wrapper_type_to_str (guint32 wrapper_type)
{
  _Bool D.17413;
  long int D.17414;
  long int D.17415;
  const char * D.17418;
  short int D.17419;
  sizetype D.17420;

  D.17413 = wrapper_type > 28;
  D.17414 = (long int) D.17413;
  D.17415 = __builtin_expect (D.17414, 0);
  if (D.17415 != 0) goto <D.17416>; else goto <D.17417>;
  <D.17416>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debug-helpers.c", 51, "wrapper_type < MONO_WRAPPER_NUM");
  <D.17417>:
  D.17419 = opidx[wrapper_type];
  D.17420 = (sizetype) D.17419;
  D.17418 = &opstr + D.17420;
  return D.17418;
}


__attribute__((__artificial__, __gnu_inline__, __always_inline__, __leaf__, __nothrow__))
sprintf (char * restrict __s, const char * restrict __fmt)
{
  int D.17422;
  long unsigned int D.17423;

  D.17423 = __builtin_object_size (__s, 1);
  D.17422 = __builtin___sprintf_chk (__s, 1, D.17423, __fmt, __builtin_va_arg_pack ());
  return D.17422;
}


__attribute__((__artificial__, __gnu_inline__, __always_inline__, __nothrow__, __leaf__))
strcpy (char * restrict __dest, const char * restrict __src)
{
  char * D.17425;
  long unsigned int D.17426;

  D.17426 = __builtin_object_size (__dest, 1);
  D.17425 = __builtin___strcpy_chk (__dest, __src, D.17426);
  return D.17425;
}


mono_object_describe (struct MonoObject * obj)
{
  struct MonoVTable * D.17430;
  struct MonoClass * D.17431;
  long unsigned int D.17434;
  char * D.17437;
  char * D.17438;
  char * D.17439;
  char * D.17440;
  int D.17441;
  unsigned char D.17443;
  const char * D.17446;
  int D.17447;
  long unsigned int D.17448;
  int D.17449;
  struct MonoClass * klass;
  const char * sep;

  if (obj == 0B) goto <D.17428>; else goto <D.17429>;
  <D.17428>:
  monoeg_g_print ("(null)\n");
  return;
  <D.17429>:
  D.17430 = obj->vtable;
  klass = D.17430->klass;
  D.17431 = mono_defaults.string_class;
  if (D.17431 == klass) goto <D.17432>; else goto <D.17433>;
  <D.17432>:
  {
    char * utf8;

    utf8 = mono_string_to_utf8 (obj);
    D.17434 = __strlen_g (utf8);
    if (D.17434 > 60) goto <D.17435>; else goto <D.17436>;
    <D.17435>:
    D.17437 = utf8 + 57;
    *D.17437 = 46;
    D.17438 = utf8 + 58;
    *D.17438 = 46;
    D.17439 = utf8 + 59;
    *D.17439 = 46;
    D.17440 = utf8 + 60;
    *D.17440 = 0;
    <D.17436>:
    D.17441 = mono_string_length (obj);
    monoeg_g_print ("String at %p, length: %d, \'%s\'\n", obj, D.17441, utf8);
    monoeg_g_free (utf8);
  }
  goto <D.17442>;
  <D.17433>:
  D.17443 = klass->rank;
  if (D.17443 != 0) goto <D.17444>; else goto <D.17445>;
  <D.17444>:
  {
    struct MonoArray * array;

    array = obj;
    sep = print_name_space (klass);
    D.17446 = klass->name;
    monoeg_g_print ("%s%s", sep, D.17446);
    D.17443 = klass->rank;
    D.17447 = (int) D.17443;
    D.17448 = mono_array_length (array);
    D.17449 = (int) D.17448;
    monoeg_g_print (" at %p, rank: %d, length: %d\n", obj, D.17447, D.17449);
  }
  goto <D.17450>;
  <D.17445>:
  sep = print_name_space (klass);
  D.17446 = klass->name;
  monoeg_g_print ("%s%s", sep, D.17446);
  monoeg_g_print (" object at %p (klass: %p)\n", obj, klass);
  <D.17450>:
  <D.17442>:
}


print_name_space (struct MonoClass * klass)
{
  struct MonoClass * D.17452;
  const char * D.17455;
  const char * D.17456;
  const char * D.17457;
  char D.17458;

  D.17452 = klass->nested_in;
  if (D.17452 != 0B) goto <D.17453>; else goto <D.17454>;
  <D.17453>:
  D.17452 = klass->nested_in;
  print_name_space (D.17452);
  D.17452 = klass->nested_in;
  D.17455 = D.17452->name;
  monoeg_g_print ("%s", D.17455);
  D.17456 = "/";
  return D.17456;
  <D.17454>:
  D.17457 = klass->name_space;
  D.17458 = *D.17457;
  if (D.17458 != 0) goto <D.17459>; else goto <D.17460>;
  <D.17459>:
  D.17457 = klass->name_space;
  monoeg_g_print ("%s", D.17457);
  D.17456 = ".";
  return D.17456;
  <D.17460>:
  D.17456 = "";
  return D.17456;
}


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

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


objval_describe (struct MonoClass * class, const char * addr)
{
  long unsigned int D.17463;
  long unsigned int D.17464;
  struct MonoType * D.17467;
  short unsigned int D.17468;
  int D.17469;
  int D.17470;
  const char * D.17477;
  int D.17478;
  sizetype D.17479;
  sizetype type_offset.28;
  sizetype D.17481;
  int D.17482;
  struct MonoClassField * field;
  struct MonoClass * p;
  const char * field_ptr;
  gssize type_offset;

  type_offset = 0;
  D.17463 = BIT_FIELD_REF <*class, 64, 256>;
  D.17464 = D.17463 & 1152921504606846976;
  if (D.17464 != 0) goto <D.17465>; else goto <D.17466>;
  <D.17465>:
  type_offset = -16;
  <D.17466>:
  p = class;
  goto <D.16856>;
  <D.16855>:
  {
    void * iter;
    int printed_header;

    try
      {
        iter = 0B;
        printed_header = 0;
        goto <D.16851>;
        <D.16853>:
        D.17467 = field->type;
        D.17468 = D.17467->attrs;
        D.17469 = (int) D.17468;
        D.17470 = D.17469 & 272;
        if (D.17470 != 0) goto <D.17471>; else goto <D.17472>;
        <D.17471>:
        // predicted unlikely by continue predictor.
        goto <D.16851>;
        <D.17472>:
        if (p != class) goto <D.17473>; else goto <D.17474>;
        <D.17473>:
        if (printed_header == 0) goto <D.17475>; else goto <D.17476>;
        <D.17475>:
        {
          const char * sep;

          monoeg_g_print ("In class ");
          sep = print_name_space (p);
          D.17477 = p->name;
          monoeg_g_print ("%s%s:\n", sep, D.17477);
          printed_header = 1;
        }
        <D.17476>:
        <D.17474>:
        D.17478 = field->offset;
        D.17479 = (sizetype) D.17478;
        type_offset.28 = (sizetype) type_offset;
        D.17481 = D.17479 + type_offset.28;
        field_ptr = addr + D.17481;
        D.17482 = (int) type_offset;
        print_field_value (field_ptr, field, D.17482);
        <D.16851>:
        field = mono_class_get_fields (p, &iter);
        if (field != 0B) goto <D.16853>; else goto <D.16854>;
        <D.16854>:
      }
    finally
      {
        iter = {CLOBBER};
      }
  }
  p = p->parent;
  <D.16856>:
  if (p != 0B) goto <D.16855>; else goto <D.16857>;
  <D.16857>:
}


print_field_value (const char * field_ptr, struct MonoClassField * field, int type_offset)
{
  int D.17483;
  int D.17484;
  const char * D.17485;
  struct MonoType * D.17486;
  unsigned char D.17487;
  int D.17488;
  const void * D.17489;
  struct MonoObject * D.17490;
  int D.17491;
  const char * D.17494;
  signed char D.17495;
  int D.17496;
  unsigned char D.17497;
  int D.17498;
  short int D.17499;
  int D.17500;
  short unsigned int D.17501;
  int D.17502;
  int D.17503;
  unsigned int D.17504;
  long int D.17505;
  long unsigned int D.17506;
  float D.17507;
  double D.17508;
  double D.17509;
  const char * iftmp.29;
  struct MonoType * type;

  D.17483 = field->offset;
  D.17484 = D.17483 + type_offset;
  D.17485 = mono_field_get_name (field);
  monoeg_g_print ("At %p (ofs: %2d) %s: ", field_ptr, D.17484, D.17485);
  D.17486 = field->type;
  type = mono_type_get_underlying_type (D.17486);
  D.17487 = type->type;
  D.17488 = (int) D.17487;
  switch (D.17488) <default: <D.16840>, case 2: <D.16838>, case 3: <D.16839>, case 4: <D.16828>, case 5: <D.16829>, case 6: <D.16830>, case 7: <D.16831>, case 8: <D.16832>, case 9: <D.16833>, case 10: <D.16834>, case 11: <D.16835>, case 12: <D.16836>, case 13: <D.16837>, case 14: <D.16820>, case 15: <D.16817>, case 17: <D.16826>, case 18: <D.16822>, case 20: <D.16824>, case 21: <D.16825>, case 24: <D.16815>, case 25: <D.16816>, case 27: <D.16818>, case 28: <D.16823>, case 29: <D.16821>>
  <D.16815>:
  <D.16816>:
  <D.16817>:
  <D.16818>:
  D.17489 = MEM[(const void * *)field_ptr];
  monoeg_g_print ("%p\n", D.17489);
  goto <D.16819>;
  <D.16820>:
  <D.16821>:
  <D.16822>:
  <D.16823>:
  <D.16824>:
  D.17490 = MEM[(struct MonoObject * *)field_ptr];
  mono_object_describe (D.17490);
  goto <D.16819>;
  <D.16825>:
  D.17491 = mono_type_generic_inst_is_valuetype (type);
  if (D.17491 == 0) goto <D.17492>; else goto <D.17493>;
  <D.17492>:
  D.17490 = MEM[(struct MonoObject * *)field_ptr];
  mono_object_describe (D.17490);
  goto <D.16819>;
  <D.17493>:
  <D.16826>:
  {
    struct MonoClass * k;

    k = mono_class_from_mono_type (type);
    D.17494 = k->name;
    monoeg_g_print ("%s ValueType (type: %p) at %p\n", D.17494, k, field_ptr);
    goto <D.16819>;
  }
  <D.16828>:
  D.17495 = MEM[(gint8 *)field_ptr];
  D.17496 = (int) D.17495;
  monoeg_g_print ("%d\n", D.17496);
  goto <D.16819>;
  <D.16829>:
  D.17497 = MEM[(guint8 *)field_ptr];
  D.17498 = (int) D.17497;
  monoeg_g_print ("%d\n", D.17498);
  goto <D.16819>;
  <D.16830>:
  D.17499 = MEM[(gint16 *)field_ptr];
  D.17500 = (int) D.17499;
  monoeg_g_print ("%d\n", D.17500);
  goto <D.16819>;
  <D.16831>:
  D.17501 = MEM[(guint16 *)field_ptr];
  D.17502 = (int) D.17501;
  monoeg_g_print ("%d\n", D.17502);
  goto <D.16819>;
  <D.16832>:
  D.17503 = MEM[(gint32 *)field_ptr];
  monoeg_g_print ("%d\n", D.17503);
  goto <D.16819>;
  <D.16833>:
  D.17504 = MEM[(guint32 *)field_ptr];
  monoeg_g_print ("%u\n", D.17504);
  goto <D.16819>;
  <D.16834>:
  D.17505 = MEM[(gint64 *)field_ptr];
  monoeg_g_print ("%lld\n", D.17505);
  goto <D.16819>;
  <D.16835>:
  D.17506 = MEM[(guint64 *)field_ptr];
  monoeg_g_print ("%llu\n", D.17506);
  goto <D.16819>;
  <D.16836>:
  D.17507 = MEM[(gfloat *)field_ptr];
  D.17508 = (double) D.17507;
  monoeg_g_print ("%f\n", D.17508);
  goto <D.16819>;
  <D.16837>:
  D.17509 = MEM[(gdouble *)field_ptr];
  monoeg_g_print ("%f\n", D.17509);
  goto <D.16819>;
  <D.16838>:
  D.17497 = MEM[(guint8 *)field_ptr];
  if (D.17497 != 0) goto <D.17511>; else goto <D.17512>;
  <D.17511>:
  iftmp.29 = "True";
  goto <D.17513>;
  <D.17512>:
  iftmp.29 = "False";
  <D.17513>:
  D.17497 = MEM[(guint8 *)field_ptr];
  D.17498 = (int) D.17497;
  monoeg_g_print ("%s (%d)\n", iftmp.29, D.17498);
  goto <D.16819>;
  <D.16839>:
  D.17501 = MEM[(guint16 *)field_ptr];
  D.17502 = (int) D.17501;
  D.17501 = MEM[(guint16 *)field_ptr];
  D.17502 = (int) D.17501;
  D.17501 = MEM[(guint16 *)field_ptr];
  D.17502 = (int) D.17501;
  monoeg_g_print ("\'%c\' (%d 0x%04x)\n", D.17502, D.17502, D.17502);
  goto <D.16819>;
  <D.16840>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "debug-helpers.c", 928);
  <D.16819>:
}


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


mono_class_describe_statics (struct MonoClass * klass)
{
  struct MonoDomain * D.17514;
  struct MonoType * D.17519;
  short unsigned int D.17520;
  int D.17521;
  int D.17522;
  int D.17525;
  int D.17528;
  sizetype D.17529;
  struct MonoClassField * field;
  struct MonoClass * p;
  const char * field_ptr;
  struct MonoVTable * vtable;
  const char * addr;

  D.17514 = mono_domain_get ();
  vtable = mono_class_vtable_full (D.17514, klass, 0);
  if (vtable == 0B) goto <D.17515>; else goto <D.17516>;
  <D.17515>:
  return;
  <D.17516>:
  addr = mono_vtable_get_static_field_data (vtable);
  if (addr == 0B) goto <D.17517>; else goto <D.17518>;
  <D.17517>:
  return;
  <D.17518>:
  p = klass;
  goto <D.16879>;
  <D.16878>:
  {
    void * iter;

    try
      {
        iter = 0B;
        goto <D.16875>;
        <D.16876>:
        D.17519 = field->type;
        D.17520 = D.17519->attrs;
        D.17521 = (int) D.17520;
        D.17522 = D.17521 & 64;
        if (D.17522 != 0) goto <D.17523>; else goto <D.17524>;
        <D.17523>:
        // predicted unlikely by continue predictor.
        goto <D.16875>;
        <D.17524>:
        D.17519 = field->type;
        D.17520 = D.17519->attrs;
        D.17521 = (int) D.17520;
        D.17525 = D.17521 & 272;
        if (D.17525 == 0) goto <D.17526>; else goto <D.17527>;
        <D.17526>:
        // predicted unlikely by continue predictor.
        goto <D.16875>;
        <D.17527>:
        D.17528 = field->offset;
        D.17529 = (sizetype) D.17528;
        field_ptr = addr + D.17529;
        print_field_value (field_ptr, field, 0);
        <D.16875>:
        field = mono_class_get_fields (p, &iter);
        if (field != 0B) goto <D.16876>; else goto <D.16877>;
        <D.16877>:
      }
    finally
      {
        iter = {CLOBBER};
      }
  }
  p = p->parent;
  <D.16879>:
  if (p != 0B) goto <D.16878>; else goto <D.16880>;
  <D.16880>:
}