mono_type_get_desc (struct GString * res, struct MonoType * type, gboolean include_namespace)
{
  unsigned char D.19142;
  int D.19143;
  struct MonoType * D.19144;
  struct MonoArrayType * D.19145;
  struct MonoClass * D.19146;
  struct MonoType * D.19147;
  unsigned char D.19148;
  int D.19149;
  struct MonoClass * D.19150;
  struct MonoType * D.19151;
  struct MonoGenericClass * D.19152;
  struct MonoClass * D.19153;
  struct MonoType * D.19154;
  struct MonoGenericInst * D.19155;
  struct MonoType * D.19160;
  <unnamed-unsigned:22> D.19161;
  int D.19162;
  struct MonoGenericInst * D.19163;
  struct MonoType * D.19170;
  <unnamed-unsigned:22> D.19171;
  int D.19172;
  struct MonoGenericParam * D.19173;
  struct MonoGenericParamInfo * iftmp.0;
  struct MonoGenericContainer * D.19177;
  const char * D.19183;
  const char * iftmp.1;
  short unsigned int D.19189;
  int D.19190;
  unsigned char D.19192;
  unsigned char D.19193;
  int i;

  D.19142 = type->type;
  D.19143 = (int) D.19142;
  switch (D.19143) <default: <D.18812>, case 1: <D.18776>, case 2: <D.18779>, case 3: <D.18778>, case 4: <D.18781>, case 5: <D.18780>, case 6: <D.18783>, case 7: <D.18782>, case 8: <D.18785>, case 9: <D.18784>, case 10: <D.18787>, case 11: <D.18786>, case 12: <D.18791>, case 13: <D.18792>, case 14: <D.18793>, case 15: <D.18795>, case 17: <D.18799>, case 18: <D.18798>, case 19: <D.18808>, case 20: <D.18796>, case 21: <D.18800>, case 22: <D.18811>, case 24: <D.18790>, case 25: <D.18789>, case 27: <D.18788>, case 28: <D.18794>, case 29: <D.18797>, case 30: <D.18809>>
  <D.18776>:
  monoeg_g_string_append (res, "void");
  goto <D.18777>;
  <D.18778>:
  monoeg_g_string_append (res, "char");
  goto <D.18777>;
  <D.18779>:
  monoeg_g_string_append (res, "bool");
  goto <D.18777>;
  <D.18780>:
  monoeg_g_string_append (res, "byte");
  goto <D.18777>;
  <D.18781>:
  monoeg_g_string_append (res, "sbyte");
  goto <D.18777>;
  <D.18782>:
  monoeg_g_string_append (res, "uint16");
  goto <D.18777>;
  <D.18783>:
  monoeg_g_string_append (res, "int16");
  goto <D.18777>;
  <D.18784>:
  monoeg_g_string_append (res, "uint");
  goto <D.18777>;
  <D.18785>:
  monoeg_g_string_append (res, "int");
  goto <D.18777>;
  <D.18786>:
  monoeg_g_string_append (res, "ulong");
  goto <D.18777>;
  <D.18787>:
  monoeg_g_string_append (res, "long");
  goto <D.18777>;
  <D.18788>:
  monoeg_g_string_append (res, "*()");
  goto <D.18777>;
  <D.18789>:
  monoeg_g_string_append (res, "uintptr");
  goto <D.18777>;
  <D.18790>:
  monoeg_g_string_append (res, "intptr");
  goto <D.18777>;
  <D.18791>:
  monoeg_g_string_append (res, "single");
  goto <D.18777>;
  <D.18792>:
  monoeg_g_string_append (res, "double");
  goto <D.18777>;
  <D.18793>:
  monoeg_g_string_append (res, "string");
  goto <D.18777>;
  <D.18794>:
  monoeg_g_string_append (res, "object");
  goto <D.18777>;
  <D.18795>:
  D.19144 = type->data.type;
  mono_type_get_desc (res, D.19144, include_namespace);
  monoeg_g_string_append_c (res, 42);
  goto <D.18777>;
  <D.18796>:
  D.19145 = type->data.array;
  D.19146 = D.19145->eklass;
  D.19147 = &D.19146->byval_arg;
  mono_type_get_desc (res, D.19147, include_namespace);
  D.19145 = type->data.array;
  D.19148 = D.19145->rank;
  D.19149 = (int) D.19148;
  monoeg_g_string_append_printf (res, "[%d]", D.19149);
  goto <D.18777>;
  <D.18797>:
  D.19150 = type->data.klass;
  D.19151 = &D.19150->byval_arg;
  mono_type_get_desc (res, D.19151, include_namespace);
  monoeg_g_string_append (res, "[]");
  goto <D.18777>;
  <D.18798>:
  <D.18799>:
  D.19150 = type->data.klass;
  append_class_name (res, D.19150, include_namespace);
  goto <D.18777>;
  <D.18800>:
  {
    struct MonoGenericContext * context;

    D.19152 = type->data.generic_class;
    D.19153 = D.19152->container_class;
    D.19154 = &D.19153->byval_arg;
    mono_type_get_desc (res, D.19154, include_namespace);
    monoeg_g_string_append (res, "<");
    D.19152 = type->data.generic_class;
    context = &D.19152->context;
    D.19155 = context->class_inst;
    if (D.19155 != 0B) goto <D.19156>; else goto <D.19157>;
    <D.19156>:
    i = 0;
    goto <D.18803>;
    <D.18802>:
    if (i > 0) goto <D.19158>; else goto <D.19159>;
    <D.19158>:
    monoeg_g_string_append (res, ", ");
    <D.19159>:
    D.19155 = context->class_inst;
    D.19160 = D.19155->type_argv[i];
    mono_type_get_desc (res, D.19160, include_namespace);
    i = i + 1;
    <D.18803>:
    D.19155 = context->class_inst;
    D.19161 = D.19155->type_argc;
    D.19162 = (int) D.19161;
    if (D.19162 > i) goto <D.18802>; else goto <D.18804>;
    <D.18804>:
    <D.19157>:
    D.19163 = context->method_inst;
    if (D.19163 != 0B) goto <D.19164>; else goto <D.19165>;
    <D.19164>:
    D.19155 = context->class_inst;
    if (D.19155 != 0B) goto <D.19166>; else goto <D.19167>;
    <D.19166>:
    monoeg_g_string_append (res, "; ");
    <D.19167>:
    i = 0;
    goto <D.18806>;
    <D.18805>:
    if (i > 0) goto <D.19168>; else goto <D.19169>;
    <D.19168>:
    monoeg_g_string_append (res, ", ");
    <D.19169>:
    D.19163 = context->method_inst;
    D.19170 = D.19163->type_argv[i];
    mono_type_get_desc (res, D.19170, include_namespace);
    i = i + 1;
    <D.18806>:
    D.19163 = context->method_inst;
    D.19171 = D.19163->type_argc;
    D.19172 = (int) D.19171;
    if (D.19172 > i) goto <D.18805>; else goto <D.18807>;
    <D.18807>:
    <D.19165>:
    monoeg_g_string_append (res, ">");
    goto <D.18777>;
  }
  <D.18808>:
  <D.18809>:
  D.19173 = type->data.generic_param;
  if (D.19173 != 0B) goto <D.19174>; else goto <D.19175>;
  <D.19174>:
  {
    struct MonoGenericParamInfo * info;

    D.19173 = type->data.generic_param;
    D.19177 = D.19173->owner;
    if (D.19177 != 0B) goto <D.19178>; else goto <D.19179>;
    <D.19178>:
    D.19173 = type->data.generic_param;
    iftmp.0 = &MEM[(struct MonoGenericParamFull *)D.19173].info;
    goto <D.19180>;
    <D.19179>:
    iftmp.0 = 0B;
    <D.19180>:
    info = iftmp.0;
    if (info != 0B) goto <D.19181>; else goto <D.19182>;
    <D.19181>:
    D.19183 = info->name;
    monoeg_g_string_append (res, D.19183);
    goto <D.19184>;
    <D.19182>:
    D.19142 = type->type;
    if (D.19142 == 19) goto <D.19186>; else goto <D.19187>;
    <D.19186>:
    iftmp.1 = "!";
    goto <D.19188>;
    <D.19187>:
    iftmp.1 = "!!";
    <D.19188>:
    D.19173 = type->data.generic_param;
    D.19189 = D.19173->num;
    D.19190 = (int) D.19189;
    monoeg_g_string_append_printf (res, "%s%d", iftmp.1, D.19190);
    <D.19184>:
  }
  goto <D.19191>;
  <D.19175>:
  monoeg_g_string_append (res, "<unknown>");
  <D.19191>:
  goto <D.18777>;
  <D.18811>:
  monoeg_g_string_append (res, "typedbyref");
  goto <D.18777>;
  <D.18812>:
  goto <D.18777>;
  <D.18777>:
  D.19192 = BIT_FIELD_REF <*type, 8, 56>;
  D.19193 = D.19192 & 64;
  if (D.19193 != 0) goto <D.19194>; else goto <D.19195>;
  <D.19194>:
  monoeg_g_string_append_c (res, 38);
  <D.19195>:
}


append_class_name (struct GString * res, struct MonoClass * class, gboolean include_namespace)
{
  struct MonoClass * D.19199;
  const char * D.19204;
  char D.19205;
  const char * D.19208;

  if (class == 0B) goto <D.19197>; else goto <D.19198>;
  <D.19197>:
  monoeg_g_string_append (res, "Unknown");
  return;
  <D.19198>:
  D.19199 = class->nested_in;
  if (D.19199 != 0B) goto <D.19200>; else goto <D.19201>;
  <D.19200>:
  D.19199 = class->nested_in;
  append_class_name (res, D.19199, include_namespace);
  monoeg_g_string_append_c (res, 47);
  <D.19201>:
  if (include_namespace != 0) goto <D.19202>; else goto <D.19203>;
  <D.19202>:
  D.19204 = class->name_space;
  D.19205 = *D.19204;
  if (D.19205 != 0) goto <D.19206>; else goto <D.19207>;
  <D.19206>:
  D.19204 = class->name_space;
  monoeg_g_string_append_printf (res, "%s.", D.19204);
  <D.19207>:
  <D.19203>:
  D.19208 = class->name;
  monoeg_g_string_append_printf (res, "%s", D.19208);
}


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

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


mono_signature_get_desc (struct MonoMethodSignature * sig, gboolean include_namespace)
{
  char * D.19214;
  struct MonoType * D.19217;
  short unsigned int D.19218;
  int D.19219;
  int i;
  char * result;
  struct GString * res;

  if (sig == 0B) goto <D.19212>; else goto <D.19213>;
  <D.19212>:
  D.19214 = monoeg_strdup ("<invalid signature>");
  return D.19214;
  <D.19213>:
  res = monoeg_g_string_new ("");
  i = 0;
  goto <D.18825>;
  <D.18824>:
  if (i > 0) goto <D.19215>; else goto <D.19216>;
  <D.19215>:
  monoeg_g_string_append_c (res, 44);
  <D.19216>:
  D.19217 = sig->params[i];
  mono_type_get_desc (res, D.19217, include_namespace);
  i = i + 1;
  <D.18825>:
  D.19218 = sig->param_count;
  D.19219 = (int) D.19218;
  if (D.19219 > i) goto <D.18824>; else goto <D.18826>;
  <D.18826>:
  result = res->str;
  monoeg_g_string_free (res, 0);
  D.19214 = result;
  return D.19214;
}


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

  if (str != 0B) goto <D.19221>; else goto <D.19222>;
  <D.19221>:
  D.19223 = __strdup (str);
  return D.19223;
  <D.19222>:
  D.19223 = 0B;
  return D.19223;
}


mono_context_get_desc (struct MonoGenericContext * context)
{
  struct MonoGenericInst * D.19225;
  struct MonoGenericInst * D.19228;
  char * D.19233;
  char * D.19234;
  struct GString * str;
  char * res;

  str = monoeg_g_string_new ("");
  monoeg_g_string_append (str, "<");
  D.19225 = context->class_inst;
  if (D.19225 != 0B) goto <D.19226>; else goto <D.19227>;
  <D.19226>:
  D.19225 = context->class_inst;
  ginst_get_desc (str, D.19225);
  <D.19227>:
  D.19228 = context->method_inst;
  if (D.19228 != 0B) goto <D.19229>; else goto <D.19230>;
  <D.19229>:
  D.19225 = context->class_inst;
  if (D.19225 != 0B) goto <D.19231>; else goto <D.19232>;
  <D.19231>:
  monoeg_g_string_append (str, "; ");
  <D.19232>:
  D.19228 = context->method_inst;
  ginst_get_desc (str, D.19228);
  <D.19230>:
  monoeg_g_string_append (str, ">");
  D.19233 = str->str;
  res = monoeg_strdup (D.19233);
  monoeg_g_string_free (str, 1);
  D.19234 = res;
  return D.19234;
}


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

  i = 0;
  goto <D.18833>;
  <D.18832>:
  if (i > 0) goto <D.19236>; else goto <D.19237>;
  <D.19236>:
  monoeg_g_string_append (str, ", ");
  <D.19237>:
  D.19238 = ginst->type_argv[i];
  mono_type_get_desc (str, D.19238, 1);
  i = i + 1;
  <D.18833>:
  D.19239 = ginst->type_argc;
  D.19240 = (int) D.19239;
  if (D.19240 > i) goto <D.18832>; else goto <D.18834>;
  <D.18834>:
}


mono_method_desc_new (const char * name, gboolean include_namespace)
{
  char * D.19245;
  char D.19246;
  char * use_args.2;
  struct MonoMethodDesc * D.19252;
  char * D.19257;
  char D.19258;
  char * method_name.3;
  char * class_name.4;
  char * iftmp.5;
  char * D.19270;
  char * D.19271;
  char * D.19274;
  char * D.19275;
  char D.19280;
  unsigned int D.19285;
  unsigned int D.19286;
  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.19241>; else goto <D.19242>;
  <D.19241>:
  if (use_args > class_nspace) goto <D.19243>; else goto <D.19244>;
  <D.19243>:
  D.19245 = use_args + 4294967295;
  D.19246 = *D.19245;
  if (D.19246 == 32) goto <D.19247>; else goto <D.19248>;
  <D.19247>:
  D.19245 = use_args + 4294967295;
  *D.19245 = 0;
  <D.19248>:
  <D.19244>:
  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.19250>; else goto <D.19251>;
  <D.19250>:
  monoeg_g_free (class_nspace);
  D.19252 = 0B;
  return D.19252;
  <D.19251>:
  *end = 0;
  <D.19242>:
  method_name = strrchr (class_nspace, 58);
  if (method_name == 0B) goto <D.19253>; else goto <D.19254>;
  <D.19253>:
  monoeg_g_free (class_nspace);
  D.19252 = 0B;
  return D.19252;
  <D.19254>:
  if (method_name != class_nspace) goto <D.19255>; else goto <D.19256>;
  <D.19255>:
  D.19257 = method_name + 4294967295;
  D.19258 = *D.19257;
  if (D.19258 == 58) goto <D.19259>; else goto <D.19260>;
  <D.19259>:
  D.19257 = method_name + 4294967295;
  *D.19257 = 0;
  <D.19260>:
  <D.19256>:
  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.19262>; else goto <D.19263>;
  <D.19262>:
  class_name.4 = class_name;
  class_name = class_name.4 + 1;
  *class_name.4 = 0;
  use_namespace = 1;
  goto <D.19265>;
  <D.19263>:
  class_name = class_nspace;
  use_namespace = 0;
  <D.19265>:
  result = monoeg_malloc0 (32);
  result->include_namespace = include_namespace;
  result->name = method_name;
  result->klass = class_name;
  if (use_namespace != 0) goto <D.19267>; else goto <D.19268>;
  <D.19267>:
  iftmp.5 = class_nspace;
  goto <D.19269>;
  <D.19268>:
  iftmp.5 = 0B;
  <D.19269>:
  result->namespace = iftmp.5;
  result->args = use_args;
  D.19270 = result->name;
  D.19271 = __builtin_strchr (D.19270, 42);
  if (D.19271 != 0B) goto <D.19272>; else goto <D.19273>;
  <D.19272>:
  result->name_glob = 1;
  <D.19273>:
  D.19274 = result->klass;
  D.19275 = __builtin_strchr (D.19274, 42);
  if (D.19275 != 0B) goto <D.19276>; else goto <D.19277>;
  <D.19276>:
  result->klass_glob = 1;
  <D.19277>:
  if (use_args != 0B) goto <D.19278>; else goto <D.19279>;
  <D.19278>:
  end = use_args;
  D.19280 = *end;
  if (D.19280 != 0) goto <D.19281>; else goto <D.19282>;
  <D.19281>:
  result->num_args = 1;
  <D.19282>:
  goto <D.18852>;
  <D.18851>:
  D.19280 = *end;
  if (D.19280 == 44) goto <D.19283>; else goto <D.19284>;
  <D.19283>:
  D.19285 = result->num_args;
  D.19286 = D.19285 + 1;
  result->num_args = D.19286;
  <D.19284>:
  end = end + 1;
  <D.18852>:
  D.19280 = *end;
  if (D.19280 != 0) goto <D.18851>; else goto <D.18853>;
  <D.18853>:
  <D.19279>:
  D.19252 = result;
  return D.19252;
}


mono_method_desc_from_method (struct MonoMethod * method)
{
  const char * D.19288;
  gchar * D.19289;
  struct MonoClass * D.19290;
  const char * D.19291;
  gchar * D.19292;
  const char * D.19293;
  gchar * D.19294;
  struct MonoMethodDesc * D.19295;
  struct MonoMethodDesc * result;

  result = monoeg_malloc0 (32);
  result->include_namespace = 1;
  D.19288 = method->name;
  D.19289 = monoeg_strdup (D.19288);
  result->name = D.19289;
  D.19290 = method->klass;
  D.19291 = D.19290->name;
  D.19292 = monoeg_strdup (D.19291);
  result->klass = D.19292;
  D.19290 = method->klass;
  D.19293 = D.19290->name_space;
  D.19294 = monoeg_strdup (D.19293);
  result->namespace = D.19294;
  D.19295 = result;
  return D.19295;
}


mono_method_desc_free (struct MonoMethodDesc * desc)
{
  char * D.19297;
  char * D.19301;

  D.19297 = desc->namespace;
  if (D.19297 != 0B) goto <D.19298>; else goto <D.19299>;
  <D.19298>:
  D.19297 = desc->namespace;
  monoeg_g_free (D.19297);
  goto <D.19300>;
  <D.19299>:
  D.19301 = desc->klass;
  if (D.19301 != 0B) goto <D.19302>; else goto <D.19303>;
  <D.19302>:
  D.19301 = desc->klass;
  monoeg_g_free (D.19301);
  <D.19303>:
  <D.19300>:
  monoeg_g_free (desc);
}


mono_method_desc_match (struct MonoMethodDesc * desc, struct MonoMethod * method)
{
  int D.18875;
  char * D.19304;
  const char * D.19305;
  _Bool D.19306;
  mono_bool D.19309;
  char * D.19310;
  unsigned int D.19313;
  struct MonoMethodSignature * D.19314;
  short unsigned int D.19315;
  unsigned int D.19316;
  struct MonoMethodSignature * D.19319;
  int D.19320;
  int D.18884;
  char * sig;
  gboolean name_match;

  {
    size_t __s1_len;
    size_t __s2_len;

    D.19304 = desc->name;
    D.19305 = method->name;
    D.18875 = __builtin_strcmp (D.19304, D.19305);
  }
  D.19306 = D.18875 == 0;
  name_match = (gboolean) D.19306;
  if (name_match == 0) goto <D.19307>; else goto <D.19308>;
  <D.19307>:
  D.19309 = 0;
  return D.19309;
  <D.19308>:
  D.19310 = desc->args;
  if (D.19310 == 0B) goto <D.19311>; else goto <D.19312>;
  <D.19311>:
  D.19309 = 1;
  return D.19309;
  <D.19312>:
  D.19313 = desc->num_args;
  D.19314 = mono_method_signature (method);
  D.19315 = D.19314->param_count;
  D.19316 = (unsigned int) D.19315;
  if (D.19313 != D.19316) goto <D.19317>; else goto <D.19318>;
  <D.19317>:
  D.19309 = 0;
  return D.19309;
  <D.19318>:
  D.19319 = mono_method_signature (method);
  D.19320 = desc->include_namespace;
  sig = mono_signature_get_desc (D.19319, D.19320);
  {
    size_t __s1_len;
    size_t __s2_len;

    D.19310 = desc->args;
    D.18884 = __builtin_strcmp (sig, D.19310);
  }
  if (D.18884 != 0) goto <D.19321>; else goto <D.19322>;
  <D.19321>:
  monoeg_g_free (sig);
  D.19309 = 0;
  return D.19309;
  <D.19322>:
  monoeg_g_free (sig);
  D.19309 = 1;
  return D.19309;
}


mono_method_desc_full_match (struct MonoMethodDesc * desc, struct MonoMethod * method)
{
  char * D.19324;
  mono_bool D.19327;
  unsigned int D.19328;
  int D.19329;
  struct MonoClass * D.19330;
  int D.19331;

  D.19324 = desc->klass;
  if (D.19324 == 0B) goto <D.19325>; else goto <D.19326>;
  <D.19325>:
  D.19327 = 0;
  return D.19327;
  <D.19326>:
  D.19324 = desc->klass;
  D.19328 = strlen (D.19324);
  D.19329 = (int) D.19328;
  D.19330 = method->klass;
  D.19331 = match_class (desc, D.19329, D.19330);
  if (D.19331 == 0) goto <D.19332>; else goto <D.19333>;
  <D.19332>:
  D.19327 = 0;
  return D.19327;
  <D.19333>:
  D.19327 = mono_method_desc_match (desc, method);
  return D.19327;
}


match_class (struct MonoMethodDesc * desc, int pos, struct MonoClass * klass)
{
  int D.19335;
  int D.18909;
  int iftmp.6;
  int D.18908;
  const char[2] * D.19341;
  unsigned char D.19342;
  int D.19343;
  unsigned char D.19344;
  int D.19345;
  _Bool D.19346;
  _Bool D.19347;
  _Bool D.19348;
  const unsigned char * D.19351;
  unsigned char D.19352;
  int D.19353;
  const unsigned char * D.19354;
  unsigned char D.19355;
  int D.19356;
  _Bool D.19357;
  _Bool D.19358;
  const unsigned char * D.19361;
  unsigned char D.19362;
  int D.19363;
  const unsigned char * D.19364;
  unsigned char D.19365;
  int D.19366;
  _Bool D.19367;
  _Bool D.19368;
  const unsigned char * D.19371;
  unsigned char D.19372;
  int D.19373;
  const unsigned char * D.19374;
  unsigned char D.19375;
  int D.19376;
  char * D.19378;
  gboolean D.19381;
  const char * D.19384;
  int pos.7;
  unsigned int pos.8;
  int D.19387;
  char * D.19390;
  int D.18927;
  const char * D.19393;
  int D.18936;
  const char * D.19396;
  struct MonoClass * D.19399;
  const char * p;

  D.19335 = desc->klass_glob;
  if (D.19335 != 0) goto <D.19336>; else goto <D.19337>;
  <D.19336>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = desc->klass;
      D.19341 = "*";
      D.19342 = MEM[(const unsigned char *)D.19341];
      D.19343 = (int) D.19342;
      D.19344 = *__s2;
      D.19345 = (int) D.19344;
      __result = D.19343 - D.19345;
      {
        D.19346 = __s2_len != 0;
        D.19347 = __result == 0;
        D.19348 = D.19346 & D.19347;
        if (D.19348 != 0) goto <D.19349>; else goto <D.19350>;
        <D.19349>:
        D.19351 = &MEM[(void *)"*" + 1B];
        D.19352 = *D.19351;
        D.19353 = (int) D.19352;
        D.19354 = __s2 + 1;
        D.19355 = *D.19354;
        D.19356 = (int) D.19355;
        __result = D.19353 - D.19356;
        D.19357 = __s2_len > 1;
        D.19347 = __result == 0;
        D.19358 = D.19357 & D.19347;
        if (D.19358 != 0) goto <D.19359>; else goto <D.19360>;
        <D.19359>:
        D.19361 = &MEM[(void *)"*" + 2B];
        D.19362 = *D.19361;
        D.19363 = (int) D.19362;
        D.19364 = __s2 + 2;
        D.19365 = *D.19364;
        D.19366 = (int) D.19365;
        __result = D.19363 - D.19366;
        D.19367 = __s2_len > 2;
        D.19347 = __result == 0;
        D.19368 = D.19367 & D.19347;
        if (D.19368 != 0) goto <D.19369>; else goto <D.19370>;
        <D.19369>:
        D.19371 = &MEM[(void *)"*" + 3B];
        D.19372 = *D.19371;
        D.19373 = (int) D.19372;
        D.19374 = __s2 + 3;
        D.19375 = *D.19374;
        D.19376 = (int) D.19375;
        __result = D.19373 - D.19376;
        <D.19370>:
        <D.19360>:
        <D.19350>:
      }
      D.18908 = __result;
    }
    iftmp.6 = -D.18908;
    goto <D.19377>;
    <D.19340>:
    D.19378 = desc->klass;
    iftmp.6 = __builtin_strcmp (D.19378, "*");
    <D.19377>:
    D.18909 = iftmp.6;
  }
  if (D.18909 == 0) goto <D.19379>; else goto <D.19380>;
  <D.19379>:
  D.19381 = 1;
  return D.19381;
  <D.19380>:
  <D.19337>:
  D.19378 = desc->klass;
  p = my_strrchr (D.19378, 47, &pos);
  if (p == 0B) goto <D.19382>; else goto <D.19383>;
  <D.19382>:
  D.19378 = desc->klass;
  D.19384 = klass->name;
  pos.7 = pos;
  pos.8 = (unsigned int) pos.7;
  D.19387 = strncmp (D.19378, D.19384, pos.8);
  if (D.19387 != 0) goto <D.19388>; else goto <D.19389>;
  <D.19388>:
  D.19381 = 0;
  return D.19381;
  <D.19389>:
  D.19390 = desc->namespace;
  if (D.19390 != 0B) goto <D.19391>; else goto <D.19392>;
  <D.19391>:
  {
    size_t __s1_len;
    size_t __s2_len;

    D.19390 = desc->namespace;
    D.19393 = klass->name_space;
    D.18927 = __builtin_strcmp (D.19390, D.19393);
  }
  if (D.18927 != 0) goto <D.19394>; else goto <D.19395>;
  <D.19394>:
  D.19381 = 0;
  return D.19381;
  <D.19395>:
  <D.19392>:
  D.19381 = 1;
  return D.19381;
  <D.19383>:
  {
    size_t __s1_len;
    size_t __s2_len;

    D.19396 = p + 1;
    D.19384 = klass->name;
    D.18936 = __builtin_strcmp (D.19396, D.19384);
  }
  if (D.18936 != 0) goto <D.19397>; else goto <D.19398>;
  <D.19397>:
  D.19381 = 0;
  return D.19381;
  <D.19398>:
  D.19399 = klass->nested_in;
  if (D.19399 == 0B) goto <D.19400>; else goto <D.19401>;
  <D.19400>:
  D.19381 = 0;
  return D.19381;
  <D.19401>:
  pos.7 = pos;
  D.19399 = klass->nested_in;
  D.19381 = match_class (desc, pos.7, D.19399);
  return D.19381;
}


my_strrchr (const char * str, char ch, int * len)
{
  int D.19403;
  sizetype pos.9;
  const char * D.19405;
  char D.19406;
  const char * D.19409;
  int pos;

  D.19403 = *len;
  pos = D.19403 + -1;
  goto <D.18893>;
  <D.18892>:
  pos.9 = (sizetype) pos;
  D.19405 = str + pos.9;
  D.19406 = *D.19405;
  if (D.19406 != ch) goto <D.19407>; else goto <D.19408>;
  <D.19407>:
  // predicted unlikely by continue predictor.
  goto <D.18891>;
  <D.19408>:
  *len = pos;
  pos.9 = (sizetype) pos;
  D.19409 = str + pos.9;
  return D.19409;
  <D.18891>:
  pos = pos + -1;
  <D.18893>:
  if (pos >= 0) goto <D.18892>; else goto <D.18894>;
  <D.18894>:
  D.19409 = 0B;
  return D.19409;
}


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

  try
    {
      iter = 0B;
      goto <D.18948>;
      <D.18947>:
      D.19411 = mono_method_desc_match (desc, m);
      if (D.19411 != 0) goto <D.19412>; else goto <D.19413>;
      <D.19412>:
      D.19414 = m;
      return D.19414;
      <D.19413>:
      <D.18948>:
      m = mono_class_get_methods (klass, &iter);
      if (m != 0B) goto <D.18947>; else goto <D.18949>;
      <D.18949>:
      D.19414 = 0B;
      return D.19414;
    }
  finally
    {
      iter = {CLOBBER};
    }
}


mono_method_desc_search_in_image (struct MonoMethodDesc * desc, struct MonoImage * image)
{
  char * D.19417;
  struct MonoImage * D.19420;
  char * D.19423;
  struct MonoMethod * D.19426;
  int D.18969;
  char * D.19433;
  int D.19436;
  int D.19437;
  unsigned int D.19438;
  int D.19439;
  int D.19442;
  struct MonoClass * klass;
  const struct MonoTableInfo * tdef;
  const struct MonoTableInfo * methods;
  struct MonoMethod * method;
  int i;

  D.19417 = desc->namespace;
  if (D.19417 == 0B) goto <D.19418>; else goto <D.19419>;
  <D.19418>:
  D.19420 = mono_defaults.corlib;
  if (D.19420 == image) goto <D.19421>; else goto <D.19422>;
  <D.19421>:
  D.19423 = desc->klass;
  klass = find_system_class (D.19423);
  if (klass != 0B) goto <D.19424>; else goto <D.19425>;
  <D.19424>:
  D.19426 = mono_method_desc_search_in_class (desc, klass);
  return D.19426;
  <D.19425>:
  <D.19422>:
  <D.19419>:
  D.19417 = desc->namespace;
  if (D.19417 != 0B) goto <D.19427>; else goto <D.19428>;
  <D.19427>:
  D.19423 = desc->klass;
  if (D.19423 != 0B) goto <D.19429>; else goto <D.19430>;
  <D.19429>:
  D.19417 = desc->namespace;
  D.19423 = desc->klass;
  klass = mono_class_from_name (image, D.19417, D.19423);
  if (klass == 0B) goto <D.19431>; else goto <D.19432>;
  <D.19431>:
  D.19426 = 0B;
  return D.19426;
  <D.19432>:
  D.19426 = mono_method_desc_search_in_class (desc, klass);
  return D.19426;
  <D.19430>:
  <D.19428>:
  tdef = mono_image_get_table_info (image, 2);
  methods = mono_image_get_table_info (image, 6);
  i = 0;
  goto <D.18972>;
  <D.18971>:
  {
    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.19433 = desc->name;
      D.18969 = __builtin_strcmp (n, D.19433);
    }
    if (D.18969 != 0) goto <D.19434>; else goto <D.19435>;
    <D.19434>:
    // predicted unlikely by continue predictor.
    goto <D.18970>;
    <D.19435>:
    D.19436 = i + 1;
    D.19437 = D.19436 | 100663296;
    D.19438 = (unsigned int) D.19437;
    method = mono_get_method (image, D.19438, 0B);
    D.19439 = mono_method_desc_full_match (desc, method);
    if (D.19439 != 0) goto <D.19440>; else goto <D.19441>;
    <D.19440>:
    D.19426 = method;
    return D.19426;
    <D.19441>:
  }
  <D.18970>:
  i = i + 1;
  <D.18972>:
  D.19442 = mono_table_info_get_rows (methods);
  if (D.19442 > i) goto <D.18971>; else goto <D.18973>;
  <D.18973>:
  D.19426 = 0B;
  return D.19426;
}


find_system_class (const char * name)
{
  int D.18625;
  int iftmp.10;
  int D.18624;
  const char[5] * D.19447;
  unsigned char D.19448;
  int D.19449;
  unsigned char D.19450;
  int D.19451;
  _Bool D.19452;
  _Bool D.19453;
  _Bool D.19454;
  const unsigned char * D.19457;
  unsigned char D.19458;
  int D.19459;
  const unsigned char * D.19460;
  unsigned char D.19461;
  int D.19462;
  _Bool D.19463;
  _Bool D.19464;
  const unsigned char * D.19467;
  unsigned char D.19468;
  int D.19469;
  const unsigned char * D.19470;
  unsigned char D.19471;
  int D.19472;
  _Bool D.19473;
  _Bool D.19474;
  const unsigned char * D.19477;
  unsigned char D.19478;
  int D.19479;
  const unsigned char * D.19480;
  unsigned char D.19481;
  int D.19482;
  struct MonoClass * D.19486;
  int D.18634;
  int iftmp.11;
  int D.18633;
  const char[5] * D.19490;
  unsigned char D.19491;
  int D.19492;
  unsigned char D.19493;
  int D.19494;
  _Bool D.19495;
  _Bool D.19496;
  _Bool D.19497;
  const unsigned char * D.19500;
  unsigned char D.19501;
  int D.19502;
  const unsigned char * D.19503;
  unsigned char D.19504;
  int D.19505;
  _Bool D.19506;
  _Bool D.19507;
  const unsigned char * D.19510;
  unsigned char D.19511;
  int D.19512;
  const unsigned char * D.19513;
  unsigned char D.19514;
  int D.19515;
  _Bool D.19516;
  _Bool D.19517;
  const unsigned char * D.19520;
  unsigned char D.19521;
  int D.19522;
  const unsigned char * D.19523;
  unsigned char D.19524;
  int D.19525;
  int D.18643;
  int iftmp.12;
  int D.18642;
  const char[5] * D.19532;
  unsigned char D.19533;
  int D.19534;
  unsigned char D.19535;
  int D.19536;
  _Bool D.19537;
  _Bool D.19538;
  _Bool D.19539;
  const unsigned char * D.19542;
  unsigned char D.19543;
  int D.19544;
  const unsigned char * D.19545;
  unsigned char D.19546;
  int D.19547;
  _Bool D.19548;
  _Bool D.19549;
  const unsigned char * D.19552;
  unsigned char D.19553;
  int D.19554;
  const unsigned char * D.19555;
  unsigned char D.19556;
  int D.19557;
  _Bool D.19558;
  _Bool D.19559;
  const unsigned char * D.19562;
  unsigned char D.19563;
  int D.19564;
  const unsigned char * D.19565;
  unsigned char D.19566;
  int D.19567;
  int D.18652;
  int iftmp.13;
  int D.18651;
  const char[5] * D.19574;
  unsigned char D.19575;
  int D.19576;
  unsigned char D.19577;
  int D.19578;
  _Bool D.19579;
  _Bool D.19580;
  _Bool D.19581;
  const unsigned char * D.19584;
  unsigned char D.19585;
  int D.19586;
  const unsigned char * D.19587;
  unsigned char D.19588;
  int D.19589;
  _Bool D.19590;
  _Bool D.19591;
  const unsigned char * D.19594;
  unsigned char D.19595;
  int D.19596;
  const unsigned char * D.19597;
  unsigned char D.19598;
  int D.19599;
  _Bool D.19600;
  _Bool D.19601;
  const unsigned char * D.19604;
  unsigned char D.19605;
  int D.19606;
  const unsigned char * D.19607;
  unsigned char D.19608;
  int D.19609;
  int D.18661;
  int iftmp.14;
  int D.18660;
  const char[6] * D.19616;
  unsigned char D.19617;
  int D.19618;
  unsigned char D.19619;
  int D.19620;
  _Bool D.19621;
  _Bool D.19622;
  _Bool D.19623;
  const unsigned char * D.19626;
  unsigned char D.19627;
  int D.19628;
  const unsigned char * D.19629;
  unsigned char D.19630;
  int D.19631;
  _Bool D.19632;
  _Bool D.19633;
  const unsigned char * D.19636;
  unsigned char D.19637;
  int D.19638;
  const unsigned char * D.19639;
  unsigned char D.19640;
  int D.19641;
  _Bool D.19642;
  _Bool D.19643;
  const unsigned char * D.19646;
  unsigned char D.19647;
  int D.19648;
  const unsigned char * D.19649;
  unsigned char D.19650;
  int D.19651;
  int D.18670;
  int iftmp.15;
  int D.18669;
  const char[7] * D.19658;
  unsigned char D.19659;
  int D.19660;
  unsigned char D.19661;
  int D.19662;
  _Bool D.19663;
  _Bool D.19664;
  _Bool D.19665;
  const unsigned char * D.19668;
  unsigned char D.19669;
  int D.19670;
  const unsigned char * D.19671;
  unsigned char D.19672;
  int D.19673;
  _Bool D.19674;
  _Bool D.19675;
  const unsigned char * D.19678;
  unsigned char D.19679;
  int D.19680;
  const unsigned char * D.19681;
  unsigned char D.19682;
  int D.19683;
  _Bool D.19684;
  _Bool D.19685;
  const unsigned char * D.19688;
  unsigned char D.19689;
  int D.19690;
  const unsigned char * D.19691;
  unsigned char D.19692;
  int D.19693;
  int D.18679;
  int iftmp.16;
  int D.18678;
  const char[6] * D.19700;
  unsigned char D.19701;
  int D.19702;
  unsigned char D.19703;
  int D.19704;
  _Bool D.19705;
  _Bool D.19706;
  _Bool D.19707;
  const unsigned char * D.19710;
  unsigned char D.19711;
  int D.19712;
  const unsigned char * D.19713;
  unsigned char D.19714;
  int D.19715;
  _Bool D.19716;
  _Bool D.19717;
  const unsigned char * D.19720;
  unsigned char D.19721;
  int D.19722;
  const unsigned char * D.19723;
  unsigned char D.19724;
  int D.19725;
  _Bool D.19726;
  _Bool D.19727;
  const unsigned char * D.19730;
  unsigned char D.19731;
  int D.19732;
  const unsigned char * D.19733;
  unsigned char D.19734;
  int D.19735;
  int D.18688;
  int iftmp.17;
  int D.18687;
  const char[5] * D.19742;
  unsigned char D.19743;
  int D.19744;
  unsigned char D.19745;
  int D.19746;
  _Bool D.19747;
  _Bool D.19748;
  _Bool D.19749;
  const unsigned char * D.19752;
  unsigned char D.19753;
  int D.19754;
  const unsigned char * D.19755;
  unsigned char D.19756;
  int D.19757;
  _Bool D.19758;
  _Bool D.19759;
  const unsigned char * D.19762;
  unsigned char D.19763;
  int D.19764;
  const unsigned char * D.19765;
  unsigned char D.19766;
  int D.19767;
  _Bool D.19768;
  _Bool D.19769;
  const unsigned char * D.19772;
  unsigned char D.19773;
  int D.19774;
  const unsigned char * D.19775;
  unsigned char D.19776;
  int D.19777;
  int D.18697;
  int iftmp.18;
  int D.18696;
  const char[4] * D.19784;
  unsigned char D.19785;
  int D.19786;
  unsigned char D.19787;
  int D.19788;
  _Bool D.19789;
  _Bool D.19790;
  _Bool D.19791;
  const unsigned char * D.19794;
  unsigned char D.19795;
  int D.19796;
  const unsigned char * D.19797;
  unsigned char D.19798;
  int D.19799;
  _Bool D.19800;
  _Bool D.19801;
  const unsigned char * D.19804;
  unsigned char D.19805;
  int D.19806;
  const unsigned char * D.19807;
  unsigned char D.19808;
  int D.19809;
  _Bool D.19810;
  _Bool D.19811;
  const unsigned char * D.19814;
  unsigned char D.19815;
  int D.19816;
  const unsigned char * D.19817;
  unsigned char D.19818;
  int D.19819;
  int D.18706;
  int iftmp.19;
  int D.18705;
  const char[6] * D.19826;
  unsigned char D.19827;
  int D.19828;
  unsigned char D.19829;
  int D.19830;
  _Bool D.19831;
  _Bool D.19832;
  _Bool D.19833;
  const unsigned char * D.19836;
  unsigned char D.19837;
  int D.19838;
  const unsigned char * D.19839;
  unsigned char D.19840;
  int D.19841;
  _Bool D.19842;
  _Bool D.19843;
  const unsigned char * D.19846;
  unsigned char D.19847;
  int D.19848;
  const unsigned char * D.19849;
  unsigned char D.19850;
  int D.19851;
  _Bool D.19852;
  _Bool D.19853;
  const unsigned char * D.19856;
  unsigned char D.19857;
  int D.19858;
  const unsigned char * D.19859;
  unsigned char D.19860;
  int D.19861;
  int D.18715;
  int iftmp.20;
  int D.18714;
  const char[5] * D.19868;
  unsigned char D.19869;
  int D.19870;
  unsigned char D.19871;
  int D.19872;
  _Bool D.19873;
  _Bool D.19874;
  _Bool D.19875;
  const unsigned char * D.19878;
  unsigned char D.19879;
  int D.19880;
  const unsigned char * D.19881;
  unsigned char D.19882;
  int D.19883;
  _Bool D.19884;
  _Bool D.19885;
  const unsigned char * D.19888;
  unsigned char D.19889;
  int D.19890;
  const unsigned char * D.19891;
  unsigned char D.19892;
  int D.19893;
  _Bool D.19894;
  _Bool D.19895;
  const unsigned char * D.19898;
  unsigned char D.19899;
  int D.19900;
  const unsigned char * D.19901;
  unsigned char D.19902;
  int D.19903;
  int D.18724;
  int iftmp.21;
  int D.18723;
  const char[8] * D.19910;
  unsigned char D.19911;
  int D.19912;
  unsigned char D.19913;
  int D.19914;
  _Bool D.19915;
  _Bool D.19916;
  _Bool D.19917;
  const unsigned char * D.19920;
  unsigned char D.19921;
  int D.19922;
  const unsigned char * D.19923;
  unsigned char D.19924;
  int D.19925;
  _Bool D.19926;
  _Bool D.19927;
  const unsigned char * D.19930;
  unsigned char D.19931;
  int D.19932;
  const unsigned char * D.19933;
  unsigned char D.19934;
  int D.19935;
  _Bool D.19936;
  _Bool D.19937;
  const unsigned char * D.19940;
  unsigned char D.19941;
  int D.19942;
  const unsigned char * D.19943;
  unsigned char D.19944;
  int D.19945;
  int D.18733;
  int iftmp.22;
  int D.18732;
  const char[7] * D.19952;
  unsigned char D.19953;
  int D.19954;
  unsigned char D.19955;
  int D.19956;
  _Bool D.19957;
  _Bool D.19958;
  _Bool D.19959;
  const unsigned char * D.19962;
  unsigned char D.19963;
  int D.19964;
  const unsigned char * D.19965;
  unsigned char D.19966;
  int D.19967;
  _Bool D.19968;
  _Bool D.19969;
  const unsigned char * D.19972;
  unsigned char D.19973;
  int D.19974;
  const unsigned char * D.19975;
  unsigned char D.19976;
  int D.19977;
  _Bool D.19978;
  _Bool D.19979;
  const unsigned char * D.19982;
  unsigned char D.19983;
  int D.19984;
  const unsigned char * D.19985;
  unsigned char D.19986;
  int D.19987;
  int D.18742;
  int iftmp.23;
  int D.18741;
  const char[7] * D.19994;
  unsigned char D.19995;
  int D.19996;
  unsigned char D.19997;
  int D.19998;
  _Bool D.19999;
  _Bool D.20000;
  _Bool D.20001;
  const unsigned char * D.20004;
  unsigned char D.20005;
  int D.20006;
  const unsigned char * D.20007;
  unsigned char D.20008;
  int D.20009;
  _Bool D.20010;
  _Bool D.20011;
  const unsigned char * D.20014;
  unsigned char D.20015;
  int D.20016;
  const unsigned char * D.20017;
  unsigned char D.20018;
  int D.20019;
  _Bool D.20020;
  _Bool D.20021;
  const unsigned char * D.20024;
  unsigned char D.20025;
  int D.20026;
  const unsigned char * D.20027;
  unsigned char D.20028;
  int D.20029;
  int D.18751;
  int iftmp.24;
  int D.18750;
  const char[7] * D.20036;
  unsigned char D.20037;
  int D.20038;
  unsigned char D.20039;
  int D.20040;
  _Bool D.20041;
  _Bool D.20042;
  _Bool D.20043;
  const unsigned char * D.20046;
  unsigned char D.20047;
  int D.20048;
  const unsigned char * D.20049;
  unsigned char D.20050;
  int D.20051;
  _Bool D.20052;
  _Bool D.20053;
  const unsigned char * D.20056;
  unsigned char D.20057;
  int D.20058;
  const unsigned char * D.20059;
  unsigned char D.20060;
  int D.20061;
  _Bool D.20062;
  _Bool D.20063;
  const unsigned char * D.20066;
  unsigned char D.20067;
  int D.20068;
  const unsigned char * D.20069;
  unsigned char D.20070;
  int D.20071;
  int D.18760;
  int iftmp.25;
  int D.18759;
  const char[7] * D.20078;
  unsigned char D.20079;
  int D.20080;
  unsigned char D.20081;
  int D.20082;
  _Bool D.20083;
  _Bool D.20084;
  _Bool D.20085;
  const unsigned char * D.20088;
  unsigned char D.20089;
  int D.20090;
  const unsigned char * D.20091;
  unsigned char D.20092;
  int D.20093;
  _Bool D.20094;
  _Bool D.20095;
  const unsigned char * D.20098;
  unsigned char D.20099;
  int D.20100;
  const unsigned char * D.20101;
  unsigned char D.20102;
  int D.20103;
  _Bool D.20104;
  _Bool D.20105;
  const unsigned char * D.20108;
  unsigned char D.20109;
  int D.20110;
  const unsigned char * D.20111;
  unsigned char D.20112;
  int D.20113;
  int D.18769;
  int iftmp.26;
  int D.18768;
  const char[7] * D.20120;
  unsigned char D.20121;
  int D.20122;
  unsigned char D.20123;
  int D.20124;
  _Bool D.20125;
  _Bool D.20126;
  _Bool D.20127;
  const unsigned char * D.20130;
  unsigned char D.20131;
  int D.20132;
  const unsigned char * D.20133;
  unsigned char D.20134;
  int D.20135;
  _Bool D.20136;
  _Bool D.20137;
  const unsigned char * D.20140;
  unsigned char D.20141;
  int D.20142;
  const unsigned char * D.20143;
  unsigned char D.20144;
  int D.20145;
  _Bool D.20146;
  _Bool D.20147;
  const unsigned char * D.20150;
  unsigned char D.20151;
  int D.20152;
  const unsigned char * D.20153;
  unsigned char D.20154;
  int D.20155;

  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = name;
      D.19447 = "void";
      D.19448 = MEM[(const unsigned char *)D.19447];
      D.19449 = (int) D.19448;
      D.19450 = *__s2;
      D.19451 = (int) D.19450;
      __result = D.19449 - D.19451;
      {
        D.19452 = __s2_len != 0;
        D.19453 = __result == 0;
        D.19454 = D.19452 & D.19453;
        if (D.19454 != 0) goto <D.19455>; else goto <D.19456>;
        <D.19455>:
        D.19457 = &MEM[(void *)"void" + 1B];
        D.19458 = *D.19457;
        D.19459 = (int) D.19458;
        D.19460 = __s2 + 1;
        D.19461 = *D.19460;
        D.19462 = (int) D.19461;
        __result = D.19459 - D.19462;
        D.19463 = __s2_len > 1;
        D.19453 = __result == 0;
        D.19464 = D.19463 & D.19453;
        if (D.19464 != 0) goto <D.19465>; else goto <D.19466>;
        <D.19465>:
        D.19467 = &MEM[(void *)"void" + 2B];
        D.19468 = *D.19467;
        D.19469 = (int) D.19468;
        D.19470 = __s2 + 2;
        D.19471 = *D.19470;
        D.19472 = (int) D.19471;
        __result = D.19469 - D.19472;
        D.19473 = __s2_len > 2;
        D.19453 = __result == 0;
        D.19474 = D.19473 & D.19453;
        if (D.19474 != 0) goto <D.19475>; else goto <D.19476>;
        <D.19475>:
        D.19477 = &MEM[(void *)"void" + 3B];
        D.19478 = *D.19477;
        D.19479 = (int) D.19478;
        D.19480 = __s2 + 3;
        D.19481 = *D.19480;
        D.19482 = (int) D.19481;
        __result = D.19479 - D.19482;
        <D.19476>:
        <D.19466>:
        <D.19456>:
      }
      D.18624 = __result;
    }
    iftmp.10 = -D.18624;
    goto <D.19483>;
    <D.19446>:
    iftmp.10 = __builtin_strcmp (name, "void");
    <D.19483>:
    D.18625 = iftmp.10;
  }
  if (D.18625 == 0) goto <D.19484>; else goto <D.19485>;
  <D.19484>:
  D.19486 = mono_defaults.void_class;
  return D.19486;
  <D.19485>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = name;
      D.19490 = "char";
      D.19491 = MEM[(const unsigned char *)D.19490];
      D.19492 = (int) D.19491;
      D.19493 = *__s2;
      D.19494 = (int) D.19493;
      __result = D.19492 - D.19494;
      {
        D.19495 = __s2_len != 0;
        D.19496 = __result == 0;
        D.19497 = D.19495 & D.19496;
        if (D.19497 != 0) goto <D.19498>; else goto <D.19499>;
        <D.19498>:
        D.19500 = &MEM[(void *)"char" + 1B];
        D.19501 = *D.19500;
        D.19502 = (int) D.19501;
        D.19503 = __s2 + 1;
        D.19504 = *D.19503;
        D.19505 = (int) D.19504;
        __result = D.19502 - D.19505;
        D.19506 = __s2_len > 1;
        D.19496 = __result == 0;
        D.19507 = D.19506 & D.19496;
        if (D.19507 != 0) goto <D.19508>; else goto <D.19509>;
        <D.19508>:
        D.19510 = &MEM[(void *)"char" + 2B];
        D.19511 = *D.19510;
        D.19512 = (int) D.19511;
        D.19513 = __s2 + 2;
        D.19514 = *D.19513;
        D.19515 = (int) D.19514;
        __result = D.19512 - D.19515;
        D.19516 = __s2_len > 2;
        D.19496 = __result == 0;
        D.19517 = D.19516 & D.19496;
        if (D.19517 != 0) goto <D.19518>; else goto <D.19519>;
        <D.19518>:
        D.19520 = &MEM[(void *)"char" + 3B];
        D.19521 = *D.19520;
        D.19522 = (int) D.19521;
        D.19523 = __s2 + 3;
        D.19524 = *D.19523;
        D.19525 = (int) D.19524;
        __result = D.19522 - D.19525;
        <D.19519>:
        <D.19509>:
        <D.19499>:
      }
      D.18633 = __result;
    }
    iftmp.11 = -D.18633;
    goto <D.19526>;
    <D.19489>:
    iftmp.11 = __builtin_strcmp (name, "char");
    <D.19526>:
    D.18634 = iftmp.11;
  }
  if (D.18634 == 0) goto <D.19527>; else goto <D.19528>;
  <D.19527>:
  D.19486 = mono_defaults.char_class;
  return D.19486;
  <D.19528>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = name;
      D.19532 = "bool";
      D.19533 = MEM[(const unsigned char *)D.19532];
      D.19534 = (int) D.19533;
      D.19535 = *__s2;
      D.19536 = (int) D.19535;
      __result = D.19534 - D.19536;
      {
        D.19537 = __s2_len != 0;
        D.19538 = __result == 0;
        D.19539 = D.19537 & D.19538;
        if (D.19539 != 0) goto <D.19540>; else goto <D.19541>;
        <D.19540>:
        D.19542 = &MEM[(void *)"bool" + 1B];
        D.19543 = *D.19542;
        D.19544 = (int) D.19543;
        D.19545 = __s2 + 1;
        D.19546 = *D.19545;
        D.19547 = (int) D.19546;
        __result = D.19544 - D.19547;
        D.19548 = __s2_len > 1;
        D.19538 = __result == 0;
        D.19549 = D.19548 & D.19538;
        if (D.19549 != 0) goto <D.19550>; else goto <D.19551>;
        <D.19550>:
        D.19552 = &MEM[(void *)"bool" + 2B];
        D.19553 = *D.19552;
        D.19554 = (int) D.19553;
        D.19555 = __s2 + 2;
        D.19556 = *D.19555;
        D.19557 = (int) D.19556;
        __result = D.19554 - D.19557;
        D.19558 = __s2_len > 2;
        D.19538 = __result == 0;
        D.19559 = D.19558 & D.19538;
        if (D.19559 != 0) goto <D.19560>; else goto <D.19561>;
        <D.19560>:
        D.19562 = &MEM[(void *)"bool" + 3B];
        D.19563 = *D.19562;
        D.19564 = (int) D.19563;
        D.19565 = __s2 + 3;
        D.19566 = *D.19565;
        D.19567 = (int) D.19566;
        __result = D.19564 - D.19567;
        <D.19561>:
        <D.19551>:
        <D.19541>:
      }
      D.18642 = __result;
    }
    iftmp.12 = -D.18642;
    goto <D.19568>;
    <D.19531>:
    iftmp.12 = __builtin_strcmp (name, "bool");
    <D.19568>:
    D.18643 = iftmp.12;
  }
  if (D.18643 == 0) goto <D.19569>; else goto <D.19570>;
  <D.19569>:
  D.19486 = mono_defaults.boolean_class;
  return D.19486;
  <D.19570>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = name;
      D.19574 = "byte";
      D.19575 = MEM[(const unsigned char *)D.19574];
      D.19576 = (int) D.19575;
      D.19577 = *__s2;
      D.19578 = (int) D.19577;
      __result = D.19576 - D.19578;
      {
        D.19579 = __s2_len != 0;
        D.19580 = __result == 0;
        D.19581 = D.19579 & D.19580;
        if (D.19581 != 0) goto <D.19582>; else goto <D.19583>;
        <D.19582>:
        D.19584 = &MEM[(void *)"byte" + 1B];
        D.19585 = *D.19584;
        D.19586 = (int) D.19585;
        D.19587 = __s2 + 1;
        D.19588 = *D.19587;
        D.19589 = (int) D.19588;
        __result = D.19586 - D.19589;
        D.19590 = __s2_len > 1;
        D.19580 = __result == 0;
        D.19591 = D.19590 & D.19580;
        if (D.19591 != 0) goto <D.19592>; else goto <D.19593>;
        <D.19592>:
        D.19594 = &MEM[(void *)"byte" + 2B];
        D.19595 = *D.19594;
        D.19596 = (int) D.19595;
        D.19597 = __s2 + 2;
        D.19598 = *D.19597;
        D.19599 = (int) D.19598;
        __result = D.19596 - D.19599;
        D.19600 = __s2_len > 2;
        D.19580 = __result == 0;
        D.19601 = D.19600 & D.19580;
        if (D.19601 != 0) goto <D.19602>; else goto <D.19603>;
        <D.19602>:
        D.19604 = &MEM[(void *)"byte" + 3B];
        D.19605 = *D.19604;
        D.19606 = (int) D.19605;
        D.19607 = __s2 + 3;
        D.19608 = *D.19607;
        D.19609 = (int) D.19608;
        __result = D.19606 - D.19609;
        <D.19603>:
        <D.19593>:
        <D.19583>:
      }
      D.18651 = __result;
    }
    iftmp.13 = -D.18651;
    goto <D.19610>;
    <D.19573>:
    iftmp.13 = __builtin_strcmp (name, "byte");
    <D.19610>:
    D.18652 = iftmp.13;
  }
  if (D.18652 == 0) goto <D.19611>; else goto <D.19612>;
  <D.19611>:
  D.19486 = mono_defaults.byte_class;
  return D.19486;
  <D.19612>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = name;
      D.19616 = "sbyte";
      D.19617 = MEM[(const unsigned char *)D.19616];
      D.19618 = (int) D.19617;
      D.19619 = *__s2;
      D.19620 = (int) D.19619;
      __result = D.19618 - D.19620;
      {
        D.19621 = __s2_len != 0;
        D.19622 = __result == 0;
        D.19623 = D.19621 & D.19622;
        if (D.19623 != 0) goto <D.19624>; else goto <D.19625>;
        <D.19624>:
        D.19626 = &MEM[(void *)"sbyte" + 1B];
        D.19627 = *D.19626;
        D.19628 = (int) D.19627;
        D.19629 = __s2 + 1;
        D.19630 = *D.19629;
        D.19631 = (int) D.19630;
        __result = D.19628 - D.19631;
        D.19632 = __s2_len > 1;
        D.19622 = __result == 0;
        D.19633 = D.19632 & D.19622;
        if (D.19633 != 0) goto <D.19634>; else goto <D.19635>;
        <D.19634>:
        D.19636 = &MEM[(void *)"sbyte" + 2B];
        D.19637 = *D.19636;
        D.19638 = (int) D.19637;
        D.19639 = __s2 + 2;
        D.19640 = *D.19639;
        D.19641 = (int) D.19640;
        __result = D.19638 - D.19641;
        D.19642 = __s2_len > 2;
        D.19622 = __result == 0;
        D.19643 = D.19642 & D.19622;
        if (D.19643 != 0) goto <D.19644>; else goto <D.19645>;
        <D.19644>:
        D.19646 = &MEM[(void *)"sbyte" + 3B];
        D.19647 = *D.19646;
        D.19648 = (int) D.19647;
        D.19649 = __s2 + 3;
        D.19650 = *D.19649;
        D.19651 = (int) D.19650;
        __result = D.19648 - D.19651;
        <D.19645>:
        <D.19635>:
        <D.19625>:
      }
      D.18660 = __result;
    }
    iftmp.14 = -D.18660;
    goto <D.19652>;
    <D.19615>:
    iftmp.14 = __builtin_strcmp (name, "sbyte");
    <D.19652>:
    D.18661 = iftmp.14;
  }
  if (D.18661 == 0) goto <D.19653>; else goto <D.19654>;
  <D.19653>:
  D.19486 = mono_defaults.sbyte_class;
  return D.19486;
  <D.19654>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = name;
      D.19658 = "uint16";
      D.19659 = MEM[(const unsigned char *)D.19658];
      D.19660 = (int) D.19659;
      D.19661 = *__s2;
      D.19662 = (int) D.19661;
      __result = D.19660 - D.19662;
      {
        D.19663 = __s2_len != 0;
        D.19664 = __result == 0;
        D.19665 = D.19663 & D.19664;
        if (D.19665 != 0) goto <D.19666>; else goto <D.19667>;
        <D.19666>:
        D.19668 = &MEM[(void *)"uint16" + 1B];
        D.19669 = *D.19668;
        D.19670 = (int) D.19669;
        D.19671 = __s2 + 1;
        D.19672 = *D.19671;
        D.19673 = (int) D.19672;
        __result = D.19670 - D.19673;
        D.19674 = __s2_len > 1;
        D.19664 = __result == 0;
        D.19675 = D.19674 & D.19664;
        if (D.19675 != 0) goto <D.19676>; else goto <D.19677>;
        <D.19676>:
        D.19678 = &MEM[(void *)"uint16" + 2B];
        D.19679 = *D.19678;
        D.19680 = (int) D.19679;
        D.19681 = __s2 + 2;
        D.19682 = *D.19681;
        D.19683 = (int) D.19682;
        __result = D.19680 - D.19683;
        D.19684 = __s2_len > 2;
        D.19664 = __result == 0;
        D.19685 = D.19684 & D.19664;
        if (D.19685 != 0) goto <D.19686>; else goto <D.19687>;
        <D.19686>:
        D.19688 = &MEM[(void *)"uint16" + 3B];
        D.19689 = *D.19688;
        D.19690 = (int) D.19689;
        D.19691 = __s2 + 3;
        D.19692 = *D.19691;
        D.19693 = (int) D.19692;
        __result = D.19690 - D.19693;
        <D.19687>:
        <D.19677>:
        <D.19667>:
      }
      D.18669 = __result;
    }
    iftmp.15 = -D.18669;
    goto <D.19694>;
    <D.19657>:
    iftmp.15 = __builtin_strcmp (name, "uint16");
    <D.19694>:
    D.18670 = iftmp.15;
  }
  if (D.18670 == 0) goto <D.19695>; else goto <D.19696>;
  <D.19695>:
  D.19486 = mono_defaults.uint16_class;
  return D.19486;
  <D.19696>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = name;
      D.19700 = "int16";
      D.19701 = MEM[(const unsigned char *)D.19700];
      D.19702 = (int) D.19701;
      D.19703 = *__s2;
      D.19704 = (int) D.19703;
      __result = D.19702 - D.19704;
      {
        D.19705 = __s2_len != 0;
        D.19706 = __result == 0;
        D.19707 = D.19705 & D.19706;
        if (D.19707 != 0) goto <D.19708>; else goto <D.19709>;
        <D.19708>:
        D.19710 = &MEM[(void *)"int16" + 1B];
        D.19711 = *D.19710;
        D.19712 = (int) D.19711;
        D.19713 = __s2 + 1;
        D.19714 = *D.19713;
        D.19715 = (int) D.19714;
        __result = D.19712 - D.19715;
        D.19716 = __s2_len > 1;
        D.19706 = __result == 0;
        D.19717 = D.19716 & D.19706;
        if (D.19717 != 0) goto <D.19718>; else goto <D.19719>;
        <D.19718>:
        D.19720 = &MEM[(void *)"int16" + 2B];
        D.19721 = *D.19720;
        D.19722 = (int) D.19721;
        D.19723 = __s2 + 2;
        D.19724 = *D.19723;
        D.19725 = (int) D.19724;
        __result = D.19722 - D.19725;
        D.19726 = __s2_len > 2;
        D.19706 = __result == 0;
        D.19727 = D.19726 & D.19706;
        if (D.19727 != 0) goto <D.19728>; else goto <D.19729>;
        <D.19728>:
        D.19730 = &MEM[(void *)"int16" + 3B];
        D.19731 = *D.19730;
        D.19732 = (int) D.19731;
        D.19733 = __s2 + 3;
        D.19734 = *D.19733;
        D.19735 = (int) D.19734;
        __result = D.19732 - D.19735;
        <D.19729>:
        <D.19719>:
        <D.19709>:
      }
      D.18678 = __result;
    }
    iftmp.16 = -D.18678;
    goto <D.19736>;
    <D.19699>:
    iftmp.16 = __builtin_strcmp (name, "int16");
    <D.19736>:
    D.18679 = iftmp.16;
  }
  if (D.18679 == 0) goto <D.19737>; else goto <D.19738>;
  <D.19737>:
  D.19486 = mono_defaults.int16_class;
  return D.19486;
  <D.19738>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = name;
      D.19742 = "uint";
      D.19743 = MEM[(const unsigned char *)D.19742];
      D.19744 = (int) D.19743;
      D.19745 = *__s2;
      D.19746 = (int) D.19745;
      __result = D.19744 - D.19746;
      {
        D.19747 = __s2_len != 0;
        D.19748 = __result == 0;
        D.19749 = D.19747 & D.19748;
        if (D.19749 != 0) goto <D.19750>; else goto <D.19751>;
        <D.19750>:
        D.19752 = &MEM[(void *)"uint" + 1B];
        D.19753 = *D.19752;
        D.19754 = (int) D.19753;
        D.19755 = __s2 + 1;
        D.19756 = *D.19755;
        D.19757 = (int) D.19756;
        __result = D.19754 - D.19757;
        D.19758 = __s2_len > 1;
        D.19748 = __result == 0;
        D.19759 = D.19758 & D.19748;
        if (D.19759 != 0) goto <D.19760>; else goto <D.19761>;
        <D.19760>:
        D.19762 = &MEM[(void *)"uint" + 2B];
        D.19763 = *D.19762;
        D.19764 = (int) D.19763;
        D.19765 = __s2 + 2;
        D.19766 = *D.19765;
        D.19767 = (int) D.19766;
        __result = D.19764 - D.19767;
        D.19768 = __s2_len > 2;
        D.19748 = __result == 0;
        D.19769 = D.19768 & D.19748;
        if (D.19769 != 0) goto <D.19770>; else goto <D.19771>;
        <D.19770>:
        D.19772 = &MEM[(void *)"uint" + 3B];
        D.19773 = *D.19772;
        D.19774 = (int) D.19773;
        D.19775 = __s2 + 3;
        D.19776 = *D.19775;
        D.19777 = (int) D.19776;
        __result = D.19774 - D.19777;
        <D.19771>:
        <D.19761>:
        <D.19751>:
      }
      D.18687 = __result;
    }
    iftmp.17 = -D.18687;
    goto <D.19778>;
    <D.19741>:
    iftmp.17 = __builtin_strcmp (name, "uint");
    <D.19778>:
    D.18688 = iftmp.17;
  }
  if (D.18688 == 0) goto <D.19779>; else goto <D.19780>;
  <D.19779>:
  D.19486 = mono_defaults.uint32_class;
  return D.19486;
  <D.19780>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = name;
      D.19784 = "int";
      D.19785 = MEM[(const unsigned char *)D.19784];
      D.19786 = (int) D.19785;
      D.19787 = *__s2;
      D.19788 = (int) D.19787;
      __result = D.19786 - D.19788;
      {
        D.19789 = __s2_len != 0;
        D.19790 = __result == 0;
        D.19791 = D.19789 & D.19790;
        if (D.19791 != 0) goto <D.19792>; else goto <D.19793>;
        <D.19792>:
        D.19794 = &MEM[(void *)"int" + 1B];
        D.19795 = *D.19794;
        D.19796 = (int) D.19795;
        D.19797 = __s2 + 1;
        D.19798 = *D.19797;
        D.19799 = (int) D.19798;
        __result = D.19796 - D.19799;
        D.19800 = __s2_len > 1;
        D.19790 = __result == 0;
        D.19801 = D.19800 & D.19790;
        if (D.19801 != 0) goto <D.19802>; else goto <D.19803>;
        <D.19802>:
        D.19804 = &MEM[(void *)"int" + 2B];
        D.19805 = *D.19804;
        D.19806 = (int) D.19805;
        D.19807 = __s2 + 2;
        D.19808 = *D.19807;
        D.19809 = (int) D.19808;
        __result = D.19806 - D.19809;
        D.19810 = __s2_len > 2;
        D.19790 = __result == 0;
        D.19811 = D.19810 & D.19790;
        if (D.19811 != 0) goto <D.19812>; else goto <D.19813>;
        <D.19812>:
        D.19814 = &MEM[(void *)"int" + 3B];
        D.19815 = *D.19814;
        D.19816 = (int) D.19815;
        D.19817 = __s2 + 3;
        D.19818 = *D.19817;
        D.19819 = (int) D.19818;
        __result = D.19816 - D.19819;
        <D.19813>:
        <D.19803>:
        <D.19793>:
      }
      D.18696 = __result;
    }
    iftmp.18 = -D.18696;
    goto <D.19820>;
    <D.19783>:
    iftmp.18 = __builtin_strcmp (name, "int");
    <D.19820>:
    D.18697 = iftmp.18;
  }
  if (D.18697 == 0) goto <D.19821>; else goto <D.19822>;
  <D.19821>:
  D.19486 = mono_defaults.int32_class;
  return D.19486;
  <D.19822>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = name;
      D.19826 = "ulong";
      D.19827 = MEM[(const unsigned char *)D.19826];
      D.19828 = (int) D.19827;
      D.19829 = *__s2;
      D.19830 = (int) D.19829;
      __result = D.19828 - D.19830;
      {
        D.19831 = __s2_len != 0;
        D.19832 = __result == 0;
        D.19833 = D.19831 & D.19832;
        if (D.19833 != 0) goto <D.19834>; else goto <D.19835>;
        <D.19834>:
        D.19836 = &MEM[(void *)"ulong" + 1B];
        D.19837 = *D.19836;
        D.19838 = (int) D.19837;
        D.19839 = __s2 + 1;
        D.19840 = *D.19839;
        D.19841 = (int) D.19840;
        __result = D.19838 - D.19841;
        D.19842 = __s2_len > 1;
        D.19832 = __result == 0;
        D.19843 = D.19842 & D.19832;
        if (D.19843 != 0) goto <D.19844>; else goto <D.19845>;
        <D.19844>:
        D.19846 = &MEM[(void *)"ulong" + 2B];
        D.19847 = *D.19846;
        D.19848 = (int) D.19847;
        D.19849 = __s2 + 2;
        D.19850 = *D.19849;
        D.19851 = (int) D.19850;
        __result = D.19848 - D.19851;
        D.19852 = __s2_len > 2;
        D.19832 = __result == 0;
        D.19853 = D.19852 & D.19832;
        if (D.19853 != 0) goto <D.19854>; else goto <D.19855>;
        <D.19854>:
        D.19856 = &MEM[(void *)"ulong" + 3B];
        D.19857 = *D.19856;
        D.19858 = (int) D.19857;
        D.19859 = __s2 + 3;
        D.19860 = *D.19859;
        D.19861 = (int) D.19860;
        __result = D.19858 - D.19861;
        <D.19855>:
        <D.19845>:
        <D.19835>:
      }
      D.18705 = __result;
    }
    iftmp.19 = -D.18705;
    goto <D.19862>;
    <D.19825>:
    iftmp.19 = __builtin_strcmp (name, "ulong");
    <D.19862>:
    D.18706 = iftmp.19;
  }
  if (D.18706 == 0) goto <D.19863>; else goto <D.19864>;
  <D.19863>:
  D.19486 = mono_defaults.uint64_class;
  return D.19486;
  <D.19864>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = name;
      D.19868 = "long";
      D.19869 = MEM[(const unsigned char *)D.19868];
      D.19870 = (int) D.19869;
      D.19871 = *__s2;
      D.19872 = (int) D.19871;
      __result = D.19870 - D.19872;
      {
        D.19873 = __s2_len != 0;
        D.19874 = __result == 0;
        D.19875 = D.19873 & D.19874;
        if (D.19875 != 0) goto <D.19876>; else goto <D.19877>;
        <D.19876>:
        D.19878 = &MEM[(void *)"long" + 1B];
        D.19879 = *D.19878;
        D.19880 = (int) D.19879;
        D.19881 = __s2 + 1;
        D.19882 = *D.19881;
        D.19883 = (int) D.19882;
        __result = D.19880 - D.19883;
        D.19884 = __s2_len > 1;
        D.19874 = __result == 0;
        D.19885 = D.19884 & D.19874;
        if (D.19885 != 0) goto <D.19886>; else goto <D.19887>;
        <D.19886>:
        D.19888 = &MEM[(void *)"long" + 2B];
        D.19889 = *D.19888;
        D.19890 = (int) D.19889;
        D.19891 = __s2 + 2;
        D.19892 = *D.19891;
        D.19893 = (int) D.19892;
        __result = D.19890 - D.19893;
        D.19894 = __s2_len > 2;
        D.19874 = __result == 0;
        D.19895 = D.19894 & D.19874;
        if (D.19895 != 0) goto <D.19896>; else goto <D.19897>;
        <D.19896>:
        D.19898 = &MEM[(void *)"long" + 3B];
        D.19899 = *D.19898;
        D.19900 = (int) D.19899;
        D.19901 = __s2 + 3;
        D.19902 = *D.19901;
        D.19903 = (int) D.19902;
        __result = D.19900 - D.19903;
        <D.19897>:
        <D.19887>:
        <D.19877>:
      }
      D.18714 = __result;
    }
    iftmp.20 = -D.18714;
    goto <D.19904>;
    <D.19867>:
    iftmp.20 = __builtin_strcmp (name, "long");
    <D.19904>:
    D.18715 = iftmp.20;
  }
  if (D.18715 == 0) goto <D.19905>; else goto <D.19906>;
  <D.19905>:
  D.19486 = mono_defaults.int64_class;
  return D.19486;
  <D.19906>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = name;
      D.19910 = "uintptr";
      D.19911 = MEM[(const unsigned char *)D.19910];
      D.19912 = (int) D.19911;
      D.19913 = *__s2;
      D.19914 = (int) D.19913;
      __result = D.19912 - D.19914;
      {
        D.19915 = __s2_len != 0;
        D.19916 = __result == 0;
        D.19917 = D.19915 & D.19916;
        if (D.19917 != 0) goto <D.19918>; else goto <D.19919>;
        <D.19918>:
        D.19920 = &MEM[(void *)"uintptr" + 1B];
        D.19921 = *D.19920;
        D.19922 = (int) D.19921;
        D.19923 = __s2 + 1;
        D.19924 = *D.19923;
        D.19925 = (int) D.19924;
        __result = D.19922 - D.19925;
        D.19926 = __s2_len > 1;
        D.19916 = __result == 0;
        D.19927 = D.19926 & D.19916;
        if (D.19927 != 0) goto <D.19928>; else goto <D.19929>;
        <D.19928>:
        D.19930 = &MEM[(void *)"uintptr" + 2B];
        D.19931 = *D.19930;
        D.19932 = (int) D.19931;
        D.19933 = __s2 + 2;
        D.19934 = *D.19933;
        D.19935 = (int) D.19934;
        __result = D.19932 - D.19935;
        D.19936 = __s2_len > 2;
        D.19916 = __result == 0;
        D.19937 = D.19936 & D.19916;
        if (D.19937 != 0) goto <D.19938>; else goto <D.19939>;
        <D.19938>:
        D.19940 = &MEM[(void *)"uintptr" + 3B];
        D.19941 = *D.19940;
        D.19942 = (int) D.19941;
        D.19943 = __s2 + 3;
        D.19944 = *D.19943;
        D.19945 = (int) D.19944;
        __result = D.19942 - D.19945;
        <D.19939>:
        <D.19929>:
        <D.19919>:
      }
      D.18723 = __result;
    }
    iftmp.21 = -D.18723;
    goto <D.19946>;
    <D.19909>:
    iftmp.21 = __builtin_strcmp (name, "uintptr");
    <D.19946>:
    D.18724 = iftmp.21;
  }
  if (D.18724 == 0) goto <D.19947>; else goto <D.19948>;
  <D.19947>:
  D.19486 = mono_defaults.uint_class;
  return D.19486;
  <D.19948>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = name;
      D.19952 = "intptr";
      D.19953 = MEM[(const unsigned char *)D.19952];
      D.19954 = (int) D.19953;
      D.19955 = *__s2;
      D.19956 = (int) D.19955;
      __result = D.19954 - D.19956;
      {
        D.19957 = __s2_len != 0;
        D.19958 = __result == 0;
        D.19959 = D.19957 & D.19958;
        if (D.19959 != 0) goto <D.19960>; else goto <D.19961>;
        <D.19960>:
        D.19962 = &MEM[(void *)"intptr" + 1B];
        D.19963 = *D.19962;
        D.19964 = (int) D.19963;
        D.19965 = __s2 + 1;
        D.19966 = *D.19965;
        D.19967 = (int) D.19966;
        __result = D.19964 - D.19967;
        D.19968 = __s2_len > 1;
        D.19958 = __result == 0;
        D.19969 = D.19968 & D.19958;
        if (D.19969 != 0) goto <D.19970>; else goto <D.19971>;
        <D.19970>:
        D.19972 = &MEM[(void *)"intptr" + 2B];
        D.19973 = *D.19972;
        D.19974 = (int) D.19973;
        D.19975 = __s2 + 2;
        D.19976 = *D.19975;
        D.19977 = (int) D.19976;
        __result = D.19974 - D.19977;
        D.19978 = __s2_len > 2;
        D.19958 = __result == 0;
        D.19979 = D.19978 & D.19958;
        if (D.19979 != 0) goto <D.19980>; else goto <D.19981>;
        <D.19980>:
        D.19982 = &MEM[(void *)"intptr" + 3B];
        D.19983 = *D.19982;
        D.19984 = (int) D.19983;
        D.19985 = __s2 + 3;
        D.19986 = *D.19985;
        D.19987 = (int) D.19986;
        __result = D.19984 - D.19987;
        <D.19981>:
        <D.19971>:
        <D.19961>:
      }
      D.18732 = __result;
    }
    iftmp.22 = -D.18732;
    goto <D.19988>;
    <D.19951>:
    iftmp.22 = __builtin_strcmp (name, "intptr");
    <D.19988>:
    D.18733 = iftmp.22;
  }
  if (D.18733 == 0) goto <D.19989>; else goto <D.19990>;
  <D.19989>:
  D.19486 = mono_defaults.int_class;
  return D.19486;
  <D.19990>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = name;
      D.19994 = "single";
      D.19995 = MEM[(const unsigned char *)D.19994];
      D.19996 = (int) D.19995;
      D.19997 = *__s2;
      D.19998 = (int) D.19997;
      __result = D.19996 - D.19998;
      {
        D.19999 = __s2_len != 0;
        D.20000 = __result == 0;
        D.20001 = D.19999 & D.20000;
        if (D.20001 != 0) goto <D.20002>; else goto <D.20003>;
        <D.20002>:
        D.20004 = &MEM[(void *)"single" + 1B];
        D.20005 = *D.20004;
        D.20006 = (int) D.20005;
        D.20007 = __s2 + 1;
        D.20008 = *D.20007;
        D.20009 = (int) D.20008;
        __result = D.20006 - D.20009;
        D.20010 = __s2_len > 1;
        D.20000 = __result == 0;
        D.20011 = D.20010 & D.20000;
        if (D.20011 != 0) goto <D.20012>; else goto <D.20013>;
        <D.20012>:
        D.20014 = &MEM[(void *)"single" + 2B];
        D.20015 = *D.20014;
        D.20016 = (int) D.20015;
        D.20017 = __s2 + 2;
        D.20018 = *D.20017;
        D.20019 = (int) D.20018;
        __result = D.20016 - D.20019;
        D.20020 = __s2_len > 2;
        D.20000 = __result == 0;
        D.20021 = D.20020 & D.20000;
        if (D.20021 != 0) goto <D.20022>; else goto <D.20023>;
        <D.20022>:
        D.20024 = &MEM[(void *)"single" + 3B];
        D.20025 = *D.20024;
        D.20026 = (int) D.20025;
        D.20027 = __s2 + 3;
        D.20028 = *D.20027;
        D.20029 = (int) D.20028;
        __result = D.20026 - D.20029;
        <D.20023>:
        <D.20013>:
        <D.20003>:
      }
      D.18741 = __result;
    }
    iftmp.23 = -D.18741;
    goto <D.20030>;
    <D.19993>:
    iftmp.23 = __builtin_strcmp (name, "single");
    <D.20030>:
    D.18742 = iftmp.23;
  }
  if (D.18742 == 0) goto <D.20031>; else goto <D.20032>;
  <D.20031>:
  D.19486 = mono_defaults.single_class;
  return D.19486;
  <D.20032>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = name;
      D.20036 = "double";
      D.20037 = MEM[(const unsigned char *)D.20036];
      D.20038 = (int) D.20037;
      D.20039 = *__s2;
      D.20040 = (int) D.20039;
      __result = D.20038 - D.20040;
      {
        D.20041 = __s2_len != 0;
        D.20042 = __result == 0;
        D.20043 = D.20041 & D.20042;
        if (D.20043 != 0) goto <D.20044>; else goto <D.20045>;
        <D.20044>:
        D.20046 = &MEM[(void *)"double" + 1B];
        D.20047 = *D.20046;
        D.20048 = (int) D.20047;
        D.20049 = __s2 + 1;
        D.20050 = *D.20049;
        D.20051 = (int) D.20050;
        __result = D.20048 - D.20051;
        D.20052 = __s2_len > 1;
        D.20042 = __result == 0;
        D.20053 = D.20052 & D.20042;
        if (D.20053 != 0) goto <D.20054>; else goto <D.20055>;
        <D.20054>:
        D.20056 = &MEM[(void *)"double" + 2B];
        D.20057 = *D.20056;
        D.20058 = (int) D.20057;
        D.20059 = __s2 + 2;
        D.20060 = *D.20059;
        D.20061 = (int) D.20060;
        __result = D.20058 - D.20061;
        D.20062 = __s2_len > 2;
        D.20042 = __result == 0;
        D.20063 = D.20062 & D.20042;
        if (D.20063 != 0) goto <D.20064>; else goto <D.20065>;
        <D.20064>:
        D.20066 = &MEM[(void *)"double" + 3B];
        D.20067 = *D.20066;
        D.20068 = (int) D.20067;
        D.20069 = __s2 + 3;
        D.20070 = *D.20069;
        D.20071 = (int) D.20070;
        __result = D.20068 - D.20071;
        <D.20065>:
        <D.20055>:
        <D.20045>:
      }
      D.18750 = __result;
    }
    iftmp.24 = -D.18750;
    goto <D.20072>;
    <D.20035>:
    iftmp.24 = __builtin_strcmp (name, "double");
    <D.20072>:
    D.18751 = iftmp.24;
  }
  if (D.18751 == 0) goto <D.20073>; else goto <D.20074>;
  <D.20073>:
  D.19486 = mono_defaults.double_class;
  return D.19486;
  <D.20074>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = name;
      D.20078 = "string";
      D.20079 = MEM[(const unsigned char *)D.20078];
      D.20080 = (int) D.20079;
      D.20081 = *__s2;
      D.20082 = (int) D.20081;
      __result = D.20080 - D.20082;
      {
        D.20083 = __s2_len != 0;
        D.20084 = __result == 0;
        D.20085 = D.20083 & D.20084;
        if (D.20085 != 0) goto <D.20086>; else goto <D.20087>;
        <D.20086>:
        D.20088 = &MEM[(void *)"string" + 1B];
        D.20089 = *D.20088;
        D.20090 = (int) D.20089;
        D.20091 = __s2 + 1;
        D.20092 = *D.20091;
        D.20093 = (int) D.20092;
        __result = D.20090 - D.20093;
        D.20094 = __s2_len > 1;
        D.20084 = __result == 0;
        D.20095 = D.20094 & D.20084;
        if (D.20095 != 0) goto <D.20096>; else goto <D.20097>;
        <D.20096>:
        D.20098 = &MEM[(void *)"string" + 2B];
        D.20099 = *D.20098;
        D.20100 = (int) D.20099;
        D.20101 = __s2 + 2;
        D.20102 = *D.20101;
        D.20103 = (int) D.20102;
        __result = D.20100 - D.20103;
        D.20104 = __s2_len > 2;
        D.20084 = __result == 0;
        D.20105 = D.20104 & D.20084;
        if (D.20105 != 0) goto <D.20106>; else goto <D.20107>;
        <D.20106>:
        D.20108 = &MEM[(void *)"string" + 3B];
        D.20109 = *D.20108;
        D.20110 = (int) D.20109;
        D.20111 = __s2 + 3;
        D.20112 = *D.20111;
        D.20113 = (int) D.20112;
        __result = D.20110 - D.20113;
        <D.20107>:
        <D.20097>:
        <D.20087>:
      }
      D.18759 = __result;
    }
    iftmp.25 = -D.18759;
    goto <D.20114>;
    <D.20077>:
    iftmp.25 = __builtin_strcmp (name, "string");
    <D.20114>:
    D.18760 = iftmp.25;
  }
  if (D.18760 == 0) goto <D.20115>; else goto <D.20116>;
  <D.20115>:
  D.19486 = mono_defaults.string_class;
  return D.19486;
  <D.20116>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = name;
      D.20120 = "object";
      D.20121 = MEM[(const unsigned char *)D.20120];
      D.20122 = (int) D.20121;
      D.20123 = *__s2;
      D.20124 = (int) D.20123;
      __result = D.20122 - D.20124;
      {
        D.20125 = __s2_len != 0;
        D.20126 = __result == 0;
        D.20127 = D.20125 & D.20126;
        if (D.20127 != 0) goto <D.20128>; else goto <D.20129>;
        <D.20128>:
        D.20130 = &MEM[(void *)"object" + 1B];
        D.20131 = *D.20130;
        D.20132 = (int) D.20131;
        D.20133 = __s2 + 1;
        D.20134 = *D.20133;
        D.20135 = (int) D.20134;
        __result = D.20132 - D.20135;
        D.20136 = __s2_len > 1;
        D.20126 = __result == 0;
        D.20137 = D.20136 & D.20126;
        if (D.20137 != 0) goto <D.20138>; else goto <D.20139>;
        <D.20138>:
        D.20140 = &MEM[(void *)"object" + 2B];
        D.20141 = *D.20140;
        D.20142 = (int) D.20141;
        D.20143 = __s2 + 2;
        D.20144 = *D.20143;
        D.20145 = (int) D.20144;
        __result = D.20142 - D.20145;
        D.20146 = __s2_len > 2;
        D.20126 = __result == 0;
        D.20147 = D.20146 & D.20126;
        if (D.20147 != 0) goto <D.20148>; else goto <D.20149>;
        <D.20148>:
        D.20150 = &MEM[(void *)"object" + 3B];
        D.20151 = *D.20150;
        D.20152 = (int) D.20151;
        D.20153 = __s2 + 3;
        D.20154 = *D.20153;
        D.20155 = (int) D.20154;
        __result = D.20152 - D.20155;
        <D.20149>:
        <D.20139>:
        <D.20129>:
      }
      D.18768 = __result;
    }
    iftmp.26 = -D.18768;
    goto <D.20156>;
    <D.20119>:
    iftmp.26 = __builtin_strcmp (name, "object");
    <D.20156>:
    D.18769 = iftmp.26;
  }
  if (D.18769 == 0) goto <D.20157>; else goto <D.20158>;
  <D.20157>:
  D.19486 = mono_defaults.object_class;
  return D.19486;
  <D.20158>:
  D.19486 = 0B;
  return D.19486;
}


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

  res = monoeg_g_string_new ("");
  if (dh == 0B) goto <D.20160>; else goto <D.20161>;
  <D.20160>:
  dh = &default_dh;
  <D.20161>:
  D.20162 = ip + 2;
  ip = dis_one (res, dh, method, ip, D.20162);
  if (endp != 0B) goto <D.20163>; else goto <D.20164>;
  <D.20163>:
  *endp = ip;
  <D.20164>:
  result = res->str;
  monoeg_g_string_free (res, 0);
  D.20165 = result;
  return D.20165;
}


dis_one (struct GString * str, struct MonoDisHelper * dh, struct MonoMethod * method, const unsigned char * ip, const unsigned char * end)
{
  const unsigned char * ip.27;
  int ip.28;
  int il_code.29;
  int D.20170;
  char * (*<T31d8>) (struct MonoDisHelper *, struct MonoMethod *, uint32_t) D.20171;
  const char * D.20174;
  <unnamed type> D.20177;
  const unsigned char * ip.30;
  const char * D.20179;
  unsigned char D.20180;
  int D.20181;
  char * (*<T31d8>) (struct MonoDisHelper *, struct MonoMethod *, uint32_t) D.20182;
  const unsigned char * ip.31;
  struct MonoClass * D.20187;
  struct MonoImage * D.20188;
  unsigned char D.20189;
  unsigned char D.20190;
  unsigned int D.20193;
  const char * blob.32;
  const char * blob.33;
  unsigned int D.20196;
  unsigned int D.20197;
  long int len2.34;
  short unsigned int D.20201;
  int D.20202;
  const unsigned char * ip.35;
  unsigned char D.20204;
  int D.20205;
  unsigned int D.20206;
  const char * D.20207;
  sizetype sval.36;
  const unsigned char * D.20211;
  int D.20212;
  int D.20213;
  signed char D.20215;
  unsigned int D.20219;
  int D.20220;
  sizetype D.20221;
  const unsigned char * D.20226;
  int D.20227;
  int D.20228;
  long long unsigned int D.20230;
  double r.37;
  double r.38;
  const unsigned char * ip.39;
  unsigned int D.20234;
  float r.40;
  float r.41;
  double D.20237;
  unsigned int D.20238;
  int D.20239;
  int D.20240;
  const char * D.20241;
  const unsigned char * D.20244;
  struct MonoMethodHeader * header;
  const struct MonoOpcode * opcode;
  guint32 label;
  guint32 token;
  gint32 sval;
  int i;
  char * tmp;
  const unsigned char * il_code;

  header = mono_method_get_header (method);
  il_code = mono_method_header_get_code (header, 0B, 0B);
  ip.27 = ip;
  ip.28 = (int) ip.27;
  il_code.29 = (int) il_code;
  D.20170 = ip.28 - il_code.29;
  label = (guint32) D.20170;
  D.20171 = dh->indenter;
  if (D.20171 != 0B) goto <D.20172>; else goto <D.20173>;
  <D.20172>:
  D.20171 = dh->indenter;
  tmp = D.20171 (dh, method, label);
  monoeg_g_string_append (str, tmp);
  monoeg_g_free (tmp);
  <D.20173>:
  D.20174 = dh->label_format;
  if (D.20174 != 0B) goto <D.20175>; else goto <D.20176>;
  <D.20175>:
  D.20174 = dh->label_format;
  monoeg_g_string_append_printf (str, D.20174, label);
  <D.20176>:
  D.20177 = mono_opcode_value (&ip, end);
  i = (int) D.20177;
  ip.27 = ip;
  ip.30 = ip.27 + 1;
  ip = ip.30;
  opcode = &mono_opcodes[i];
  D.20179 = mono_opcode_name (i);
  monoeg_g_string_append_printf (str, "%-10s", D.20179);
  D.20180 = opcode->argument;
  D.20181 = (int) D.20180;
  switch (D.20181) <default: <D.19019>, case 0: <D.18989>, case 1: <D.18991>, case 2: <D.18992>, case 3: <D.18993>, case 4: <D.18994>, case 5: <D.18996>, case 6: <D.18995>, case 7: <D.19001>, case 8: <D.19002>, case 9: <D.19003>, case 10: <D.19004>, case 11: <D.19005>, case 12: <D.19010>, case 13: <D.19013>, case 14: <D.19016>, case 15: <D.19017>, case 16: <D.19018>>
  <D.18989>:
  goto <D.18990>;
  <D.18991>:
  <D.18992>:
  <D.18993>:
  <D.18994>:
  <D.18995>:
  ip.27 = ip;
  token = mono_read32 (ip.27);
  D.20182 = dh->tokener;
  if (D.20182 != 0B) goto <D.20183>; else goto <D.20184>;
  <D.20183>:
  D.20182 = dh->tokener;
  tmp = D.20182 (dh, method, token);
  monoeg_g_string_append (str, tmp);
  monoeg_g_free (tmp);
  goto <D.20185>;
  <D.20184>:
  monoeg_g_string_append_printf (str, "0x%08x", token);
  <D.20185>:
  ip.27 = ip;
  ip.31 = ip.27 + 4;
  ip = ip.31;
  goto <D.18990>;
  <D.18996>:
  {
    const char * blob;
    char * s;
    size_t len2;
    char * blob2;

    try
      {
        blob2 = 0B;
        D.20187 = method->klass;
        D.20188 = D.20187->image;
        D.20189 = BIT_FIELD_REF <*D.20188, 8, 128>;
        D.20190 = D.20189 & 8;
        if (D.20190 == 0) goto <D.20191>; else goto <D.20192>;
        <D.20191>:
        ip.27 = ip;
        token = mono_read32 (ip.27);
        D.20187 = method->klass;
        D.20188 = D.20187->image;
        D.20193 = token & 16777215;
        blob.32 = mono_metadata_user_string (D.20188, D.20193);
        blob = blob.32;
        blob.33 = blob;
        len2 = mono_metadata_decode_blob_size (blob.33, &blob);
        len2 = len2 >> 1;
        D.20196 = len2 * 2;
        D.20197 = D.20196 + 1;
        blob2 = monoeg_malloc (D.20197);
        blob.33 = blob;
        D.20196 = len2 * 2;
        memcpy (blob2, blob.33, D.20196);
        len2.34 = (long int) len2;
        s = monoeg_g_utf16_to_utf8 (blob2, len2.34, 0B, 0B, 0B);
        monoeg_g_string_append_printf (str, "\"%s\"", s);
        monoeg_g_free (s);
        blob.33 = blob;
        if (blob.33 != blob2) goto <D.20199>; else goto <D.20200>;
        <D.20199>:
        monoeg_g_free (blob2);
        <D.20200>:
        <D.20192>:
        ip.27 = ip;
        ip.31 = ip.27 + 4;
        ip = ip.31;
        goto <D.18990>;
      }
    finally
      {
        blob = {CLOBBER};
      }
  }
  <D.19001>:
  ip.27 = ip;
  D.20201 = mono_read16 (ip.27);
  D.20202 = (int) D.20201;
  monoeg_g_string_append_printf (str, "%d", D.20202);
  ip.27 = ip;
  ip.35 = ip.27 + 2;
  ip = ip.35;
  goto <D.18990>;
  <D.19002>:
  ip.27 = ip;
  D.20204 = *ip.27;
  D.20205 = (int) D.20204;
  monoeg_g_string_append_printf (str, "%d", D.20205);
  ip.27 = ip;
  ip.30 = ip.27 + 1;
  ip = ip.30;
  goto <D.18990>;
  <D.19003>:
  ip.27 = ip;
  D.20206 = mono_read32 (ip.27);
  sval = (gint32) D.20206;
  ip.27 = ip;
  ip.31 = ip.27 + 4;
  ip = ip.31;
  D.20207 = dh->label_target;
  if (D.20207 != 0B) goto <D.20208>; else goto <D.20209>;
  <D.20208>:
  D.20207 = dh->label_target;
  ip.27 = ip;
  sval.36 = (sizetype) sval;
  D.20211 = ip.27 + sval.36;
  D.20212 = (int) D.20211;
  il_code.29 = (int) il_code;
  D.20213 = D.20212 - il_code.29;
  monoeg_g_string_append_printf (str, D.20207, D.20213);
  goto <D.20214>;
  <D.20209>:
  monoeg_g_string_append_printf (str, "%d", sval);
  <D.20214>:
  goto <D.18990>;
  <D.19004>:
  ip.27 = ip;
  D.20215 = MEM[(const signed char *)ip.27];
  sval = (gint32) D.20215;
  ip.27 = ip;
  ip.30 = ip.27 + 1;
  ip = ip.30;
  D.20207 = dh->label_target;
  if (D.20207 != 0B) goto <D.20216>; else goto <D.20217>;
  <D.20216>:
  D.20207 = dh->label_target;
  ip.27 = ip;
  sval.36 = (sizetype) sval;
  D.20211 = ip.27 + sval.36;
  D.20212 = (int) D.20211;
  il_code.29 = (int) il_code;
  D.20213 = D.20212 - il_code.29;
  monoeg_g_string_append_printf (str, D.20207, D.20213);
  goto <D.20218>;
  <D.20217>:
  monoeg_g_string_append_printf (str, "%d", sval);
  <D.20218>:
  goto <D.18990>;
  <D.19005>:
  {
    const unsigned char * end;

    ip.27 = ip;
    D.20219 = mono_read32 (ip.27);
    sval = (gint32) D.20219;
    ip.27 = ip;
    ip.31 = ip.27 + 4;
    ip = ip.31;
    ip.27 = ip;
    D.20220 = sval * 4;
    D.20221 = (sizetype) D.20220;
    end = ip.27 + D.20221;
    monoeg_g_string_append_c (str, 40);
    i = 0;
    goto <D.19008>;
    <D.19007>:
    if (i > 0) goto <D.20222>; else goto <D.20223>;
    <D.20222>:
    monoeg_g_string_append (str, ", ");
    <D.20223>:
    ip.27 = ip;
    label = mono_read32 (ip.27);
    D.20207 = dh->label_target;
    if (D.20207 != 0B) goto <D.20224>; else goto <D.20225>;
    <D.20224>:
    D.20207 = dh->label_target;
    D.20226 = end + label;
    D.20227 = (int) D.20226;
    il_code.29 = (int) il_code;
    D.20228 = D.20227 - il_code.29;
    monoeg_g_string_append_printf (str, D.20207, D.20228);
    goto <D.20229>;
    <D.20225>:
    monoeg_g_string_append_printf (str, "%d", label);
    <D.20229>:
    ip.27 = ip;
    ip.31 = ip.27 + 4;
    ip = ip.31;
    i = i + 1;
    <D.19008>:
    if (i < sval) goto <D.19007>; else goto <D.19009>;
    <D.19009>:
    monoeg_g_string_append_c (str, 41);
    goto <D.18990>;
  }
  <D.19010>:
  {
    double r;

    try
      {
        {
          union mono_rdouble mf;

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

    try
      {
        {
          union mono_rfloat mf;

          try
            {
              ip.27 = ip;
              D.20234 = mono_read32 (ip.27);
              mf.ival = D.20234;
              r.40 = mf.fval;
              r = r.40;
            }
          finally
            {
              mf = {CLOBBER};
            }
        }
        r.41 = r;
        D.20237 = (double) r.41;
        monoeg_g_string_append_printf (str, "%g", D.20237);
        ip.27 = ip;
        ip.31 = ip.27 + 4;
        ip = ip.31;
        goto <D.18990>;
      }
    finally
      {
        r = {CLOBBER};
      }
  }
  <D.19016>:
  ip.27 = ip;
  D.20238 = mono_read32 (ip.27);
  D.20239 = (int) D.20238;
  monoeg_g_string_append_printf (str, "%d", D.20239);
  ip.27 = ip;
  ip.31 = ip.27 + 4;
  ip = ip.31;
  goto <D.18990>;
  <D.19017>:
  ip.27 = ip;
  D.20215 = MEM[(const signed char *)ip.27];
  D.20240 = (int) D.20215;
  monoeg_g_string_append_printf (str, "%d", D.20240);
  ip.27 = ip;
  ip.30 = ip.27 + 1;
  ip = ip.30;
  goto <D.18990>;
  <D.19018>:
  ip.27 = ip;
  ip.39 = ip.27 + 8;
  ip = ip.39;
  goto <D.18990>;
  <D.19019>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "debug-helpers.c", 684);
  <D.18990>:
  D.20241 = dh->newline;
  if (D.20241 != 0B) goto <D.20242>; else goto <D.20243>;
  <D.20242>:
  D.20241 = dh->newline;
  monoeg_g_string_append (str, D.20241);
  <D.20243>:
  mono_metadata_free_mh (header);
  D.20244 = ip;
  return D.20244;
}


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

  D.20251 = __builtin_object_size (__dest, 0);
  D.20250 = __builtin___memcpy_chk (__dest, __src, __len, D.20251);
  return D.20250;
}


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

  res = monoeg_g_string_new ("");
  if (dh == 0B) goto <D.20253>; else goto <D.20254>;
  <D.20253>:
  dh = &default_dh;
  <D.20254>:
  goto <D.19038>;
  <D.19037>:
  ip = dis_one (res, dh, method, ip, end);
  <D.19038>:
  if (ip < end) goto <D.19037>; else goto <D.19039>;
  <D.19039>:
  result = res->str;
  monoeg_g_string_free (res, 0);
  D.20255 = result;
  return D.20255;
}


mono_field_full_name (struct MonoClassField * field)
{
  struct MonoClass * D.20257;
  const char * iftmp.42;
  char D.20259;
  const char * D.20263;
  const char * D.20264;
  char * D.20265;
  char * res;
  const char * nspace;

  D.20257 = field->parent;
  nspace = D.20257->name_space;
  D.20259 = *nspace;
  if (D.20259 != 0) goto <D.20260>; else goto <D.20261>;
  <D.20260>:
  iftmp.42 = ".";
  goto <D.20262>;
  <D.20261>:
  iftmp.42 = "";
  <D.20262>:
  D.20257 = field->parent;
  D.20263 = D.20257->name;
  D.20264 = mono_field_get_name (field);
  res = monoeg_g_strdup_printf ("%s%s%s:%s", nspace, iftmp.42, D.20263, D.20264);
  D.20265 = res;
  return D.20265;
}


mono_method_full_name (struct MonoMethod * method, gboolean signature)
{
  struct MonoClass * D.20267;
  struct MonoType * D.20268;
  unsigned char D.20271;
  unsigned char D.20272;
  struct MonoGenericInst * D.20274;
  unsigned char D.20276;
  struct MonoGenericInst * D.20279;
  unsigned char D.20280;
  unsigned char D.20281;
  <unnamed-unsigned:5> D.20284;
  unsigned int D.20285;
  const char * D.20286;
  struct MonoMethodSignature * D.20290;
  const char * D.20293;
  const char * D.20295;
  const char * iftmp.43;
  const char * iftmp.44;
  char * D.20305;
  char * res;
  char wrapper[64];
  char * klass_desc;
  char * inst_desc;

  try
    {
      D.20267 = method->klass;
      D.20268 = &D.20267->byval_arg;
      klass_desc = mono_type_full_name (D.20268);
      inst_desc = 0B;
      D.20271 = BIT_FIELD_REF <*method, 8, 168>;
      D.20272 = D.20271 & 16;
      if (D.20272 != 0) goto <D.20273>; else goto <D.20269>;
      <D.20273>:
      D.20274 = MEM[(struct MonoMethodInflated *)method].context.method_inst;
      if (D.20274 != 0B) goto <D.20275>; else goto <D.20269>;
      <D.20275>:
      {
        struct GString * str;

        str = monoeg_g_string_new ("");
        monoeg_g_string_append (str, "<");
        D.20274 = MEM[(struct MonoMethodInflated *)method].context.method_inst;
        ginst_get_desc (str, D.20274);
        monoeg_g_string_append (str, ">");
        inst_desc = str->str;
        monoeg_g_string_free (str, 0);
      }
      goto <D.20270>;
      <D.20269>:
      D.20271 = BIT_FIELD_REF <*method, 8, 168>;
      D.20276 = D.20271 & 8;
      if (D.20276 != 0) goto <D.20277>; else goto <D.20278>;
      <D.20277>:
      {
        struct MonoGenericContainer * container;
        struct GString * str;

        container = mono_method_get_generic_container (method);
        str = monoeg_g_string_new ("");
        monoeg_g_string_append (str, "<");
        D.20279 = container->context.method_inst;
        ginst_get_desc (str, D.20279);
        monoeg_g_string_append (str, ">");
        inst_desc = str->str;
        monoeg_g_string_free (str, 0);
      }
      <D.20278>:
      <D.20270>:
      D.20280 = BIT_FIELD_REF <*method, 8, 160>;
      D.20281 = D.20280 & 124;
      if (D.20281 != 0) goto <D.20282>; else goto <D.20283>;
      <D.20282>:
      D.20284 = method->wrapper_type;
      D.20285 = (unsigned int) D.20284;
      D.20286 = wrapper_type_to_str (D.20285);
      sprintf (&wrapper, "(wrapper %s) ", D.20286);
      goto <D.20287>;
      <D.20283>:
      strcpy (&wrapper, "");
      <D.20287>:
      if (signature != 0) goto <D.20288>; else goto <D.20289>;
      <D.20288>:
      {
        char * tmpsig;

        D.20290 = mono_method_signature (method);
        tmpsig = mono_signature_get_desc (D.20290, 1);
        D.20280 = BIT_FIELD_REF <*method, 8, 160>;
        D.20281 = D.20280 & 124;
        if (D.20281 != 0) goto <D.20291>; else goto <D.20292>;
        <D.20291>:
        D.20284 = method->wrapper_type;
        D.20285 = (unsigned int) D.20284;
        D.20293 = wrapper_type_to_str (D.20285);
        sprintf (&wrapper, "(wrapper %s) ", D.20293);
        goto <D.20294>;
        <D.20292>:
        strcpy (&wrapper, "");
        <D.20294>:
        D.20295 = method->name;
        if (inst_desc != 0B) goto <D.20297>; else goto <D.20298>;
        <D.20297>:
        iftmp.43 = inst_desc;
        goto <D.20299>;
        <D.20298>:
        iftmp.43 = "";
        <D.20299>:
        res = monoeg_g_strdup_printf ("%s%s:%s%s (%s)", &wrapper, klass_desc, D.20295, iftmp.43, tmpsig);
        monoeg_g_free (tmpsig);
      }
      goto <D.20300>;
      <D.20289>:
      D.20295 = method->name;
      if (inst_desc != 0B) goto <D.20302>; else goto <D.20303>;
      <D.20302>:
      iftmp.44 = inst_desc;
      goto <D.20304>;
      <D.20303>:
      iftmp.44 = "";
      <D.20304>:
      res = monoeg_g_strdup_printf ("%s%s:%s%s", &wrapper, klass_desc, D.20295, iftmp.44);
      <D.20300>:
      monoeg_g_free (klass_desc);
      monoeg_g_free (inst_desc);
      D.20305 = res;
      return D.20305;
    }
  finally
    {
      wrapper = {CLOBBER};
    }
}


wrapper_type_to_str (guint32 wrapper_type)
{
  _Bool D.20308;
  long int D.20309;
  long int D.20310;
  const char * D.20313;
  short int D.20314;
  sizetype D.20315;

  D.20308 = wrapper_type > 28;
  D.20309 = (long int) D.20308;
  D.20310 = __builtin_expect (D.20309, 0);
  if (D.20310 != 0) goto <D.20311>; else goto <D.20312>;
  <D.20311>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "debug-helpers.c", 51, "wrapper_type < MONO_WRAPPER_NUM");
  <D.20312>:
  D.20314 = opidx[wrapper_type];
  D.20315 = (sizetype) D.20314;
  D.20313 = &opstr + D.20315;
  return D.20313;
}


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

  D.20318 = __builtin_object_size (__s, 1);
  D.20317 = __builtin___sprintf_chk (__s, 1, D.20318, __fmt, __builtin_va_arg_pack ());
  return D.20317;
}


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

  D.20321 = __builtin_object_size (__dest, 1);
  D.20320 = __builtin___strcpy_chk (__dest, __src, D.20321);
  return D.20320;
}


mono_object_describe (struct MonoObject * obj)
{
  struct MonoVTable * D.20325;
  struct MonoClass * D.20326;
  unsigned int D.20329;
  char * D.20332;
  char * D.20333;
  char * D.20334;
  char * D.20335;
  int D.20336;
  unsigned char D.20338;
  const char * D.20341;
  int D.20342;
  unsigned int D.20343;
  int D.20344;
  struct MonoClass * klass;
  const char * sep;

  if (obj == 0B) goto <D.20323>; else goto <D.20324>;
  <D.20323>:
  monoeg_g_print ("(null)\n");
  return;
  <D.20324>:
  D.20325 = obj->vtable;
  klass = D.20325->klass;
  D.20326 = mono_defaults.string_class;
  if (D.20326 == klass) goto <D.20327>; else goto <D.20328>;
  <D.20327>:
  {
    char * utf8;

    utf8 = mono_string_to_utf8 (obj);
    D.20329 = strlen (utf8);
    if (D.20329 > 60) goto <D.20330>; else goto <D.20331>;
    <D.20330>:
    D.20332 = utf8 + 57;
    *D.20332 = 46;
    D.20333 = utf8 + 58;
    *D.20333 = 46;
    D.20334 = utf8 + 59;
    *D.20334 = 46;
    D.20335 = utf8 + 60;
    *D.20335 = 0;
    <D.20331>:
    D.20336 = mono_string_length (obj);
    monoeg_g_print ("String at %p, length: %d, \'%s\'\n", obj, D.20336, utf8);
    monoeg_g_free (utf8);
  }
  goto <D.20337>;
  <D.20328>:
  D.20338 = klass->rank;
  if (D.20338 != 0) goto <D.20339>; else goto <D.20340>;
  <D.20339>:
  {
    struct MonoArray * array;

    array = obj;
    sep = print_name_space (klass);
    D.20341 = klass->name;
    monoeg_g_print ("%s%s", sep, D.20341);
    D.20338 = klass->rank;
    D.20342 = (int) D.20338;
    D.20343 = mono_array_length (array);
    D.20344 = (int) D.20343;
    monoeg_g_print (" at %p, rank: %d, length: %d\n", obj, D.20342, D.20344);
  }
  goto <D.20345>;
  <D.20340>:
  sep = print_name_space (klass);
  D.20341 = klass->name;
  monoeg_g_print ("%s%s", sep, D.20341);
  monoeg_g_print (" object at %p (klass: %p)\n", obj, klass);
  <D.20345>:
  <D.20337>:
}


print_name_space (struct MonoClass * klass)
{
  struct MonoClass * D.20347;
  const char * D.20350;
  const char * D.20351;
  const char * D.20352;
  char D.20353;

  D.20347 = klass->nested_in;
  if (D.20347 != 0B) goto <D.20348>; else goto <D.20349>;
  <D.20348>:
  D.20347 = klass->nested_in;
  print_name_space (D.20347);
  D.20347 = klass->nested_in;
  D.20350 = D.20347->name;
  monoeg_g_print ("%s", D.20350);
  D.20351 = "/";
  return D.20351;
  <D.20349>:
  D.20352 = klass->name_space;
  D.20353 = *D.20352;
  if (D.20353 != 0) goto <D.20354>; else goto <D.20355>;
  <D.20354>:
  D.20352 = klass->name_space;
  monoeg_g_print ("%s", D.20352);
  D.20351 = ".";
  return D.20351;
  <D.20355>:
  D.20351 = "";
  return D.20351;
}


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

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


objval_describe (struct MonoClass * class, const char * addr)
{
  unsigned char D.20358;
  unsigned char D.20359;
  struct MonoType * D.20362;
  short unsigned int D.20363;
  int D.20364;
  int D.20365;
  _Bool D.20368;
  _Bool D.20369;
  _Bool D.20370;
  const char * D.20373;
  int D.20374;
  sizetype D.20375;
  sizetype type_offset.45;
  sizetype D.20377;
  struct MonoClassField * field;
  struct MonoClass * p;
  const char * field_ptr;
  gssize type_offset;

  type_offset = 0;
  D.20358 = BIT_FIELD_REF <*class, 8, 160>;
  D.20359 = D.20358 & 8;
  if (D.20359 != 0) goto <D.20360>; else goto <D.20361>;
  <D.20360>:
  type_offset = -8;
  <D.20361>:
  p = class;
  goto <D.19114>;
  <D.19113>:
  {
    void * iter;
    int printed_header;

    try
      {
        iter = 0B;
        printed_header = 0;
        goto <D.19109>;
        <D.19111>:
        D.20362 = field->type;
        D.20363 = D.20362->attrs;
        D.20364 = (int) D.20363;
        D.20365 = D.20364 & 272;
        if (D.20365 != 0) goto <D.20366>; else goto <D.20367>;
        <D.20366>:
        // predicted unlikely by continue predictor.
        goto <D.19109>;
        <D.20367>:
        D.20368 = p != class;
        D.20369 = printed_header == 0;
        D.20370 = D.20368 & D.20369;
        if (D.20370 != 0) goto <D.20371>; else goto <D.20372>;
        <D.20371>:
        {
          const char * sep;

          monoeg_g_print ("In class ");
          sep = print_name_space (p);
          D.20373 = p->name;
          monoeg_g_print ("%s%s:\n", sep, D.20373);
          printed_header = 1;
        }
        <D.20372>:
        D.20374 = field->offset;
        D.20375 = (sizetype) D.20374;
        type_offset.45 = (sizetype) type_offset;
        D.20377 = D.20375 + type_offset.45;
        field_ptr = addr + D.20377;
        print_field_value (field_ptr, field, type_offset);
        <D.19109>:
        field = mono_class_get_fields (p, &iter);
        if (field != 0B) goto <D.19111>; else goto <D.19112>;
        <D.19112>:
      }
    finally
      {
        iter = {CLOBBER};
      }
  }
  p = p->parent;
  <D.19114>:
  if (p != 0B) goto <D.19113>; else goto <D.19115>;
  <D.19115>:
}


print_field_value (const char * field_ptr, struct MonoClassField * field, int type_offset)
{
  int D.20378;
  int D.20379;
  const char * D.20380;
  struct MonoType * D.20381;
  unsigned char D.20382;
  int D.20383;
  const void * D.20384;
  struct MonoObject * D.20385;
  int D.20386;
  const char * D.20389;
  signed char D.20390;
  int D.20391;
  unsigned char D.20392;
  int D.20393;
  short int D.20394;
  int D.20395;
  short unsigned int D.20396;
  int D.20397;
  int D.20398;
  unsigned int D.20399;
  long long int D.20400;
  long long unsigned int D.20401;
  float D.20402;
  double D.20403;
  double D.20404;
  const char * iftmp.46;
  struct MonoType * type;

  D.20378 = field->offset;
  D.20379 = D.20378 + type_offset;
  D.20380 = mono_field_get_name (field);
  monoeg_g_print ("At %p (ofs: %2d) %s: ", field_ptr, D.20379, D.20380);
  D.20381 = field->type;
  type = mono_type_get_underlying_type (D.20381);
  D.20382 = type->type;
  D.20383 = (int) D.20382;
  switch (D.20383) <default: <D.19098>, case 2: <D.19096>, case 3: <D.19097>, case 4: <D.19086>, case 5: <D.19087>, case 6: <D.19088>, case 7: <D.19089>, case 8: <D.19090>, case 9: <D.19091>, case 10: <D.19092>, case 11: <D.19093>, case 12: <D.19094>, case 13: <D.19095>, case 14: <D.19078>, case 15: <D.19075>, case 17: <D.19084>, case 18: <D.19080>, case 20: <D.19082>, case 21: <D.19083>, case 24: <D.19073>, case 25: <D.19074>, case 27: <D.19076>, case 28: <D.19081>, case 29: <D.19079>>
  <D.19073>:
  <D.19074>:
  <D.19075>:
  <D.19076>:
  D.20384 = MEM[(const void * *)field_ptr];
  monoeg_g_print ("%p\n", D.20384);
  goto <D.19077>;
  <D.19078>:
  <D.19079>:
  <D.19080>:
  <D.19081>:
  <D.19082>:
  D.20385 = MEM[(struct MonoObject * *)field_ptr];
  mono_object_describe (D.20385);
  goto <D.19077>;
  <D.19083>:
  D.20386 = mono_type_generic_inst_is_valuetype (type);
  if (D.20386 == 0) goto <D.20387>; else goto <D.20388>;
  <D.20387>:
  D.20385 = MEM[(struct MonoObject * *)field_ptr];
  mono_object_describe (D.20385);
  goto <D.19077>;
  <D.20388>:
  <D.19084>:
  {
    struct MonoClass * k;

    k = mono_class_from_mono_type (type);
    D.20389 = k->name;
    monoeg_g_print ("%s ValueType (type: %p) at %p\n", D.20389, k, field_ptr);
    goto <D.19077>;
  }
  <D.19086>:
  D.20390 = MEM[(gint8 *)field_ptr];
  D.20391 = (int) D.20390;
  monoeg_g_print ("%d\n", D.20391);
  goto <D.19077>;
  <D.19087>:
  D.20392 = MEM[(guint8 *)field_ptr];
  D.20393 = (int) D.20392;
  monoeg_g_print ("%d\n", D.20393);
  goto <D.19077>;
  <D.19088>:
  D.20394 = MEM[(gint16 *)field_ptr];
  D.20395 = (int) D.20394;
  monoeg_g_print ("%d\n", D.20395);
  goto <D.19077>;
  <D.19089>:
  D.20396 = MEM[(guint16 *)field_ptr];
  D.20397 = (int) D.20396;
  monoeg_g_print ("%d\n", D.20397);
  goto <D.19077>;
  <D.19090>:
  D.20398 = MEM[(gint32 *)field_ptr];
  monoeg_g_print ("%d\n", D.20398);
  goto <D.19077>;
  <D.19091>:
  D.20399 = MEM[(guint32 *)field_ptr];
  monoeg_g_print ("%u\n", D.20399);
  goto <D.19077>;
  <D.19092>:
  D.20400 = MEM[(gint64 *)field_ptr];
  monoeg_g_print ("%lld\n", D.20400);
  goto <D.19077>;
  <D.19093>:
  D.20401 = MEM[(guint64 *)field_ptr];
  monoeg_g_print ("%llu\n", D.20401);
  goto <D.19077>;
  <D.19094>:
  D.20402 = MEM[(gfloat *)field_ptr];
  D.20403 = (double) D.20402;
  monoeg_g_print ("%f\n", D.20403);
  goto <D.19077>;
  <D.19095>:
  D.20404 = MEM[(gdouble *)field_ptr];
  monoeg_g_print ("%f\n", D.20404);
  goto <D.19077>;
  <D.19096>:
  D.20392 = MEM[(guint8 *)field_ptr];
  if (D.20392 != 0) goto <D.20406>; else goto <D.20407>;
  <D.20406>:
  iftmp.46 = "True";
  goto <D.20408>;
  <D.20407>:
  iftmp.46 = "False";
  <D.20408>:
  D.20392 = MEM[(guint8 *)field_ptr];
  D.20393 = (int) D.20392;
  monoeg_g_print ("%s (%d)\n", iftmp.46, D.20393);
  goto <D.19077>;
  <D.19097>:
  D.20396 = MEM[(guint16 *)field_ptr];
  D.20397 = (int) D.20396;
  D.20396 = MEM[(guint16 *)field_ptr];
  D.20397 = (int) D.20396;
  D.20396 = MEM[(guint16 *)field_ptr];
  D.20397 = (int) D.20396;
  monoeg_g_print ("\'%c\' (%d 0x%04x)\n", D.20397, D.20397, D.20397);
  goto <D.19077>;
  <D.19098>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "debug-helpers.c", 928);
  <D.19077>:
}


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


mono_class_describe_statics (struct MonoClass * klass)
{
  struct MonoDomain * D.20409;
  struct MonoType * D.20414;
  short unsigned int D.20415;
  int D.20416;
  int D.20417;
  int D.20420;
  int D.20423;
  sizetype D.20424;
  struct MonoClassField * field;
  struct MonoClass * p;
  const char * field_ptr;
  struct MonoVTable * vtable;
  const char * addr;

  D.20409 = mono_domain_get ();
  vtable = mono_class_vtable_full (D.20409, klass, 0);
  if (vtable == 0B) goto <D.20410>; else goto <D.20411>;
  <D.20410>:
  return;
  <D.20411>:
  addr = mono_vtable_get_static_field_data (vtable);
  if (addr == 0B) goto <D.20412>; else goto <D.20413>;
  <D.20412>:
  return;
  <D.20413>:
  p = klass;
  goto <D.19137>;
  <D.19136>:
  {
    void * iter;

    try
      {
        iter = 0B;
        goto <D.19133>;
        <D.19134>:
        D.20414 = field->type;
        D.20415 = D.20414->attrs;
        D.20416 = (int) D.20415;
        D.20417 = D.20416 & 64;
        if (D.20417 != 0) goto <D.20418>; else goto <D.20419>;
        <D.20418>:
        // predicted unlikely by continue predictor.
        goto <D.19133>;
        <D.20419>:
        D.20414 = field->type;
        D.20415 = D.20414->attrs;
        D.20416 = (int) D.20415;
        D.20420 = D.20416 & 272;
        if (D.20420 == 0) goto <D.20421>; else goto <D.20422>;
        <D.20421>:
        // predicted unlikely by continue predictor.
        goto <D.19133>;
        <D.20422>:
        D.20423 = field->offset;
        D.20424 = (sizetype) D.20423;
        field_ptr = addr + D.20424;
        print_field_value (field_ptr, field, 0);
        <D.19133>:
        field = mono_class_get_fields (p, &iter);
        if (field != 0B) goto <D.19134>; else goto <D.19135>;
        <D.19135>:
      }
    finally
      {
        iter = {CLOBBER};
      }
  }
  p = p->parent;
  <D.19137>:
  if (p != 0B) goto <D.19136>; else goto <D.19138>;
  <D.19138>:
}