__attribute__((visibility ("hidden")))
mono_class_get_methods_by_name (struct MonoClass * klass, const char * name, guint32 bflags, gboolean ignore_case, gboolean allow_ctors, struct MonoException * * ex)
{
  int (*<T3b2a>) (const char *, const char *) iftmp.0;
  long unsigned int D.25306;
  long unsigned int D.25307;
  int D.25312;
  struct MonoLoaderError * D.25317;
  struct GPtrArray * D.25319;
  unsigned char D.25320;
  struct MonoLoaderError * D.25322;
  struct MonoType * D.25324;
  unsigned char D.25325;
  struct MonoClass * D.25328;
  int iftmp.1;
  unsigned int D.25334;
  unsigned int D.25335;
  unsigned char D.25337;
  unsigned int nslots.2;
  int D.25342;
  int D.25343;
  long unsigned int D.25344;
  long unsigned int D.25345;
  struct MonoLoaderError * D.25348;
  short int D.25350;
  int D.25353;
  _Bool D.25354;
  long int D.25355;
  long int D.25356;
  short int D.25359;
  long unsigned int D.25360;
  long unsigned int D.25361;
  guint32 * D.25362;
  unsigned int D.25363;
  int D.25364;
  int D.25365;
  unsigned int D.25366;
  unsigned int D.25367;
  short unsigned int D.25370;
  int D.25371;
  int D.25372;
  unsigned int D.25375;
  const char * D.25380;
  char D.25381;
  int D.25384;
  int D.25386;
  int D.25387;
  unsigned int D.25390;
  unsigned int D.25394;
  _Bool D.25397;
  int D.25398;
  int D.25399;
  int D.25404;
  unsigned int D.25407;
  unsigned int D.25412;
  unsigned int D.25415;
  int D.25422;
  unsigned int D.25425;
  struct MonoException * D.25435;
  struct MonoLoaderError * D.25437;
  struct MonoException * D.25438;
  struct GPtrArray * array;
  struct MonoClass * startklass;
  struct MonoMethod * method;
  void * iter;
  int len;
  int match;
  int nslots;
  guint32 method_slots_default[8];
  guint32 * method_slots;
  int (*<T3b2a>) (const char *, const char *) compare_func;
  void loader_error = <<< error >>>;
  void handle_parent = <<< error >>>;

  try
    {
      method_slots = 0B;
      compare_func = 0B;
      array = monoeg_g_ptr_array_new ();
      startklass = klass;
      *ex = 0B;
      len = 0;
      if (name != 0B) goto <D.25300>; else goto <D.25301>;
      <D.25300>:
      if (ignore_case != 0) goto <D.25303>; else goto <D.25304>;
      <D.25303>:
      iftmp.0 = monoeg_ascii_strcasecmp;
      goto <D.25305>;
      <D.25304>:
      iftmp.0 = strcmp;
      <D.25305>:
      compare_func = iftmp.0;
      <D.25301>:
      D.25306 = BIT_FIELD_REF <*klass, 64, 256>;
      D.25307 = D.25306 & 549755813888;
      if (D.25307 != 0) goto <D.25308>; else goto <D.25309>;
      <D.25308>:
      if (name != 0B) goto <D.25310>; else goto <D.25311>;
      <D.25310>:
      D.25312 = strcmp (name, "Invoke");
      if (D.25312 == 0) goto <D.25313>; else goto <D.25314>;
      <D.25313>:
      if (bflags == 28) goto <D.25315>; else goto <D.25316>;
      <D.25315>:
      method = mono_get_delegate_invoke (klass);
      D.25317 = mono_loader_get_last_error ();
      if (D.25317 != 0B) goto loader_error; else goto <D.25318>;
      <D.25318>:
      monoeg_g_ptr_array_add (array, method);
      D.25319 = array;
      return D.25319;
      <D.25316>:
      <D.25314>:
      <D.25311>:
      <D.25309>:
      mono_class_setup_vtable (klass);
      D.25320 = klass->exception_type;
      if (D.25320 != 0) goto loader_error; else goto <D.25321>;
      <D.25321>:
      D.25322 = mono_loader_get_last_error ();
      if (D.25322 != 0B) goto loader_error; else goto <D.25323>;
      <D.25323>:
      D.25324 = &klass->byval_arg;
      D.25325 = is_generic_parameter (D.25324);
      if (D.25325 != 0) goto <D.25326>; else goto <D.25327>;
      <D.25326>:
      D.25328 = klass->parent;
      nslots = mono_class_get_vtable_size (D.25328);
      goto <D.25329>;
      <D.25327>:
      D.25334 = klass->flags;
      D.25335 = D.25334 & 32;
      if (D.25335 != 0) goto <D.25331>; else goto <D.25336>;
      <D.25336>:
      D.25337 = klass->byval_arg.type;
      if (D.25337 == 19) goto <D.25331>; else goto <D.25338>;
      <D.25338>:
      D.25337 = klass->byval_arg.type;
      if (D.25337 == 30) goto <D.25331>; else goto <D.25332>;
      <D.25331>:
      iftmp.1 = mono_class_num_methods (klass);
      goto <D.25333>;
      <D.25332>:
      iftmp.1 = mono_class_get_vtable_size (klass);
      <D.25333>:
      nslots = iftmp.1;
      <D.25329>:
      nslots.2 = (unsigned int) nslots;
      if (nslots.2 > 255) goto <D.25340>; else goto <D.25341>;
      <D.25340>:
      D.25342 = nslots / 32;
      D.25343 = D.25342 + 1;
      D.25344 = (long unsigned int) D.25343;
      D.25345 = D.25344 * 4;
      method_slots = monoeg_malloc0 (D.25345);
      goto <D.25346>;
      <D.25341>:
      method_slots = &method_slots_default;
      memset (method_slots, 0, 32);
      <D.25346>:
      handle_parent:
      mono_class_setup_vtable (klass);
      D.25320 = klass->exception_type;
      if (D.25320 != 0) goto loader_error; else goto <D.25347>;
      <D.25347>:
      D.25348 = mono_loader_get_last_error ();
      if (D.25348 != 0B) goto loader_error; else goto <D.25349>;
      <D.25349>:
      iter = 0B;
      goto <D.22229>;
      <D.22230>:
      match = 0;
      D.25350 = method->slot;
      if (D.25350 != -1) goto <D.25351>; else goto <D.25352>;
      <D.25351>:
      D.25350 = method->slot;
      D.25353 = (int) D.25350;
      D.25354 = D.25353 >= nslots;
      D.25355 = (long int) D.25354;
      D.25356 = __builtin_expect (D.25355, 0);
      if (D.25356 != 0) goto <D.25357>; else goto <D.25358>;
      <D.25357>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 3493, "method->slot < nslots");
      <D.25358>:
      D.25350 = method->slot;
      D.25359 = D.25350 >> 5;
      D.25360 = (long unsigned int) D.25359;
      D.25361 = D.25360 * 4;
      D.25362 = method_slots + D.25361;
      D.25363 = *D.25362;
      D.25350 = method->slot;
      D.25353 = (int) D.25350;
      D.25364 = D.25353 & 31;
      D.25365 = 1 << D.25364;
      D.25366 = (unsigned int) D.25365;
      D.25367 = D.25363 & D.25366;
      if (D.25367 != 0) goto <D.25368>; else goto <D.25369>;
      <D.25368>:
      // predicted unlikely by continue predictor.
      goto <D.22229>;
      <D.25369>:
      D.25370 = method->flags;
      D.25371 = (int) D.25370;
      D.25372 = D.25371 & 256;
      if (D.25372 == 0) goto <D.25373>; else goto <D.25374>;
      <D.25373>:
      D.25350 = method->slot;
      D.25359 = D.25350 >> 5;
      D.25360 = (long unsigned int) D.25359;
      D.25361 = D.25360 * 4;
      D.25362 = method_slots + D.25361;
      D.25350 = method->slot;
      D.25359 = D.25350 >> 5;
      D.25360 = (long unsigned int) D.25359;
      D.25361 = D.25360 * 4;
      D.25362 = method_slots + D.25361;
      D.25363 = *D.25362;
      D.25350 = method->slot;
      D.25353 = (int) D.25350;
      D.25364 = D.25353 & 31;
      D.25365 = 1 << D.25364;
      D.25366 = (unsigned int) D.25365;
      D.25375 = D.25363 | D.25366;
      *D.25362 = D.25375;
      <D.25374>:
      <D.25352>:
      if (allow_ctors == 0) goto <D.25378>; else goto <D.25379>;
      <D.25378>:
      D.25380 = method->name;
      D.25381 = *D.25380;
      if (D.25381 == 46) goto <D.25382>; else goto <D.25383>;
      <D.25382>:
      D.25380 = method->name;
      D.25384 = strcmp (D.25380, ".ctor");
      if (D.25384 == 0) goto <D.25376>; else goto <D.25385>;
      <D.25385>:
      D.25380 = method->name;
      D.25386 = strcmp (D.25380, ".cctor");
      if (D.25386 == 0) goto <D.25376>; else goto <D.25377>;
      <D.25376>:
      // predicted unlikely by continue predictor.
      goto <D.22229>;
      <D.25377>:
      <D.25383>:
      <D.25379>:
      D.25370 = method->flags;
      D.25371 = (int) D.25370;
      D.25387 = D.25371 & 7;
      if (D.25387 == 6) goto <D.25388>; else goto <D.25389>;
      <D.25388>:
      D.25390 = bflags & 16;
      if (D.25390 != 0) goto <D.25391>; else goto <D.25392>;
      <D.25391>:
      match = match + 1;
      <D.25392>:
      goto <D.25393>;
      <D.25389>:
      D.25394 = bflags & 32;
      if (D.25394 != 0) goto <D.25395>; else goto <D.25396>;
      <D.25395>:
      D.25397 = klass == startklass;
      D.25398 = (int) D.25397;
      D.25399 = method_nonpublic (method, D.25398);
      if (D.25399 != 0) goto <D.25400>; else goto <D.25401>;
      <D.25400>:
      match = match + 1;
      <D.25401>:
      <D.25396>:
      <D.25393>:
      if (match == 0) goto <D.25402>; else goto <D.25403>;
      <D.25402>:
      // predicted unlikely by continue predictor.
      goto <D.22229>;
      <D.25403>:
      match = 0;
      D.25370 = method->flags;
      D.25371 = (int) D.25370;
      D.25404 = D.25371 & 16;
      if (D.25404 != 0) goto <D.25405>; else goto <D.25406>;
      <D.25405>:
      D.25407 = bflags & 8;
      if (D.25407 != 0) goto <D.25408>; else goto <D.25409>;
      <D.25408>:
      D.25412 = bflags & 64;
      if (D.25412 != 0) goto <D.25410>; else goto <D.25413>;
      <D.25413>:
      if (klass == startklass) goto <D.25410>; else goto <D.25411>;
      <D.25410>:
      match = match + 1;
      <D.25411>:
      <D.25409>:
      goto <D.25414>;
      <D.25406>:
      D.25415 = bflags & 4;
      if (D.25415 != 0) goto <D.25416>; else goto <D.25417>;
      <D.25416>:
      match = match + 1;
      <D.25417>:
      <D.25414>:
      if (match == 0) goto <D.25418>; else goto <D.25419>;
      <D.25418>:
      // predicted unlikely by continue predictor.
      goto <D.22229>;
      <D.25419>:
      if (name != 0B) goto <D.25420>; else goto <D.25421>;
      <D.25420>:
      D.25380 = method->name;
      D.25422 = compare_func (name, D.25380);
      if (D.25422 != 0) goto <D.25423>; else goto <D.25424>;
      <D.25423>:
      // predicted unlikely by continue predictor.
      goto <D.22229>;
      <D.25424>:
      <D.25421>:
      match = 0;
      monoeg_g_ptr_array_add (array, method);
      <D.22229>:
      method = mono_class_get_methods (klass, &iter);
      if (method != 0B) goto <D.22230>; else goto <D.22231>;
      <D.22231>:
      D.25425 = bflags & 2;
      if (D.25425 == 0) goto <D.25426>; else goto <D.25427>;
      <D.25426>:
      klass = klass->parent;
      if (klass != 0B) goto handle_parent; else goto <D.25428>;
      <D.25428>:
      <D.25427>:
      if (&method_slots_default != method_slots) goto <D.25429>; else goto <D.25430>;
      <D.25429>:
      monoeg_g_free (method_slots);
      <D.25430>:
      D.25319 = array;
      return D.25319;
      loader_error:
      if (&method_slots_default != method_slots) goto <D.25431>; else goto <D.25432>;
      <D.25431>:
      monoeg_g_free (method_slots);
      <D.25432>:
      monoeg_g_ptr_array_free (array, 1);
      D.25320 = klass->exception_type;
      if (D.25320 != 0) goto <D.25433>; else goto <D.25434>;
      <D.25433>:
      D.25435 = mono_class_get_exception_for_failure (klass);
      *ex = D.25435;
      goto <D.25436>;
      <D.25434>:
      D.25437 = mono_loader_get_last_error ();
      D.25438 = mono_loader_error_prepare_exception (D.25437);
      *ex = D.25438;
      mono_loader_clear_error ();
      <D.25436>:
      D.25319 = 0B;
      return D.25319;
    }
  finally
    {
      iter = {CLOBBER};
      method_slots_default = {CLOBBER};
    }
}


is_generic_parameter (struct MonoType * type)
{
  MonoBoolean D.25441;
  int iftmp.3;
  long unsigned int D.25446;
  long unsigned int D.25447;
  unsigned char D.25449;

  D.25446 = BIT_FIELD_REF <*type, 64, 64>;
  D.25447 = D.25446 & 8589934592;
  if (D.25447 == 0) goto <D.25448>; else goto <D.25443>;
  <D.25448>:
  D.25449 = type->type;
  if (D.25449 == 19) goto <D.25444>; else goto <D.25450>;
  <D.25450>:
  D.25449 = type->type;
  if (D.25449 == 30) goto <D.25444>; else goto <D.25443>;
  <D.25444>:
  iftmp.3 = 1;
  goto <D.25445>;
  <D.25443>:
  iftmp.3 = 0;
  <D.25445>:
  D.25441 = (MonoBoolean) iftmp.3;
  return D.25441;
}


__attribute__((__artificial__, __gnu_inline__, __always_inline__, __nothrow__, __leaf__))
memset (void * __dest, int __ch, size_t __len)
{
  void * D.25452;
  long unsigned int D.25453;

  D.25453 = __builtin_object_size (__dest, 0);
  D.25452 = __builtin___memset_chk (__dest, __ch, __len, D.25453);
  return D.25452;
}


__attribute__((__gnu_inline__, nothrow, leaf, pure))
strcmp (const char * __s1, const char * __s2)
{
  int iftmp.4;
  int iftmp.5;
  int D.25463;
  char * __p1;
  char * __p2;
  int __ret;

  __p1 = __s1;
  __p2 = __s2;
  __asm__ __volatile__("   slr   0,0
0: clst  %1,%2
   jo    0b
   ipm   %0
   srl   %0,28" : "=d" __ret, "=&a" __p1, "=&a" __p2 : "1" __p1, "2" __p2 : "0", "memory", "cc");
  if (__ret != 0) goto <D.25456>; else goto <D.25457>;
  <D.25456>:
  if (__ret == 1) goto <D.25459>; else goto <D.25460>;
  <D.25459>:
  iftmp.5 = -1;
  goto <D.25461>;
  <D.25460>:
  iftmp.5 = 1;
  <D.25461>:
  iftmp.4 = iftmp.5;
  goto <D.25462>;
  <D.25457>:
  iftmp.4 = 0;
  <D.25462>:
  __ret = iftmp.4;
  D.25463 = __ret;
  return D.25463;
}


method_nonpublic (struct MonoMethod * method, gboolean start_klass)
{
  short unsigned int D.25465;
  int D.25466;
  int D.25467;
  gboolean D.25468;
  int iftmp.6;
  struct MonoClass * D.25474;

  D.25465 = method->flags;
  D.25466 = (int) D.25465;
  D.25467 = D.25466 & 7;
  switch (D.25467) <default: <D.22206>, case 1: <D.22204>, case 3: <D.22203>, case 6: <D.22205>>
  <D.22203>:
  if (start_klass != 0) goto <D.25470>; else goto <D.25473>;
  <D.25473>:
  D.25474 = mono_defaults.generic_ilist_class;
  if (D.25474 != 0B) goto <D.25470>; else goto <D.25471>;
  <D.25470>:
  iftmp.6 = 1;
  goto <D.25472>;
  <D.25471>:
  iftmp.6 = 0;
  <D.25472>:
  D.25468 = iftmp.6;
  return D.25468;
  <D.22204>:
  D.25468 = start_klass;
  return D.25468;
  <D.22205>:
  D.25468 = 0;
  return D.25468;
  <D.22206>:
  D.25468 = 1;
  return D.25468;
}


__attribute__((visibility ("hidden")))
ves_icall_System_Environment_get_UserName ()
{
  struct MonoString * D.25476;
  struct MonoDomain * D.25477;
  const gchar * D.25478;

  D.25477 = mono_domain_get ();
  D.25478 = monoeg_g_get_user_name ();
  D.25476 = mono_string_new (D.25477, D.25478);
  return D.25476;
}


__attribute__((visibility ("hidden")))
mono_icall_init ()
{
  short unsigned int D.25484;
  sizetype D.25485;
  const char * D.25486;
  int D.25487;
  const struct IcallTypeDesc * D.25490;
  short unsigned int D.25491;
  int D.25492;
  short unsigned int D.25493;
  int D.25494;
  int D.25495;
  short unsigned int D.25496;
  sizetype D.25497;
  int D.25500;
  struct GHashTable * D.25503;
  int i;

  i = 0;
  if (1 != 0) goto <D.25480>; else goto <D.25481>;
  <D.25480>:
  {
    int j;
    const char * prev_class;
    const char * prev_method;

    prev_class = 0B;
    i = 0;
    goto <D.25188>;
    <D.25187>:
    {
      const struct IcallTypeDesc * desc;
      int num_icalls;

      prev_method = 0B;
      if (prev_class != 0B) goto <D.25482>; else goto <D.25483>;
      <D.25482>:
      D.25484 = icall_type_names_idx[i];
      D.25485 = (sizetype) D.25484;
      D.25486 = &icall_type_names_str + D.25485;
      D.25487 = strcmp (prev_class, D.25486);
      if (D.25487 >= 0) goto <D.25488>; else goto <D.25489>;
      <D.25488>:
      D.25484 = icall_type_names_idx[i];
      D.25485 = (sizetype) D.25484;
      D.25486 = &icall_type_names_str + D.25485;
      monoeg_g_print ("class %s should come before class %s\n", D.25486, prev_class);
      <D.25489>:
      <D.25483>:
      D.25484 = icall_type_names_idx[i];
      D.25485 = (sizetype) D.25484;
      prev_class = &icall_type_names_str + D.25485;
      desc = &icall_type_descs[i];
      D.25490 = desc + 2;
      D.25491 = D.25490->first_icall;
      D.25492 = (int) D.25491;
      D.25493 = desc->first_icall;
      D.25494 = (int) D.25493;
      num_icalls = D.25492 - D.25494;
      j = 0;
      goto <D.25185>;
      <D.25184>:
      {
        const char * methodn;

        D.25493 = desc->first_icall;
        D.25494 = (int) D.25493;
        D.25495 = D.25494 + j;
        D.25496 = icall_names_idx[D.25495];
        D.25497 = (sizetype) D.25496;
        methodn = &icall_names_str + D.25497;
        if (prev_method != 0B) goto <D.25498>; else goto <D.25499>;
        <D.25498>:
        D.25500 = strcmp (prev_method, methodn);
        if (D.25500 >= 0) goto <D.25501>; else goto <D.25502>;
        <D.25501>:
        monoeg_g_print ("method %s should come before method %s\n", methodn, prev_method);
        <D.25502>:
        <D.25499>:
        prev_method = methodn;
      }
      j = j + 1;
      <D.25185>:
      if (j < num_icalls) goto <D.25184>; else goto <D.25186>;
      <D.25186>:
    }
    i = i + 1;
    <D.25188>:
    if (i <= 107) goto <D.25187>; else goto <D.25189>;
    <D.25189>:
  }
  <D.25481>:
  D.25503 = monoeg_g_hash_table_new_full (monoeg_g_str_hash, monoeg_g_str_equal, monoeg_g_free, 0B);
  icall_hash = D.25503;
  pthread_mutex_init (&icall_mutex, 0B);
}


__attribute__((visibility ("hidden")))
mono_icall_cleanup ()
{
  struct GHashTable * icall_hash.7;
  struct GHashTable * jit_icall_hash_name.8;
  struct GHashTable * jit_icall_hash_addr.9;

  icall_hash.7 = icall_hash;
  monoeg_g_hash_table_destroy (icall_hash.7);
  jit_icall_hash_name.8 = jit_icall_hash_name;
  monoeg_g_hash_table_destroy (jit_icall_hash_name.8);
  jit_icall_hash_addr.9 = jit_icall_hash_addr;
  monoeg_g_hash_table_destroy (jit_icall_hash_addr.9);
  pthread_mutex_destroy (&icall_mutex);
}


mono_add_internal_call (const char * name, const void * method)
{
  struct GHashTable * icall_hash.10;
  gchar * D.25508;

  mono_icall_lock ();
  icall_hash.10 = icall_hash;
  D.25508 = monoeg_strdup (name);
  monoeg_g_hash_table_insert_replace (icall_hash.10, D.25508, method, 0);
  mono_icall_unlock ();
}


mono_icall_lock ()
{
  pthread_mutex_lock (&icall_mutex);
}


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

  if (str != 0B) goto <D.25509>; else goto <D.25510>;
  <D.25509>:
  D.25511 = __strdup (str);
  return D.25511;
  <D.25510>:
  D.25511 = 0B;
  return D.25511;
}


mono_icall_unlock ()
{
  pthread_mutex_unlock (&icall_mutex);
}


mono_lookup_internal_call (struct MonoMethod * method)
{
  _Bool D.25513;
  long int D.25514;
  long int D.25515;
  long unsigned int D.25518;
  long unsigned int D.25519;
  struct MonoClass * D.25522;
  struct MonoClass * D.25523;
  void * D.25528;
  int pos.11;
  sizetype D.25530;
  char * D.25531;
  unsigned int pos.12;
  unsigned int D.25533;
  int D.25534;
  int D.25540;
  const char * D.25541;
  long unsigned int D.25542;
  sizetype D.25543;
  sizetype D.25544;
  void * D.25545;
  long unsigned int D.25546;
  sizetype D.25547;
  sizetype D.25548;
  sizetype D.25549;
  struct MonoMethodSignature * D.25550;
  long unsigned int D.25551;
  int D.25552;
  int D.25553;
  int D.25554;
  unsigned int D.25555;
  char * D.25558;
  long unsigned int D.25559;
  sizetype D.25560;
  sizetype D.25561;
  char * D.25562;
  sizetype D.25563;
  char * D.25564;
  struct GHashTable * icall_hash.13;
  sizetype D.25572;
  char * D.25573;
  struct MonoImage * D.25578;
  char * D.25579;
  char * sigstart;
  char * tmpsig;
  char mname[2048];
  int typelen;
  int mlen;
  int siglen;
  void * res;
  const struct IcallTypeDesc * imap;

  try
    {
      typelen = 0;
      imap = 0B;
      D.25513 = method == 0B;
      D.25514 = (long int) D.25513;
      D.25515 = __builtin_expect (D.25514, 0);
      if (D.25515 != 0) goto <D.25516>; else goto <D.25517>;
      <D.25516>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 8049, "method != NULL");
      <D.25517>:
      D.25518 = BIT_FIELD_REF <*method, 64, 256>;
      D.25519 = D.25518 & 2251799813685248;
      if (D.25519 != 0) goto <D.25520>; else goto <D.25521>;
      <D.25520>:
      method = MEM[(struct MonoMethodInflated *)method].declaring;
      <D.25521>:
      D.25522 = method->klass;
      D.25523 = D.25522->nested_in;
      if (D.25523 != 0B) goto <D.25524>; else goto <D.25525>;
      <D.25524>:
      {
        int pos;

        D.25522 = method->klass;
        D.25523 = D.25522->nested_in;
        pos = concat_class_name (&mname, 2046, D.25523);
        if (pos == 0) goto <D.25526>; else goto <D.25527>;
        <D.25526>:
        D.25528 = 0B;
        return D.25528;
        <D.25527>:
        pos.11 = pos;
        pos = pos.11 + 1;
        mname[pos.11] = 47;
        mname[pos] = 0;
        D.25530 = (sizetype) pos;
        D.25531 = &mname + D.25530;
        pos.12 = (unsigned int) pos;
        D.25533 = 2047 - pos.12;
        D.25534 = (int) D.25533;
        D.25522 = method->klass;
        typelen = concat_class_name (D.25531, D.25534, D.25522);
        if (typelen == 0) goto <D.25535>; else goto <D.25536>;
        <D.25535>:
        D.25528 = 0B;
        return D.25528;
        <D.25536>:
        typelen = typelen + pos;
      }
      goto <D.25537>;
      <D.25525>:
      D.25522 = method->klass;
      typelen = concat_class_name (&mname, 2048, D.25522);
      if (typelen == 0) goto <D.25538>; else goto <D.25539>;
      <D.25538>:
      D.25528 = 0B;
      return D.25528;
      <D.25539>:
      <D.25537>:
      imap = find_class_icalls (&mname);
      mname[typelen] = 58;
      D.25540 = typelen + 1;
      mname[D.25540] = 58;
      D.25541 = method->name;
      D.25542 = __strlen_g (D.25541);
      mlen = (int) D.25542;
      D.25543 = (sizetype) typelen;
      D.25544 = D.25543 + 2;
      D.25545 = &mname + D.25544;
      D.25541 = method->name;
      D.25546 = (long unsigned int) mlen;
      memcpy (D.25545, D.25541, D.25546);
      D.25543 = (sizetype) typelen;
      D.25547 = (sizetype) mlen;
      D.25548 = D.25543 + D.25547;
      D.25549 = D.25548 + 2;
      sigstart = &mname + D.25549;
      *sigstart = 0;
      D.25550 = mono_method_signature (method);
      tmpsig = mono_signature_get_desc (D.25550, 1);
      D.25551 = __strlen_g (tmpsig);
      siglen = (int) D.25551;
      D.25552 = typelen + mlen;
      D.25553 = D.25552 + siglen;
      D.25554 = D.25553 + 6;
      D.25555 = (unsigned int) D.25554;
      if (D.25555 > 2048) goto <D.25556>; else goto <D.25557>;
      <D.25556>:
      D.25528 = 0B;
      return D.25528;
      <D.25557>:
      *sigstart = 40;
      D.25558 = sigstart + 1;
      D.25559 = (long unsigned int) siglen;
      memcpy (D.25558, tmpsig, D.25559);
      D.25560 = (sizetype) siglen;
      D.25561 = D.25560 + 1;
      D.25562 = sigstart + D.25561;
      *D.25562 = 41;
      D.25560 = (sizetype) siglen;
      D.25563 = D.25560 + 2;
      D.25564 = sigstart + D.25563;
      *D.25564 = 0;
      monoeg_g_free (tmpsig);
      mono_icall_lock ();
      icall_hash.13 = icall_hash;
      res = monoeg_g_hash_table_lookup (icall_hash.13, &mname);
      if (res != 0B) goto <D.25566>; else goto <D.25567>;
      <D.25566>:
      mono_icall_unlock ();
      D.25528 = res;
      return D.25528;
      <D.25567>:
      *sigstart = 0;
      icall_hash.13 = icall_hash;
      res = monoeg_g_hash_table_lookup (icall_hash.13, &mname);
      if (res != 0B) goto <D.25568>; else goto <D.25569>;
      <D.25568>:
      mono_icall_unlock ();
      D.25528 = res;
      return D.25528;
      <D.25569>:
      if (imap == 0B) goto <D.25570>; else goto <D.25571>;
      <D.25570>:
      mono_icall_unlock ();
      D.25528 = 0B;
      return D.25528;
      <D.25571>:
      D.25547 = (sizetype) mlen;
      D.25572 = -D.25547;
      D.25573 = sigstart + D.25572;
      res = find_method_icall (imap, D.25573);
      if (res != 0B) goto <D.25574>; else goto <D.25575>;
      <D.25574>:
      mono_icall_unlock ();
      D.25528 = res;
      return D.25528;
      <D.25575>:
      *sigstart = 40;
      D.25547 = (sizetype) mlen;
      D.25572 = -D.25547;
      D.25573 = sigstart + D.25572;
      res = find_method_icall (imap, D.25573);
      if (res != 0B) goto <D.25576>; else goto <D.25577>;
      <D.25576>:
      mono_icall_unlock ();
      D.25528 = res;
      return D.25528;
      <D.25577>:
      monoeg_g_log (0B, 16, "cant resolve internal call to \"%s\" (tested without signature also)", &mname);
      monoeg_g_print ("\nYour mono runtime and class libraries are out of sync.\n");
      D.25522 = method->klass;
      D.25578 = D.25522->image;
      D.25579 = D.25578->name;
      monoeg_g_print ("The out of sync library is: %s\n", D.25579);
      monoeg_g_print ("\nWhen you update one from svn you need to update, compile and install\nthe other too.\n");
      monoeg_g_print ("Do not report this as a bug unless you\'re sure you have updated correctly:\nyou probably have a broken mono install.\n");
      monoeg_g_print ("If you see other errors or faults after this message they are probably related\n");
      monoeg_g_print ("and you need to fix your mono install first.\n");
      mono_icall_unlock ();
      D.25528 = 0B;
      return D.25528;
    }
  finally
    {
      mname = {CLOBBER};
    }
}


concat_class_name (char * buf, int bufsize, struct MonoClass * klass)
{
  const char * D.25582;
  long unsigned int D.25583;
  const char * D.25584;
  long unsigned int D.25585;
  int D.25586;
  int D.25587;
  int D.25590;
  long unsigned int D.25593;
  int nspacelen.14;
  sizetype D.25595;
  char * D.25596;
  sizetype D.25597;
  char * D.25598;
  long unsigned int D.25599;
  sizetype D.25600;
  char * D.25601;
  int nspacelen;
  int cnamelen;

  D.25582 = klass->name_space;
  D.25583 = __strlen_g (D.25582);
  nspacelen = (int) D.25583;
  D.25584 = klass->name;
  D.25585 = __strlen_g (D.25584);
  cnamelen = (int) D.25585;
  D.25586 = nspacelen + cnamelen;
  D.25587 = D.25586 + 1;
  if (D.25587 >= bufsize) goto <D.25588>; else goto <D.25589>;
  <D.25588>:
  D.25590 = 0;
  return D.25590;
  <D.25589>:
  if (nspacelen != 0) goto <D.25591>; else goto <D.25592>;
  <D.25591>:
  D.25582 = klass->name_space;
  D.25593 = (long unsigned int) nspacelen;
  memcpy (buf, D.25582, D.25593);
  nspacelen.14 = nspacelen;
  nspacelen = nspacelen.14 + 1;
  D.25595 = (sizetype) nspacelen.14;
  D.25596 = buf + D.25595;
  *D.25596 = 46;
  <D.25592>:
  D.25597 = (sizetype) nspacelen;
  D.25598 = buf + D.25597;
  D.25584 = klass->name;
  D.25599 = (long unsigned int) cnamelen;
  memcpy (D.25598, D.25584, D.25599);
  D.25586 = nspacelen + cnamelen;
  D.25600 = (sizetype) D.25586;
  D.25601 = buf + D.25600;
  *D.25601 = 0;
  D.25590 = nspacelen + cnamelen;
  return D.25590;
}


find_class_icalls (const char * name)
{
  const struct IcallTypeDesc * D.25605;
  long int nameslot.15;
  long int D.25607;
  long int D.25608;
  long int D.25609;
  const guint16 * nameslot;

  nameslot = mono_binary_search (name, &icall_type_names_idx, 108, 2, compare_class_imap);
  if (nameslot == 0B) goto <D.25603>; else goto <D.25604>;
  <D.25603>:
  D.25605 = 0B;
  return D.25605;
  <D.25604>:
  nameslot.15 = (long int) nameslot;
  D.25607 = (long int) &icall_type_names_idx[0];
  D.25608 = nameslot.15 - D.25607;
  D.25609 = D.25608 /[ex] 2;
  D.25605 = &icall_type_descs[D.25609];
  return D.25605;
}


compare_class_imap (const void * key, const void * elem)
{
  short unsigned int D.25611;
  sizetype D.25612;
  int D.25613;
  const char * class_name;

  D.25611 = MEM[(guint16 *)elem];
  D.25612 = (sizetype) D.25611;
  class_name = &icall_type_names_str + D.25612;
  D.25613 = strcmp (key, class_name);
  return D.25613;
}


__attribute__((__gnu_inline__))
__strlen_g (const char * __str)
{
  size_t D.25615;
  long int __ptr.16;
  long int __str.17;
  long int D.25618;
  char * __ptr;
  char * __tmp;

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


__attribute__((__artificial__, __gnu_inline__, __always_inline__, __nothrow__, __leaf__))
memcpy (void * restrict __dest, const void * restrict __src, size_t __len)
{
  void * D.25620;
  long unsigned int D.25621;

  D.25621 = __builtin_object_size (__dest, 0);
  D.25620 = __builtin___memcpy_chk (__dest, __src, __len, D.25621);
  return D.25620;
}


find_method_icall (const struct IcallTypeDesc * imap, const char * name)
{
  short unsigned int D.25623;
  long unsigned int D.25624;
  long unsigned int D.25625;
  const void * D.25626;
  const struct IcallTypeDesc * D.25627;
  short unsigned int D.25628;
  int D.25629;
  int D.25630;
  int D.25631;
  long unsigned int D.25632;
  void * D.25635;
  long int nameslot.18;
  long int D.25637;
  long int D.25638;
  long int D.25639;
  const guint16 * nameslot;

  D.25623 = imap->first_icall;
  D.25624 = (long unsigned int) D.25623;
  D.25625 = D.25624 * 2;
  D.25626 = &icall_names_idx + D.25625;
  D.25627 = imap + 2;
  D.25628 = D.25627->first_icall;
  D.25629 = (int) D.25628;
  D.25623 = imap->first_icall;
  D.25630 = (int) D.25623;
  D.25631 = D.25629 - D.25630;
  D.25632 = (long unsigned int) D.25631;
  nameslot = mono_binary_search (name, D.25626, D.25632, 2, compare_method_imap);
  if (nameslot == 0B) goto <D.25633>; else goto <D.25634>;
  <D.25633>:
  D.25635 = 0B;
  return D.25635;
  <D.25634>:
  nameslot.18 = (long int) nameslot;
  D.25637 = (long int) &icall_names_idx[0];
  D.25638 = nameslot.18 - D.25637;
  D.25639 = D.25638 /[ex] 2;
  D.25635 = icall_functions[D.25639];
  return D.25635;
}


ves_icall_get_resources_ptr (struct MonoReflectionAssembly * assembly, void * * result, gint32 * size)
{
  gboolean D.25645;
  struct MonoAssembly * D.25646;
  unsigned int D.25649;
  char * D.25650;
  void * D.25651;
  unsigned int D.25654;
  int D.25655;
  struct MonoPEResourceDataEntry * entry;
  struct MonoImage * image;

  if (assembly == 0B) goto <D.25641>; else goto <D.25643>;
  <D.25643>:
  if (result == 0B) goto <D.25641>; else goto <D.25644>;
  <D.25644>:
  if (size == 0B) goto <D.25641>; else goto <D.25642>;
  <D.25641>:
  D.25645 = 0;
  return D.25645;
  <D.25642>:
  *result = 0B;
  *size = 0;
  D.25646 = assembly->assembly;
  image = D.25646->image;
  entry = mono_image_lookup_resource (image, 101, 0, 0B);
  if (entry == 0B) goto <D.25647>; else goto <D.25648>;
  <D.25647>:
  D.25645 = 0;
  return D.25645;
  <D.25648>:
  D.25649 = entry->rde_data_offset;
  D.25650 = mono_image_rva_map (image, D.25649);
  *result = D.25650;
  D.25651 = *result;
  if (D.25651 == 0B) goto <D.25652>; else goto <D.25653>;
  <D.25652>:
  monoeg_g_free (entry);
  D.25645 = 0;
  return D.25645;
  <D.25653>:
  D.25654 = entry->rde_size;
  D.25655 = (int) D.25654;
  *size = D.25655;
  monoeg_g_free (entry);
  D.25645 = 1;
  return D.25645;
}


ves_icall_System_Web_Util_ICalls_get_machine_install_dir ()
{
  const char * D.25657;
  struct MonoDomain * D.25658;
  struct MonoString * D.25659;
  struct MonoString * ipath;
  gchar * path;

  D.25657 = mono_get_config_dir ();
  path = monoeg_g_path_get_dirname (D.25657);
  D.25658 = mono_domain_get ();
  ipath = mono_string_new (D.25658, path);
  monoeg_g_free (path);
  D.25659 = ipath;
  return D.25659;
}


ves_icall_System_ValueType_InternalGetHashCode (struct MonoObject * this, struct MonoArray * * fields)
{
  struct MonoVTable * D.25661;
  int D.25662;
  gint32 D.25665;
  struct MonoType * D.25666;
  short unsigned int D.25667;
  int D.25668;
  int D.25669;
  int D.25672;
  const char * D.25675;
  int D.25676;
  unsigned char D.25679;
  int D.25680;
  int D.25681;
  sizetype D.25682;
  gint32 * D.25683;
  int D.25684;
  struct MonoString * * D.25685;
  unsigned int D.25688;
  unsigned int result.19;
  unsigned int D.25690;
  int D.25693;
  long unsigned int D.25694;
  long unsigned int D.25695;
  struct MonoDomain * D.25696;
  int count.20;
  long unsigned int D.25698;
  long unsigned int D.25699;
  struct MonoObject * * D.25700;
  struct MonoDomain * D.25703;
  struct MonoClass * D.25704;
  long unsigned int D.25705;
  struct MonoArray * D.25706;
  struct MonoArray * D.25707;
  long unsigned int D.25708;
  long unsigned int D.25709;
  long unsigned int D.25710;
  struct MonoObject * * D.25711;
  struct MonoObject * D.25712;
  struct MonoClass * klass;
  struct MonoObject * * values;
  struct MonoObject * o;
  int count;
  gint32 result;
  struct MonoClassField * field;
  void * iter;

  try
    {
      values = 0B;
      count = 0;
      result = 0;
      D.25661 = this->vtable;
      klass = D.25661->klass;
      D.25662 = mono_class_num_fields (klass);
      if (D.25662 == 0) goto <D.25663>; else goto <D.25664>;
      <D.25663>:
      D.25665 = mono_object_hash (this);
      return D.25665;
      <D.25664>:
      iter = 0B;
      goto <D.21260>;
      <D.21266>:
      D.25666 = field->type;
      D.25667 = D.25666->attrs;
      D.25668 = (int) D.25667;
      D.25669 = D.25668 & 16;
      if (D.25669 != 0) goto <D.25670>; else goto <D.25671>;
      <D.25670>:
      // predicted unlikely by continue predictor.
      goto <D.21260>;
      <D.25671>:
      D.25666 = field->type;
      D.25667 = D.25666->attrs;
      D.25668 = (int) D.25667;
      D.25672 = D.25668 & 1536;
      if (D.25672 != 0) goto <D.25673>; else goto <D.25674>;
      <D.25673>:
      D.25675 = mono_field_get_name (field);
      D.25676 = strcmp (D.25675, "_Deleted");
      if (D.25676 == 0) goto <D.25677>; else goto <D.25678>;
      <D.25677>:
      // predicted unlikely by continue predictor.
      goto <D.21260>;
      <D.25678>:
      <D.25674>:
      D.25666 = field->type;
      D.25679 = D.25666->type;
      D.25680 = (int) D.25679;
      switch (D.25680) <default: <D.21265>, case 8: <D.21261>, case 14: <D.21263>>
      <D.21261>:
      D.25681 = field->offset;
      D.25682 = (sizetype) D.25681;
      D.25683 = this + D.25682;
      D.25684 = *D.25683;
      result = D.25684 ^ result;
      goto <D.21262>;
      <D.21263>:
      {
        struct MonoString * s;

        D.25681 = field->offset;
        D.25682 = (sizetype) D.25681;
        D.25685 = this + D.25682;
        s = *D.25685;
        if (s != 0B) goto <D.25686>; else goto <D.25687>;
        <D.25686>:
        D.25688 = mono_string_hash (s);
        result.19 = (unsigned int) result;
        D.25690 = D.25688 ^ result.19;
        result = (gint32) D.25690;
        <D.25687>:
        goto <D.21262>;
      }
      <D.21265>:
      if (values == 0B) goto <D.25691>; else goto <D.25692>;
      <D.25691>:
      D.25693 = mono_class_num_fields (klass);
      D.25694 = (long unsigned int) D.25693;
      D.25695 = D.25694 * 8;
      values = __builtin_alloca (D.25695);
      <D.25692>:
      D.25661 = this->vtable;
      D.25696 = D.25661->domain;
      o = mono_field_get_value_object (D.25696, field, this);
      count.20 = count;
      count = count.20 + 1;
      D.25698 = (long unsigned int) count.20;
      D.25699 = D.25698 * 8;
      D.25700 = values + D.25699;
      *D.25700 = o;
      <D.21262>:
      <D.21260>:
      field = mono_class_get_fields (klass, &iter);
      if (field != 0B) goto <D.21266>; else goto <D.21267>;
      <D.21267>:
      if (values != 0B) goto <D.25701>; else goto <D.25702>;
      <D.25701>:
      {
        int i;

        D.25703 = mono_domain_get ();
        D.25704 = mono_defaults.object_class;
        D.25705 = (long unsigned int) count;
        D.25706 = mono_array_new (D.25703, D.25704, D.25705);
        mono_gc_wbarrier_generic_store (fields, D.25706);
        i = 0;
        goto <D.21271>;
        <D.21270>:
        {
          void * * __p;

          D.25707 = *fields;
          D.25708 = (long unsigned int) i;
          __p = mono_array_addr_with_size (D.25707, 8, D.25708);
          D.25707 = *fields;
          D.25709 = (long unsigned int) i;
          D.25710 = D.25709 * 8;
          D.25711 = values + D.25710;
          D.25712 = *D.25711;
          mono_gc_wbarrier_set_arrayref (D.25707, __p, D.25712);
        }
        i = i + 1;
        <D.21271>:
        if (i < count) goto <D.21270>; else goto <D.21272>;
        <D.21272>:
      }
      goto <D.25713>;
      <D.25702>:
      *fields = 0B;
      <D.25713>:
      D.25665 = result;
      return D.25665;
    }
  finally
    {
      iter = {CLOBBER};
    }
}


ves_icall_System_ValueType_Equals (struct MonoObject * this, struct MonoObject * that, struct MonoArray * * fields)
{
  _Bool D.25716;
  long int D.25717;
  long int D.25718;
  struct MonoVTable * D.25723;
  struct MonoVTable * D.25724;
  MonoBoolean D.25727;
  long unsigned int D.25728;
  long unsigned int D.25729;
  struct MonoType * D.25732;
  struct MonoType * D.25735;
  unsigned char D.25736;
  gint32 * D.25739;
  int D.25740;
  gint32 * D.25741;
  int D.25742;
  _Bool D.25743;
  struct MonoType * D.25744;
  short unsigned int D.25745;
  int D.25746;
  int D.25747;
  int D.25750;
  const char * D.25753;
  int D.25754;
  unsigned char D.25757;
  int D.25758;
  int D.25759;
  sizetype D.25760;
  guint8 * D.25761;
  unsigned char D.25762;
  guint8 * D.25763;
  unsigned char D.25764;
  gint16 * D.25767;
  short int D.25768;
  gint16 * D.25769;
  short int D.25770;
  gint32 * D.25773;
  int D.25774;
  gint32 * D.25775;
  int D.25776;
  gint64 * D.25779;
  long int D.25780;
  gint64 * D.25781;
  long int D.25782;
  float * D.25785;
  float D.25786;
  float * D.25787;
  float D.25788;
  double * D.25791;
  double D.25792;
  double * D.25793;
  double D.25794;
  struct MonoString * * D.25797;
  struct MonoString * * D.25798;
  int D.25803;
  int D.25804;
  mono_unichar2 * D.25807;
  mono_unichar2 * D.25808;
  long unsigned int D.25809;
  long unsigned int D.25810;
  int D.25811;
  int D.25816;
  int D.25817;
  long unsigned int D.25818;
  long unsigned int D.25819;
  struct MonoDomain * D.25820;
  int count.21;
  long unsigned int D.25822;
  long unsigned int D.25823;
  struct MonoObject * * D.25824;
  int count.22;
  long unsigned int D.25826;
  long unsigned int D.25827;
  struct MonoObject * * D.25828;
  struct MonoDomain * D.25832;
  struct MonoClass * D.25833;
  long unsigned int D.25834;
  struct MonoArray * D.25835;
  struct MonoArray * D.25836;
  double[0:] * D.25837;
  long unsigned int D.25838;
  long unsigned int D.25839;
  struct MonoObject * * D.25840;
  struct MonoObject * D.25841;
  struct MonoClass * klass;
  struct MonoObject * * values;
  struct MonoObject * o;
  struct MonoClassField * field;
  void * iter;
  int count;

  try
    {
      values = 0B;
      count = 0;
      D.25716 = that == 0B;
      D.25717 = (long int) D.25716;
      D.25718 = __builtin_expect (D.25717, 0);
      if (D.25718 != 0) goto <D.25719>; else goto <D.25720>;
      <D.25719>:
      {
        struct MonoException * ex;

        if (that != 0B) goto <D.25721>; else goto <D.25722>;
        <D.25721>:
        <D.25722>:
        ex = mono_get_exception_argument_null ("that");
        mono_raise_exception (ex);
      }
      <D.25720>:
      D.25723 = this->vtable;
      D.25724 = that->vtable;
      if (D.25723 != D.25724) goto <D.25725>; else goto <D.25726>;
      <D.25725>:
      D.25727 = 0;
      return D.25727;
      <D.25726>:
      D.25723 = this->vtable;
      klass = D.25723->klass;
      D.25728 = BIT_FIELD_REF <*klass, 64, 256>;
      D.25729 = D.25728 & 576460752303423488;
      if (D.25729 != 0) goto <D.25730>; else goto <D.25731>;
      <D.25730>:
      D.25732 = mono_class_enum_basetype (klass);
      if (D.25732 != 0B) goto <D.25733>; else goto <D.25734>;
      <D.25733>:
      D.25735 = mono_class_enum_basetype (klass);
      D.25736 = D.25735->type;
      if (D.25736 == 8) goto <D.25737>; else goto <D.25738>;
      <D.25737>:
      D.25739 = this + 16;
      D.25740 = *D.25739;
      D.25741 = that + 16;
      D.25742 = *D.25741;
      D.25743 = D.25740 == D.25742;
      D.25727 = (MonoBoolean) D.25743;
      return D.25727;
      <D.25738>:
      <D.25734>:
      <D.25731>:
      *fields = 0B;
      iter = 0B;
      goto <D.21285>;
      <D.21306>:
      D.25744 = field->type;
      D.25745 = D.25744->attrs;
      D.25746 = (int) D.25745;
      D.25747 = D.25746 & 16;
      if (D.25747 != 0) goto <D.25748>; else goto <D.25749>;
      <D.25748>:
      // predicted unlikely by continue predictor.
      goto <D.21285>;
      <D.25749>:
      D.25744 = field->type;
      D.25745 = D.25744->attrs;
      D.25746 = (int) D.25745;
      D.25750 = D.25746 & 1536;
      if (D.25750 != 0) goto <D.25751>; else goto <D.25752>;
      <D.25751>:
      D.25753 = mono_field_get_name (field);
      D.25754 = strcmp (D.25753, "_Deleted");
      if (D.25754 == 0) goto <D.25755>; else goto <D.25756>;
      <D.25755>:
      // predicted unlikely by continue predictor.
      goto <D.21285>;
      <D.25756>:
      <D.25752>:
      D.25744 = field->type;
      D.25757 = D.25744->type;
      D.25758 = (int) D.25757;
      switch (D.25758) <default: <D.21304>, case 2: <D.21288>, case 3: <D.21292>, case 4: <D.21287>, case 5: <D.21286>, case 6: <D.21291>, case 7: <D.21290>, case 8: <D.21294>, case 9: <D.21293>, case 10: <D.21296>, case 11: <D.21295>, case 12: <D.21297>, case 13: <D.21298>, case 14: <D.21299>>
      <D.21286>:
      <D.21287>:
      <D.21288>:
      D.25759 = field->offset;
      D.25760 = (sizetype) D.25759;
      D.25761 = this + D.25760;
      D.25762 = *D.25761;
      D.25759 = field->offset;
      D.25760 = (sizetype) D.25759;
      D.25763 = that + D.25760;
      D.25764 = *D.25763;
      if (D.25762 != D.25764) goto <D.25765>; else goto <D.25766>;
      <D.25765>:
      D.25727 = 0;
      return D.25727;
      <D.25766>:
      goto <D.21289>;
      <D.21290>:
      <D.21291>:
      <D.21292>:
      D.25759 = field->offset;
      D.25760 = (sizetype) D.25759;
      D.25767 = this + D.25760;
      D.25768 = *D.25767;
      D.25759 = field->offset;
      D.25760 = (sizetype) D.25759;
      D.25769 = that + D.25760;
      D.25770 = *D.25769;
      if (D.25768 != D.25770) goto <D.25771>; else goto <D.25772>;
      <D.25771>:
      D.25727 = 0;
      return D.25727;
      <D.25772>:
      goto <D.21289>;
      <D.21293>:
      <D.21294>:
      D.25759 = field->offset;
      D.25760 = (sizetype) D.25759;
      D.25773 = this + D.25760;
      D.25774 = *D.25773;
      D.25759 = field->offset;
      D.25760 = (sizetype) D.25759;
      D.25775 = that + D.25760;
      D.25776 = *D.25775;
      if (D.25774 != D.25776) goto <D.25777>; else goto <D.25778>;
      <D.25777>:
      D.25727 = 0;
      return D.25727;
      <D.25778>:
      goto <D.21289>;
      <D.21295>:
      <D.21296>:
      D.25759 = field->offset;
      D.25760 = (sizetype) D.25759;
      D.25779 = this + D.25760;
      D.25780 = *D.25779;
      D.25759 = field->offset;
      D.25760 = (sizetype) D.25759;
      D.25781 = that + D.25760;
      D.25782 = *D.25781;
      if (D.25780 != D.25782) goto <D.25783>; else goto <D.25784>;
      <D.25783>:
      D.25727 = 0;
      return D.25727;
      <D.25784>:
      goto <D.21289>;
      <D.21297>:
      D.25759 = field->offset;
      D.25760 = (sizetype) D.25759;
      D.25785 = this + D.25760;
      D.25786 = *D.25785;
      D.25759 = field->offset;
      D.25760 = (sizetype) D.25759;
      D.25787 = that + D.25760;
      D.25788 = *D.25787;
      if (D.25786 != D.25788) goto <D.25789>; else goto <D.25790>;
      <D.25789>:
      D.25727 = 0;
      return D.25727;
      <D.25790>:
      goto <D.21289>;
      <D.21298>:
      D.25759 = field->offset;
      D.25760 = (sizetype) D.25759;
      D.25791 = this + D.25760;
      D.25792 = *D.25791;
      D.25759 = field->offset;
      D.25760 = (sizetype) D.25759;
      D.25793 = that + D.25760;
      D.25794 = *D.25793;
      if (D.25792 != D.25794) goto <D.25795>; else goto <D.25796>;
      <D.25795>:
      D.25727 = 0;
      return D.25727;
      <D.25796>:
      goto <D.21289>;
      <D.21299>:
      {
        struct MonoString * s1;
        struct MonoString * s2;
        guint32 s1len;
        guint32 s2len;

        D.25759 = field->offset;
        D.25760 = (sizetype) D.25759;
        D.25797 = this + D.25760;
        s1 = *D.25797;
        D.25759 = field->offset;
        D.25760 = (sizetype) D.25759;
        D.25798 = that + D.25760;
        s2 = *D.25798;
        if (s1 == s2) goto <D.21289>; else goto <D.25799>;
        <D.25799>:
        if (s1 == 0B) goto <D.25800>; else goto <D.25802>;
        <D.25802>:
        if (s2 == 0B) goto <D.25800>; else goto <D.25801>;
        <D.25800>:
        D.25727 = 0;
        return D.25727;
        <D.25801>:
        D.25803 = mono_string_length (s1);
        s1len = (guint32) D.25803;
        D.25804 = mono_string_length (s2);
        s2len = (guint32) D.25804;
        if (s1len != s2len) goto <D.25805>; else goto <D.25806>;
        <D.25805>:
        D.25727 = 0;
        return D.25727;
        <D.25806>:
        D.25807 = mono_string_chars (s1);
        D.25808 = mono_string_chars (s2);
        D.25809 = (long unsigned int) s1len;
        D.25810 = D.25809 * 2;
        D.25811 = memcmp (D.25807, D.25808, D.25810);
        if (D.25811 != 0) goto <D.25812>; else goto <D.25813>;
        <D.25812>:
        D.25727 = 0;
        return D.25727;
        <D.25813>:
        goto <D.21289>;
      }
      <D.21304>:
      if (values == 0B) goto <D.25814>; else goto <D.25815>;
      <D.25814>:
      D.25816 = mono_class_num_fields (klass);
      D.25817 = D.25816 * 2;
      D.25818 = (long unsigned int) D.25817;
      D.25819 = D.25818 * 8;
      values = __builtin_alloca (D.25819);
      <D.25815>:
      D.25723 = this->vtable;
      D.25820 = D.25723->domain;
      o = mono_field_get_value_object (D.25820, field, this);
      count.21 = count;
      count = count.21 + 1;
      D.25822 = (long unsigned int) count.21;
      D.25823 = D.25822 * 8;
      D.25824 = values + D.25823;
      *D.25824 = o;
      D.25723 = this->vtable;
      D.25820 = D.25723->domain;
      o = mono_field_get_value_object (D.25820, field, that);
      count.22 = count;
      count = count.22 + 1;
      D.25826 = (long unsigned int) count.22;
      D.25827 = D.25826 * 8;
      D.25828 = values + D.25827;
      *D.25828 = o;
      <D.21289>:
      D.25728 = BIT_FIELD_REF <*klass, 64, 256>;
      D.25729 = D.25728 & 576460752303423488;
      if (D.25729 != 0) goto <D.21305>; else goto <D.25829>;
      <D.25829>:
      <D.21285>:
      field = mono_class_get_fields (klass, &iter);
      if (field != 0B) goto <D.21306>; else goto <D.21305>;
      <D.21305>:
      if (values != 0B) goto <D.25830>; else goto <D.25831>;
      <D.25830>:
      {
        int i;

        D.25832 = mono_domain_get ();
        D.25833 = mono_defaults.object_class;
        D.25834 = (long unsigned int) count;
        D.25835 = mono_array_new (D.25832, D.25833, D.25834);
        mono_gc_wbarrier_generic_store (fields, D.25835);
        i = 0;
        goto <D.21310>;
        <D.21309>:
        {
          void * * __p;

          D.25836 = *fields;
          D.25837 = &D.25836->vector;
          D.25838 = (long unsigned int) i;
          D.25839 = D.25838 * 8;
          __p = D.25837 + D.25839;
          D.25836 = *fields;
          D.25838 = (long unsigned int) i;
          D.25839 = D.25838 * 8;
          D.25840 = values + D.25839;
          D.25841 = *D.25840;
          mono_gc_wbarrier_set_arrayref (D.25836, __p, D.25841);
        }
        i = i + 1;
        <D.21310>:
        if (i < count) goto <D.21309>; else goto <D.21311>;
        <D.21311>:
        D.25727 = 0;
        return D.25727;
      }
      <D.25831>:
      D.25727 = 1;
      return D.25727;
    }
  finally
    {
      iter = {CLOBBER};
    }
}


mono_TypedReference_ToObjectInternal (struct MonoType * type, void * value, struct MonoClass * klass)
{
  int D.25844;
  struct MonoObject * D.25847;
  struct MonoDomain * D.25848;

  D.25844 = mono_type_is_reference (type);
  if (D.25844 != 0) goto <D.25845>; else goto <D.25846>;
  <D.25845>:
  {
    struct MonoObject * * objp;

    objp = value;
    D.25847 = *objp;
    return D.25847;
  }
  <D.25846>:
  D.25848 = mono_domain_get ();
  D.25847 = mono_value_box (D.25848, klass, value);
  return D.25847;
}


mono_TypedReference_ToObject (struct MonoTypedRef tref)
{
  struct MonoType * D.25850;
  int D.25851;
  struct MonoObject * D.25854;
  struct MonoDomain * D.25855;
  struct MonoClass * D.25856;
  void * D.25857;

  D.25850 = tref.type;
  D.25851 = mono_type_is_reference (D.25850);
  if (D.25851 != 0) goto <D.25852>; else goto <D.25853>;
  <D.25852>:
  {
    struct MonoObject * * objp;

    objp = tref.value;
    D.25854 = *objp;
    return D.25854;
  }
  <D.25853>:
  D.25855 = mono_domain_get ();
  D.25856 = tref.klass;
  D.25857 = tref.value;
  D.25854 = mono_value_box (D.25855, D.25856, D.25857);
  return D.25854;
}


ves_icall_type_is_subtype_of (struct MonoReflectionType * type, struct MonoReflectionType * c, MonoBoolean check_interfaces)
{
  _Bool D.25859;
  long int D.25860;
  long int D.25861;
  struct MonoVTable * D.25864;
  guint32 D.25867;
  struct MonoType * D.25868;
  struct MonoType * D.25869;
  struct MonoClass * * D.25875;
  struct MonoClass * * D.25877;
  long unsigned int D.25878;
  long unsigned int D.25879;
  struct MonoClass * D.25882;
  _Bool D.25883;
  int D.25884;
  int D.25885;
  struct MonoDomain * domain;
  struct MonoClass * klass;
  struct MonoClass * klassc;

  D.25859 = type == 0B;
  D.25860 = (long int) D.25859;
  D.25861 = __builtin_expect (D.25860, 0);
  if (D.25861 != 0) goto <D.25862>; else goto <D.25863>;
  <D.25862>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 1502, "type != NULL");
  <D.25863>:
  D.25864 = MEM[(struct MonoObject *)type].vtable;
  domain = D.25864->domain;
  if (c == 0B) goto <D.25865>; else goto <D.25866>;
  <D.25865>:
  D.25867 = 0;
  return D.25867;
  <D.25866>:
  D.25868 = type->type;
  klass = mono_class_from_mono_type (D.25868);
  D.25869 = c->type;
  klassc = mono_class_from_mono_type (D.25869);
  if (check_interfaces != 0) goto <D.25870>; else goto <D.25871>;
  <D.25870>:
  mono_class_init_or_throw (klass);
  mono_class_init_or_throw (klassc);
  goto <D.25872>;
  <D.25871>:
  D.25875 = klass->supertypes;
  if (D.25875 == 0B) goto <D.25873>; else goto <D.25876>;
  <D.25876>:
  D.25877 = klassc->supertypes;
  if (D.25877 == 0B) goto <D.25873>; else goto <D.25874>;
  <D.25873>:
  mono_class_setup_supertypes (klass);
  mono_class_setup_supertypes (klassc);
  <D.25874>:
  <D.25872>:
  D.25868 = type->type;
  D.25878 = BIT_FIELD_REF <*D.25868, 64, 64>;
  D.25879 = D.25878 & 8589934592;
  if (D.25879 != 0) goto <D.25880>; else goto <D.25881>;
  <D.25880>:
  D.25882 = mono_defaults.object_class;
  D.25883 = D.25882 == klassc;
  D.25867 = (guint32) D.25883;
  return D.25867;
  <D.25881>:
  D.25884 = (int) check_interfaces;
  D.25885 = mono_class_is_subclass_of (klass, klassc, D.25884);
  D.25867 = (guint32) D.25885;
  return D.25867;
}


mono_class_init_or_throw (struct MonoClass * klass)
{
  int D.25887;
  struct MonoException * D.25890;

  D.25887 = mono_class_init (klass);
  if (D.25887 == 0) goto <D.25888>; else goto <D.25889>;
  <D.25888>:
  D.25890 = mono_class_get_exception_for_failure (klass);
  mono_raise_exception (D.25890);
  <D.25889>:
}


ves_icall_type_is_assignable_from (struct MonoReflectionType * type, struct MonoReflectionType * c)
{
  _Bool D.25891;
  long int D.25892;
  long int D.25893;
  struct MonoVTable * D.25896;
  struct MonoType * D.25897;
  struct MonoType * D.25898;
  long unsigned int D.25899;
  long unsigned int D.25900;
  long unsigned int D.25901;
  long unsigned int D.25902;
  guint32 D.25905;
  long unsigned int D.25906;
  int D.25909;
  int iftmp.23;
  int D.25915;
  int D.25917;
  int D.25918;
  unsigned char D.25922;
  int iftmp.24;
  unsigned char D.25927;
  struct MonoGenericParam * D.25929;
  short unsigned int D.25930;
  struct MonoGenericParam * D.25931;
  short unsigned int D.25932;
  _Bool D.25937;
  long unsigned int D.25941;
  long unsigned int D.25942;
  _Bool D.25945;
  long unsigned int D.25946;
  long unsigned int D.25947;
  long unsigned int D.25948;
  _Bool D.25949;
  int D.25950;
  struct MonoDomain * domain;
  struct MonoClass * klass;
  struct MonoClass * klassc;

  D.25891 = type == 0B;
  D.25892 = (long int) D.25891;
  D.25893 = __builtin_expect (D.25892, 0);
  if (D.25893 != 0) goto <D.25894>; else goto <D.25895>;
  <D.25894>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 1555, "type != NULL");
  <D.25895>:
  D.25896 = MEM[(struct MonoObject *)type].vtable;
  domain = D.25896->domain;
  D.25897 = type->type;
  klass = mono_class_from_mono_type (D.25897);
  D.25898 = c->type;
  klassc = mono_class_from_mono_type (D.25898);
  D.25897 = type->type;
  D.25899 = BIT_FIELD_REF <*D.25897, 64, 64>;
  D.25898 = c->type;
  D.25900 = BIT_FIELD_REF <*D.25898, 64, 64>;
  D.25901 = D.25899 ^ D.25900;
  D.25902 = D.25901 & 8589934592;
  if (D.25902 != 0) goto <D.25903>; else goto <D.25904>;
  <D.25903>:
  D.25905 = 0;
  return D.25905;
  <D.25904>:
  D.25897 = type->type;
  D.25899 = BIT_FIELD_REF <*D.25897, 64, 64>;
  D.25906 = D.25899 & 8589934592;
  if (D.25906 != 0) goto <D.25907>; else goto <D.25908>;
  <D.25907>:
  {
    struct MonoType * t;
    struct MonoType * ot;

    D.25897 = type->type;
    t = mono_type_get_underlying_type_ignore_byref (D.25897);
    D.25898 = c->type;
    ot = mono_type_get_underlying_type_ignore_byref (D.25898);
    klass = mono_class_from_mono_type (t);
    klassc = mono_class_from_mono_type (ot);
    D.25909 = mono_type_is_primitive (t);
    if (D.25909 != 0) goto <D.25910>; else goto <D.25911>;
    <D.25910>:
    D.25915 = mono_type_is_primitive (ot);
    if (D.25915 != 0) goto <D.25916>; else goto <D.25913>;
    <D.25916>:
    D.25917 = klass->instance_size;
    D.25918 = klassc->instance_size;
    if (D.25917 == D.25918) goto <D.25919>; else goto <D.25913>;
    <D.25919>:
    iftmp.23 = 1;
    goto <D.25914>;
    <D.25913>:
    iftmp.23 = 0;
    <D.25914>:
    D.25905 = (guint32) iftmp.23;
    return D.25905;
    <D.25911>:
    D.25922 = t->type;
    if (D.25922 == 19) goto <D.25920>; else goto <D.25923>;
    <D.25923>:
    D.25922 = t->type;
    if (D.25922 == 30) goto <D.25920>; else goto <D.25921>;
    <D.25920>:
    D.25922 = t->type;
    D.25927 = ot->type;
    if (D.25922 == D.25927) goto <D.25928>; else goto <D.25925>;
    <D.25928>:
    D.25929 = t->data.generic_param;
    D.25930 = D.25929->num;
    D.25931 = ot->data.generic_param;
    D.25932 = D.25931->num;
    if (D.25930 == D.25932) goto <D.25933>; else goto <D.25925>;
    <D.25933>:
    iftmp.24 = 1;
    goto <D.25926>;
    <D.25925>:
    iftmp.24 = 0;
    <D.25926>:
    D.25905 = (guint32) iftmp.24;
    return D.25905;
    <D.25921>:
    D.25922 = t->type;
    if (D.25922 == 15) goto <D.25934>; else goto <D.25936>;
    <D.25936>:
    D.25922 = t->type;
    if (D.25922 == 27) goto <D.25934>; else goto <D.25935>;
    <D.25934>:
    D.25922 = t->type;
    D.25927 = ot->type;
    D.25937 = D.25922 == D.25927;
    D.25905 = (guint32) D.25937;
    return D.25905;
    <D.25935>:
    D.25927 = ot->type;
    if (D.25927 == 19) goto <D.25938>; else goto <D.25940>;
    <D.25940>:
    D.25927 = ot->type;
    if (D.25927 == 30) goto <D.25938>; else goto <D.25939>;
    <D.25938>:
    D.25905 = 0;
    return D.25905;
    <D.25939>:
    D.25941 = BIT_FIELD_REF <*klass, 64, 256>;
    D.25942 = D.25941 & 1152921504606846976;
    if (D.25942 != 0) goto <D.25943>; else goto <D.25944>;
    <D.25943>:
    D.25945 = klass == klassc;
    D.25905 = (guint32) D.25945;
    return D.25905;
    <D.25944>:
    D.25941 = BIT_FIELD_REF <*klass, 64, 256>;
    D.25946 = BIT_FIELD_REF <*klassc, 64, 256>;
    D.25947 = D.25941 ^ D.25946;
    D.25948 = D.25947 & 1152921504606846976;
    D.25949 = D.25948 == 0;
    D.25905 = (guint32) D.25949;
    return D.25905;
  }
  <D.25908>:
  D.25950 = mono_class_is_assignable_from (klass, klassc);
  D.25905 = (guint32) D.25950;
  return D.25905;
}


mono_type_get_underlying_type_ignore_byref (struct MonoType * type)
{
  unsigned char D.25952;
  struct MonoClass * D.25955;
  long unsigned int D.25956;
  long unsigned int D.25957;
  struct MonoType * D.25960;
  struct MonoGenericClass * D.25963;
  struct MonoClass * D.25964;
  long unsigned int D.25965;
  long unsigned int D.25966;

  D.25952 = type->type;
  if (D.25952 == 17) goto <D.25953>; else goto <D.25954>;
  <D.25953>:
  D.25955 = type->data.klass;
  D.25956 = BIT_FIELD_REF <*D.25955, 64, 256>;
  D.25957 = D.25956 & 576460752303423488;
  if (D.25957 != 0) goto <D.25958>; else goto <D.25959>;
  <D.25958>:
  D.25955 = type->data.klass;
  D.25960 = mono_class_enum_basetype (D.25955);
  return D.25960;
  <D.25959>:
  <D.25954>:
  D.25952 = type->type;
  if (D.25952 == 21) goto <D.25961>; else goto <D.25962>;
  <D.25961>:
  D.25963 = type->data.generic_class;
  D.25964 = D.25963->container_class;
  D.25965 = BIT_FIELD_REF <*D.25964, 64, 256>;
  D.25966 = D.25965 & 576460752303423488;
  if (D.25966 != 0) goto <D.25967>; else goto <D.25968>;
  <D.25967>:
  D.25963 = type->data.generic_class;
  D.25964 = D.25963->container_class;
  D.25960 = mono_class_enum_basetype (D.25964);
  return D.25960;
  <D.25968>:
  <D.25962>:
  D.25960 = type;
  return D.25960;
}


mono_type_is_primitive (struct MonoType * type)
{
  gboolean D.25970;
  int iftmp.25;
  unsigned char D.25975;
  unsigned char D.25976;

  D.25975 = type->type;
  D.25976 = D.25975 + 254;
  if (D.25976 <= 11) goto <D.25972>; else goto <D.25977>;
  <D.25977>:
  D.25975 = type->type;
  if (D.25975 == 24) goto <D.25972>; else goto <D.25978>;
  <D.25978>:
  D.25975 = type->type;
  if (D.25975 == 25) goto <D.25972>; else goto <D.25973>;
  <D.25972>:
  iftmp.25 = 1;
  goto <D.25974>;
  <D.25973>:
  iftmp.25 = 0;
  <D.25974>:
  D.25970 = iftmp.25;
  return D.25970;
}


ves_icall_Type_make_byref_type (struct MonoReflectionType * type)
{
  struct MonoType * D.25980;
  struct MonoReflectionType * D.25981;
  struct MonoVTable * D.25982;
  struct MonoDomain * D.25983;
  struct MonoType * D.25984;
  struct MonoClass * klass;

  D.25980 = type->type;
  klass = mono_class_from_mono_type (D.25980);
  mono_class_init_or_throw (klass);
  check_for_invalid_type (klass);
  D.25982 = MEM[(struct MonoObject *)type].vtable;
  D.25983 = D.25982->domain;
  D.25984 = &klass->this_arg;
  D.25981 = mono_type_get_object (D.25983, D.25984);
  return D.25981;
}


check_for_invalid_type (struct MonoClass * klass)
{
  unsigned char D.25986;
  struct MonoDomain * D.25989;
  struct MonoException * D.25990;
  char * name;
  struct MonoString * str;

  D.25986 = klass->byval_arg.type;
  if (D.25986 != 22) goto <D.25987>; else goto <D.25988>;
  <D.25987>:
  return;
  <D.25988>:
  name = mono_type_get_full_name (klass);
  D.25989 = mono_domain_get ();
  str = mono_string_new (D.25989, name);
  monoeg_g_free (name);
  D.25990 = mono_get_exception_type_load (str, 0B);
  mono_raise_exception (D.25990);
}


ves_icall_Type_make_array_type (struct MonoReflectionType * type, int rank)
{
  struct MonoType * D.25992;
  unsigned int rank.26;
  struct MonoReflectionType * D.25997;
  struct MonoVTable * D.25998;
  struct MonoDomain * D.25999;
  struct MonoType * D.26000;
  struct MonoClass * klass;
  struct MonoClass * aklass;

  D.25992 = type->type;
  klass = mono_class_from_mono_type (D.25992);
  check_for_invalid_type (klass);
  if (rank == 0) goto <D.25993>; else goto <D.25994>;
  <D.25993>:
  aklass = mono_array_class_get (klass, 1);
  goto <D.25995>;
  <D.25994>:
  rank.26 = (unsigned int) rank;
  aklass = mono_bounded_array_class_get (klass, rank.26, 1);
  <D.25995>:
  D.25998 = MEM[(struct MonoObject *)type].vtable;
  D.25999 = D.25998->domain;
  D.26000 = &aklass->byval_arg;
  D.25997 = mono_type_get_object (D.25999, D.26000);
  return D.25997;
}


ves_icall_type_from_name (struct MonoString * name, MonoBoolean throwOnError, MonoBoolean ignoreCase)
{
  struct MonoReflectionType * D.26008;
  char * str;
  struct MonoReflectionType * type;

  str = mono_string_to_utf8 (name);
  type = type_from_name (str, ignoreCase);
  monoeg_g_free (str);
  if (type == 0B) goto <D.26002>; else goto <D.26003>;
  <D.26002>:
  {
    struct MonoException * e;

    e = 0B;
    if (throwOnError != 0) goto <D.26004>; else goto <D.26005>;
    <D.26004>:
    e = mono_get_exception_type_load (name, 0B);
    <D.26005>:
    mono_loader_clear_error ();
    if (e != 0B) goto <D.26006>; else goto <D.26007>;
    <D.26006>:
    mono_raise_exception (e);
    <D.26007>:
  }
  <D.26003>:
  D.26008 = type;
  return D.26008;
}


type_from_name (const char * str, MonoBoolean ignoreCase)
{
  int D.26010;
  struct MonoReflectionType * D.26013;
  const char * D.26014;
  struct MonoMethod * dest.27;
  struct MonoClass * D.26023;
  struct MonoImage * D.26024;
  struct MonoImage * D.26028;
  int D.26029;
  int type_resolve.28;
  struct MonoDomain * D.26043;
  struct MonoType * type;
  struct MonoAssembly * assembly;
  struct MonoTypeNameParse info;
  char * temp_str;
  gboolean type_resolve;

  try
    {
      type = 0B;
      assembly = 0B;
      temp_str = monoeg_strdup (str);
      type_resolve = 0;
      D.26010 = mono_reflection_parse_type (temp_str, &info);
      if (D.26010 == 0) goto <D.26011>; else goto <D.26012>;
      <D.26011>:
      mono_reflection_free_type_info (&info);
      monoeg_g_free (temp_str);
      D.26013 = 0B;
      return D.26013;
      <D.26012>:
      D.26014 = info.assembly.name;
      if (D.26014 != 0B) goto <D.26015>; else goto <D.26016>;
      <D.26015>:
      assembly = mono_assembly_load (&info.assembly, 0B, 0B);
      goto <D.26017>;
      <D.26016>:
      {
        struct MonoMethod * m;
        struct MonoMethod * dest;

        try
          {
            m = mono_method_get_last_managed ();
            dest = m;
            mono_stack_walk_no_il (get_caller_no_reflection, &dest);
            dest.27 = dest;
            if (dest.27 == 0B) goto <D.26019>; else goto <D.26020>;
            <D.26019>:
            dest = m;
            <D.26020>:
            dest.27 = dest;
            if (dest.27 != 0B) goto <D.26021>; else goto <D.26022>;
            <D.26021>:
            dest.27 = dest;
            D.26023 = dest.27->klass;
            D.26024 = D.26023->image;
            assembly = D.26024->assembly;
            type_resolve = 1;
            goto <D.26025>;
            <D.26022>:
            monoeg_g_log (0B, 16, "icall.c:1303:");
            <D.26025>:
          }
        finally
          {
            dest = {CLOBBER};
          }
      }
      <D.26017>:
      if (assembly != 0B) goto <D.26026>; else goto <D.26027>;
      <D.26026>:
      D.26028 = assembly->image;
      D.26029 = (int) ignoreCase;
      type = mono_reflection_get_type (D.26028, &info, D.26029, &type_resolve);
      <D.26027>:
      D.26014 = info.assembly.name;
      if (D.26014 == 0B) goto <D.26030>; else goto <D.26031>;
      <D.26030>:
      if (type == 0B) goto <D.26032>; else goto <D.26033>;
      <D.26032>:
      D.26029 = (int) ignoreCase;
      type = mono_reflection_get_type (0B, &info, D.26029, &type_resolve);
      <D.26033>:
      <D.26031>:
      if (assembly != 0B) goto <D.26034>; else goto <D.26035>;
      <D.26034>:
      if (type == 0B) goto <D.26036>; else goto <D.26037>;
      <D.26036>:
      type_resolve.28 = type_resolve;
      if (type_resolve.28 != 0) goto <D.26039>; else goto <D.26040>;
      <D.26039>:
      type_resolve = 0;
      D.26028 = assembly->image;
      D.26029 = (int) ignoreCase;
      type = mono_reflection_get_type (D.26028, &info, D.26029, &type_resolve);
      <D.26040>:
      <D.26037>:
      <D.26035>:
      mono_reflection_free_type_info (&info);
      monoeg_g_free (temp_str);
      if (type == 0B) goto <D.26041>; else goto <D.26042>;
      <D.26041>:
      D.26013 = 0B;
      return D.26013;
      <D.26042>:
      D.26043 = mono_domain_get ();
      D.26013 = mono_type_get_object (D.26043, type);
      return D.26013;
    }
  finally
    {
      info = {CLOBBER};
      type_resolve = {CLOBBER};
    }
}


get_caller_no_reflection (struct MonoMethod * m, gint32 no, gint32 ilo, gboolean managed, void * data)
{
  gboolean D.26048;
  long unsigned int D.26049;
  long unsigned int D.26050;
  struct MonoClass * D.26053;
  struct MonoImage * D.26054;
  struct MonoImage * D.26055;
  const char * D.26058;
  int D.26059;
  struct MonoMethod * D.26062;
  struct MonoMethod * * dest;

  dest = data;
  if (managed == 0) goto <D.26046>; else goto <D.26047>;
  <D.26046>:
  D.26048 = 0;
  return D.26048;
  <D.26047>:
  D.26049 = BIT_FIELD_REF <*m, 64, 256>;
  D.26050 = D.26049 & 4467570830351532032;
  if (D.26050 != 0) goto <D.26051>; else goto <D.26052>;
  <D.26051>:
  D.26048 = 0;
  return D.26048;
  <D.26052>:
  D.26053 = m->klass;
  D.26054 = D.26053->image;
  D.26055 = mono_defaults.corlib;
  if (D.26054 == D.26055) goto <D.26056>; else goto <D.26057>;
  <D.26056>:
  D.26053 = m->klass;
  D.26058 = D.26053->name_space;
  D.26059 = strcmp (D.26058, "System.Reflection");
  if (D.26059 == 0) goto <D.26060>; else goto <D.26061>;
  <D.26060>:
  D.26048 = 0;
  return D.26048;
  <D.26061>:
  <D.26057>:
  D.26062 = *dest;
  if (D.26062 == m) goto <D.26063>; else goto <D.26064>;
  <D.26063>:
  *dest = 0B;
  D.26048 = 0;
  return D.26048;
  <D.26064>:
  D.26062 = *dest;
  if (D.26062 == 0B) goto <D.26065>; else goto <D.26066>;
  <D.26065>:
  *dest = m;
  D.26048 = 1;
  return D.26048;
  <D.26066>:
  D.26048 = 0;
  return D.26048;
}


ves_icall_type_from_handle (struct MonoType * handle)
{
  struct MonoReflectionType * D.26068;
  struct MonoDomain * domain;

  domain = mono_domain_get ();
  D.26068 = mono_type_get_object (domain, handle);
  return D.26068;
}


ves_icall_Type_get_IsGenericTypeDefinition (struct MonoReflectionType * type)
{
  struct MonoVTable * D.26074;
  struct MonoClass * D.26075;
  struct MonoImage * D.26076;
  struct MonoImage * D.26077;
  struct MonoType * D.26079;
  gboolean D.26080;
  long unsigned int D.26081;
  long unsigned int D.26082;
  struct MonoGenericContainer * D.26085;
  _Bool D.26086;
  struct MonoClass * klass;

  if (type != 0B) goto <D.26072>; else goto <D.26073>;
  <D.26072>:
  D.26074 = MEM[(struct MonoObject *)type].vtable;
  D.26075 = D.26074->klass;
  D.26076 = D.26075->image;
  D.26077 = mono_defaults.corlib;
  if (D.26076 != D.26077) goto <D.26070>; else goto <D.26078>;
  <D.26078>:
  D.26079 = type->type;
  if (D.26079 == 0B) goto <D.26070>; else goto <D.26071>;
  <D.26070>:
  D.26080 = 0;
  return D.26080;
  <D.26071>:
  <D.26073>:
  D.26079 = type->type;
  D.26081 = BIT_FIELD_REF <*D.26079, 64, 64>;
  D.26082 = D.26081 & 8589934592;
  if (D.26082 != 0) goto <D.26083>; else goto <D.26084>;
  <D.26083>:
  D.26080 = 0;
  return D.26080;
  <D.26084>:
  D.26079 = type->type;
  klass = mono_class_from_mono_type (D.26079);
  D.26085 = klass->generic_container;
  D.26086 = D.26085 != 0B;
  D.26080 = (gboolean) D.26086;
  return D.26080;
}


ves_icall_Type_get_IsGenericType (struct MonoReflectionType * type)
{
  struct MonoVTable * D.26092;
  struct MonoClass * D.26093;
  struct MonoImage * D.26094;
  struct MonoImage * D.26095;
  struct MonoType * D.26097;
  gboolean D.26098;
  long unsigned int D.26099;
  long unsigned int D.26100;
  int iftmp.29;
  struct MonoGenericClass * D.26107;
  struct MonoGenericContainer * D.26109;
  struct MonoClass * klass;

  if (type != 0B) goto <D.26090>; else goto <D.26091>;
  <D.26090>:
  D.26092 = MEM[(struct MonoObject *)type].vtable;
  D.26093 = D.26092->klass;
  D.26094 = D.26093->image;
  D.26095 = mono_defaults.corlib;
  if (D.26094 != D.26095) goto <D.26088>; else goto <D.26096>;
  <D.26096>:
  D.26097 = type->type;
  if (D.26097 == 0B) goto <D.26088>; else goto <D.26089>;
  <D.26088>:
  D.26098 = 0;
  return D.26098;
  <D.26089>:
  <D.26091>:
  D.26097 = type->type;
  D.26099 = BIT_FIELD_REF <*D.26097, 64, 64>;
  D.26100 = D.26099 & 8589934592;
  if (D.26100 != 0) goto <D.26101>; else goto <D.26102>;
  <D.26101>:
  D.26098 = 0;
  return D.26098;
  <D.26102>:
  D.26097 = type->type;
  klass = mono_class_from_mono_type (D.26097);
  D.26107 = klass->generic_class;
  if (D.26107 != 0B) goto <D.26104>; else goto <D.26108>;
  <D.26108>:
  D.26109 = klass->generic_container;
  if (D.26109 != 0B) goto <D.26104>; else goto <D.26105>;
  <D.26104>:
  iftmp.29 = 1;
  goto <D.26106>;
  <D.26105>:
  iftmp.29 = 0;
  <D.26106>:
  D.26098 = iftmp.29;
  return D.26098;
}


ves_icall_Type_get_IsGenericInstance (struct MonoReflectionType * type)
{
  struct MonoType * D.26111;
  long unsigned int D.26112;
  long unsigned int D.26113;
  gboolean D.26116;
  struct MonoGenericClass * D.26117;
  _Bool D.26118;
  struct MonoClass * klass;

  D.26111 = type->type;
  D.26112 = BIT_FIELD_REF <*D.26111, 64, 64>;
  D.26113 = D.26112 & 8589934592;
  if (D.26113 != 0) goto <D.26114>; else goto <D.26115>;
  <D.26114>:
  D.26116 = 0;
  return D.26116;
  <D.26115>:
  D.26111 = type->type;
  klass = mono_class_from_mono_type (D.26111);
  D.26117 = klass->generic_class;
  D.26118 = D.26117 != 0B;
  D.26116 = (gboolean) D.26118;
  return D.26116;
}


ves_icall_Type_MakePointerType (struct MonoReflectionType * type)
{
  struct MonoType * D.26120;
  struct MonoReflectionType * D.26121;
  struct MonoVTable * D.26122;
  struct MonoDomain * D.26123;
  struct MonoType * D.26124;
  struct MonoClass * klass;
  struct MonoClass * pklass;

  D.26120 = type->type;
  klass = mono_class_from_mono_type (D.26120);
  mono_class_init_or_throw (klass);
  check_for_invalid_type (klass);
  D.26120 = type->type;
  pklass = mono_ptr_class_get (D.26120);
  D.26122 = MEM[(struct MonoObject *)type].vtable;
  D.26123 = D.26122->domain;
  D.26124 = &pklass->byval_arg;
  D.26121 = mono_type_get_object (D.26123, D.26124);
  return D.26121;
}


ves_icall_Type_MakeGenericType (struct MonoReflectionType * type, struct MonoArray * type_array)
{
  int iftmp.30;
  struct MonoVTable * D.26131;
  struct MonoClass * D.26132;
  struct MonoImage * D.26133;
  struct MonoImage * D.26134;
  struct MonoType * D.26136;
  _Bool D.26137;
  long int D.26138;
  long int D.26139;
  struct MonoClass * D.26142;
  long unsigned int D.26143;
  long unsigned int D.26144;
  long unsigned int D.26145;
  long unsigned int D.26146;
  char * D.26147;
  long unsigned int D.26148;
  long unsigned int D.26149;
  struct MonoType * * D.26150;
  struct MonoType * D.26151;
  struct MonoReflectionType * D.26154;
  struct MonoGenericClass * D.26155;
  int D.26158;
  struct MonoException * D.26161;
  struct MonoDomain * D.26162;
  struct MonoClass * class;
  struct MonoType * geninst;
  struct MonoType * * types;
  int i;
  int count;

  if (type != 0B) goto <D.26130>; else goto <D.26127>;
  <D.26130>:
  D.26131 = MEM[(struct MonoObject *)type].vtable;
  D.26132 = D.26131->klass;
  D.26133 = D.26132->image;
  D.26134 = mono_defaults.corlib;
  if (D.26133 != D.26134) goto <D.26128>; else goto <D.26135>;
  <D.26135>:
  D.26136 = type->type;
  if (D.26136 == 0B) goto <D.26128>; else goto <D.26127>;
  <D.26128>:
  iftmp.30 = 1;
  goto <D.26129>;
  <D.26127>:
  iftmp.30 = 0;
  <D.26129>:
  D.26137 = iftmp.30 != 0;
  D.26138 = (long int) D.26137;
  D.26139 = __builtin_expect (D.26138, 0);
  if (D.26139 != 0) goto <D.26140>; else goto <D.26141>;
  <D.26140>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 2404, "IS_MONOTYPE (type)");
  <D.26141>:
  D.26136 = type->type;
  D.26142 = mono_class_from_mono_type (D.26136);
  mono_class_init_or_throw (D.26142);
  D.26143 = mono_array_length (type_array);
  count = (int) D.26143;
  D.26144 = (long unsigned int) count;
  D.26145 = D.26144 * 8;
  types = monoeg_malloc0 (D.26145);
  i = 0;
  goto <D.21822>;
  <D.21821>:
  {
    struct MonoReflectionType * t;

    D.26146 = (long unsigned int) i;
    D.26147 = mono_array_addr_with_size (type_array, 8, D.26146);
    t = MEM[(void * *)D.26147];
    D.26148 = (long unsigned int) i;
    D.26149 = D.26148 * 8;
    D.26150 = types + D.26149;
    D.26151 = t->type;
    *D.26150 = D.26151;
  }
  i = i + 1;
  <D.21822>:
  if (i < count) goto <D.21821>; else goto <D.21823>;
  <D.21823>:
  geninst = mono_reflection_bind_generic_parameters (type, count, types);
  monoeg_g_free (types);
  if (geninst == 0B) goto <D.26152>; else goto <D.26153>;
  <D.26152>:
  D.26154 = 0B;
  return D.26154;
  <D.26153>:
  class = mono_class_from_mono_type (geninst);
  D.26155 = class->generic_class;
  if (D.26155 != 0B) goto <D.26156>; else goto <D.26157>;
  <D.26156>:
  D.26158 = mono_verifier_class_is_valid_generic_instantiation (class);
  if (D.26158 == 0) goto <D.26159>; else goto <D.26160>;
  <D.26159>:
  D.26161 = mono_get_exception_argument ("typeArguments", "Invalid generic arguments");
  mono_raise_exception (D.26161);
  <D.26160>:
  <D.26157>:
  D.26131 = MEM[(struct MonoObject *)type].vtable;
  D.26162 = D.26131->domain;
  D.26154 = mono_type_get_object (D.26162, geninst);
  return D.26154;
}


ves_icall_type_IsInstanceOfType (struct MonoReflectionType * type, struct MonoObject * obj)
{
  struct MonoType * D.26164;
  guint32 D.26165;
  struct MonoObject * D.26166;
  _Bool D.26167;
  struct MonoClass * klass;

  D.26164 = type->type;
  klass = mono_class_from_mono_type (D.26164);
  mono_class_init_or_throw (klass);
  D.26166 = mono_object_isinst (obj, klass);
  D.26167 = D.26166 != 0B;
  D.26165 = (guint32) D.26167;
  return D.26165;
}


ves_icall_Type_IsArrayImpl (struct MonoReflectionType * t)
{
  int iftmp.31;
  long unsigned int D.26173;
  long unsigned int D.26174;
  unsigned char D.26176;
  MonoBoolean D.26178;
  struct MonoType * type;
  MonoBoolean res;

  type = t->type;
  D.26173 = BIT_FIELD_REF <*type, 64, 64>;
  D.26174 = D.26173 & 8589934592;
  if (D.26174 == 0) goto <D.26175>; else goto <D.26170>;
  <D.26175>:
  D.26176 = type->type;
  if (D.26176 == 20) goto <D.26171>; else goto <D.26177>;
  <D.26177>:
  D.26176 = type->type;
  if (D.26176 == 29) goto <D.26171>; else goto <D.26170>;
  <D.26171>:
  iftmp.31 = 1;
  goto <D.26172>;
  <D.26170>:
  iftmp.31 = 0;
  <D.26172>:
  res = (MonoBoolean) iftmp.31;
  D.26178 = res;
  return D.26178;
}


ves_icall_type_GetTypeCodeInternal (struct MonoReflectionType * type)
{
  struct MonoType * D.26180;
  unsigned char D.26181;
  long unsigned int D.26182;
  long unsigned int D.26183;
  guint32 D.26186;
  long unsigned int D.26187;
  long unsigned int D.26188;
  struct MonoType * D.26191;
  unsigned char D.26192;
  struct MonoImage * D.26193;
  int D.26194;
  const char * D.26197;
  int D.26198;
  const char * D.26201;
  int D.26202;
  int D.26205;
  struct MonoImage * D.26208;
  struct MonoImage * D.26209;
  const char * D.26212;
  int D.26213;
  const char * D.26216;
  int D.26217;
  int t;
  void handle_enum = <<< error >>>;

  D.26180 = type->type;
  D.26181 = D.26180->type;
  t = (int) D.26181;
  D.26180 = type->type;
  D.26182 = BIT_FIELD_REF <*D.26180, 64, 64>;
  D.26183 = D.26182 & 8589934592;
  if (D.26183 != 0) goto <D.26184>; else goto <D.26185>;
  <D.26184>:
  D.26186 = 1;
  return D.26186;
  <D.26185>:
  handle_enum:
  switch (t) <default: <D.21447>, case 1: <D.21419>, case 2: <D.21420>, case 3: <D.21425>, case 4: <D.21422>, case 5: <D.21421>, case 6: <D.21424>, case 7: <D.21423>, case 8: <D.21430>, case 9: <D.21429>, case 10: <D.21432>, case 11: <D.21431>, case 12: <D.21433>, case 13: <D.21434>, case 14: <D.21437>, case 15: <D.21426>, case 17: <D.21435>, case 18: <D.21444>, case 19: <D.21441>, case 20: <D.21439>, case 21: <D.21446>, case 22: <D.21443>, case 24: <D.21428>, case 25: <D.21427>, case 28: <D.21440>, case 29: <D.21438>, case 30: <D.21442>>
  <D.21419>:
  D.26186 = 1;
  return D.26186;
  <D.21420>:
  D.26186 = 3;
  return D.26186;
  <D.21421>:
  D.26186 = 6;
  return D.26186;
  <D.21422>:
  D.26186 = 5;
  return D.26186;
  <D.21423>:
  D.26186 = 8;
  return D.26186;
  <D.21424>:
  D.26186 = 7;
  return D.26186;
  <D.21425>:
  D.26186 = 4;
  return D.26186;
  <D.21426>:
  <D.21427>:
  <D.21428>:
  D.26186 = 1;
  return D.26186;
  <D.21429>:
  D.26186 = 10;
  return D.26186;
  <D.21430>:
  D.26186 = 9;
  return D.26186;
  <D.21431>:
  D.26186 = 12;
  return D.26186;
  <D.21432>:
  D.26186 = 11;
  return D.26186;
  <D.21433>:
  D.26186 = 13;
  return D.26186;
  <D.21434>:
  D.26186 = 14;
  return D.26186;
  <D.21435>:
  {
    struct MonoClass * klass;

    D.26180 = type->type;
    klass = D.26180->data.klass;
    D.26187 = BIT_FIELD_REF <*klass, 64, 256>;
    D.26188 = D.26187 & 576460752303423488;
    if (D.26188 != 0) goto <D.26189>; else goto <D.26190>;
    <D.26189>:
    D.26191 = mono_class_enum_basetype (klass);
    D.26192 = D.26191->type;
    t = (int) D.26192;
    goto handle_enum;
    <D.26190>:
    D.26193 = klass->image;
    D.26194 = mono_is_corlib_image (D.26193);
    if (D.26194 != 0) goto <D.26195>; else goto <D.26196>;
    <D.26195>:
    D.26197 = klass->name_space;
    D.26198 = strcmp (D.26197, "System");
    if (D.26198 == 0) goto <D.26199>; else goto <D.26200>;
    <D.26199>:
    D.26201 = klass->name;
    D.26202 = strcmp (D.26201, "Decimal");
    if (D.26202 == 0) goto <D.26203>; else goto <D.26204>;
    <D.26203>:
    D.26186 = 15;
    return D.26186;
    <D.26204>:
    D.26201 = klass->name;
    D.26205 = strcmp (D.26201, "DateTime");
    if (D.26205 == 0) goto <D.26206>; else goto <D.26207>;
    <D.26206>:
    D.26186 = 16;
    return D.26186;
    <D.26207>:
    <D.26200>:
    <D.26196>:
    D.26186 = 1;
    return D.26186;
  }
  <D.21437>:
  D.26186 = 18;
  return D.26186;
  <D.21438>:
  <D.21439>:
  <D.21440>:
  <D.21441>:
  <D.21442>:
  <D.21443>:
  D.26186 = 1;
  return D.26186;
  <D.21444>:
  {
    struct MonoClass * klass;

    D.26180 = type->type;
    klass = D.26180->data.klass;
    D.26208 = klass->image;
    D.26209 = mono_defaults.corlib;
    if (D.26208 == D.26209) goto <D.26210>; else goto <D.26211>;
    <D.26210>:
    D.26212 = klass->name_space;
    D.26213 = strcmp (D.26212, "System");
    if (D.26213 == 0) goto <D.26214>; else goto <D.26215>;
    <D.26214>:
    D.26216 = klass->name;
    D.26217 = strcmp (D.26216, "DBNull");
    if (D.26217 == 0) goto <D.26218>; else goto <D.26219>;
    <D.26218>:
    D.26186 = 2;
    return D.26186;
    <D.26219>:
    <D.26215>:
    <D.26211>:
  }
  D.26186 = 1;
  return D.26186;
  <D.21446>:
  D.26186 = 1;
  return D.26186;
  <D.21447>:
  monoeg_g_log (0B, 4, "type 0x%02x not handled in GetTypeCode()", t);
  <D.21448>:
  goto <D.21448>;
  D.26186 = 0;
  return D.26186;
}


ves_icall_Type_GetPacking (struct MonoReflectionType * type, guint32 * packing, guint32 * size)
{
  struct MonoType * D.26221;
  struct MonoImage * D.26222;
  long unsigned int D.26223;
  long unsigned int D.26224;
  int D.26227;
  unsigned int D.26228;
  int D.26229;
  unsigned int D.26230;
  unsigned int D.26232;
  struct MonoClass * klass;

  D.26221 = type->type;
  klass = mono_class_from_mono_type (D.26221);
  mono_class_init_or_throw (klass);
  D.26222 = klass->image;
  D.26223 = BIT_FIELD_REF <*D.26222, 64, 192>;
  D.26224 = D.26223 & 268435456;
  if (D.26224 != 0) goto <D.26225>; else goto <D.26226>;
  <D.26225>:
  {
    struct MonoReflectionTypeBuilder * tb;

    tb = type;
    D.26227 = tb->packing_size;
    D.26228 = (unsigned int) D.26227;
    *packing = D.26228;
    D.26229 = tb->class_size;
    D.26230 = (unsigned int) D.26229;
    *size = D.26230;
  }
  goto <D.26231>;
  <D.26226>:
  D.26222 = klass->image;
  D.26232 = klass->type_token;
  mono_metadata_packing_from_typedef (D.26222, D.26232, packing, size);
  <D.26231>:
}


ves_icall_Type_GetInterfaceMapData (struct MonoReflectionType * type, struct MonoReflectionType * iface, struct MonoArray * * targets, struct MonoArray * * methods)
{
  struct MonoType * D.26233;
  struct MonoType * D.26234;
  struct MonoVTable * D.26237;
  struct MonoClass * D.26238;
  long unsigned int D.26239;
  struct MonoArray * D.26240;
  struct MonoArray * D.26241;
  struct MonoArray * D.26242;
  long unsigned int D.26243;
  struct MonoMethod * * D.26244;
  int D.26245;
  long unsigned int D.26246;
  long unsigned int D.26247;
  struct MonoMethod * * D.26248;
  struct MonoMethod * D.26249;
  struct MonoArray * D.26250;
  gboolean variance_used;
  struct MonoClass * class;
  struct MonoClass * iclass;
  struct MonoReflectionMethod * member;
  struct MonoMethod * method;
  void * iter;
  int i;
  int len;
  int ioffset;
  struct MonoDomain * domain;

  try
    {
      D.26233 = type->type;
      class = mono_class_from_mono_type (D.26233);
      D.26234 = iface->type;
      iclass = mono_class_from_mono_type (D.26234);
      i = 0;
      mono_class_init_or_throw (class);
      mono_class_init_or_throw (iclass);
      mono_class_setup_vtable (class);
      ioffset = mono_class_interface_offset_with_variance (class, iclass, &variance_used);
      if (ioffset == -1) goto <D.26235>; else goto <D.26236>;
      <D.26235>:
      return;
      <D.26236>:
      len = mono_class_num_methods (iclass);
      D.26237 = MEM[(struct MonoObject *)type].vtable;
      domain = D.26237->domain;
      D.26238 = mono_defaults.method_info_class;
      D.26239 = (long unsigned int) len;
      D.26240 = mono_array_new (domain, D.26238, D.26239);
      mono_gc_wbarrier_generic_store (targets, D.26240);
      D.26238 = mono_defaults.method_info_class;
      D.26239 = (long unsigned int) len;
      D.26241 = mono_array_new (domain, D.26238, D.26239);
      mono_gc_wbarrier_generic_store (methods, D.26241);
      iter = 0B;
      goto <D.21717>;
      <D.21716>:
      member = mono_method_get_object (domain, method, iclass);
      {
        void * * __p;

        D.26242 = *methods;
        D.26243 = (long unsigned int) i;
        __p = mono_array_addr_with_size (D.26242, 8, D.26243);
        D.26242 = *methods;
        mono_gc_wbarrier_set_arrayref (D.26242, __p, member);
      }
      D.26244 = class->vtable;
      D.26245 = i + ioffset;
      D.26246 = (long unsigned int) D.26245;
      D.26247 = D.26246 * 8;
      D.26248 = D.26244 + D.26247;
      D.26249 = *D.26248;
      member = mono_method_get_object (domain, D.26249, class);
      {
        void * * __p;

        D.26250 = *targets;
        D.26243 = (long unsigned int) i;
        __p = mono_array_addr_with_size (D.26250, 8, D.26243);
        D.26250 = *targets;
        mono_gc_wbarrier_set_arrayref (D.26250, __p, member);
      }
      i = i + 1;
      <D.21717>:
      method = mono_class_get_methods (iclass, &iter);
      if (method != 0B) goto <D.21716>; else goto <D.21718>;
      <D.21718>:
    }
  finally
    {
      variance_used = {CLOBBER};
      iter = {CLOBBER};
    }
}


ves_icall_Type_GetGenericTypeDefinition_impl (struct MonoReflectionType * type)
{
  struct MonoType * D.26254;
  long unsigned int D.26255;
  long unsigned int D.26256;
  struct MonoReflectionType * D.26259;
  struct MonoGenericContainer * D.26260;
  struct MonoGenericClass * D.26263;
  long unsigned int D.26267;
  long unsigned int D.26268;
  struct MonoVTable * D.26271;
  struct MonoDomain * D.26272;
  struct MonoType * D.26273;
  struct MonoClass * klass;

  D.26254 = type->type;
  D.26255 = BIT_FIELD_REF <*D.26254, 64, 64>;
  D.26256 = D.26255 & 8589934592;
  if (D.26256 != 0) goto <D.26257>; else goto <D.26258>;
  <D.26257>:
  D.26259 = 0B;
  return D.26259;
  <D.26258>:
  D.26254 = type->type;
  klass = mono_class_from_mono_type (D.26254);
  D.26260 = klass->generic_container;
  if (D.26260 != 0B) goto <D.26261>; else goto <D.26262>;
  <D.26261>:
  D.26259 = type;
  return D.26259;
  <D.26262>:
  D.26263 = klass->generic_class;
  if (D.26263 != 0B) goto <D.26264>; else goto <D.26265>;
  <D.26264>:
  {
    struct MonoClass * generic_class;
    void * tb;

    D.26263 = klass->generic_class;
    generic_class = D.26263->container_class;
    tb = mono_class_get_ref_info (generic_class);
    D.26267 = BIT_FIELD_REF <*generic_class, 64, 256>;
    D.26268 = D.26267 & 72057594037927936;
    if (D.26268 != 0) goto <D.26269>; else goto <D.26266>;
    <D.26269>:
    if (tb != 0B) goto <D.26270>; else goto <D.26266>;
    <D.26270>:
    D.26259 = tb;
    return D.26259;
    <D.26266>:
    D.26271 = MEM[(struct MonoObject *)type].vtable;
    D.26272 = D.26271->domain;
    D.26273 = &generic_class->byval_arg;
    D.26259 = mono_type_get_object (D.26272, D.26273);
    return D.26259;
  }
  <D.26265>:
  D.26259 = 0B;
  return D.26259;
}


ves_icall_Type_GetGenericParameterPosition (struct MonoReflectionType * type)
{
  struct MonoVTable * D.26279;
  struct MonoClass * D.26280;
  struct MonoImage * D.26281;
  struct MonoImage * D.26282;
  struct MonoType * D.26284;
  gint32 D.26285;
  unsigned char D.26286;
  struct MonoGenericParam * D.26289;
  short unsigned int D.26290;

  if (type != 0B) goto <D.26277>; else goto <D.26278>;
  <D.26277>:
  D.26279 = MEM[(struct MonoObject *)type].vtable;
  D.26280 = D.26279->klass;
  D.26281 = D.26280->image;
  D.26282 = mono_defaults.corlib;
  if (D.26281 != D.26282) goto <D.26275>; else goto <D.26283>;
  <D.26283>:
  D.26284 = type->type;
  if (D.26284 == 0B) goto <D.26275>; else goto <D.26276>;
  <D.26275>:
  D.26285 = -1;
  return D.26285;
  <D.26276>:
  <D.26278>:
  D.26284 = type->type;
  D.26286 = is_generic_parameter (D.26284);
  if (D.26286 != 0) goto <D.26287>; else goto <D.26288>;
  <D.26287>:
  D.26284 = type->type;
  D.26289 = D.26284->data.generic_param;
  D.26290 = D.26289->num;
  D.26285 = (gint32) D.26290;
  return D.26285;
  <D.26288>:
  D.26285 = -1;
  return D.26285;
}


ves_icall_Type_GetGenericParameterConstraints (struct MonoReflectionType * type)
{
  int iftmp.32;
  struct MonoVTable * D.26297;
  struct MonoClass * D.26298;
  struct MonoImage * D.26299;
  struct MonoImage * D.26300;
  struct MonoType * D.26302;
  _Bool D.26303;
  long int D.26304;
  long int D.26305;
  struct MonoGenericParamInfo * iftmp.33;
  struct MonoGenericParam * D.26309;
  struct MonoGenericContainer * D.26310;
  struct MonoClass * D.26315;
  struct MonoClass * D.26316;
  long unsigned int D.26317;
  long unsigned int D.26318;
  struct MonoClass * * D.26319;
  long unsigned int D.26320;
  long unsigned int D.26321;
  struct MonoClass * * D.26322;
  struct MonoClass * D.26323;
  struct MonoType * D.26324;
  struct MonoReflectionType * D.26325;
  struct MonoArray * D.26326;
  struct MonoGenericParamInfo * param_info;
  struct MonoDomain * domain;
  struct MonoClass * * ptr;
  struct MonoArray * res;
  int i;
  int count;

  if (type != 0B) goto <D.26296>; else goto <D.26293>;
  <D.26296>:
  D.26297 = MEM[(struct MonoObject *)type].vtable;
  D.26298 = D.26297->klass;
  D.26299 = D.26298->image;
  D.26300 = mono_defaults.corlib;
  if (D.26299 != D.26300) goto <D.26294>; else goto <D.26301>;
  <D.26301>:
  D.26302 = type->type;
  if (D.26302 == 0B) goto <D.26294>; else goto <D.26293>;
  <D.26294>:
  iftmp.32 = 1;
  goto <D.26295>;
  <D.26293>:
  iftmp.32 = 0;
  <D.26295>:
  D.26303 = iftmp.32 != 0;
  D.26304 = (long int) D.26303;
  D.26305 = __builtin_expect (D.26304, 0);
  if (D.26305 != 0) goto <D.26306>; else goto <D.26307>;
  <D.26306>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 2493, "IS_MONOTYPE (type)");
  <D.26307>:
  D.26297 = MEM[(struct MonoObject *)type].vtable;
  domain = D.26297->domain;
  D.26302 = type->type;
  D.26309 = D.26302->data.generic_param;
  D.26310 = D.26309->owner;
  if (D.26310 != 0B) goto <D.26311>; else goto <D.26312>;
  <D.26311>:
  D.26302 = type->type;
  D.26309 = D.26302->data.generic_param;
  iftmp.33 = &MEM[(struct MonoGenericParamFull *)D.26309].info;
  goto <D.26313>;
  <D.26312>:
  iftmp.33 = 0B;
  <D.26313>:
  param_info = iftmp.33;
  count = 0;
  ptr = param_info->constraints;
  goto <D.21848>;
  <D.21847>:
  ptr = ptr + 8;
  count = count + 1;
  <D.21848>:
  if (ptr != 0B) goto <D.26314>; else goto <D.21849>;
  <D.26314>:
  D.26315 = *ptr;
  if (D.26315 != 0B) goto <D.21847>; else goto <D.21849>;
  <D.21849>:
  D.26316 = mono_defaults.monotype_class;
  D.26317 = (long unsigned int) count;
  res = mono_array_new (domain, D.26316, D.26317);
  i = 0;
  goto <D.21852>;
  <D.21851>:
  {
    void * * __p;

    D.26318 = (long unsigned int) i;
    __p = mono_array_addr_with_size (res, 8, D.26318);
    D.26319 = param_info->constraints;
    D.26320 = (long unsigned int) i;
    D.26321 = D.26320 * 8;
    D.26322 = D.26319 + D.26321;
    D.26323 = *D.26322;
    D.26324 = &D.26323->byval_arg;
    D.26325 = mono_type_get_object (domain, D.26324);
    mono_gc_wbarrier_set_arrayref (res, __p, D.26325);
  }
  i = i + 1;
  <D.21852>:
  if (i < count) goto <D.21851>; else goto <D.21853>;
  <D.21853>:
  D.26326 = res;
  return D.26326;
}


ves_icall_Type_GetGenericParameterAttributes (struct MonoReflectionType * type)
{
  int iftmp.34;
  struct MonoVTable * D.26333;
  struct MonoClass * D.26334;
  struct MonoImage * D.26335;
  struct MonoImage * D.26336;
  struct MonoType * D.26338;
  _Bool D.26339;
  long int D.26340;
  long int D.26341;
  unsigned char D.26344;
  _Bool D.26345;
  long int D.26346;
  long int D.26347;
  GenericParameterAttributes D.26350;
  struct MonoGenericParamInfo * iftmp.35;
  struct MonoGenericParam * D.26352;
  struct MonoGenericContainer * D.26353;
  short unsigned int D.26357;

  if (type != 0B) goto <D.26332>; else goto <D.26329>;
  <D.26332>:
  D.26333 = MEM[(struct MonoObject *)type].vtable;
  D.26334 = D.26333->klass;
  D.26335 = D.26334->image;
  D.26336 = mono_defaults.corlib;
  if (D.26335 != D.26336) goto <D.26330>; else goto <D.26337>;
  <D.26337>:
  D.26338 = type->type;
  if (D.26338 == 0B) goto <D.26330>; else goto <D.26329>;
  <D.26330>:
  iftmp.34 = 1;
  goto <D.26331>;
  <D.26329>:
  iftmp.34 = 0;
  <D.26331>:
  D.26339 = iftmp.34 != 0;
  D.26340 = (long int) D.26339;
  D.26341 = __builtin_expect (D.26340, 0);
  if (D.26341 != 0) goto <D.26342>; else goto <D.26343>;
  <D.26342>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 2477, "IS_MONOTYPE (type)");
  <D.26343>:
  D.26338 = type->type;
  D.26344 = is_generic_parameter (D.26338);
  D.26345 = D.26344 == 0;
  D.26346 = (long int) D.26345;
  D.26347 = __builtin_expect (D.26346, 0);
  if (D.26347 != 0) goto <D.26348>; else goto <D.26349>;
  <D.26348>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 2478, "is_generic_parameter (type->type)");
  <D.26349>:
  D.26338 = type->type;
  D.26352 = D.26338->data.generic_param;
  D.26353 = D.26352->owner;
  if (D.26353 != 0B) goto <D.26354>; else goto <D.26355>;
  <D.26354>:
  D.26338 = type->type;
  D.26352 = D.26338->data.generic_param;
  iftmp.35 = &MEM[(struct MonoGenericParamFull *)D.26352].info;
  goto <D.26356>;
  <D.26355>:
  iftmp.35 = 0B;
  <D.26356>:
  D.26357 = iftmp.35->flags;
  D.26350 = (GenericParameterAttributes) D.26357;
  return D.26350;
}


ves_icall_System_Type_EqualsInternal (struct MonoReflectionType * type, struct MonoReflectionType * c)
{
  struct MonoType * D.26361;
  struct MonoType * D.26363;
  MonoBoolean D.26365;
  int D.26366;
  _Bool D.26367;

  if (c != 0B) goto <D.26360>; else goto <D.26359>;
  <D.26360>:
  D.26361 = type->type;
  if (D.26361 != 0B) goto <D.26362>; else goto <D.26359>;
  <D.26362>:
  D.26363 = c->type;
  if (D.26363 != 0B) goto <D.26364>; else goto <D.26359>;
  <D.26364>:
  D.26361 = type->type;
  D.26363 = c->type;
  D.26366 = mono_metadata_type_equal (D.26361, D.26363);
  D.26365 = (MonoBoolean) D.26366;
  return D.26365;
  <D.26359>:
  D.26367 = type == c;
  D.26365 = (MonoBoolean) D.26367;
  return D.26365;
}


ves_icall_System_Text_Encoding_InternalCodePage (gint32 * int_code_page)
{
  const char * cset.36;
  char D.26370;
  int D.26371;
  int D.26372;
  const short unsigned int * * D.26375;
  const short unsigned int * D.26376;
  long unsigned int D.26377;
  long unsigned int D.26378;
  const short unsigned int * D.26379;
  short unsigned int D.26380;
  int D.26381;
  int D.26382;
  int D.23228;
  int D.26387;
  const int iftmp.37;
  unsigned int __c.38;
  unsigned int D.26392;
  const __int32_t * * D.26395;
  const __int32_t * D.26396;
  long unsigned int D.26397;
  long unsigned int D.26398;
  const __int32_t * D.26399;
  long unsigned int D.26403;
  const __int32_t * D.26404;
  char D.26405;
  long int p.39;
  int D.26411;
  char * D.26414;
  int D.26417;
  int D.26418;
  struct MonoString * D.26422;
  struct MonoDomain * D.26423;
  const char * cset;
  const char * p;
  char * c;
  char * codepage;
  int code;
  int want_name;
  int i;

  try
    {
      codepage = 0B;
      want_name = *int_code_page;
      *int_code_page = -1;
      monoeg_g_get_charset (&cset);
      cset.36 = cset;
      codepage = __strdup (cset.36);
      c = codepage;
      c = codepage;
      goto <D.23230>;
      <D.23229>:
      D.26370 = *c;
      D.26371 = (int) D.26370;
      D.26372 = D.26371 & -128;
      if (D.26372 == 0) goto <D.26373>; else goto <D.26374>;
      <D.26373>:
      D.26375 = __ctype_b_loc ();
      D.26376 = *D.26375;
      D.26370 = *c;
      D.26377 = (long unsigned int) D.26370;
      D.26378 = D.26377 * 2;
      D.26379 = D.26376 + D.26378;
      D.26380 = *D.26379;
      D.26381 = (int) D.26380;
      D.26382 = D.26381 & 4;
      if (D.26382 != 0) goto <D.26383>; else goto <D.26384>;
      <D.26383>:
      {
        int __res;

        {
          if (0 != 0) goto <D.26385>; else goto <D.26386>;
          <D.26385>:
          D.26370 = *c;
          D.26371 = (int) D.26370;
          D.26387 = __builtin_constant_p (D.26371);
          if (D.26387 != 0) goto <D.26388>; else goto <D.26389>;
          <D.26388>:
          {
            int __c;

            D.26370 = *c;
            __c = (int) D.26370;
            __c.38 = (unsigned int) __c;
            D.26392 = __c.38 + 128;
            if (D.26392 <= 383) goto <D.26393>; else goto <D.26394>;
            <D.26393>:
            D.26395 = __ctype_tolower_loc ();
            D.26396 = *D.26395;
            D.26397 = (long unsigned int) __c;
            D.26398 = D.26397 * 4;
            D.26399 = D.26396 + D.26398;
            iftmp.37 = *D.26399;
            goto <D.26400>;
            <D.26394>:
            iftmp.37 = __c;
            <D.26400>:
            __res = iftmp.37;
          }
          goto <D.26401>;
          <D.26389>:
          D.26370 = *c;
          D.26371 = (int) D.26370;
          __res = tolower (D.26371);
          <D.26401>:
          goto <D.26402>;
          <D.26386>:
          D.26395 = __ctype_tolower_loc ();
          D.26396 = *D.26395;
          D.26370 = *c;
          D.26377 = (long unsigned int) D.26370;
          D.26403 = D.26377 * 4;
          D.26404 = D.26396 + D.26403;
          __res = *D.26404;
          <D.26402>:
        }
        D.23228 = __res;
      }
      D.26405 = (char) D.23228;
      *c = D.26405;
      <D.26384>:
      <D.26374>:
      D.26370 = *c;
      if (D.26370 == 45) goto <D.26406>; else goto <D.26407>;
      <D.26406>:
      *c = 95;
      <D.26407>:
      c = c + 1;
      <D.23230>:
      D.26370 = *c;
      if (D.26370 != 0) goto <D.23229>; else goto <D.23231>;
      <D.23231>:
      p = encodings[0];
      code = 0;
      i = 0;
      goto <D.23232>;
      <D.23234>:
      p.39 = (long int) p;
      if (p.39 <= 6) goto <D.26409>; else goto <D.26410>;
      <D.26409>:
      p.39 = (long int) p;
      code = (int) p.39;
      i = i + 1;
      p = encodings[i];
      // predicted unlikely by continue predictor.
      goto <D.23232>;
      <D.26410>:
      D.26411 = strcmp (p, codepage);
      if (D.26411 == 0) goto <D.26412>; else goto <D.26413>;
      <D.26412>:
      *int_code_page = code;
      goto <D.23233>;
      <D.26413>:
      i = i + 1;
      p = encodings[i];
      <D.23232>:
      if (p != 0B) goto <D.23234>; else goto <D.23233>;
      <D.23233>:
      D.26414 = strstr (codepage, "utf_8");
      if (D.26414 != 0B) goto <D.26415>; else goto <D.26416>;
      <D.26415>:
      D.26417 = *int_code_page;
      D.26418 = D.26417 | 268435456;
      *int_code_page = D.26418;
      <D.26416>:
      free (codepage);
      if (want_name != 0) goto <D.26420>; else goto <D.26419>;
      <D.26420>:
      D.26417 = *int_code_page;
      if (D.26417 == -1) goto <D.26421>; else goto <D.26419>;
      <D.26421>:
      D.26423 = mono_domain_get ();
      cset.36 = cset;
      D.26422 = mono_string_new (D.26423, cset.36);
      return D.26422;
      <D.26419>:
      D.26422 = 0B;
      return D.26422;
    }
  finally
    {
      cset = {CLOBBER};
    }
}


ves_icall_RuntimeMethod_GetFunctionPointer (struct MonoMethod * method)
{
  void * D.26426;

  D.26426 = mono_compile_method (method);
  return D.26426;
}


ves_icall_IsTransparentProxy (struct MonoObject * proxy)
{
  MonoBoolean D.26430;
  struct MonoVTable * D.26431;
  struct MonoClass * D.26432;
  struct MonoClass * D.26433;

  if (proxy == 0B) goto <D.26428>; else goto <D.26429>;
  <D.26428>:
  D.26430 = 0;
  return D.26430;
  <D.26429>:
  D.26431 = proxy->vtable;
  D.26432 = D.26431->klass;
  D.26433 = mono_defaults.transparent_proxy_class;
  if (D.26432 == D.26433) goto <D.26434>; else goto <D.26435>;
  <D.26434>:
  D.26430 = 1;
  return D.26430;
  <D.26435>:
  D.26430 = 0;
  return D.26430;
}


ves_icall_InternalExecute (struct MonoReflectionMethod * method, struct MonoObject * this, struct MonoArray * params, struct MonoArray * * outArgs)
{
  struct MonoVTable * D.26437;
  struct MonoClass * D.26438;
  struct MonoClass * D.26439;
  const char * D.26442;
  int D.26443;
  struct MonoVTable * D.26446;
  struct MonoClass * D.26447;
  struct MonoRealProxy * D.26450;
  _Bool D.26451;
  long int D.26452;
  long int D.26453;
  char * D.26456;
  struct MonoType * D.26459;
  long unsigned int D.26460;
  long unsigned int D.26461;
  int D.26464;
  sizetype D.26465;
  void * D.26466;
  void * * D.26468;
  struct MonoObject * D.26469;
  int D.26470;
  struct MonoRealProxy * D.26475;
  char * D.26478;
  struct MonoType * D.26481;
  char * D.26482;
  long unsigned int D.26483;
  long unsigned int D.26484;
  int D.26487;
  int D.26488;
  unsigned int D.26489;
  _Bool D.26490;
  long int D.26491;
  long int D.26492;
  int D.26495;
  sizetype D.26496;
  void * D.26497;
  void * D.26498;
  struct MonoType * D.26500;
  long unsigned int D.26501;
  long unsigned int D.26502;
  long unsigned int D.26505;
  long unsigned int D.26506;
  long unsigned int D.26507;
  struct MonoMethod * D.26508;
  const char * D.26509;
  int D.26510;
  struct MonoClass * D.26515;
  long unsigned int D.26516;
  long unsigned int D.26517;
  _Bool D.26518;
  long int D.26519;
  long int D.26520;
  char * D.26525;
  long unsigned int D.26526;
  long unsigned int D.26527;
  struct MonoDomain * domain;
  struct MonoMethod * m;
  struct MonoMethodSignature * sig;
  struct MonoArray * out_args;
  struct MonoObject * result;
  int i;
  int j;
  int outarg_count;

  D.26437 = MEM[(struct MonoObject *)method].vtable;
  domain = D.26437->domain;
  m = method->method;
  sig = mono_method_signature (m);
  outarg_count = 0;
  D.26438 = m->klass;
  D.26439 = mono_defaults.object_class;
  if (D.26438 == D.26439) goto <D.26440>; else goto <D.26441>;
  <D.26440>:
  D.26442 = m->name;
  D.26443 = strcmp (D.26442, "FieldGetter");
  if (D.26443 == 0) goto <D.26444>; else goto <D.26445>;
  <D.26444>:
  {
    struct MonoClass * k;
    struct MonoString * name;
    char * str;

    D.26446 = this->vtable;
    k = D.26446->klass;
    D.26447 = mono_defaults.transparent_proxy_class;
    if (D.26447 == k) goto <D.26448>; else goto <D.26449>;
    <D.26448>:
    {
      struct MonoTransparentProxy * tp;

      tp = this;
      D.26450 = tp->rp;
      this = D.26450->unwrapped_server;
      D.26451 = this == 0B;
      D.26452 = (long int) D.26451;
      D.26453 = __builtin_expect (D.26452, 0);
      if (D.26453 != 0) goto <D.26454>; else goto <D.26455>;
      <D.26454>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 2870, "this");
      <D.26455>:
      D.26446 = this->vtable;
      k = D.26446->klass;
    }
    <D.26449>:
    D.26456 = mono_array_addr_with_size (params, 8, 1);
    name = MEM[(struct MonoString * *)D.26456];
    str = mono_string_to_utf8 (name);
    <D.21971>:
    {
      struct MonoClassField * field;

      field = mono_class_get_field_from_name (k, str);
      if (field != 0B) goto <D.26457>; else goto <D.26458>;
      <D.26457>:
      {
        struct MonoClass * field_klass;

        D.26459 = field->type;
        field_klass = mono_class_from_mono_type (D.26459);
        D.26460 = BIT_FIELD_REF <*field_klass, 64, 256>;
        D.26461 = D.26460 & 1152921504606846976;
        if (D.26461 != 0) goto <D.26462>; else goto <D.26463>;
        <D.26462>:
        D.26464 = field->offset;
        D.26465 = (sizetype) D.26464;
        D.26466 = this + D.26465;
        result = mono_value_box (domain, field_klass, D.26466);
        goto <D.26467>;
        <D.26463>:
        D.26464 = field->offset;
        D.26465 = (sizetype) D.26464;
        D.26468 = this + D.26465;
        result = *D.26468;
        <D.26467>:
        D.26439 = mono_defaults.object_class;
        out_args = mono_array_new (domain, D.26439, 1);
        mono_gc_wbarrier_generic_store (outArgs, out_args);
        {
          void * * __p;

          __p = mono_array_addr_with_size (out_args, 8, 0);
          mono_gc_wbarrier_set_arrayref (out_args, __p, result);
        }
        monoeg_g_free (str);
        D.26469 = 0B;
        return D.26469;
      }
      <D.26458>:
      k = k->parent;
    }
    if (k != 0B) goto <D.21971>; else goto <D.21972>;
    <D.21972>:
    monoeg_g_free (str);
    monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "icall.c", 2896);
  }
  <D.26445>:
  D.26442 = m->name;
  D.26470 = strcmp (D.26442, "FieldSetter");
  if (D.26470 == 0) goto <D.26471>; else goto <D.26472>;
  <D.26471>:
  {
    struct MonoClass * k;
    struct MonoString * name;
    guint32 size;
    gint32 align;
    char * str;

    try
      {
        D.26446 = this->vtable;
        k = D.26446->klass;
        D.26447 = mono_defaults.transparent_proxy_class;
        if (D.26447 == k) goto <D.26473>; else goto <D.26474>;
        <D.26473>:
        {
          struct MonoTransparentProxy * tp;

          tp = this;
          D.26475 = tp->rp;
          this = D.26475->unwrapped_server;
          D.26451 = this == 0B;
          D.26452 = (long int) D.26451;
          D.26453 = __builtin_expect (D.26452, 0);
          if (D.26453 != 0) goto <D.26476>; else goto <D.26477>;
          <D.26476>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 2909, "this");
          <D.26477>:
          D.26446 = this->vtable;
          k = D.26446->klass;
        }
        <D.26474>:
        D.26478 = mono_array_addr_with_size (params, 8, 1);
        name = MEM[(struct MonoString * *)D.26478];
        str = mono_string_to_utf8 (name);
        <D.21982>:
        {
          struct MonoClassField * field;

          field = mono_class_get_field_from_name (k, str);
          if (field != 0B) goto <D.26479>; else goto <D.26480>;
          <D.26479>:
          {
            struct MonoClass * field_klass;
            struct MonoObject * val;

            D.26481 = field->type;
            field_klass = mono_class_from_mono_type (D.26481);
            D.26482 = mono_array_addr_with_size (params, 8, 2);
            val = MEM[(void * *)D.26482];
            D.26483 = BIT_FIELD_REF <*field_klass, 64, 256>;
            D.26484 = D.26483 & 1152921504606846976;
            if (D.26484 != 0) goto <D.26485>; else goto <D.26486>;
            <D.26485>:
            D.26481 = field->type;
            D.26487 = mono_type_size (D.26481, &align);
            size = (guint32) D.26487;
            D.26488 = mono_class_value_size (field_klass, 0B);
            D.26489 = (unsigned int) D.26488;
            D.26490 = D.26489 != size;
            D.26491 = (long int) D.26490;
            D.26492 = __builtin_expect (D.26491, 0);
            if (D.26492 != 0) goto <D.26493>; else goto <D.26494>;
            <D.26493>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 2924, "size == mono_class_value_size (field_klass, NULL)");
            <D.26494>:
            D.26495 = field->offset;
            D.26496 = (sizetype) D.26495;
            D.26497 = this + D.26496;
            D.26498 = val + 16;
            mono_gc_wbarrier_value_copy (D.26497, D.26498, 1, field_klass);
            goto <D.26499>;
            <D.26486>:
            D.26495 = field->offset;
            D.26496 = (sizetype) D.26495;
            D.26497 = this + D.26496;
            mono_gc_wbarrier_set_field (this, D.26497, val);
            <D.26499>:
            D.26439 = mono_defaults.object_class;
            out_args = mono_array_new (domain, D.26439, 0);
            mono_gc_wbarrier_generic_store (outArgs, out_args);
            monoeg_g_free (str);
            D.26469 = 0B;
            return D.26469;
          }
          <D.26480>:
          k = k->parent;
        }
        if (k != 0B) goto <D.21982>; else goto <D.21983>;
        <D.21983>:
        monoeg_g_free (str);
        monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "icall.c", 2941);
      }
    finally
      {
        align = {CLOBBER};
      }
  }
  <D.26472>:
  <D.26441>:
  i = 0;
  goto <D.21985>;
  <D.21984>:
  D.26500 = sig->params[i];
  D.26501 = BIT_FIELD_REF <*D.26500, 64, 64>;
  D.26502 = D.26501 & 8589934592;
  if (D.26502 != 0) goto <D.26503>; else goto <D.26504>;
  <D.26503>:
  outarg_count = outarg_count + 1;
  <D.26504>:
  i = i + 1;
  <D.21985>:
  D.26505 = (long unsigned int) i;
  D.26506 = mono_array_length (params);
  if (D.26505 < D.26506) goto <D.21984>; else goto <D.21986>;
  <D.21986>:
  D.26439 = mono_defaults.object_class;
  D.26507 = (long unsigned int) outarg_count;
  out_args = mono_array_new (domain, D.26439, D.26507);
  D.26508 = method->method;
  D.26509 = D.26508->name;
  D.26510 = strcmp (D.26509, ".ctor");
  if (D.26510 == 0) goto <D.26511>; else goto <D.26512>;
  <D.26511>:
  D.26451 = this == 0B;
  D.26452 = (long int) D.26451;
  D.26453 = __builtin_expect (D.26452, 0);
  if (D.26453 != 0) goto <D.26513>; else goto <D.26514>;
  <D.26513>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 2955, "this");
  <D.26514>:
  <D.26512>:
  D.26508 = method->method;
  D.26515 = D.26508->klass;
  D.26516 = BIT_FIELD_REF <*D.26515, 64, 256>;
  D.26517 = D.26516 & 1152921504606846976;
  D.26518 = D.26517 != 0;
  D.26519 = (long int) D.26518;
  D.26520 = __builtin_expect (D.26519, 0);
  if (D.26520 != 0) goto <D.26521>; else goto <D.26522>;
  <D.26521>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 2958, "!method->method->klass->valuetype");
  <D.26522>:
  D.26508 = method->method;
  result = mono_runtime_invoke_array (D.26508, this, params, 0B);
  i = 0;
  j = 0;
  goto <D.21990>;
  <D.21989>:
  D.26500 = sig->params[i];
  D.26501 = BIT_FIELD_REF <*D.26500, 64, 64>;
  D.26502 = D.26501 & 8589934592;
  if (D.26502 != 0) goto <D.26523>; else goto <D.26524>;
  <D.26523>:
  {
    void * arg;

    D.26505 = (long unsigned int) i;
    D.26525 = mono_array_addr_with_size (params, 8, D.26505);
    arg = MEM[(void * *)D.26525];
    {
      void * * __p;

      D.26526 = (long unsigned int) j;
      __p = mono_array_addr_with_size (out_args, 8, D.26526);
      mono_gc_wbarrier_set_arrayref (out_args, __p, arg);
    }
    j = j + 1;
  }
  <D.26524>:
  i = i + 1;
  <D.21990>:
  D.26505 = (long unsigned int) i;
  D.26527 = mono_array_length (params);
  if (D.26505 < D.26527) goto <D.21989>; else goto <D.21991>;
  <D.21991>:
  mono_gc_wbarrier_generic_store (outArgs, out_args);
  D.26469 = result;
  return D.26469;
}


ves_icall_Remoting_RemotingServices_GetVirtualMethod (struct MonoReflectionType * rtype, struct MonoReflectionMethod * rmethod)
{
  _Bool D.26530;
  long int D.26531;
  long int D.26532;
  _Bool D.26537;
  long int D.26538;
  long int D.26539;
  struct MonoType * D.26544;
  unsigned int D.26547;
  unsigned int D.26548;
  unsigned char D.26550;
  struct MonoReflectionMethod * D.26552;
  short unsigned int D.26553;
  int D.26554;
  int D.26555;
  unsigned int D.26558;
  unsigned int D.26559;
  struct MonoClass * D.26564;
  int D.26566;
  unsigned int D.26567;
  unsigned int D.26568;
  short int D.26573;
  int D.26574;
  int D.26575;
  long unsigned int D.26576;
  long unsigned int D.26577;
  struct MonoMethod * * D.26578;
  int D.26582;
  long unsigned int D.26587;
  long unsigned int D.26588;
  struct MonoMethod * * D.26589;
  struct MonoDomain * D.26592;
  struct MonoClass * klass;
  struct MonoMethod * method;
  struct MonoMethod * * vtable;
  struct MonoMethod * res;

  res = 0B;
  D.26530 = rtype == 0B;
  D.26531 = (long int) D.26530;
  D.26532 = __builtin_expect (D.26531, 0);
  if (D.26532 != 0) goto <D.26533>; else goto <D.26534>;
  <D.26533>:
  {
    struct MonoException * ex;

    if (rtype != 0B) goto <D.26535>; else goto <D.26536>;
    <D.26535>:
    <D.26536>:
    ex = mono_get_exception_argument_null ("rtype");
    mono_raise_exception (ex);
  }
  <D.26534>:
  D.26537 = rmethod == 0B;
  D.26538 = (long int) D.26537;
  D.26539 = __builtin_expect (D.26538, 0);
  if (D.26539 != 0) goto <D.26540>; else goto <D.26541>;
  <D.26540>:
  {
    struct MonoException * ex;

    if (rmethod != 0B) goto <D.26542>; else goto <D.26543>;
    <D.26542>:
    <D.26543>:
    ex = mono_get_exception_argument_null ("rmethod");
    mono_raise_exception (ex);
  }
  <D.26541>:
  method = rmethod->method;
  D.26544 = rtype->type;
  klass = mono_class_from_mono_type (D.26544);
  mono_class_init_or_throw (klass);
  D.26547 = klass->flags;
  D.26548 = D.26547 & 32;
  if (D.26548 != 0) goto <D.26545>; else goto <D.26549>;
  <D.26549>:
  D.26550 = klass->byval_arg.type;
  if (D.26550 == 19) goto <D.26545>; else goto <D.26551>;
  <D.26551>:
  D.26550 = klass->byval_arg.type;
  if (D.26550 == 30) goto <D.26545>; else goto <D.26546>;
  <D.26545>:
  D.26552 = 0B;
  return D.26552;
  <D.26546>:
  D.26553 = method->flags;
  D.26554 = (int) D.26553;
  D.26555 = D.26554 & 16;
  if (D.26555 != 0) goto <D.26556>; else goto <D.26557>;
  <D.26556>:
  D.26552 = 0B;
  return D.26552;
  <D.26557>:
  D.26553 = method->flags;
  D.26558 = (unsigned int) D.26553;
  D.26559 = D.26558 & 96;
  if (D.26559 != 64) goto <D.26560>; else goto <D.26561>;
  <D.26560>:
  D.26564 = method->klass;
  if (D.26564 == klass) goto <D.26562>; else goto <D.26565>;
  <D.26565>:
  D.26564 = method->klass;
  D.26566 = mono_class_is_subclass_of (klass, D.26564, 0);
  if (D.26566 != 0) goto <D.26562>; else goto <D.26563>;
  <D.26562>:
  D.26552 = rmethod;
  return D.26552;
  <D.26563>:
  D.26552 = 0B;
  return D.26552;
  <D.26561>:
  mono_class_setup_vtable (klass);
  vtable = klass->vtable;
  D.26564 = method->klass;
  D.26567 = D.26564->flags;
  D.26568 = D.26567 & 32;
  if (D.26568 != 0) goto <D.26569>; else goto <D.26570>;
  <D.26569>:
  {
    gboolean variance_used;
    int offs;

    try
      {
        variance_used = 0;
        D.26564 = method->klass;
        offs = mono_class_interface_offset_with_variance (klass, D.26564, &variance_used);
        if (offs >= 0) goto <D.26571>; else goto <D.26572>;
        <D.26571>:
        D.26573 = method->slot;
        D.26574 = (int) D.26573;
        D.26575 = D.26574 + offs;
        D.26576 = (long unsigned int) D.26575;
        D.26577 = D.26576 * 8;
        D.26578 = vtable + D.26577;
        res = *D.26578;
        <D.26572>:
      }
    finally
      {
        variance_used = {CLOBBER};
      }
  }
  goto <D.26579>;
  <D.26570>:
  D.26564 = method->klass;
  if (D.26564 != klass) goto <D.26580>; else goto <D.26581>;
  <D.26580>:
  D.26564 = method->klass;
  D.26582 = mono_class_is_subclass_of (klass, D.26564, 0);
  if (D.26582 == 0) goto <D.26583>; else goto <D.26584>;
  <D.26583>:
  D.26552 = 0B;
  return D.26552;
  <D.26584>:
  <D.26581>:
  D.26573 = method->slot;
  if (D.26573 != -1) goto <D.26585>; else goto <D.26586>;
  <D.26585>:
  D.26573 = method->slot;
  D.26587 = (long unsigned int) D.26573;
  D.26588 = D.26587 * 8;
  D.26589 = vtable + D.26588;
  res = *D.26589;
  <D.26586>:
  <D.26579>:
  if (res == 0B) goto <D.26590>; else goto <D.26591>;
  <D.26590>:
  D.26552 = 0B;
  return D.26552;
  <D.26591>:
  D.26592 = mono_domain_get ();
  D.26552 = mono_method_get_object (D.26592, res, 0B);
  return D.26552;
}


ves_icall_Remoting_RealProxy_GetTransparentProxy (struct MonoObject * this, struct MonoString * class_name)
{
  struct MonoVTable * D.26594;
  struct MonoClass * D.26595;
  struct MonoRealProxy * * D.26596;
  struct MonoReflectionType * D.26597;
  struct MonoClass * D.26598;
  struct MonoObject * D.26599;
  _Bool D.26600;
  unsigned char D.26601;
  struct MonoRemoteClass * D.26602;
  struct MonoRemoteClass * D.26603;
  void * D.26604;
  struct MonoObject * D.26605;
  struct MonoDomain * domain;
  struct MonoObject * res;
  struct MonoRealProxy * rp;
  struct MonoTransparentProxy * tp;
  struct MonoType * type;
  struct MonoClass * klass;

  D.26594 = this->vtable;
  domain = D.26594->domain;
  rp = this;
  D.26595 = mono_defaults.transparent_proxy_class;
  res = mono_object_new (domain, D.26595);
  tp = res;
  D.26596 = &tp->rp;
  mono_gc_wbarrier_set_field (tp, D.26596, rp);
  D.26597 = rp->class_to_proxy;
  type = D.26597->type;
  klass = mono_class_from_mono_type (type);
  D.26598 = mono_defaults.iremotingtypeinfo_class;
  D.26599 = mono_object_isinst (this, D.26598);
  D.26600 = D.26599 != 0B;
  D.26601 = (unsigned char) D.26600;
  tp->custom_type_info = D.26601;
  D.26602 = mono_remote_class (domain, class_name, klass);
  tp->remote_class = D.26602;
  D.26603 = tp->remote_class;
  D.26604 = mono_remote_class_vtable (domain, D.26603, rp);
  res->vtable = D.26604;
  D.26605 = res;
  return D.26605;
}


ves_icall_Remoting_RealProxy_InternalGetProxyType (struct MonoTransparentProxy * tp)
{
  struct MonoReflectionType * D.26607;
  struct MonoVTable * D.26608;
  struct MonoDomain * D.26609;
  struct MonoRemoteClass * D.26610;
  struct MonoClass * D.26611;
  struct MonoType * D.26612;

  D.26608 = MEM[(struct MonoObject *)tp].vtable;
  D.26609 = D.26608->domain;
  D.26610 = tp->remote_class;
  D.26611 = D.26610->proxy_class;
  D.26612 = &D.26611->byval_arg;
  D.26607 = mono_type_get_object (D.26609, D.26612);
  return D.26607;
}


ves_icall_MonoMethodMessage_InitMessage (struct MonoMethodMessage * this, struct MonoReflectionMethod * method, struct MonoArray * out_args)
{
  struct MonoVTable * D.26614;
  struct MonoDomain * D.26615;

  D.26614 = MEM[(struct MonoObject *)this].vtable;
  D.26615 = D.26614->domain;
  mono_message_init (D.26615, this, method, out_args);
}


ves_icall_System_Runtime_Activation_ActivationServices_EnableProxyActivation (struct MonoReflectionType * type, MonoBoolean enable)
{
  struct MonoType * D.26616;
  struct MonoDomain * D.26617;
  _Bool D.26618;
  struct MonoClass * klass;
  struct MonoVTable * vtable;

  D.26616 = type->type;
  klass = mono_class_from_mono_type (D.26616);
  D.26617 = mono_domain_get ();
  vtable = mono_class_vtable_full (D.26617, klass, 1);
  D.26618 = enable != 0;
  vtable->remote = D.26618;
}


ves_icall_System_Runtime_Activation_ActivationServices_AllocateUninitializedClassInstance (struct MonoReflectionType * type)
{
  struct MonoVTable * D.26619;
  struct MonoType * D.26620;
  unsigned int D.26623;
  unsigned int D.26624;
  unsigned char D.26626;
  unsigned int D.26629;
  struct MonoException * D.26630;
  unsigned char D.26631;
  _Bool D.26634;
  long int D.26635;
  long int D.26636;
  struct MonoObject * D.26639;
  struct MonoClass * D.26640;
  struct MonoVTable * D.26641;
  struct MonoClass * klass;
  struct MonoDomain * domain;

  D.26619 = MEM[(struct MonoObject *)type].vtable;
  domain = D.26619->domain;
  D.26620 = type->type;
  klass = mono_class_from_mono_type (D.26620);
  mono_class_init_or_throw (klass);
  D.26623 = klass->flags;
  D.26624 = D.26623 & 32;
  if (D.26624 != 0) goto <D.26621>; else goto <D.26625>;
  <D.26625>:
  D.26626 = klass->byval_arg.type;
  if (D.26626 == 19) goto <D.26621>; else goto <D.26627>;
  <D.26627>:
  D.26626 = klass->byval_arg.type;
  if (D.26626 == 30) goto <D.26621>; else goto <D.26628>;
  <D.26628>:
  D.26623 = klass->flags;
  D.26629 = D.26623 & 128;
  if (D.26629 != 0) goto <D.26621>; else goto <D.26622>;
  <D.26621>:
  D.26630 = mono_get_exception_argument ("type", "Type cannot be instantiated");
  mono_raise_exception (D.26630);
  <D.26622>:
  D.26631 = klass->rank;
  if (D.26631 != 0) goto <D.26632>; else goto <D.26633>;
  <D.26632>:
  D.26631 = klass->rank;
  D.26634 = D.26631 != 1;
  D.26635 = (long int) D.26634;
  D.26636 = __builtin_expect (D.26635, 0);
  if (D.26636 != 0) goto <D.26637>; else goto <D.26638>;
  <D.26637>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 6838, "klass->rank == 1");
  <D.26638>:
  D.26640 = klass->element_class;
  D.26639 = mono_array_new (domain, D.26640, 0);
  return D.26639;
  <D.26633>:
  D.26641 = mono_class_vtable_full (domain, klass, 1);
  D.26639 = mono_object_new_alloc_specific (D.26641);
  return D.26639;
}


ves_icall_System_Runtime_InteropServices_Marshal_PrelinkAll (struct MonoReflectionType * type)
{
  struct MonoType * D.26643;
  struct MonoClass * klass;
  struct MonoMethod * m;
  void * iter;

  try
    {
      D.26643 = type->type;
      klass = mono_class_from_mono_type (D.26643);
      iter = 0B;
      mono_class_init_or_throw (klass);
      goto <D.23416>;
      <D.23415>:
      prelink_method (m);
      <D.23416>:
      m = mono_class_get_methods (klass, &iter);
      if (m != 0B) goto <D.23415>; else goto <D.23417>;
      <D.23417>:
    }
  finally
    {
      iter = {CLOBBER};
    }
}


prelink_method (struct MonoMethod * method)
{
  short unsigned int D.26644;
  int D.26645;
  int D.26646;
  const char * exc_class.40;
  struct MonoImage * D.26652;
  const char * exc_arg.41;
  struct MonoException * D.26654;
  const char * exc_class;
  const char * exc_arg;

  try
    {
      D.26644 = method->flags;
      D.26645 = (int) D.26644;
      D.26646 = D.26645 & 8192;
      if (D.26646 == 0) goto <D.26647>; else goto <D.26648>;
      <D.26647>:
      return;
      <D.26648>:
      mono_lookup_pinvoke_call (method, &exc_class, &exc_arg);
      exc_class.40 = exc_class;
      if (exc_class.40 != 0B) goto <D.26650>; else goto <D.26651>;
      <D.26650>:
      D.26652 = mono_defaults.corlib;
      exc_class.40 = exc_class;
      exc_arg.41 = exc_arg;
      D.26654 = mono_exception_from_name_msg (D.26652, "System", exc_class.40, exc_arg.41);
      mono_raise_exception (D.26654);
      <D.26651>:
    }
  finally
    {
      exc_class = {CLOBBER};
      exc_arg = {CLOBBER};
    }
}


ves_icall_System_Runtime_InteropServices_Marshal_Prelink (struct MonoReflectionMethod * method)
{
  struct MonoMethod * D.26658;

  D.26658 = method->method;
  prelink_method (D.26658);
}


ves_icall_System_Runtime_CompilerServices_RuntimeHelpers_SufficientExecutionStack ()
{
  guint8 * stack_addr.42;
  MonoBoolean D.26662;
  long int current.43;
  long int stack_addr.44;
  long int D.26667;
  long int D.26668;
  long unsigned int stack_size.45;
  sizetype D.26673;
  guint8 * D.26674;
  long int D.26675;
  long int D.26676;
  guint8 * stack_addr;
  guint8 * current;
  size_t stack_size;
  int min_size;

  try
    {
      min_size = 131072;
      mono_thread_get_stack_bounds (&stack_addr, &stack_size);
      stack_addr.42 = stack_addr;
      if (stack_addr.42 == 0B) goto <D.26660>; else goto <D.26661>;
      <D.26660>:
      D.26662 = 1;
      return D.26662;
      <D.26661>:
      current = &stack_addr;
      stack_addr.42 = stack_addr;
      if (current > stack_addr.42) goto <D.26663>; else goto <D.26664>;
      <D.26663>:
      current.43 = (long int) current;
      stack_addr.42 = stack_addr;
      stack_addr.44 = (long int) stack_addr.42;
      D.26667 = current.43 - stack_addr.44;
      D.26668 = (long int) min_size;
      if (D.26667 < D.26668) goto <D.26669>; else goto <D.26670>;
      <D.26669>:
      D.26662 = 0;
      return D.26662;
      <D.26670>:
      goto <D.26671>;
      <D.26664>:
      current.43 = (long int) current;
      stack_addr.42 = stack_addr;
      stack_size.45 = stack_size;
      D.26673 = -stack_size.45;
      D.26674 = stack_addr.42 + D.26673;
      D.26675 = (long int) D.26674;
      D.26676 = current.43 - D.26675;
      D.26668 = (long int) min_size;
      if (D.26676 < D.26668) goto <D.26677>; else goto <D.26678>;
      <D.26677>:
      D.26662 = 0;
      return D.26662;
      <D.26678>:
      <D.26671>:
      D.26662 = 1;
      return D.26662;
    }
  finally
    {
      stack_addr = {CLOBBER};
      stack_size = {CLOBBER};
    }
}


ves_icall_System_Runtime_CompilerServices_RuntimeHelpers_RunModuleConstructor (struct MonoImage * image)
{
  long unsigned int D.26681;
  long unsigned int D.26682;
  struct MonoDomain * D.26685;
  struct MonoVTable * D.26686;

  mono_image_check_for_module_cctor (image);
  D.26681 = BIT_FIELD_REF <*image, 64, 192>;
  D.26682 = D.26681 & 16777216;
  if (D.26682 != 0) goto <D.26683>; else goto <D.26684>;
  <D.26683>:
  {
    struct MonoClass * module_klass;

    module_klass = mono_class_get (image, 33554433);
    D.26685 = mono_domain_get ();
    D.26686 = mono_class_vtable_full (D.26685, module_klass, 1);
    mono_runtime_class_init (D.26686);
  }
  <D.26684>:
}


ves_icall_System_Runtime_CompilerServices_RuntimeHelpers_RunClassConstructor (struct MonoType * handle)
{
  _Bool D.26687;
  long int D.26688;
  long int D.26689;
  _Bool D.26694;
  long int D.26695;
  long int D.26696;
  struct MonoDomain * D.26701;
  struct MonoClass * klass;
  struct MonoVTable * vtable;

  D.26687 = handle == 0B;
  D.26688 = (long int) D.26687;
  D.26689 = __builtin_expect (D.26688, 0);
  if (D.26689 != 0) goto <D.26690>; else goto <D.26691>;
  <D.26690>:
  {
    struct MonoException * ex;

    if (handle != 0B) goto <D.26692>; else goto <D.26693>;
    <D.26692>:
    <D.26693>:
    ex = mono_get_exception_argument_null ("handle");
    mono_raise_exception (ex);
  }
  <D.26691>:
  klass = mono_class_from_mono_type (handle);
  D.26694 = klass == 0B;
  D.26695 = (long int) D.26694;
  D.26696 = __builtin_expect (D.26695, 0);
  if (D.26696 != 0) goto <D.26697>; else goto <D.26698>;
  <D.26697>:
  {
    struct MonoException * ex;
    char * msg;

    msg = monoeg_g_strdup_printf ("assertion `%s\' failed", "klass");
    if (handle != 0B) goto <D.26699>; else goto <D.26700>;
    <D.26699>:
    <D.26700>:
    ex = mono_get_exception_argument ("handle", msg);
    monoeg_g_free (msg);
    mono_raise_exception (ex);
  }
  <D.26698>:
  D.26701 = mono_domain_get ();
  vtable = mono_class_vtable_full (D.26701, klass, 1);
  mono_runtime_class_init (vtable);
}


ves_icall_System_Runtime_CompilerServices_RuntimeHelpers_InitializeArray (struct MonoArray * array, struct MonoClassField * field_handle)
{
  struct MonoVTable * D.26702;
  int D.26703;
  struct MonoClass * D.26704;
  struct MonoType * D.26705;
  int D.26708;
  unsigned char D.26710;
  struct MonoType * D.26711;
  short unsigned int D.26712;
  int D.26713;
  int D.26714;
  unsigned int D.26717;
  int D.26718;
  unsigned int D.26719;
  int D.26722;
  sizetype D.26723;
  short unsigned int D.26724;
  short unsigned int D.26725;
  signed short D.26726;
  int D.26727;
  int D.26728;
  signed short D.26729;
  signed short D.26730;
  short unsigned int D.26731;
  unsigned int D.26732;
  unsigned int D.26733;
  unsigned int D.26734;
  unsigned int D.26735;
  unsigned int D.26736;
  unsigned int D.26737;
  unsigned int D.26738;
  unsigned int D.26739;
  unsigned int D.26740;
  unsigned int D.26741;
  long unsigned int D.26742;
  unsigned int D.26743;
  unsigned int D.26744;
  unsigned int D.26745;
  unsigned int D.26746;
  unsigned int D.26747;
  unsigned int D.26748;
  unsigned int D.26749;
  unsigned int D.26750;
  unsigned int D.26751;
  unsigned int D.26752;
  long unsigned int D.26753;
  long unsigned int D.26754;
  long unsigned int D.26755;
  unsigned int D.26756;
  unsigned int D.26757;
  unsigned int D.26758;
  unsigned int D.26759;
  unsigned int D.26760;
  unsigned int D.26761;
  unsigned int D.26762;
  unsigned int D.26763;
  unsigned int D.26764;
  unsigned int D.26765;
  long unsigned int D.26766;
  long unsigned int D.26767;
  char * D.26768;
  long unsigned int D.26769;
  struct MonoClass * klass;
  guint32 size;
  struct MonoType * type;
  int align;
  const char * field_data;

  try
    {
      D.26702 = array->obj.vtable;
      klass = D.26702->klass;
      D.26703 = mono_array_element_size (klass);
      size = (guint32) D.26703;
      D.26704 = klass->element_class;
      D.26705 = &D.26704->byval_arg;
      type = mono_type_get_underlying_type (D.26705);
      D.26708 = mono_type_is_reference (type);
      if (D.26708 != 0) goto <D.26706>; else goto <D.26709>;
      <D.26709>:
      D.26710 = type->type;
      if (D.26710 == 17) goto <D.26706>; else goto <D.26707>;
      <D.26706>:
      {
        struct MonoException * exc;

        exc = mono_get_exception_argument ("array", "Cannot initialize array of non-primitive type.");
        mono_raise_exception (exc);
      }
      <D.26707>:
      D.26711 = field_handle->type;
      D.26712 = D.26711->attrs;
      D.26713 = (int) D.26712;
      D.26714 = D.26713 & 256;
      if (D.26714 == 0) goto <D.26715>; else goto <D.26716>;
      <D.26715>:
      {
        struct MonoException * exc;

        exc = mono_get_exception_argument ("field_handle", "Field doesn\'t have an RVA");
        mono_raise_exception (exc);
      }
      <D.26716>:
      D.26717 = array->max_length;
      size = D.26717 * size;
      field_data = mono_field_get_data (field_handle);
      D.26711 = field_handle->type;
      D.26718 = mono_type_size (D.26711, &align);
      D.26719 = (unsigned int) D.26718;
      if (D.26719 < size) goto <D.26720>; else goto <D.26721>;
      <D.26720>:
      {
        struct MonoException * exc;

        exc = mono_get_exception_argument ("field_handle", "Field not large enough to fill array");
        mono_raise_exception (exc);
      }
      <D.26721>:
      D.26710 = type->type;
      D.26722 = (int) D.26710;
      switch (D.26722) <default: <D.21220>, case 3: <D.21192>, case 6: <D.21193>, case 7: <D.21194>, case 8: <D.21202>, case 9: <D.21203>, case 10: <D.21211>, case 11: <D.21212>, case 12: <D.21204>, case 13: <D.21213>>
      <D.21192>:
      <D.21193>:
      <D.21194>:
      {
        guint16 * data;
        guint16 * src;
        guint16 * end;

        data = mono_array_addr_with_size (array, 1, 0);
        src = field_data;
        D.26723 = (sizetype) size;
        end = src + D.26723;
        goto <D.21199>;
        <D.21198>:
        D.26724 = MEM[(const guint16 *)src];
        D.26725 = D.26724 >> 8;
        D.26726 = (signed short) D.26725;
        D.26724 = MEM[(const guint16 *)src];
        D.26727 = (int) D.26724;
        D.26728 = D.26727 << 8;
        D.26729 = (signed short) D.26728;
        D.26730 = D.26726 | D.26729;
        D.26731 = (short unsigned int) D.26730;
        *data = D.26731;
        data = data + 2;
        src = src + 2;
        <D.21199>:
        if (src < end) goto <D.21198>; else goto <D.21200>;
        <D.21200>:
      }
      goto <D.21201>;
      <D.21202>:
      <D.21203>:
      <D.21204>:
      {
        guint32 * data;
        guint32 * src;
        guint32 * end;

        data = mono_array_addr_with_size (array, 1, 0);
        src = field_data;
        D.26723 = (sizetype) size;
        end = src + D.26723;
        goto <D.21209>;
        <D.21208>:
        D.26732 = MEM[(const guint32 *)src];
        D.26733 = D.26732 << 24;
        D.26732 = MEM[(const guint32 *)src];
        D.26734 = D.26732 >> 8;
        D.26735 = D.26734 & 65280;
        D.26736 = D.26733 | D.26735;
        D.26732 = MEM[(const guint32 *)src];
        D.26737 = D.26732 << 8;
        D.26738 = D.26737 & 16711680;
        D.26739 = D.26736 | D.26738;
        D.26732 = MEM[(const guint32 *)src];
        D.26740 = D.26732 >> 24;
        D.26741 = D.26739 | D.26740;
        *data = D.26741;
        data = data + 4;
        src = src + 4;
        <D.21209>:
        if (src < end) goto <D.21208>; else goto <D.21210>;
        <D.21210>:
      }
      goto <D.21201>;
      <D.21211>:
      <D.21212>:
      <D.21213>:
      {
        guint64 * data;
        guint64 * src;
        guint64 * end;

        data = mono_array_addr_with_size (array, 1, 0);
        src = field_data;
        D.26723 = (sizetype) size;
        end = src + D.26723;
        goto <D.21218>;
        <D.21217>:
        D.26742 = MEM[(const guint64 *)src];
        D.26743 = (unsigned int) D.26742;
        D.26744 = D.26743 << 24;
        D.26742 = MEM[(const guint64 *)src];
        D.26743 = (unsigned int) D.26742;
        D.26745 = D.26743 >> 8;
        D.26746 = D.26745 & 65280;
        D.26747 = D.26744 | D.26746;
        D.26742 = MEM[(const guint64 *)src];
        D.26743 = (unsigned int) D.26742;
        D.26748 = D.26743 << 8;
        D.26749 = D.26748 & 16711680;
        D.26750 = D.26747 | D.26749;
        D.26742 = MEM[(const guint64 *)src];
        D.26743 = (unsigned int) D.26742;
        D.26751 = D.26743 >> 24;
        D.26752 = D.26750 | D.26751;
        D.26753 = (long unsigned int) D.26752;
        D.26754 = D.26753 << 32;
        D.26742 = MEM[(const guint64 *)src];
        D.26755 = D.26742 >> 32;
        D.26756 = (unsigned int) D.26755;
        D.26757 = D.26756 << 24;
        D.26742 = MEM[(const guint64 *)src];
        D.26755 = D.26742 >> 32;
        D.26756 = (unsigned int) D.26755;
        D.26758 = D.26756 >> 8;
        D.26759 = D.26758 & 65280;
        D.26760 = D.26757 | D.26759;
        D.26742 = MEM[(const guint64 *)src];
        D.26755 = D.26742 >> 32;
        D.26756 = (unsigned int) D.26755;
        D.26761 = D.26756 << 8;
        D.26762 = D.26761 & 16711680;
        D.26763 = D.26760 | D.26762;
        D.26742 = MEM[(const guint64 *)src];
        D.26755 = D.26742 >> 32;
        D.26756 = (unsigned int) D.26755;
        D.26764 = D.26756 >> 24;
        D.26765 = D.26763 | D.26764;
        D.26766 = (long unsigned int) D.26765;
        D.26767 = D.26754 | D.26766;
        *data = D.26767;
        data = data + 8;
        src = src + 8;
        <D.21218>:
        if (src < end) goto <D.21217>; else goto <D.21219>;
        <D.21219>:
      }
      goto <D.21201>;
      <D.21220>:
      D.26768 = mono_array_addr_with_size (array, 1, 0);
      D.26769 = (long unsigned int) size;
      memcpy (D.26768, field_data, D.26769);
      goto <D.21201>;
      <D.21201>:
    }
  finally
    {
      align = {CLOBBER};
    }
}


ves_icall_System_Runtime_CompilerServices_RuntimeHelpers_GetOffsetToStringData ()
{
  gint D.26770;

  D.26770 = 20;
  return D.26770;
}


ves_icall_System_Runtime_CompilerServices_RuntimeHelpers_GetObjectValue (struct MonoObject * obj)
{
  struct MonoVTable * D.26775;
  struct MonoClass * D.26776;
  long unsigned int D.26777;
  long unsigned int D.26778;
  struct MonoObject * D.26779;

  if (obj == 0B) goto <D.26772>; else goto <D.26774>;
  <D.26774>:
  D.26775 = obj->vtable;
  D.26776 = D.26775->klass;
  D.26777 = BIT_FIELD_REF <*D.26776, 64, 256>;
  D.26778 = D.26777 & 1152921504606846976;
  if (D.26778 == 0) goto <D.26772>; else goto <D.26773>;
  <D.26772>:
  D.26779 = obj;
  return D.26779;
  <D.26773>:
  D.26779 = mono_object_clone (obj);
  return D.26779;
}


param_info_get_type_modifiers (struct MonoReflectionParameter * param, MonoBoolean optional)
{
  struct MonoReflectionType * D.26781;
  struct MonoObject * D.26782;
  struct MonoVTable * D.26783;
  int D.26784;
  struct MonoImage * D.26790;
  struct MonoImage * D.26791;
  const char * D.26793;
  int D.26794;
  struct MonoProperty * D.26796;
  _Bool D.26799;
  long int D.26800;
  long int D.26801;
  struct MonoClass * D.26804;
  struct MonoArray * D.26808;
  int D.26809;
  struct MonoType * type;
  struct MonoClass * member_class;
  struct MonoMethod * method;
  struct MonoImage * image;
  int pos;
  struct MonoMethodSignature * sig;

  D.26781 = param->ClassImpl;
  type = D.26781->type;
  D.26782 = param->MemberImpl;
  D.26783 = D.26782->vtable;
  member_class = D.26783->klass;
  method = 0B;
  D.26784 = mono_class_is_reflection_method_or_constructor (member_class);
  if (D.26784 != 0) goto <D.26785>; else goto <D.26786>;
  <D.26785>:
  {
    struct MonoReflectionMethod * rmethod;

    rmethod = param->MemberImpl;
    method = rmethod->method;
  }
  goto <D.26787>;
  <D.26786>:
  D.26790 = member_class->image;
  D.26791 = mono_defaults.corlib;
  if (D.26790 == D.26791) goto <D.26792>; else goto <D.26788>;
  <D.26792>:
  D.26793 = member_class->name;
  D.26794 = strcmp ("MonoProperty", D.26793);
  if (D.26794 == 0) goto <D.26795>; else goto <D.26788>;
  <D.26795>:
  {
    struct MonoReflectionProperty * prop;

    prop = param->MemberImpl;
    D.26796 = prop->property;
    method = D.26796->get;
    if (method == 0B) goto <D.26797>; else goto <D.26798>;
    <D.26797>:
    D.26796 = prop->property;
    method = D.26796->set;
    <D.26798>:
    D.26799 = method == 0B;
    D.26800 = (long int) D.26799;
    D.26801 = __builtin_expect (D.26800, 0);
    if (D.26801 != 0) goto <D.26802>; else goto <D.26803>;
    <D.26802>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 7444, "method");
    <D.26803>:
  }
  goto <D.26789>;
  <D.26788>:
  {
    char * type_name;
    char * msg;
    struct MonoException * ex;

    type_name = mono_type_get_full_name (member_class);
    msg = monoeg_g_strdup_printf ("Custom modifiers on a ParamInfo with member %s are not supported", type_name);
    ex = mono_get_exception_not_supported (msg);
    monoeg_g_free (type_name);
    monoeg_g_free (msg);
    mono_raise_exception (ex);
  }
  <D.26789>:
  <D.26787>:
  D.26804 = method->klass;
  image = D.26804->image;
  pos = param->PositionImpl;
  sig = mono_method_signature (method);
  if (pos == -1) goto <D.26805>; else goto <D.26806>;
  <D.26805>:
  type = sig->ret;
  goto <D.26807>;
  <D.26806>:
  type = sig->params[pos];
  <D.26807>:
  D.26809 = (int) optional;
  D.26808 = type_array_from_modifiers (image, type, D.26809);
  return D.26808;
}


type_array_from_modifiers (struct MonoImage * image, struct MonoType * type, int optional)
{
  <unnamed-unsigned:1> D.26815;
  <unnamed-unsigned:6> D.26817;
  int D.26818;
  struct MonoArray * D.26821;
  struct MonoDomain * D.26822;
  struct MonoClass * D.26823;
  long unsigned int D.26824;
  <unnamed-unsigned:31> D.26830;
  unsigned int D.26831;
  struct MonoDomain * D.26832;
  struct MonoType * D.26833;
  struct MonoReflectionType * D.26834;
  struct MonoArray * res;
  int i;
  int count;

  count = 0;
  i = 0;
  goto <D.23454>;
  <D.23453>:
  if (optional != 0) goto <D.26814>; else goto <D.26811>;
  <D.26814>:
  D.26815 = type->modifiers[i].required;
  if (D.26815 == 0) goto <D.26812>; else goto <D.26811>;
  <D.26811>:
  if (optional == 0) goto <D.26816>; else goto <D.26813>;
  <D.26816>:
  D.26815 = type->modifiers[i].required;
  if (D.26815 != 0) goto <D.26812>; else goto <D.26813>;
  <D.26812>:
  count = count + 1;
  <D.26813>:
  i = i + 1;
  <D.23454>:
  D.26817 = type->num_mods;
  D.26818 = (int) D.26817;
  if (D.26818 > i) goto <D.23453>; else goto <D.23455>;
  <D.23455>:
  if (count == 0) goto <D.26819>; else goto <D.26820>;
  <D.26819>:
  D.26821 = 0B;
  return D.26821;
  <D.26820>:
  D.26822 = mono_domain_get ();
  D.26823 = mono_defaults.systemtype_class;
  D.26824 = (long unsigned int) count;
  res = mono_array_new (D.26822, D.26823, D.26824);
  count = 0;
  i = 0;
  goto <D.23459>;
  <D.23458>:
  if (optional != 0) goto <D.26828>; else goto <D.26825>;
  <D.26828>:
  D.26815 = type->modifiers[i].required;
  if (D.26815 == 0) goto <D.26826>; else goto <D.26825>;
  <D.26825>:
  if (optional == 0) goto <D.26829>; else goto <D.26827>;
  <D.26829>:
  D.26815 = type->modifiers[i].required;
  if (D.26815 != 0) goto <D.26826>; else goto <D.26827>;
  <D.26826>:
  {
    struct MonoClass * klass;

    D.26830 = type->modifiers[i].token;
    D.26831 = (unsigned int) D.26830;
    klass = mono_class_get (image, D.26831);
    {
      void * * __p;

      D.26824 = (long unsigned int) count;
      __p = mono_array_addr_with_size (res, 8, D.26824);
      D.26832 = mono_domain_get ();
      D.26833 = &klass->byval_arg;
      D.26834 = mono_type_get_object (D.26832, D.26833);
      mono_gc_wbarrier_set_arrayref (res, __p, D.26834);
    }
    count = count + 1;
  }
  <D.26827>:
  i = i + 1;
  <D.23459>:
  D.26817 = type->num_mods;
  D.26818 = (int) D.26817;
  if (D.26818 > i) goto <D.23458>; else goto <D.23460>;
  <D.23460>:
  D.26821 = res;
  return D.26821;
}


ves_icall_get_property_info (struct MonoReflectionProperty * property, struct MonoPropertyInfo * info, PInfo req_info)
{
  struct MonoVTable * D.26836;
  unsigned int D.26837;
  struct MonoReflectionType * * D.26840;
  struct MonoClass * D.26841;
  struct MonoType * D.26842;
  struct MonoReflectionType * D.26843;
  unsigned int D.26844;
  struct MonoReflectionType * * D.26847;
  struct MonoProperty * D.26848;
  struct MonoClass * D.26849;
  struct MonoType * D.26850;
  struct MonoReflectionType * D.26851;
  unsigned int D.26852;
  struct MonoString * * D.26855;
  const char * D.26856;
  struct MonoString * D.26857;
  unsigned int D.26858;
  unsigned int D.26861;
  unsigned int D.26862;
  struct MonoReflectionMethod * * D.26865;
  struct MonoObject * iftmp.46;
  struct MonoMethod * D.26867;
  unsigned int D.26871;
  struct MonoReflectionMethod * * D.26874;
  struct MonoObject * iftmp.47;
  struct MonoMethod * D.26876;
  struct MonoDomain * domain;

  D.26836 = MEM[(struct MonoObject *)property].vtable;
  domain = D.26836->domain;
  D.26837 = req_info & 8;
  if (D.26837 != 0) goto <D.26838>; else goto <D.26839>;
  <D.26838>:
  D.26840 = &info->parent;
  D.26841 = property->klass;
  D.26842 = &D.26841->byval_arg;
  D.26843 = mono_type_get_object (domain, D.26842);
  mono_gc_wbarrier_generic_store (D.26840, D.26843);
  <D.26839>:
  D.26844 = req_info & 16;
  if (D.26844 != 0) goto <D.26845>; else goto <D.26846>;
  <D.26845>:
  D.26847 = &info->declaring_type;
  D.26848 = property->property;
  D.26849 = D.26848->parent;
  D.26850 = &D.26849->byval_arg;
  D.26851 = mono_type_get_object (domain, D.26850);
  mono_gc_wbarrier_generic_store (D.26847, D.26851);
  <D.26846>:
  D.26852 = req_info & 32;
  if (D.26852 != 0) goto <D.26853>; else goto <D.26854>;
  <D.26853>:
  D.26855 = &info->name;
  D.26848 = property->property;
  D.26856 = D.26848->name;
  D.26857 = mono_string_new (domain, D.26856);
  mono_gc_wbarrier_generic_store (D.26855, D.26857);
  <D.26854>:
  D.26858 = req_info & 1;
  if (D.26858 != 0) goto <D.26859>; else goto <D.26860>;
  <D.26859>:
  D.26848 = property->property;
  D.26861 = D.26848->attrs;
  info->attrs = D.26861;
  <D.26860>:
  D.26862 = req_info & 2;
  if (D.26862 != 0) goto <D.26863>; else goto <D.26864>;
  <D.26863>:
  D.26865 = &info->get;
  D.26848 = property->property;
  D.26867 = D.26848->get;
  if (D.26867 != 0B) goto <D.26868>; else goto <D.26869>;
  <D.26868>:
  D.26848 = property->property;
  D.26867 = D.26848->get;
  D.26841 = property->klass;
  iftmp.46 = mono_method_get_object (domain, D.26867, D.26841);
  goto <D.26870>;
  <D.26869>:
  iftmp.46 = 0B;
  <D.26870>:
  mono_gc_wbarrier_generic_store (D.26865, iftmp.46);
  <D.26864>:
  D.26871 = req_info & 4;
  if (D.26871 != 0) goto <D.26872>; else goto <D.26873>;
  <D.26872>:
  D.26874 = &info->set;
  D.26848 = property->property;
  D.26876 = D.26848->set;
  if (D.26876 != 0B) goto <D.26877>; else goto <D.26878>;
  <D.26877>:
  D.26848 = property->property;
  D.26876 = D.26848->set;
  D.26841 = property->klass;
  iftmp.47 = mono_method_get_object (domain, D.26876, D.26841);
  goto <D.26879>;
  <D.26878>:
  iftmp.47 = 0B;
  <D.26879>:
  mono_gc_wbarrier_generic_store (D.26874, iftmp.47);
  <D.26873>:
}


property_info_get_default_value (struct MonoReflectionProperty * property)
{
  struct MonoVTable * D.26880;
  struct MonoClass * D.26881;
  unsigned int D.26882;
  unsigned int D.26883;
  struct MonoException * D.26886;
  <unnamed type> def_type.48;
  struct MonoObject * D.26888;
  struct MonoType blob_type;
  struct MonoProperty * prop;
  struct MonoType * type;
  struct MonoDomain * domain;
  MonoTypeEnum def_type;
  const char * def_value;
  struct MonoObject * o;

  try
    {
      prop = property->property;
      type = get_property_type (prop);
      D.26880 = MEM[(struct MonoObject *)property].vtable;
      domain = D.26880->domain;
      D.26881 = prop->parent;
      mono_class_init (D.26881);
      D.26882 = prop->attrs;
      D.26883 = D.26882 & 4096;
      if (D.26883 == 0) goto <D.26884>; else goto <D.26885>;
      <D.26884>:
      D.26886 = mono_get_exception_invalid_operation (0B);
      mono_raise_exception (D.26886);
      <D.26885>:
      def_value = mono_class_get_property_default_value (prop, &def_type);
      def_type.48 = def_type;
      mono_type_from_blob_type (&blob_type, def_type.48, type);
      o = mono_get_object_from_blob (domain, &blob_type, def_value);
      D.26888 = o;
      return D.26888;
    }
  finally
    {
      blob_type = {CLOBBER};
      def_type = {CLOBBER};
    }
}


get_property_type (struct MonoProperty * prop)
{
  struct MonoMethod * D.26891;
  struct MonoType * D.26894;
  struct MonoMethod * D.26895;
  short unsigned int D.26898;
  int D.26899;
  int D.26900;
  struct MonoMethodSignature * sig;

  D.26891 = prop->get;
  if (D.26891 != 0B) goto <D.26892>; else goto <D.26893>;
  <D.26892>:
  D.26891 = prop->get;
  sig = mono_method_signature (D.26891);
  D.26894 = sig->ret;
  return D.26894;
  <D.26893>:
  D.26895 = prop->set;
  if (D.26895 != 0B) goto <D.26896>; else goto <D.26897>;
  <D.26896>:
  D.26895 = prop->set;
  sig = mono_method_signature (D.26895);
  D.26898 = sig->param_count;
  D.26899 = (int) D.26898;
  D.26900 = D.26899 + -1;
  D.26894 = sig->params[D.26900];
  return D.26894;
  <D.26897>:
  D.26894 = 0B;
  return D.26894;
}


mono_type_from_blob_type (struct MonoType * type, MonoTypeEnum blob_type, struct MonoType * real_type)
{
  unsigned char D.26902;
  struct MonoClass * D.26905;
  unsigned char D.26909;
  struct MonoClass * D.26911;
  long unsigned int D.26912;
  long unsigned int D.26913;
  struct MonoClass * D.26915;
  struct MonoClass * D.26916;

  D.26902 = (unsigned char) blob_type;
  type->type = D.26902;
  type->data.klass = 0B;
  if (blob_type == 18) goto <D.26903>; else goto <D.26904>;
  <D.26903>:
  D.26905 = mono_defaults.object_class;
  type->data.klass = D.26905;
  goto <D.26906>;
  <D.26904>:
  D.26909 = real_type->type;
  if (D.26909 == 17) goto <D.26910>; else goto <D.26907>;
  <D.26910>:
  D.26911 = real_type->data.klass;
  D.26912 = BIT_FIELD_REF <*D.26911, 64, 256>;
  D.26913 = D.26912 & 576460752303423488;
  if (D.26913 != 0) goto <D.26914>; else goto <D.26907>;
  <D.26914>:
  type->type = 17;
  D.26915 = mono_class_from_mono_type (real_type);
  type->data.klass = D.26915;
  goto <D.26908>;
  <D.26907>:
  D.26916 = mono_class_from_mono_type (real_type);
  type->data.klass = D.26916;
  <D.26908>:
  <D.26906>:
}


property_info_get_type_modifiers (struct MonoReflectionProperty * property, MonoBoolean optional)
{
  struct MonoProperty * D.26917;
  struct MonoClass * D.26918;
  struct MonoArray * D.26921;
  int D.26922;
  struct MonoType * type;
  struct MonoImage * image;

  D.26917 = property->property;
  type = get_property_type (D.26917);
  D.26918 = property->klass;
  image = D.26918->image;
  if (type == 0B) goto <D.26919>; else goto <D.26920>;
  <D.26919>:
  D.26921 = 0B;
  return D.26921;
  <D.26920>:
  D.26922 = (int) optional;
  D.26921 = type_array_from_modifiers (image, type, D.26922);
  return D.26921;
}


ves_icall_System_MonoMethodInfo_get_retval_marshal (struct MonoMethod * method)
{
  struct MonoMethodSignature * D.26924;
  short unsigned int D.26925;
  int D.26926;
  int D.26927;
  long unsigned int D.26928;
  long unsigned int D.26929;
  struct MonoMarshalSpec * D.26930;
  struct MonoClass * D.26933;
  struct MonoMethodSignature * D.26934;
  short unsigned int D.26935;
  long unsigned int D.26936;
  long unsigned int D.26937;
  struct MonoMarshalSpec * * D.26938;
  struct MonoMarshalSpec * D.26939;
  struct MonoReflectionMarshalAsAttribute * D.26942;
  struct MonoDomain * domain;
  struct MonoReflectionMarshalAsAttribute * res;
  struct MonoMarshalSpec * * mspecs;
  int i;

  domain = mono_domain_get ();
  res = 0B;
  D.26924 = mono_method_signature (method);
  D.26925 = D.26924->param_count;
  D.26926 = (int) D.26925;
  D.26927 = D.26926 + 1;
  D.26928 = (long unsigned int) D.26927;
  D.26929 = D.26928 * 8;
  mspecs = monoeg_malloc (D.26929);
  mono_method_get_marshal_info (method, mspecs);
  D.26930 = *mspecs;
  if (D.26930 != 0B) goto <D.26931>; else goto <D.26932>;
  <D.26931>:
  D.26933 = method->klass;
  D.26930 = *mspecs;
  res = mono_reflection_marshal_as_attribute_from_marshal_spec (domain, D.26933, D.26930);
  <D.26932>:
  D.26934 = mono_method_signature (method);
  D.26935 = D.26934->param_count;
  i = (int) D.26935;
  goto <D.21529>;
  <D.21528>:
  D.26936 = (long unsigned int) i;
  D.26937 = D.26936 * 8;
  D.26938 = mspecs + D.26937;
  D.26939 = *D.26938;
  if (D.26939 != 0B) goto <D.26940>; else goto <D.26941>;
  <D.26940>:
  D.26936 = (long unsigned int) i;
  D.26937 = D.26936 * 8;
  D.26938 = mspecs + D.26937;
  D.26939 = *D.26938;
  mono_metadata_free_marshal_spec (D.26939);
  <D.26941>:
  i = i + -1;
  <D.21529>:
  if (i >= 0) goto <D.21528>; else goto <D.21530>;
  <D.21530>:
  monoeg_g_free (mspecs);
  D.26942 = res;
  return D.26942;
}


ves_icall_get_parameter_info (struct MonoMethod * method, struct MonoReflectionMethod * member)
{
  struct MonoArray * D.26944;
  struct MonoClass * iftmp.49;
  struct MonoReflectionType * D.26946;
  struct MonoType * D.26949;
  struct MonoDomain * domain;

  domain = mono_domain_get ();
  D.26946 = member->reftype;
  if (D.26946 != 0B) goto <D.26947>; else goto <D.26948>;
  <D.26947>:
  D.26946 = member->reftype;
  D.26949 = D.26946->type;
  iftmp.49 = mono_class_from_mono_type (D.26949);
  goto <D.26950>;
  <D.26948>:
  iftmp.49 = 0B;
  <D.26950>:
  D.26944 = mono_param_get_objects_internal (domain, method, iftmp.49);
  return D.26944;
}


ves_icall_get_method_info (struct MonoMethod * method, struct MonoMethodInfo * info)
{
  int D.26952;
  struct MonoReflectionType * * D.26955;
  struct MonoClass * D.26956;
  struct MonoType * D.26957;
  struct MonoReflectionType * D.26958;
  struct MonoReflectionType * * D.26959;
  struct MonoType * D.26960;
  struct MonoReflectionType * D.26961;
  short unsigned int D.26962;
  unsigned int D.26963;
  short unsigned int D.26964;
  unsigned int D.26965;
  long unsigned int D.26966;
  long unsigned int D.26967;
  guint32 iftmp.50;
  short int D.26971;
  unsigned int D.26980;
  <unnamed-unsigned:1> D.26981;
  int D.26982;
  int D.26983;
  <unnamed-unsigned:1> D.26984;
  int D.26985;
  int D.26986;
  int D.26987;
  unsigned int D.26988;
  unsigned int D.26989;
  struct MonoError error;
  struct MonoDomain * domain;
  struct MonoMethodSignature * sig;

  try
    {
      domain = mono_domain_get ();
      sig = mono_method_signature_checked (method, &error);
      D.26952 = mono_error_ok (&error);
      if (D.26952 == 0) goto <D.26953>; else goto <D.26954>;
      <D.26953>:
      mono_error_raise_exception (&error);
      <D.26954>:
      D.26955 = &info->parent;
      D.26956 = method->klass;
      D.26957 = &D.26956->byval_arg;
      D.26958 = mono_type_get_object (domain, D.26957);
      mono_gc_wbarrier_generic_store (D.26955, D.26958);
      D.26959 = &info->ret;
      D.26960 = sig->ret;
      D.26961 = mono_type_get_object (domain, D.26960);
      mono_gc_wbarrier_generic_store (D.26959, D.26961);
      D.26962 = method->flags;
      D.26963 = (unsigned int) D.26962;
      info->attrs = D.26963;
      D.26964 = method->iflags;
      D.26965 = (unsigned int) D.26964;
      info->implattrs = D.26965;
      D.26966 = BIT_FIELD_REF <*sig, 64, 64>;
      D.26967 = D.26966 & 64512;
      if (D.26967 == 0) goto <D.26968>; else goto <D.26969>;
      <D.26968>:
      D.26971 = sig->sentinelpos;
      if (D.26971 >= 0) goto <D.26972>; else goto <D.26973>;
      <D.26972>:
      iftmp.50 = 2;
      goto <D.26974>;
      <D.26973>:
      iftmp.50 = 1;
      <D.26974>:
      info->callconv = iftmp.50;
      goto <D.26975>;
      <D.26969>:
      D.26966 = BIT_FIELD_REF <*sig, 64, 64>;
      D.26967 = D.26966 & 64512;
      if (D.26967 == 5120) goto <D.26976>; else goto <D.26979>;
      <D.26979>:
      D.26971 = sig->sentinelpos;
      if (D.26971 >= 0) goto <D.26976>; else goto <D.26977>;
      <D.26976>:
      info->callconv = 2;
      goto <D.26978>;
      <D.26977>:
      info->callconv = 1;
      <D.26978>:
      <D.26975>:
      D.26980 = info->callconv;
      D.26981 = sig->hasthis;
      D.26982 = (int) D.26981;
      D.26983 = D.26982 << 5;
      D.26984 = sig->explicit_this;
      D.26985 = (int) D.26984;
      D.26986 = D.26985 << 6;
      D.26987 = D.26983 | D.26986;
      D.26988 = (unsigned int) D.26987;
      D.26989 = D.26980 | D.26988;
      info->callconv = D.26989;
    }
  finally
    {
      error = {CLOBBER};
    }
}


vell_icall_get_method_attributes (struct MonoMethod * method)
{
  int D.26990;
  short unsigned int D.26991;

  D.26991 = method->flags;
  D.26990 = (int) D.26991;
  return D.26990;
}


ves_icall_MonoMethod_get_name (struct MonoReflectionMethod * m)
{
  struct MonoString * * D.26993;
  struct MonoVTable * D.26994;
  struct MonoDomain * D.26995;
  const char * D.26996;
  struct MonoString * D.26997;
  struct MonoString * D.26998;
  struct MonoMethod * method;

  method = m->method;
  D.26993 = &m->name;
  D.26994 = MEM[(struct MonoObject *)m].vtable;
  D.26995 = D.26994->domain;
  D.26996 = method->name;
  D.26997 = mono_string_new (D.26995, D.26996);
  mono_gc_wbarrier_set_field (m, D.26993, D.26997);
  D.26998 = m->name;
  return D.26998;
}


ves_icall_MonoMethod_get_base_method (struct MonoReflectionMethod * m, gboolean definition)
{
  struct MonoClass * D.27000;
  struct MonoReflectionMethod * D.27003;
  short unsigned int D.27006;
  int D.27007;
  int D.27008;
  unsigned int D.27010;
  unsigned int D.27011;
  unsigned char D.27013;
  int D.27016;
  struct MonoGenericClass * D.27019;
  int D.27024;
  int D.27031;
  struct MonoMethod * * D.27034;
  long unsigned int D.27035;
  long unsigned int D.27036;
  struct MonoMethod * * D.27037;
  short int D.27040;
  int D.27041;
  struct MonoDomain * D.27045;
  struct MonoClass * klass;
  struct MonoClass * parent;
  struct MonoMethod * method;
  struct MonoMethod * result;
  int slot;

  method = m->method;
  result = 0B;
  D.27000 = method->klass;
  if (D.27000 == 0B) goto <D.27001>; else goto <D.27002>;
  <D.27001>:
  D.27003 = m;
  return D.27003;
  <D.27002>:
  D.27006 = method->flags;
  D.27007 = (int) D.27006;
  D.27008 = D.27007 & 64;
  if (D.27008 == 0) goto <D.27004>; else goto <D.27009>;
  <D.27009>:
  D.27000 = method->klass;
  D.27010 = D.27000->flags;
  D.27011 = D.27010 & 32;
  if (D.27011 != 0) goto <D.27004>; else goto <D.27012>;
  <D.27012>:
  D.27000 = method->klass;
  D.27013 = D.27000->byval_arg.type;
  if (D.27013 == 19) goto <D.27004>; else goto <D.27014>;
  <D.27014>:
  D.27000 = method->klass;
  D.27013 = D.27000->byval_arg.type;
  if (D.27013 == 30) goto <D.27004>; else goto <D.27015>;
  <D.27015>:
  D.27006 = method->flags;
  D.27007 = (int) D.27006;
  D.27016 = D.27007 & 256;
  if (D.27016 != 0) goto <D.27004>; else goto <D.27005>;
  <D.27004>:
  D.27003 = m;
  return D.27003;
  <D.27005>:
  slot = mono_method_get_vtable_slot (method);
  if (slot == -1) goto <D.27017>; else goto <D.27018>;
  <D.27017>:
  D.27003 = m;
  return D.27003;
  <D.27018>:
  klass = method->klass;
  D.27019 = klass->generic_class;
  if (D.27019 != 0B) goto <D.27020>; else goto <D.27021>;
  <D.27020>:
  D.27019 = klass->generic_class;
  klass = D.27019->container_class;
  <D.27021>:
  if (definition != 0) goto <D.27022>; else goto <D.27023>;
  <D.27022>:
  parent = klass->parent;
  goto <D.23353>;
  <D.23352>:
  mono_class_setup_vtable (parent);
  D.27024 = parent->vtable_size;
  if (D.27024 <= slot) goto <D.23351>; else goto <D.27025>;
  <D.27025>:
  klass = parent;
  parent = parent->parent;
  <D.23353>:
  if (parent != 0B) goto <D.23352>; else goto <D.23351>;
  <D.23351>:
  goto <D.27026>;
  <D.27023>:
  klass = klass->parent;
  if (klass == 0B) goto <D.27027>; else goto <D.27028>;
  <D.27027>:
  D.27003 = m;
  return D.27003;
  <D.27028>:
  <D.27026>:
  D.27000 = method->klass;
  if (D.27000 == klass) goto <D.27029>; else goto <D.27030>;
  <D.27029>:
  D.27003 = m;
  return D.27003;
  <D.27030>:
  D.27031 = klass->vtable_size;
  if (D.27031 <= slot) goto <D.27032>; else goto <D.27033>;
  <D.27032>:
  D.27003 = m;
  return D.27003;
  <D.27033>:
  mono_class_setup_vtable (klass);
  D.27034 = klass->vtable;
  D.27035 = (long unsigned int) slot;
  D.27036 = D.27035 * 8;
  D.27037 = D.27034 + D.27036;
  result = *D.27037;
  if (result == 0B) goto <D.27038>; else goto <D.27039>;
  <D.27038>:
  {
    void * iter;

    try
      {
        iter = 0B;
        goto <D.23357>;
        <D.23356>:
        D.27040 = result->slot;
        D.27041 = (int) D.27040;
        if (D.27041 == slot) goto <D.23355>; else goto <D.27042>;
        <D.27042>:
        <D.23357>:
        result = mono_class_get_methods (klass, &iter);
        if (result != 0B) goto <D.23356>; else goto <D.23355>;
        <D.23355>:
      }
    finally
      {
        iter = {CLOBBER};
      }
  }
  <D.27039>:
  if (result == 0B) goto <D.27043>; else goto <D.27044>;
  <D.27043>:
  D.27003 = m;
  return D.27003;
  <D.27044>:
  D.27045 = mono_domain_get ();
  D.27003 = mono_method_get_object (D.27045, result, 0B);
  return D.27003;
}


ves_icall_MonoMethod_get_IsGenericMethodDefinition (struct MonoReflectionMethod * method)
{
  gboolean D.27047;
  struct MonoMethod * D.27048;
  <unnamed-unsigned:1> D.27049;

  D.27048 = method->method;
  D.27049 = D.27048->is_generic;
  D.27047 = (gboolean) D.27049;
  return D.27047;
}


ves_icall_MonoMethod_get_IsGenericMethod (struct MonoReflectionMethod * method)
{
  gboolean D.27051;
  struct MonoMethod * D.27052;
  struct MonoMethodSignature * D.27053;
  short unsigned int D.27054;
  _Bool D.27055;

  D.27052 = method->method;
  D.27053 = mono_method_signature (D.27052);
  D.27054 = D.27053->generic_param_count;
  D.27055 = D.27054 != 0;
  D.27051 = (gboolean) D.27055;
  return D.27051;
}


ves_icall_MonoMethod_GetGenericArguments (struct MonoReflectionMethod * method)
{
  struct MonoVTable * D.27057;
  struct MonoMethod * D.27058;
  long unsigned int D.27059;
  long unsigned int D.27060;
  struct MonoGenericContext * D.27063;
  <unnamed-unsigned:22> D.27066;
  struct MonoClass * D.27067;
  long unsigned int D.27068;
  long unsigned int D.27069;
  struct MonoType * D.27070;
  struct MonoReflectionType * D.27071;
  struct MonoArray * D.27072;
  struct MonoMethodSignature * D.27073;
  short unsigned int D.27074;
  struct MonoGenericParamFull * D.27075;
  long unsigned int D.27076;
  long unsigned int D.27077;
  struct MonoClass * D.27078;
  struct MonoImage * D.27079;
  struct MonoType * D.27080;
  struct MonoReflectionType * D.27081;
  struct MonoArray * res;
  struct MonoDomain * domain;
  int count;
  int i;

  D.27057 = MEM[(struct MonoObject *)method].vtable;
  domain = D.27057->domain;
  D.27058 = method->method;
  D.27059 = BIT_FIELD_REF <*D.27058, 64, 256>;
  D.27060 = D.27059 & 2251799813685248;
  if (D.27060 != 0) goto <D.27061>; else goto <D.27062>;
  <D.27061>:
  {
    struct MonoGenericInst * inst;

    D.27058 = method->method;
    D.27063 = mono_method_get_context (D.27058);
    inst = D.27063->method_inst;
    if (inst != 0B) goto <D.27064>; else goto <D.27065>;
    <D.27064>:
    D.27066 = inst->type_argc;
    count = (int) D.27066;
    D.27067 = mono_defaults.systemtype_class;
    D.27068 = (long unsigned int) count;
    res = mono_array_new (domain, D.27067, D.27068);
    i = 0;
    goto <D.21921>;
    <D.21920>:
    {
      void * * __p;

      D.27069 = (long unsigned int) i;
      __p = mono_array_addr_with_size (res, 8, D.27069);
      D.27070 = inst->type_argv[i];
      D.27071 = mono_type_get_object (domain, D.27070);
      mono_gc_wbarrier_set_arrayref (res, __p, D.27071);
    }
    i = i + 1;
    <D.21921>:
    if (i < count) goto <D.21920>; else goto <D.21922>;
    <D.21922>:
    D.27072 = res;
    return D.27072;
    <D.27065>:
  }
  <D.27062>:
  D.27058 = method->method;
  D.27073 = mono_method_signature (D.27058);
  D.27074 = D.27073->generic_param_count;
  count = (int) D.27074;
  D.27067 = mono_defaults.systemtype_class;
  D.27068 = (long unsigned int) count;
  res = mono_array_new (domain, D.27067, D.27068);
  i = 0;
  goto <D.21928>;
  <D.21927>:
  {
    struct MonoGenericContainer * container;
    struct MonoGenericParam * param;
    struct MonoClass * pklass;

    D.27058 = method->method;
    container = mono_method_get_generic_container (D.27058);
    D.27075 = container->type_params;
    D.27076 = (long unsigned int) i;
    D.27077 = D.27076 * 56;
    param = D.27075 + D.27077;
    D.27058 = method->method;
    D.27078 = D.27058->klass;
    D.27079 = D.27078->image;
    pklass = mono_class_from_generic_parameter (param, D.27079, 1);
    {
      void * * __p;

      D.27069 = (long unsigned int) i;
      __p = mono_array_addr_with_size (res, 8, D.27069);
      D.27080 = &pklass->byval_arg;
      D.27081 = mono_type_get_object (domain, D.27080);
      mono_gc_wbarrier_set_arrayref (res, __p, D.27081);
    }
  }
  i = i + 1;
  <D.21928>:
  if (i < count) goto <D.21927>; else goto <D.21929>;
  <D.21929>:
  D.27072 = res;
  return D.27072;
}


ves_icall_MonoMethod_GetDllImportAttribute (struct MonoMethod * method)
{
  struct MonoClass * D.27083;
  short unsigned int D.27084;
  int D.27085;
  int D.27086;
  struct MonoReflectionDllImportAttribute * D.27089;
  struct MonoClass * DllImportAttributeClass.51;
  struct MonoImage * D.27093;
  struct MonoClass * DllImportAttributeClass.52;
  _Bool D.27095;
  long int D.27096;
  long int D.27097;
  struct MonoImage * D.27100;
  long unsigned int D.27101;
  long unsigned int D.27102;
  struct GHashTable * D.27105;
  struct MonoException * D.27111;
  short unsigned int D.27113;
  int D.27116;
  int D.27117;
  unsigned int D.27118;
  short unsigned int D.27119;
  unsigned int D.27120;
  unsigned int D.27121;
  unsigned int D.27122;
  int D.27123;
  short unsigned int D.27124;
  struct MonoString * * D.27125;
  struct MonoString * D.27126;
  struct MonoString * * D.27127;
  struct MonoString * D.27128;
  unsigned int D.27129;
  int D.27130;
  int D.27131;
  unsigned int D.27132;
  unsigned int D.27133;
  unsigned int D.27134;
  int D.27135;
  int D.27136;
  unsigned int D.27139;
  _Bool D.27140;
  unsigned char D.27141;
  unsigned int D.27142;
  _Bool D.27143;
  unsigned char D.27144;
  unsigned int D.27145;
  _Bool D.27146;
  unsigned char D.27147;
  unsigned int D.27148;
  _Bool D.27149;
  unsigned char D.27150;
  static struct MonoClass * DllImportAttributeClass = 0B;
  struct MonoDomain * domain;
  struct MonoReflectionDllImportAttribute * attr;
  struct MonoImage * image;
  struct MonoMethodPInvoke * piinfo;
  struct MonoTableInfo * tables;
  struct MonoTableInfo * im;
  struct MonoTableInfo * mr;
  guint32 im_cols[4];
  guint32 scope_token;
  const char * import;
  const char * scope;
  guint32 flags;

  try
    {
      domain = mono_domain_get ();
      D.27083 = method->klass;
      image = D.27083->image;
      piinfo = method;
      tables = &image->tables;
      im = tables + 448;
      mr = tables + 416;
      import = 0B;
      scope = 0B;
      D.27084 = method->flags;
      D.27085 = (int) D.27084;
      D.27086 = D.27085 & 8192;
      if (D.27086 == 0) goto <D.27087>; else goto <D.27088>;
      <D.27087>:
      D.27089 = 0B;
      return D.27089;
      <D.27088>:
      DllImportAttributeClass.51 = DllImportAttributeClass;
      if (DllImportAttributeClass.51 == 0B) goto <D.27091>; else goto <D.27092>;
      <D.27091>:
      D.27093 = mono_defaults.corlib;
      DllImportAttributeClass.52 = mono_class_from_name (D.27093, "System.Runtime.InteropServices", "DllImportAttribute");
      DllImportAttributeClass = DllImportAttributeClass.52;
      DllImportAttributeClass.51 = DllImportAttributeClass;
      D.27095 = DllImportAttributeClass.51 == 0B;
      D.27096 = (long int) D.27095;
      D.27097 = __builtin_expect (D.27096, 0);
      if (D.27097 != 0) goto <D.27098>; else goto <D.27099>;
      <D.27098>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 2598, "DllImportAttributeClass");
      <D.27099>:
      <D.27092>:
      D.27083 = method->klass;
      D.27100 = D.27083->image;
      D.27101 = BIT_FIELD_REF <*D.27100, 64, 192>;
      D.27102 = D.27101 & 268435456;
      if (D.27102 != 0) goto <D.27103>; else goto <D.27104>;
      <D.27103>:
      {
        struct MonoReflectionMethodAux * method_aux;

        D.27083 = method->klass;
        D.27100 = D.27083->image;
        D.27105 = MEM[(struct MonoDynamicImage *)D.27100].method_aux_hash;
        method_aux = monoeg_g_hash_table_lookup (D.27105, method);
        if (method_aux != 0B) goto <D.27106>; else goto <D.27107>;
        <D.27106>:
        import = method_aux->dllentry;
        scope = method_aux->dll;
        <D.27107>:
        if (import == 0B) goto <D.27108>; else goto <D.27110>;
        <D.27110>:
        if (scope == 0B) goto <D.27108>; else goto <D.27109>;
        <D.27108>:
        D.27111 = mono_get_exception_argument ("method", "System.Reflection.Emit method with invalid pinvoke information");
        mono_raise_exception (D.27111);
        D.27089 = 0B;
        return D.27089;
        <D.27109>:
      }
      goto <D.27112>;
      <D.27104>:
      D.27113 = piinfo->implmap_idx;
      if (D.27113 != 0) goto <D.27114>; else goto <D.27115>;
      <D.27114>:
      D.27113 = piinfo->implmap_idx;
      D.27116 = (int) D.27113;
      D.27117 = D.27116 + -1;
      mono_metadata_decode_row (im, D.27117, &im_cols, 4);
      D.27118 = im_cols[0];
      D.27119 = (short unsigned int) D.27118;
      piinfo->piflags = D.27119;
      D.27120 = im_cols[2];
      import = mono_metadata_string_heap (image, D.27120);
      D.27121 = im_cols[3];
      D.27122 = D.27121 + 4294967295;
      D.27123 = (int) D.27122;
      scope_token = mono_metadata_decode_row_col (mr, D.27123, 0);
      scope = mono_metadata_string_heap (image, scope_token);
      <D.27115>:
      <D.27112>:
      D.27124 = piinfo->piflags;
      flags = (guint32) D.27124;
      DllImportAttributeClass.51 = DllImportAttributeClass;
      attr = mono_object_new (domain, DllImportAttributeClass.51);
      D.27125 = &attr->dll;
      D.27126 = mono_string_new (domain, scope);
      mono_gc_wbarrier_set_field (attr, D.27125, D.27126);
      D.27127 = &attr->entry_point;
      D.27128 = mono_string_new (domain, import);
      mono_gc_wbarrier_set_field (attr, D.27127, D.27128);
      D.27129 = flags >> 8;
      D.27130 = (int) D.27129;
      D.27131 = D.27130 & 7;
      attr->call_conv = D.27131;
      D.27132 = flags >> 1;
      D.27133 = D.27132 & 3;
      D.27134 = D.27133 + 1;
      D.27135 = (int) D.27134;
      attr->charset = D.27135;
      D.27136 = attr->charset;
      if (D.27136 == 1) goto <D.27137>; else goto <D.27138>;
      <D.27137>:
      attr->charset = 2;
      <D.27138>:
      D.27139 = flags & 1;
      D.27140 = D.27139 != 0;
      D.27141 = (unsigned char) D.27140;
      attr->exact_spelling = D.27141;
      D.27142 = flags & 64;
      D.27143 = D.27142 != 0;
      D.27144 = (unsigned char) D.27143;
      attr->set_last_error = D.27144;
      D.27145 = flags & 48;
      D.27146 = D.27145 == 16;
      D.27147 = (unsigned char) D.27146;
      attr->best_fit_mapping = D.27147;
      D.27148 = flags & 12288;
      D.27149 = D.27148 == 4096;
      D.27150 = (unsigned char) D.27149;
      attr->throw_on_unmappable = D.27150;
      attr->preserve_sig = 0;
      D.27089 = attr;
      return D.27089;
    }
  finally
    {
      im_cols = {CLOBBER};
    }
}


ves_icall_MonoGenericMethod_get_ReflectedType (struct MonoReflectionGenericMethod * rmethod)
{
  struct MonoReflectionType * D.27153;
  struct MonoVTable * D.27154;
  struct MonoDomain * D.27155;
  struct MonoClass * D.27156;
  struct MonoType * D.27157;
  struct MonoMethod * method;

  method = rmethod->method.method;
  D.27154 = MEM[(struct MonoObject *)rmethod].vtable;
  D.27155 = D.27154->domain;
  D.27156 = method->klass;
  D.27157 = &D.27156->byval_arg;
  D.27153 = mono_type_get_object (D.27155, D.27157);
  return D.27153;
}


ves_icall_MonoField_SetValueInternal (struct MonoReflectionField * field, struct MonoObject * obj, struct MonoObject * value)
{
  struct MonoClass * D.27159;
  struct MonoImage * D.27160;
  struct MonoAssembly * D.27161;
  int D.27162;
  struct MonoException * D.27165;
  <unnamed type> D.27166;
  int D.27169;
  long unsigned int D.27172;
  long unsigned int D.27173;
  unsigned char D.27176;
  int D.27177;
  struct MonoGenericInst * D.27180;
  long unsigned int D.27181;
  long unsigned int D.27182;
  _Bool D.27183;
  long int D.27184;
  long int D.27185;
  struct MonoClass * D.27188;
  int D.27189;
  struct MonoDomain * D.27192;
  void * D.27193;
  struct MonoClass * D.27195;
  long unsigned int D.27196;
  long unsigned int D.27197;
  short unsigned int D.27202;
  int D.27203;
  int D.27204;
  struct MonoVTable * D.27207;
  struct MonoDomain * D.27208;
  struct MonoClass * D.27209;
  long unsigned int D.27210;
  long unsigned int D.27211;
  struct MonoError error;
  struct MonoClassField * cf;
  struct MonoType * type;
  gchar * v;

  try
    {
      cf = field->field;
      D.27159 = field->klass;
      D.27160 = D.27159->image;
      D.27161 = D.27160->assembly;
      D.27162 = D.27161->ref_only;
      if (D.27162 != 0) goto <D.27163>; else goto <D.27164>;
      <D.27163>:
      D.27165 = mono_get_exception_invalid_operation ("It is illegal to set the value on a field on a type loaded using the ReflectionOnly methods.");
      mono_raise_exception (D.27165);
      <D.27164>:
      D.27166 = mono_security_get_mode ();
      if (D.27166 == 1) goto <D.27167>; else goto <D.27168>;
      <D.27167>:
      mono_security_core_clr_ensure_reflection_access_field (cf);
      <D.27168>:
      type = mono_field_get_type_checked (cf, &error);
      D.27169 = mono_error_ok (&error);
      if (D.27169 == 0) goto <D.27170>; else goto <D.27171>;
      <D.27170>:
      mono_error_raise_exception (&error);
      <D.27171>:
      v = value;
      D.27172 = BIT_FIELD_REF <*type, 64, 64>;
      D.27173 = D.27172 & 8589934592;
      if (D.27173 == 0) goto <D.27174>; else goto <D.27175>;
      <D.27174>:
      D.27176 = type->type;
      D.27177 = (int) D.27176;
      switch (D.27177) <default: <D.21582>, case 2: <D.21558>, case 3: <D.21561>, case 4: <D.21557>, case 5: <D.21556>, case 6: <D.21560>, case 7: <D.21559>, case 8: <D.21565>, case 9: <D.21564>, case 10: <D.21568>, case 11: <D.21567>, case 12: <D.21566>, case 13: <D.21569>, case 14: <D.21573>, case 15: <D.21571>, case 17: <D.21570>, case 18: <D.21575>, case 20: <D.21576>, case 21: <D.21578>, case 24: <D.21563>, case 25: <D.21562>, case 28: <D.21574>, case 29: <D.21577>>
      <D.21556>:
      <D.21557>:
      <D.21558>:
      <D.21559>:
      <D.21560>:
      <D.21561>:
      <D.21562>:
      <D.21563>:
      <D.21564>:
      <D.21565>:
      <D.21566>:
      <D.21567>:
      <D.21568>:
      <D.21569>:
      <D.21570>:
      <D.21571>:
      if (v != 0B) goto <D.27178>; else goto <D.27179>;
      <D.27178>:
      v = v + 16;
      <D.27179>:
      goto <D.21572>;
      <D.21573>:
      <D.21574>:
      <D.21575>:
      <D.21576>:
      <D.21577>:
      goto <D.21572>;
      <D.21578>:
      {
        struct MonoGenericClass * gclass;

        gclass = type->data.generic_class;
        D.27180 = gclass->context.class_inst;
        D.27181 = BIT_FIELD_REF <*D.27180, 64, 0>;
        D.27182 = D.27181 & 512;
        D.27183 = D.27182 != 0;
        D.27184 = (long int) D.27183;
        D.27185 = __builtin_expect (D.27184, 0);
        if (D.27185 != 0) goto <D.27186>; else goto <D.27187>;
        <D.27186>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 1825, "!gclass->context.class_inst->is_open");
        <D.27187>:
        D.27188 = mono_class_from_mono_type (type);
        D.27189 = mono_class_is_nullable (D.27188);
        if (D.27189 != 0) goto <D.27190>; else goto <D.27191>;
        <D.27190>:
        {
          struct MonoClass * nklass;
          struct MonoObject * nullable;

          nklass = mono_class_from_mono_type (type);
          D.27192 = mono_domain_get ();
          nullable = mono_object_new (D.27192, nklass);
          D.27193 = mono_object_unbox (nullable);
          mono_nullable_init (D.27193, value, nklass);
          v = mono_object_unbox (nullable);
        }
        goto <D.27194>;
        <D.27191>:
        D.27195 = gclass->container_class;
        D.27196 = BIT_FIELD_REF <*D.27195, 64, 256>;
        D.27197 = D.27196 & 1152921504606846976;
        if (D.27197 != 0) goto <D.27198>; else goto <D.27199>;
        <D.27198>:
        if (v != 0B) goto <D.27200>; else goto <D.27201>;
        <D.27200>:
        v = v + 16;
        <D.27201>:
        <D.27199>:
        <D.27194>:
        goto <D.21572>;
      }
      <D.21582>:
      D.27176 = type->type;
      D.27177 = (int) D.27176;
      monoeg_g_log (0B, 4, "type 0x%x not handled in ves_icall_FieldInfo_SetValueInternal", D.27177);
      <D.21583>:
      goto <D.21583>;
      return;
      <D.21572>:
      <D.27175>:
      D.27202 = type->attrs;
      D.27203 = (int) D.27202;
      D.27204 = D.27203 & 16;
      if (D.27204 != 0) goto <D.27205>; else goto <D.27206>;
      <D.27205>:
      {
        struct MonoVTable * vtable;

        D.27207 = MEM[(struct MonoObject *)field].vtable;
        D.27208 = D.27207->domain;
        D.27209 = cf->parent;
        vtable = mono_class_vtable_full (D.27208, D.27209, 1);
        D.27210 = BIT_FIELD_REF <*vtable, 64, 320>;
        D.27211 = D.27210 & 274877906944;
        if (D.27211 == 0) goto <D.27212>; else goto <D.27213>;
        <D.27212>:
        mono_runtime_class_init (vtable);
        <D.27213>:
        mono_field_static_set_value (vtable, cf, v);
      }
      goto <D.27214>;
      <D.27206>:
      mono_field_set_value (obj, cf, v);
      <D.27214>:
    }
  finally
    {
      error = {CLOBBER};
    }
}


ves_icall_MonoField_ResolveType (struct MonoReflectionField * ref_field)
{
  int D.27216;
  struct MonoReflectionType * D.27219;
  struct MonoVTable * D.27220;
  struct MonoDomain * D.27221;
  struct MonoError error;
  struct MonoClassField * field;
  struct MonoType * type;

  try
    {
      field = ref_field->field;
      type = mono_field_get_type_checked (field, &error);
      D.27216 = mono_error_ok (&error);
      if (D.27216 == 0) goto <D.27217>; else goto <D.27218>;
      <D.27217>:
      mono_error_raise_exception (&error);
      <D.27218>:
      D.27220 = MEM[(struct MonoObject *)ref_field].vtable;
      D.27221 = D.27220->domain;
      D.27219 = mono_type_get_object (D.27221, type);
      return D.27219;
    }
  finally
    {
      error = {CLOBBER};
    }
}


ves_icall_MonoField_GetValueInternal (struct MonoReflectionField * field, struct MonoObject * obj)
{
  struct MonoVTable * D.27224;
  struct MonoImage * D.27225;
  struct MonoAssembly * D.27226;
  int D.27227;
  struct MonoException * D.27230;
  <unnamed type> D.27231;
  struct MonoObject * D.27234;
  struct MonoClass * fklass;
  struct MonoClassField * cf;
  struct MonoDomain * domain;

  fklass = field->klass;
  cf = field->field;
  D.27224 = MEM[(struct MonoObject *)field].vtable;
  domain = D.27224->domain;
  D.27225 = fklass->image;
  D.27226 = D.27225->assembly;
  D.27227 = D.27226->ref_only;
  if (D.27227 != 0) goto <D.27228>; else goto <D.27229>;
  <D.27228>:
  D.27230 = mono_get_exception_invalid_operation ("It is illegal to get the value on a field on a type loaded using the ReflectionOnly methods.");
  mono_raise_exception (D.27230);
  <D.27229>:
  D.27231 = mono_security_get_mode ();
  if (D.27231 == 1) goto <D.27232>; else goto <D.27233>;
  <D.27232>:
  mono_security_core_clr_ensure_reflection_access_field (cf);
  <D.27233>:
  D.27234 = mono_field_get_value_object (domain, cf, obj);
  return D.27234;
}


ves_icall_MonoField_GetRawConstantValue (struct MonoReflectionField * this)
{
  struct MonoVTable * D.27236;
  struct MonoClass * D.27237;
  int D.27238;
  short unsigned int D.27241;
  signed short D.27242;
  struct MonoException * D.27245;
  struct MonoImage * D.27246;
  long unsigned int D.27247;
  long unsigned int D.27248;
  struct MonoException * D.27253;
  <unnamed type> def_type.53;
  unsigned char D.27255;
  struct MonoObject * o.54;
  struct MonoObject * o.55;
  struct MonoObject * D.27258;
  struct MonoObject * o;
  struct MonoClassField * field;
  struct MonoClass * klass;
  struct MonoDomain * domain;
  gchar * v;
  MonoTypeEnum def_type;
  const char * def_value;
  struct MonoType * t;
  struct MonoError error;

  try
    {
      o = 0B;
      field = this->field;
      D.27236 = MEM[(struct MonoObject *)this].vtable;
      domain = D.27236->domain;
      D.27237 = field->parent;
      mono_class_init (D.27237);
      t = mono_field_get_type_checked (field, &error);
      D.27238 = mono_error_ok (&error);
      if (D.27238 == 0) goto <D.27239>; else goto <D.27240>;
      <D.27239>:
      mono_error_raise_exception (&error);
      <D.27240>:
      D.27241 = t->attrs;
      D.27242 = (signed short) D.27241;
      if (D.27242 >= 0) goto <D.27243>; else goto <D.27244>;
      <D.27243>:
      D.27245 = mono_get_exception_invalid_operation (0B);
      mono_raise_exception (D.27245);
      <D.27244>:
      D.27237 = field->parent;
      D.27246 = D.27237->image;
      D.27247 = BIT_FIELD_REF <*D.27246, 64, 192>;
      D.27248 = D.27247 & 268435456;
      if (D.27248 != 0) goto <D.27249>; else goto <D.27250>;
      <D.27249>:
      monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "icall.c", 1890);
      <D.27250>:
      def_value = mono_class_get_field_default_value (field, &def_type);
      if (def_value == 0B) goto <D.27251>; else goto <D.27252>;
      <D.27251>:
      D.27253 = mono_get_exception_invalid_operation (0B);
      mono_raise_exception (D.27253);
      <D.27252>:
      def_type.53 = def_type;
      switch (def_type.53) <default: <D.21615>, case 2: <D.21599>, case 3: <D.21602>, case 4: <D.21598>, case 5: <D.21597>, case 6: <D.21601>, case 7: <D.21600>, case 8: <D.21606>, case 9: <D.21605>, case 10: <D.21609>, case 11: <D.21608>, case 12: <D.21607>, case 13: <D.21610>, case 14: <D.21613>, case 18: <D.21614>, case 24: <D.21604>, case 25: <D.21603>>
      <D.21597>:
      <D.21598>:
      <D.21599>:
      <D.21600>:
      <D.21601>:
      <D.21602>:
      <D.21603>:
      <D.21604>:
      <D.21605>:
      <D.21606>:
      <D.21607>:
      <D.21608>:
      <D.21609>:
      <D.21610>:
      {
        struct MonoType * t;

        t = monoeg_malloc0 (16);
        def_type.53 = def_type;
        D.27255 = (unsigned char) def_type.53;
        t->type = D.27255;
        klass = mono_class_from_mono_type (t);
        monoeg_g_free (t);
        o.54 = mono_object_new (domain, klass);
        o = o.54;
        o.55 = o;
        v = o.55 + 16;
        def_type.53 = def_type;
        mono_get_constant_value_from_blob (domain, def_type.53, def_value, v);
        goto <D.21612>;
      }
      <D.21613>:
      <D.21614>:
      def_type.53 = def_type;
      mono_get_constant_value_from_blob (domain, def_type.53, def_value, &o);
      goto <D.21612>;
      <D.21615>:
      monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "icall.c", 1930);
      <D.21612>:
      D.27258 = o;
      return D.27258;
    }
  finally
    {
      o = {CLOBBER};
      def_type = {CLOBBER};
      error = {CLOBBER};
    }
}


ves_icall_MonoField_GetParentType (struct MonoReflectionField * field, MonoBoolean declaring)
{
  struct MonoClass * iftmp.56;
  struct MonoClassField * D.27264;
  struct MonoReflectionType * D.27266;
  struct MonoVTable * D.27267;
  struct MonoDomain * D.27268;
  struct MonoType * D.27269;
  struct MonoClass * parent;

  if (declaring != 0) goto <D.27262>; else goto <D.27263>;
  <D.27262>:
  D.27264 = field->field;
  iftmp.56 = D.27264->parent;
  goto <D.27265>;
  <D.27263>:
  iftmp.56 = field->klass;
  <D.27265>:
  parent = iftmp.56;
  D.27267 = MEM[(struct MonoObject *)field].vtable;
  D.27268 = D.27267->domain;
  D.27269 = &parent->byval_arg;
  D.27266 = mono_type_get_object (D.27268, D.27269);
  return D.27266;
}


ves_icall_MonoField_GetFieldOffset (struct MonoReflectionField * field)
{
  struct MonoClassField * D.27271;
  long unsigned int D.27272;
  long unsigned int D.27273;
  gint32 D.27276;
  int D.27277;
  unsigned int D.27278;
  unsigned int D.27279;
  struct MonoClass * parent;

  D.27271 = field->field;
  parent = D.27271->parent;
  D.27272 = BIT_FIELD_REF <*parent, 64, 256>;
  D.27273 = D.27272 & 2305843009213693952;
  if (D.27273 == 0) goto <D.27274>; else goto <D.27275>;
  <D.27274>:
  mono_class_init (parent);
  <D.27275>:
  D.27271 = field->field;
  D.27277 = D.27271->offset;
  D.27278 = (unsigned int) D.27277;
  D.27279 = D.27278 + 4294967280;
  D.27276 = (gint32) D.27279;
  return D.27276;
}


ves_icall_get_event_info (struct MonoReflectionMonoEvent * event, struct MonoEventInfo * info)
{
  struct MonoVTable * D.27281;
  struct MonoReflectionType * * D.27282;
  struct MonoClass * D.27283;
  struct MonoType * D.27284;
  struct MonoReflectionType * D.27285;
  struct MonoReflectionType * * D.27286;
  struct MonoEvent * D.27287;
  struct MonoClass * D.27288;
  struct MonoType * D.27289;
  struct MonoReflectionType * D.27290;
  struct MonoString * * D.27291;
  const char * D.27292;
  struct MonoString * D.27293;
  unsigned int D.27294;
  struct MonoReflectionMethod * * D.27295;
  struct MonoObject * iftmp.57;
  struct MonoMethod * D.27297;
  struct MonoReflectionMethod * * D.27301;
  struct MonoObject * iftmp.58;
  struct MonoMethod * D.27303;
  struct MonoReflectionMethod * * D.27307;
  struct MonoObject * iftmp.59;
  struct MonoMethod * D.27309;
  struct MonoMethod * * D.27313;
  long unsigned int D.27316;
  long unsigned int D.27317;
  struct MonoMethod * * D.27318;
  struct MonoMethod * D.27319;
  struct MonoArray * * D.27320;
  struct MonoClass * D.27321;
  long unsigned int D.27322;
  struct MonoArray * D.27323;
  struct MonoArray * D.27324;
  long unsigned int D.27325;
  long unsigned int D.27326;
  long unsigned int D.27327;
  struct MonoMethod * * D.27328;
  struct MonoMethod * D.27329;
  struct MonoReflectionMethod * D.27330;
  struct MonoDomain * domain;

  D.27281 = MEM[(struct MonoObject *)event].vtable;
  domain = D.27281->domain;
  D.27282 = &info->reflected_type;
  D.27283 = event->klass;
  D.27284 = &D.27283->byval_arg;
  D.27285 = mono_type_get_object (domain, D.27284);
  mono_gc_wbarrier_generic_store (D.27282, D.27285);
  D.27286 = &info->declaring_type;
  D.27287 = event->event;
  D.27288 = D.27287->parent;
  D.27289 = &D.27288->byval_arg;
  D.27290 = mono_type_get_object (domain, D.27289);
  mono_gc_wbarrier_generic_store (D.27286, D.27290);
  D.27291 = &info->name;
  D.27287 = event->event;
  D.27292 = D.27287->name;
  D.27293 = mono_string_new (domain, D.27292);
  mono_gc_wbarrier_generic_store (D.27291, D.27293);
  D.27287 = event->event;
  D.27294 = D.27287->attrs;
  info->attrs = D.27294;
  D.27295 = &info->add_method;
  D.27287 = event->event;
  D.27297 = D.27287->add;
  if (D.27297 != 0B) goto <D.27298>; else goto <D.27299>;
  <D.27298>:
  D.27287 = event->event;
  D.27297 = D.27287->add;
  iftmp.57 = mono_method_get_object (domain, D.27297, 0B);
  goto <D.27300>;
  <D.27299>:
  iftmp.57 = 0B;
  <D.27300>:
  mono_gc_wbarrier_generic_store (D.27295, iftmp.57);
  D.27301 = &info->remove_method;
  D.27287 = event->event;
  D.27303 = D.27287->remove;
  if (D.27303 != 0B) goto <D.27304>; else goto <D.27305>;
  <D.27304>:
  D.27287 = event->event;
  D.27303 = D.27287->remove;
  iftmp.58 = mono_method_get_object (domain, D.27303, 0B);
  goto <D.27306>;
  <D.27305>:
  iftmp.58 = 0B;
  <D.27306>:
  mono_gc_wbarrier_generic_store (D.27301, iftmp.58);
  D.27307 = &info->raise_method;
  D.27287 = event->event;
  D.27309 = D.27287->raise;
  if (D.27309 != 0B) goto <D.27310>; else goto <D.27311>;
  <D.27310>:
  D.27287 = event->event;
  D.27309 = D.27287->raise;
  iftmp.59 = mono_method_get_object (domain, D.27309, 0B);
  goto <D.27312>;
  <D.27311>:
  iftmp.59 = 0B;
  <D.27312>:
  mono_gc_wbarrier_generic_store (D.27307, iftmp.59);
  D.27287 = event->event;
  D.27313 = D.27287->other;
  if (D.27313 != 0B) goto <D.27314>; else goto <D.27315>;
  <D.27314>:
  {
    int i;
    int n;

    n = 0;
    goto <D.21648>;
    <D.21647>:
    n = n + 1;
    <D.21648>:
    D.27287 = event->event;
    D.27313 = D.27287->other;
    D.27316 = (long unsigned int) n;
    D.27317 = D.27316 * 8;
    D.27318 = D.27313 + D.27317;
    D.27319 = *D.27318;
    if (D.27319 != 0B) goto <D.21647>; else goto <D.21649>;
    <D.21649>:
    D.27320 = &info->other_methods;
    D.27321 = mono_defaults.method_info_class;
    D.27322 = (long unsigned int) n;
    D.27323 = mono_array_new (domain, D.27321, D.27322);
    mono_gc_wbarrier_generic_store (D.27320, D.27323);
    i = 0;
    goto <D.21652>;
    <D.21651>:
    {
      void * * __p;

      D.27324 = info->other_methods;
      D.27325 = (long unsigned int) i;
      __p = mono_array_addr_with_size (D.27324, 8, D.27325);
      D.27324 = info->other_methods;
      D.27287 = event->event;
      D.27313 = D.27287->other;
      D.27326 = (long unsigned int) i;
      D.27327 = D.27326 * 8;
      D.27328 = D.27313 + D.27327;
      D.27329 = *D.27328;
      D.27330 = mono_method_get_object (domain, D.27329, 0B);
      mono_gc_wbarrier_set_arrayref (D.27324, __p, D.27330);
    }
    i = i + 1;
    <D.21652>:
    if (i < n) goto <D.21651>; else goto <D.21653>;
    <D.21653>:
  }
  <D.27315>:
}


ves_icall_InternalInvoke (struct MonoReflectionMethod * method, struct MonoObject * this, struct MonoArray * params, struct MonoException * * exc)
{
  <unnamed type> D.27331;
  short unsigned int D.27334;
  int D.27335;
  int D.27336;
  struct MonoVTable * D.27339;
  struct MonoDomain * D.27340;
  struct MonoClass * D.27341;
  struct MonoVTable * D.27342;
  struct MonoException * D.27345;
  struct MonoObject * D.27346;
  struct MonoObject * D.27349;
  struct MonoClass * D.27352;
  struct MonoImage * D.27353;
  struct MonoException * D.27354;
  long unsigned int D.27355;
  long unsigned int D.27356;
  const char * D.27360;
  int D.27361;
  long unsigned int D.27364;
  long unsigned int D.27365;
  struct MonoException * D.27368;
  struct MonoType * D.27369;
  long unsigned int D.27370;
  long unsigned int D.27371;
  struct MonoException * D.27374;
  int iftmp.60;
  long unsigned int D.27378;
  short unsigned int D.27380;
  int D.27381;
  struct MonoException * D.27384;
  unsigned int D.27385;
  unsigned int D.27386;
  int D.27389;
  struct MonoException * D.27394;
  struct MonoAssembly * D.27395;
  int D.27396;
  struct MonoException * D.27399;
  long unsigned int D.27400;
  long unsigned int D.27401;
  int D.27404;
  struct MonoException * D.27407;
  unsigned char D.27408;
  int D.27411;
  long unsigned int D.27414;
  long unsigned int D.27415;
  long unsigned int D.27416;
  long unsigned int D.27417;
  long unsigned int D.27418;
  uintptr_t * D.27419;
  long unsigned int D.27420;
  char * D.27421;
  void * D.27422;
  int32_t * D.27423;
  int D.27424;
  long unsigned int D.27425;
  int D.27426;
  int D.27430;
  _Bool D.27431;
  long int D.27432;
  long int D.27433;
  long unsigned int D.27436;
  long unsigned int D.27437;
  struct MonoVTable * D.27438;
  struct MonoDomain * D.27439;
  struct MonoMethod * m;
  struct MonoMethodSignature * sig;
  struct MonoImage * image;
  int pcount;
  void * obj;

  m = method->method;
  sig = mono_method_signature (m);
  obj = this;
  *exc = 0B;
  D.27331 = mono_security_get_mode ();
  if (D.27331 == 1) goto <D.27332>; else goto <D.27333>;
  <D.27332>:
  mono_security_core_clr_ensure_reflection_access_method (m);
  <D.27333>:
  D.27334 = m->flags;
  D.27335 = (int) D.27334;
  D.27336 = D.27335 & 16;
  if (D.27336 == 0) goto <D.27337>; else goto <D.27338>;
  <D.27337>:
  D.27339 = MEM[(struct MonoObject *)method].vtable;
  D.27340 = D.27339->domain;
  D.27341 = m->klass;
  D.27342 = mono_class_vtable_full (D.27340, D.27341, 0);
  if (D.27342 == 0B) goto <D.27343>; else goto <D.27344>;
  <D.27343>:
  D.27341 = m->klass;
  D.27345 = mono_class_get_exception_for_failure (D.27341);
  mono_gc_wbarrier_generic_store (exc, D.27345);
  D.27346 = 0B;
  return D.27346;
  <D.27344>:
  if (this != 0B) goto <D.27347>; else goto <D.27348>;
  <D.27347>:
  D.27341 = m->klass;
  D.27349 = mono_object_isinst (this, D.27341);
  if (D.27349 == 0B) goto <D.27350>; else goto <D.27351>;
  <D.27350>:
  {
    char * this_name;
    char * target_name;
    char * msg;

    D.27352 = mono_object_get_class (this);
    this_name = mono_type_get_full_name (D.27352);
    D.27341 = m->klass;
    target_name = mono_type_get_full_name (D.27341);
    msg = monoeg_g_strdup_printf ("Object of type \'%s\' doesn\'t match target type \'%s\'", this_name, target_name);
    D.27353 = mono_defaults.corlib;
    D.27354 = mono_exception_from_name_msg (D.27353, "System.Reflection", "TargetException", msg);
    mono_gc_wbarrier_generic_store (exc, D.27354);
    monoeg_g_free (msg);
    monoeg_g_free (target_name);
    monoeg_g_free (this_name);
    D.27346 = 0B;
    return D.27346;
  }
  <D.27351>:
  m = mono_object_get_virtual_method (this, m);
  D.27341 = m->klass;
  D.27355 = BIT_FIELD_REF <*D.27341, 64, 256>;
  D.27356 = D.27355 & 1152921504606846976;
  if (D.27356 != 0) goto <D.27357>; else goto <D.27358>;
  <D.27357>:
  obj = mono_object_unbox (this);
  <D.27358>:
  goto <D.27359>;
  <D.27348>:
  D.27360 = m->name;
  D.27361 = strcmp (D.27360, ".ctor");
  if (D.27361 != 0) goto <D.27362>; else goto <D.27363>;
  <D.27362>:
  D.27364 = BIT_FIELD_REF <*m, 64, 256>;
  D.27365 = D.27364 & 4467570830351532032;
  if (D.27365 == 0) goto <D.27366>; else goto <D.27367>;
  <D.27366>:
  D.27353 = mono_defaults.corlib;
  D.27368 = mono_exception_from_name_msg (D.27353, "System.Reflection", "TargetException", "Non-static method requires a target.");
  mono_gc_wbarrier_generic_store (exc, D.27368);
  D.27346 = 0B;
  return D.27346;
  <D.27367>:
  <D.27363>:
  <D.27359>:
  <D.27338>:
  D.27369 = sig->ret;
  D.27370 = BIT_FIELD_REF <*D.27369, 64, 64>;
  D.27371 = D.27370 & 8589934592;
  if (D.27371 != 0) goto <D.27372>; else goto <D.27373>;
  <D.27372>:
  D.27353 = mono_defaults.corlib;
  D.27374 = mono_exception_from_name_msg (D.27353, "System", "NotSupportedException", "Cannot invoke method returning ByRef type via reflection");
  mono_gc_wbarrier_generic_store (exc, D.27374);
  D.27346 = 0B;
  return D.27346;
  <D.27373>:
  if (params != 0B) goto <D.27376>; else goto <D.27377>;
  <D.27376>:
  D.27378 = mono_array_length (params);
  iftmp.60 = (int) D.27378;
  goto <D.27379>;
  <D.27377>:
  iftmp.60 = 0;
  <D.27379>:
  pcount = iftmp.60;
  D.27380 = sig->param_count;
  D.27381 = (int) D.27380;
  if (D.27381 != pcount) goto <D.27382>; else goto <D.27383>;
  <D.27382>:
  D.27353 = mono_defaults.corlib;
  D.27384 = mono_exception_from_name (D.27353, "System.Reflection", "TargetParameterCountException");
  mono_gc_wbarrier_generic_store (exc, D.27384);
  D.27346 = 0B;
  return D.27346;
  <D.27383>:
  D.27341 = m->klass;
  D.27385 = D.27341->flags;
  D.27386 = D.27385 & 128;
  if (D.27386 != 0) goto <D.27387>; else goto <D.27388>;
  <D.27387>:
  D.27360 = m->name;
  D.27389 = strcmp (D.27360, ".ctor");
  if (D.27389 == 0) goto <D.27390>; else goto <D.27391>;
  <D.27390>:
  if (this == 0B) goto <D.27392>; else goto <D.27393>;
  <D.27392>:
  D.27353 = mono_defaults.corlib;
  D.27394 = mono_exception_from_name_msg (D.27353, "System.Reflection", "TargetException", "Cannot invoke constructor of an abstract class.");
  mono_gc_wbarrier_generic_store (exc, D.27394);
  D.27346 = 0B;
  return D.27346;
  <D.27393>:
  <D.27391>:
  <D.27388>:
  D.27341 = m->klass;
  image = D.27341->image;
  D.27395 = image->assembly;
  D.27396 = D.27395->ref_only;
  if (D.27396 != 0) goto <D.27397>; else goto <D.27398>;
  <D.27397>:
  D.27399 = mono_get_exception_invalid_operation ("It is illegal to invoke a method on a type loaded using the ReflectionOnly api.");
  mono_gc_wbarrier_generic_store (exc, D.27399);
  D.27346 = 0B;
  return D.27346;
  <D.27398>:
  D.27400 = BIT_FIELD_REF <*image, 64, 192>;
  D.27401 = D.27400 & 268435456;
  if (D.27401 != 0) goto <D.27402>; else goto <D.27403>;
  <D.27402>:
  D.27404 = MEM[(struct MonoDynamicImage *)image].run;
  if (D.27404 == 0) goto <D.27405>; else goto <D.27406>;
  <D.27405>:
  D.27407 = mono_get_exception_not_supported ("Cannot invoke a method in a dynamic assembly without run access.");
  mono_gc_wbarrier_generic_store (exc, D.27407);
  D.27346 = 0B;
  return D.27346;
  <D.27406>:
  <D.27403>:
  D.27341 = m->klass;
  D.27408 = D.27341->rank;
  if (D.27408 != 0) goto <D.27409>; else goto <D.27410>;
  <D.27409>:
  D.27360 = m->name;
  D.27411 = strcmp (D.27360, ".ctor");
  if (D.27411 == 0) goto <D.27412>; else goto <D.27413>;
  <D.27412>:
  {
    int i;
    uintptr_t * lengths;
    intptr_t * lower_bounds;

    D.27414 = mono_array_length (params);
    pcount = (int) D.27414;
    D.27415 = (long unsigned int) pcount;
    D.27416 = D.27415 * 8;
    lengths = __builtin_alloca (D.27416);
    i = 0;
    goto <D.21948>;
    <D.21947>:
    D.27417 = (long unsigned int) i;
    D.27418 = D.27417 * 8;
    D.27419 = lengths + D.27418;
    D.27420 = (long unsigned int) i;
    D.27421 = mono_array_addr_with_size (params, 8, D.27420);
    D.27422 = MEM[(void * *)D.27421];
    D.27423 = D.27422 + 16;
    D.27424 = *D.27423;
    D.27425 = (long unsigned int) D.27424;
    *D.27419 = D.27425;
    i = i + 1;
    <D.21948>:
    if (i < pcount) goto <D.21947>; else goto <D.21949>;
    <D.21949>:
    D.27341 = m->klass;
    D.27408 = D.27341->rank;
    D.27426 = (int) D.27408;
    if (D.27426 == pcount) goto <D.27427>; else goto <D.27428>;
    <D.27427>:
    lower_bounds = 0B;
    goto <D.27429>;
    <D.27428>:
    D.27341 = m->klass;
    D.27408 = D.27341->rank;
    D.27426 = (int) D.27408;
    D.27430 = D.27426 * 2;
    D.27431 = D.27430 != pcount;
    D.27432 = (long int) D.27431;
    D.27433 = __builtin_expect (D.27432, 0);
    if (D.27433 != 0) goto <D.27434>; else goto <D.27435>;
    <D.27434>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 2835, "pcount == (m->klass->rank * 2)");
    <D.27435>:
    lower_bounds = lengths;
    D.27341 = m->klass;
    D.27408 = D.27341->rank;
    D.27436 = (long unsigned int) D.27408;
    D.27437 = D.27436 * 8;
    lengths = lengths + D.27437;
    <D.27429>:
    D.27438 = MEM[(struct MonoObject *)params].vtable;
    D.27439 = D.27438->domain;
    D.27341 = m->klass;
    D.27346 = mono_array_new_full (D.27439, D.27341, lengths, lower_bounds);
    return D.27346;
  }
  <D.27413>:
  <D.27410>:
  D.27346 = mono_runtime_invoke_array (m, obj, params, 0B);
  return D.27346;
}


ves_icall_MonoMethod_GetGenericMethodDefinition (struct MonoReflectionMethod * method)
{
  struct MonoMethod * D.27441;
  long unsigned int D.27442;
  long unsigned int D.27443;
  struct MonoReflectionMethod * D.27446;
  long unsigned int D.27447;
  long unsigned int D.27450;
  long unsigned int D.27451;
  struct MonoClass * D.27454;
  struct MonoImage * D.27455;
  long unsigned int D.27456;
  long unsigned int D.27457;
  struct MonoGHashTable * D.27460;
  struct MonoGenericInst * D.27463;
  struct MonoGenericContext * D.27466;
  struct MonoGenericContext * D.27469;
  struct MonoVTable * D.27470;
  struct MonoDomain * D.27471;
  struct MonoMethodInflated * imethod;
  struct MonoMethod * result;

  D.27441 = method->method;
  D.27442 = BIT_FIELD_REF <*D.27441, 64, 256>;
  D.27443 = D.27442 & 4503599627370496;
  if (D.27443 != 0) goto <D.27444>; else goto <D.27445>;
  <D.27444>:
  D.27446 = method;
  return D.27446;
  <D.27445>:
  D.27441 = method->method;
  D.27442 = BIT_FIELD_REF <*D.27441, 64, 256>;
  D.27447 = D.27442 & 2251799813685248;
  if (D.27447 == 0) goto <D.27448>; else goto <D.27449>;
  <D.27448>:
  D.27446 = 0B;
  return D.27446;
  <D.27449>:
  imethod = method->method;
  result = imethod->declaring;
  D.27450 = BIT_FIELD_REF <*result, 64, 256>;
  D.27451 = D.27450 & 4503599627370496;
  if (D.27451 == 0) goto <D.27452>; else goto <D.27453>;
  <D.27452>:
  D.27446 = 0B;
  return D.27446;
  <D.27453>:
  D.27441 = method->method;
  D.27454 = D.27441->klass;
  D.27455 = D.27454->image;
  D.27456 = BIT_FIELD_REF <*D.27455, 64, 192>;
  D.27457 = D.27456 & 268435456;
  if (D.27457 != 0) goto <D.27458>; else goto <D.27459>;
  <D.27458>:
  {
    struct MonoDynamicImage * image;
    struct MonoReflectionMethod * res;

    D.27441 = method->method;
    D.27454 = D.27441->klass;
    image = D.27454->image;
    mono_image_lock (image);
    D.27460 = image->generic_def_objects;
    res = mono_g_hash_table_lookup (D.27460, imethod);
    mono_image_unlock (image);
    if (res != 0B) goto <D.27461>; else goto <D.27462>;
    <D.27461>:
    D.27446 = res;
    return D.27446;
    <D.27462>:
  }
  <D.27459>:
  D.27463 = imethod->context.class_inst;
  if (D.27463 != 0B) goto <D.27464>; else goto <D.27465>;
  <D.27464>:
  {
    struct MonoClass * klass;

    klass = MEM[(struct MonoMethod *)imethod].klass;
    D.27466 = mono_class_get_context (klass);
    if (D.27466 != 0B) goto <D.27467>; else goto <D.27468>;
    <D.27467>:
    D.27469 = mono_class_get_context (klass);
    result = mono_class_inflate_generic_method_full (result, klass, D.27469);
    <D.27468>:
  }
  <D.27465>:
  D.27470 = MEM[(struct MonoObject *)method].vtable;
  D.27471 = D.27470->domain;
  D.27446 = mono_method_get_object (D.27471, result, 0B);
  return D.27446;
}


ves_icall_System_Reflection_Module_ResolveTypeToken (struct MonoImage * image, guint32 token, struct MonoArray * type_args, struct MonoArray * method_args, MonoResolveTokenError * error)
{
  unsigned int D.27473;
  int token.61;
  unsigned int table.62;
  unsigned int D.27476;
  struct MonoType * D.27481;
  long unsigned int D.27482;
  long unsigned int D.27483;
  struct MonoType * iftmp.63;
  struct MonoType * iftmp.64;
  <unnamed-unsigned:24> D.27499;
  int D.27500;
  struct MonoLoaderError * D.27501;
  struct MonoLoaderError * D.27504;
  struct MonoException * D.27505;
  struct MonoClass * klass;
  int table;
  int index;
  struct MonoGenericContext context;

  try
    {
      D.27473 = token >> 24;
      table = (int) D.27473;
      token.61 = (int) token;
      index = token.61 & 16777215;
      *error = 2;
      table.62 = (unsigned int) table;
      D.27476 = table.62 + 4294967295;
      if (D.27476 > 1) goto <D.27477>; else goto <D.27478>;
      <D.27477>:
      if (table != 27) goto <D.27479>; else goto <D.27480>;
      <D.27479>:
      *error = 1;
      D.27481 = 0B;
      return D.27481;
      <D.27480>:
      <D.27478>:
      D.27482 = BIT_FIELD_REF <*image, 64, 192>;
      D.27483 = D.27482 & 268435456;
      if (D.27483 != 0) goto <D.27484>; else goto <D.27485>;
      <D.27484>:
      table.62 = (unsigned int) table;
      D.27476 = table.62 + 4294967295;
      if (D.27476 <= 1) goto <D.27486>; else goto <D.27487>;
      <D.27486>:
      klass = mono_lookup_dynamic_token_class (image, token, 0, 0B, 0B);
      if (klass != 0B) goto <D.27489>; else goto <D.27490>;
      <D.27489>:
      iftmp.63 = &klass->byval_arg;
      goto <D.27491>;
      <D.27490>:
      iftmp.63 = 0B;
      <D.27491>:
      D.27481 = iftmp.63;
      return D.27481;
      <D.27487>:
      init_generic_context_from_args (&context, type_args, method_args);
      klass = mono_lookup_dynamic_token_class (image, token, 0, 0B, &context);
      if (klass != 0B) goto <D.27493>; else goto <D.27494>;
      <D.27493>:
      iftmp.64 = &klass->byval_arg;
      goto <D.27495>;
      <D.27494>:
      iftmp.64 = 0B;
      <D.27495>:
      D.27481 = iftmp.64;
      return D.27481;
      <D.27485>:
      if (index <= 0) goto <D.27496>; else goto <D.27498>;
      <D.27498>:
      D.27499 = image->tables[table].rows;
      D.27500 = (int) D.27499;
      if (D.27500 < index) goto <D.27496>; else goto <D.27497>;
      <D.27496>:
      *error = 0;
      D.27481 = 0B;
      return D.27481;
      <D.27497>:
      init_generic_context_from_args (&context, type_args, method_args);
      klass = mono_class_get_full (image, token, &context);
      D.27501 = mono_loader_get_last_error ();
      if (D.27501 != 0B) goto <D.27502>; else goto <D.27503>;
      <D.27502>:
      D.27504 = mono_loader_get_last_error ();
      D.27505 = mono_loader_error_prepare_exception (D.27504);
      mono_raise_exception (D.27505);
      <D.27503>:
      if (klass != 0B) goto <D.27506>; else goto <D.27507>;
      <D.27506>:
      D.27481 = &klass->byval_arg;
      return D.27481;
      <D.27507>:
      D.27481 = 0B;
      return D.27481;
    }
  finally
    {
      context = {CLOBBER};
    }
}


init_generic_context_from_args (struct MonoGenericContext * context, struct MonoArray * type_args, struct MonoArray * method_args)
{
  long unsigned int D.27512;
  int D.27513;
  char * D.27514;
  struct MonoGenericInst * D.27515;
  long unsigned int D.27519;
  int D.27520;
  char * D.27521;
  struct MonoGenericInst * D.27522;

  if (type_args != 0B) goto <D.27510>; else goto <D.27511>;
  <D.27510>:
  D.27512 = mono_array_length (type_args);
  D.27513 = (int) D.27512;
  D.27514 = mono_array_addr_with_size (type_args, 8, 0);
  D.27515 = mono_metadata_get_generic_inst (D.27513, D.27514);
  context->class_inst = D.27515;
  goto <D.27516>;
  <D.27511>:
  context->class_inst = 0B;
  <D.27516>:
  if (method_args != 0B) goto <D.27517>; else goto <D.27518>;
  <D.27517>:
  D.27519 = mono_array_length (method_args);
  D.27520 = (int) D.27519;
  D.27521 = mono_array_addr_with_size (method_args, 8, 0);
  D.27522 = mono_metadata_get_generic_inst (D.27520, D.27521);
  context->method_inst = D.27522;
  goto <D.27523>;
  <D.27518>:
  context->method_inst = 0B;
  <D.27523>:
}


ves_icall_System_Reflection_Module_ResolveStringToken (struct MonoImage * image, guint32 token, MonoResolveTokenError * error)
{
  int token.65;
  unsigned int D.27525;
  struct MonoString * D.27528;
  long unsigned int D.27529;
  long unsigned int D.27530;
  unsigned int D.27536;
  unsigned int index.66;
  struct MonoDomain * D.27538;
  unsigned int index.67;
  int index;

  token.65 = (int) token;
  index = token.65 & 16777215;
  *error = 2;
  D.27525 = token & 4278190080;
  if (D.27525 != 1879048192) goto <D.27526>; else goto <D.27527>;
  <D.27526>:
  *error = 1;
  D.27528 = 0B;
  return D.27528;
  <D.27527>:
  D.27529 = BIT_FIELD_REF <*image, 64, 192>;
  D.27530 = D.27529 & 268435456;
  if (D.27530 != 0) goto <D.27531>; else goto <D.27532>;
  <D.27531>:
  D.27528 = mono_lookup_dynamic_token_class (image, token, 0, 0B, 0B);
  return D.27528;
  <D.27532>:
  if (index <= 0) goto <D.27533>; else goto <D.27535>;
  <D.27535>:
  D.27536 = image->heap_us.size;
  index.66 = (unsigned int) index;
  if (D.27536 <= index.66) goto <D.27533>; else goto <D.27534>;
  <D.27533>:
  *error = 0;
  D.27528 = 0B;
  return D.27528;
  <D.27534>:
  D.27538 = mono_domain_get ();
  index.67 = (unsigned int) index;
  D.27528 = mono_ldstr (D.27538, image, index.67);
  return D.27528;
}


ves_icall_System_Reflection_Module_ResolveSignature (struct MonoImage * image, guint32 token, MonoResolveTokenError * error)
{
  unsigned int D.27541;
  int token.68;
  struct MonoArray * D.27545;
  long unsigned int D.27546;
  long unsigned int D.27547;
  struct MonoTableInfo * D.27553;
  <unnamed-unsigned:24> D.27554;
  int D.27555;
  int D.27556;
  const char * ptr.69;
  const char * ptr.70;
  struct MonoDomain * D.27559;
  struct MonoClass * D.27560;
  long unsigned int D.27561;
  char * D.27562;
  long unsigned int D.27563;
  int table;
  int idx;
  struct MonoTableInfo * tables;
  guint32 sig;
  guint32 len;
  const char * ptr;
  struct MonoArray * res;

  try
    {
      D.27541 = token >> 24;
      table = (int) D.27541;
      token.68 = (int) token;
      idx = token.68 & 16777215;
      tables = &image->tables;
      *error = 0;
      if (table != 17) goto <D.27543>; else goto <D.27544>;
      <D.27543>:
      D.27545 = 0B;
      return D.27545;
      <D.27544>:
      D.27546 = BIT_FIELD_REF <*image, 64, 192>;
      D.27547 = D.27546 & 268435456;
      if (D.27547 != 0) goto <D.27548>; else goto <D.27549>;
      <D.27548>:
      D.27545 = 0B;
      return D.27545;
      <D.27549>:
      if (idx == 0) goto <D.27550>; else goto <D.27552>;
      <D.27552>:
      D.27553 = tables + 272;
      D.27554 = D.27553->rows;
      D.27555 = (int) D.27554;
      if (D.27555 < idx) goto <D.27550>; else goto <D.27551>;
      <D.27550>:
      D.27545 = 0B;
      return D.27545;
      <D.27551>:
      D.27553 = tables + 272;
      D.27556 = idx + -1;
      sig = mono_metadata_decode_row_col (D.27553, D.27556, 0);
      ptr.69 = mono_metadata_blob_heap (image, sig);
      ptr = ptr.69;
      ptr.70 = ptr;
      len = mono_metadata_decode_blob_size (ptr.70, &ptr);
      D.27559 = mono_domain_get ();
      D.27560 = mono_defaults.byte_class;
      D.27561 = (long unsigned int) len;
      res = mono_array_new (D.27559, D.27560, D.27561);
      D.27562 = mono_array_addr_with_size (res, 1, 0);
      ptr.70 = ptr;
      D.27563 = (long unsigned int) len;
      memcpy (D.27562, ptr.70, D.27563);
      D.27545 = res;
      return D.27545;
    }
  finally
    {
      ptr = {CLOBBER};
    }
}


ves_icall_System_Reflection_Module_ResolveMethodToken (struct MonoImage * image, guint32 token, struct MonoArray * type_args, struct MonoArray * method_args, MonoResolveTokenError * error)
{
  unsigned int D.27566;
  int token.71;
  struct MonoMethod * D.27574;
  long unsigned int D.27575;
  long unsigned int D.27576;
  int D.27583;
  <unnamed-unsigned:24> D.27589;
  int D.27590;
  int D.27593;
  struct MonoLoaderError * D.27596;
  struct MonoLoaderError * D.27599;
  struct MonoException * D.27600;
  int table;
  int index;
  struct MonoGenericContext context;
  struct MonoMethod * method;

  try
    {
      D.27566 = token >> 24;
      table = (int) D.27566;
      token.71 = (int) token;
      index = token.71 & 16777215;
      *error = 2;
      if (table != 6) goto <D.27568>; else goto <D.27569>;
      <D.27568>:
      if (table != 43) goto <D.27570>; else goto <D.27571>;
      <D.27570>:
      if (table != 10) goto <D.27572>; else goto <D.27573>;
      <D.27572>:
      *error = 1;
      D.27574 = 0B;
      return D.27574;
      <D.27573>:
      <D.27571>:
      <D.27569>:
      D.27575 = BIT_FIELD_REF <*image, 64, 192>;
      D.27576 = D.27575 & 268435456;
      if (D.27576 != 0) goto <D.27577>; else goto <D.27578>;
      <D.27577>:
      if (table == 6) goto <D.27579>; else goto <D.27580>;
      <D.27579>:
      D.27574 = mono_lookup_dynamic_token_class (image, token, 0, 0B, 0B);
      return D.27574;
      <D.27580>:
      if (table == 10) goto <D.27581>; else goto <D.27582>;
      <D.27581>:
      D.27583 = mono_memberref_is_method (image, token);
      if (D.27583 == 0) goto <D.27584>; else goto <D.27585>;
      <D.27584>:
      *error = 1;
      D.27574 = 0B;
      return D.27574;
      <D.27585>:
      <D.27582>:
      init_generic_context_from_args (&context, type_args, method_args);
      D.27574 = mono_lookup_dynamic_token_class (image, token, 0, 0B, &context);
      return D.27574;
      <D.27578>:
      if (index <= 0) goto <D.27586>; else goto <D.27588>;
      <D.27588>:
      D.27589 = image->tables[table].rows;
      D.27590 = (int) D.27589;
      if (D.27590 < index) goto <D.27586>; else goto <D.27587>;
      <D.27586>:
      *error = 0;
      D.27574 = 0B;
      return D.27574;
      <D.27587>:
      if (table == 10) goto <D.27591>; else goto <D.27592>;
      <D.27591>:
      D.27593 = mono_memberref_is_method (image, token);
      if (D.27593 == 0) goto <D.27594>; else goto <D.27595>;
      <D.27594>:
      *error = 1;
      D.27574 = 0B;
      return D.27574;
      <D.27595>:
      <D.27592>:
      init_generic_context_from_args (&context, type_args, method_args);
      method = mono_get_method_full (image, token, 0B, &context);
      D.27596 = mono_loader_get_last_error ();
      if (D.27596 != 0B) goto <D.27597>; else goto <D.27598>;
      <D.27597>:
      D.27599 = mono_loader_get_last_error ();
      D.27600 = mono_loader_error_prepare_exception (D.27599);
      mono_raise_exception (D.27600);
      <D.27598>:
      D.27574 = method;
      return D.27574;
    }
  finally
    {
      context = {CLOBBER};
    }
}


mono_memberref_is_method (struct MonoImage * image, guint32 token)
{
  long unsigned int D.27603;
  long unsigned int D.27604;
  struct MonoTableInfo * D.27607;
  unsigned int D.27608;
  unsigned int D.27609;
  int D.27610;
  unsigned int D.27611;
  const char * sig.72;
  const char * sig.73;
  gboolean D.27614;
  char D.27615;
  _Bool D.27616;
  void * D.27617;
  struct MonoClass * D.27620;
  struct MonoClass * handle_class.74;
  _Bool D.27622;

  D.27603 = BIT_FIELD_REF <*image, 64, 192>;
  D.27604 = D.27603 & 268435456;
  if (D.27604 == 0) goto <D.27605>; else goto <D.27606>;
  <D.27605>:
  {
    guint32 cols[3];
    const char * sig;

    try
      {
        D.27607 = &image->tables[10];
        D.27608 = token & 16777215;
        D.27609 = D.27608 + 4294967295;
        D.27610 = (int) D.27609;
        mono_metadata_decode_row (D.27607, D.27610, &cols, 3);
        D.27611 = cols[2];
        sig.72 = mono_metadata_blob_heap (image, D.27611);
        sig = sig.72;
        sig.73 = sig;
        mono_metadata_decode_blob_size (sig.73, &sig);
        sig.73 = sig;
        D.27615 = *sig.73;
        D.27616 = D.27615 != 6;
        D.27614 = (gboolean) D.27616;
        return D.27614;
      }
    finally
      {
        cols = {CLOBBER};
        sig = {CLOBBER};
      }
  }
  <D.27606>:
  {
    struct MonoClass * handle_class;

    try
      {
        D.27617 = mono_lookup_dynamic_token_class (image, token, 0, &handle_class, 0B);
        if (D.27617 == 0B) goto <D.27618>; else goto <D.27619>;
        <D.27618>:
        D.27614 = 0;
        return D.27614;
        <D.27619>:
        D.27620 = mono_defaults.methodhandle_class;
        handle_class.74 = handle_class;
        D.27622 = D.27620 == handle_class.74;
        D.27614 = (gboolean) D.27622;
        return D.27614;
      }
    finally
      {
        handle_class = {CLOBBER};
      }
  }
}


ves_icall_System_Reflection_Module_ResolveMemberToken (struct MonoImage * image, guint32 token, struct MonoArray * type_args, struct MonoArray * method_args, MonoResolveTokenError * error)
{
  unsigned int D.27626;
  struct MonoObject * D.27629;
  struct MonoDomain * D.27630;
  struct MonoDomain * D.27633;
  struct MonoClass * D.27634;
  struct MonoDomain * D.27637;
  struct MonoClass * D.27638;
  int D.27639;
  struct MonoDomain * D.27644;
  struct MonoClass * D.27645;
  struct MonoDomain * D.27648;
  struct MonoClass * D.27649;
  int table;

  D.27626 = token >> 24;
  table = (int) D.27626;
  *error = 2;
  switch (table) <default: <D.22938>, case 1: <D.22927>, case 2: <D.22926>, case 4: <D.22933>, case 6: <D.22930>, case 10: <D.22935>, case 27: <D.22928>, case 43: <D.22931>>
  <D.22926>:
  <D.22927>:
  <D.22928>:
  {
    struct MonoType * t;

    t = ves_icall_System_Reflection_Module_ResolveTypeToken (image, token, type_args, method_args, error);
    if (t != 0B) goto <D.27627>; else goto <D.27628>;
    <D.27627>:
    D.27630 = mono_domain_get ();
    D.27629 = mono_type_get_object (D.27630, t);
    return D.27629;
    <D.27628>:
    D.27629 = 0B;
    return D.27629;
  }
  <D.22930>:
  <D.22931>:
  {
    struct MonoMethod * m;

    m = ves_icall_System_Reflection_Module_ResolveMethodToken (image, token, type_args, method_args, error);
    if (m != 0B) goto <D.27631>; else goto <D.27632>;
    <D.27631>:
    D.27633 = mono_domain_get ();
    D.27634 = m->klass;
    D.27629 = mono_method_get_object (D.27633, m, D.27634);
    return D.27629;
    <D.27632>:
    D.27629 = 0B;
    return D.27629;
  }
  <D.22933>:
  {
    struct MonoClassField * f;

    f = ves_icall_System_Reflection_Module_ResolveFieldToken (image, token, type_args, method_args, error);
    if (f != 0B) goto <D.27635>; else goto <D.27636>;
    <D.27635>:
    D.27637 = mono_domain_get ();
    D.27638 = f->parent;
    D.27629 = mono_field_get_object (D.27637, D.27638, f);
    return D.27629;
    <D.27636>:
    D.27629 = 0B;
    return D.27629;
  }
  <D.22935>:
  D.27639 = mono_memberref_is_method (image, token);
  if (D.27639 != 0) goto <D.27640>; else goto <D.27641>;
  <D.27640>:
  {
    struct MonoMethod * m;

    m = ves_icall_System_Reflection_Module_ResolveMethodToken (image, token, type_args, method_args, error);
    if (m != 0B) goto <D.27642>; else goto <D.27643>;
    <D.27642>:
    D.27644 = mono_domain_get ();
    D.27645 = m->klass;
    D.27629 = mono_method_get_object (D.27644, m, D.27645);
    return D.27629;
    <D.27643>:
    D.27629 = 0B;
    return D.27629;
  }
  <D.27641>:
  {
    struct MonoClassField * f;

    f = ves_icall_System_Reflection_Module_ResolveFieldToken (image, token, type_args, method_args, error);
    if (f != 0B) goto <D.27646>; else goto <D.27647>;
    <D.27646>:
    D.27648 = mono_domain_get ();
    D.27649 = f->parent;
    D.27629 = mono_field_get_object (D.27648, D.27649, f);
    return D.27629;
    <D.27647>:
    D.27629 = 0B;
    return D.27629;
  }
  <D.22938>:
  *error = 1;
  D.27629 = 0B;
  return D.27629;
}


ves_icall_System_Reflection_Module_ResolveFieldToken (struct MonoImage * image, guint32 token, struct MonoArray * type_args, struct MonoArray * method_args, MonoResolveTokenError * error)
{
  unsigned int D.27651;
  int token.75;
  struct MonoClassField * D.27657;
  long unsigned int D.27658;
  long unsigned int D.27659;
  int D.27664;
  <unnamed-unsigned:24> D.27670;
  int D.27671;
  int D.27674;
  struct MonoLoaderError * D.27677;
  struct MonoLoaderError * D.27680;
  struct MonoException * D.27681;
  struct MonoClass * klass;
  int table;
  int index;
  struct MonoGenericContext context;
  struct MonoClassField * field;

  try
    {
      D.27651 = token >> 24;
      table = (int) D.27651;
      token.75 = (int) token;
      index = token.75 & 16777215;
      *error = 2;
      if (table != 4) goto <D.27653>; else goto <D.27654>;
      <D.27653>:
      if (table != 10) goto <D.27655>; else goto <D.27656>;
      <D.27655>:
      *error = 1;
      D.27657 = 0B;
      return D.27657;
      <D.27656>:
      <D.27654>:
      D.27658 = BIT_FIELD_REF <*image, 64, 192>;
      D.27659 = D.27658 & 268435456;
      if (D.27659 != 0) goto <D.27660>; else goto <D.27661>;
      <D.27660>:
      if (table == 4) goto <D.27662>; else goto <D.27663>;
      <D.27662>:
      D.27657 = mono_lookup_dynamic_token_class (image, token, 0, 0B, 0B);
      return D.27657;
      <D.27663>:
      D.27664 = mono_memberref_is_method (image, token);
      if (D.27664 != 0) goto <D.27665>; else goto <D.27666>;
      <D.27665>:
      *error = 1;
      D.27657 = 0B;
      return D.27657;
      <D.27666>:
      init_generic_context_from_args (&context, type_args, method_args);
      D.27657 = mono_lookup_dynamic_token_class (image, token, 0, 0B, &context);
      return D.27657;
      <D.27661>:
      if (index <= 0) goto <D.27667>; else goto <D.27669>;
      <D.27669>:
      D.27670 = image->tables[table].rows;
      D.27671 = (int) D.27670;
      if (D.27671 < index) goto <D.27667>; else goto <D.27668>;
      <D.27667>:
      *error = 0;
      D.27657 = 0B;
      return D.27657;
      <D.27668>:
      if (table == 10) goto <D.27672>; else goto <D.27673>;
      <D.27672>:
      D.27674 = mono_memberref_is_method (image, token);
      if (D.27674 != 0) goto <D.27675>; else goto <D.27676>;
      <D.27675>:
      *error = 1;
      D.27657 = 0B;
      return D.27657;
      <D.27676>:
      <D.27673>:
      init_generic_context_from_args (&context, type_args, method_args);
      field = mono_field_from_token (image, token, &klass, &context);
      D.27677 = mono_loader_get_last_error ();
      if (D.27677 != 0B) goto <D.27678>; else goto <D.27679>;
      <D.27678>:
      D.27680 = mono_loader_get_last_error ();
      D.27681 = mono_loader_error_prepare_exception (D.27680);
      mono_raise_exception (D.27681);
      <D.27679>:
      D.27657 = field;
      return D.27657;
    }
  finally
    {
      klass = {CLOBBER};
      context = {CLOBBER};
    }
}


ves_icall_System_Reflection_Module_InternalGetTypes (struct MonoReflectionModule * module)
{
  struct MonoImage * D.27684;
  struct MonoArray * D.27687;
  struct MonoVTable * D.27688;
  struct MonoDomain * D.27689;
  struct MonoClass * D.27690;
  struct MonoArray * exceptions.76;
  long unsigned int D.27692;
  char * D.27693;
  long unsigned int D.27696;
  struct MonoArray * exceptions;
  int i;

  try
    {
      D.27684 = module->image;
      if (D.27684 == 0B) goto <D.27685>; else goto <D.27686>;
      <D.27685>:
      D.27688 = MEM[(struct MonoObject *)module].vtable;
      D.27689 = D.27688->domain;
      D.27690 = mono_defaults.monotype_class;
      D.27687 = mono_array_new (D.27689, D.27690, 0);
      return D.27687;
      <D.27686>:
      {
        struct MonoArray * res;

        D.27688 = MEM[(struct MonoObject *)module].vtable;
        D.27689 = D.27688->domain;
        D.27684 = module->image;
        res = mono_module_get_types (D.27689, D.27684, &exceptions, 0);
        i = 0;
        goto <D.22864>;
        <D.22863>:
        {
          struct MonoException * ex;

          exceptions.76 = exceptions;
          D.27692 = (long unsigned int) i;
          D.27693 = mono_array_addr_with_size (exceptions.76, 8, D.27692);
          ex = MEM[(struct MonoException * *)D.27693];
          if (ex != 0B) goto <D.27694>; else goto <D.27695>;
          <D.27694>:
          mono_raise_exception (ex);
          <D.27695>:
        }
        i = i + 1;
        <D.22864>:
        D.27692 = (long unsigned int) i;
        exceptions.76 = exceptions;
        D.27696 = mono_array_length (exceptions.76);
        if (D.27692 < D.27696) goto <D.22863>; else goto <D.22865>;
        <D.22865>:
        D.27687 = res;
        return D.27687;
      }
    }
  finally
    {
      exceptions = {CLOBBER};
    }
}


mono_module_get_types (struct MonoDomain * domain, struct MonoImage * image, struct MonoArray * * exceptions, MonoBoolean exportedOnly)
{
  unsigned int D.27701;
  <unnamed-unsigned:24> D.27704;
  int D.27705;
  struct MonoClass * D.27707;
  long unsigned int D.27708;
  struct MonoClass * D.27709;
  struct MonoArray * D.27710;
  int D.27714;
  int D.27715;
  unsigned int D.27716;
  struct MonoType * D.27719;
  struct MonoReflectionType * D.27720;
  _Bool D.27722;
  long int D.27723;
  long int D.27724;
  struct MonoArray * D.27727;
  struct MonoLoaderError * D.27728;
  struct MonoArray * D.27731;
  struct MonoArray * res;
  struct MonoClass * klass;
  struct MonoTableInfo * tdef;
  int i;
  int count;
  guint32 attrs;
  guint32 visibility;

  tdef = &image->tables[2];
  if (exportedOnly != 0) goto <D.27699>; else goto <D.27700>;
  <D.27699>:
  count = 0;
  i = 1;
  goto <D.22762>;
  <D.22761>:
  attrs = mono_metadata_decode_row_col (tdef, i, 0);
  visibility = attrs & 7;
  D.27701 = visibility + 4294967295;
  if (D.27701 <= 1) goto <D.27702>; else goto <D.27703>;
  <D.27702>:
  count = count + 1;
  <D.27703>:
  i = i + 1;
  <D.22762>:
  D.27704 = tdef->rows;
  D.27705 = (int) D.27704;
  if (D.27705 > i) goto <D.22761>; else goto <D.22763>;
  <D.22763>:
  goto <D.27706>;
  <D.27700>:
  D.27704 = tdef->rows;
  D.27705 = (int) D.27704;
  count = D.27705 + -1;
  <D.27706>:
  D.27707 = mono_defaults.monotype_class;
  D.27708 = (long unsigned int) count;
  res = mono_array_new (domain, D.27707, D.27708);
  D.27709 = mono_defaults.exception_class;
  D.27708 = (long unsigned int) count;
  D.27710 = mono_array_new (domain, D.27709, D.27708);
  *exceptions = D.27710;
  count = 0;
  i = 1;
  goto <D.22769>;
  <D.22768>:
  attrs = mono_metadata_decode_row_col (tdef, i, 0);
  visibility = attrs & 7;
  if (exportedOnly == 0) goto <D.27711>; else goto <D.27713>;
  <D.27713>:
  D.27701 = visibility + 4294967295;
  if (D.27701 <= 1) goto <D.27711>; else goto <D.27712>;
  <D.27711>:
  D.27714 = i + 1;
  D.27715 = D.27714 | 33554432;
  D.27716 = (unsigned int) D.27715;
  klass = mono_class_get (image, D.27716);
  if (klass != 0B) goto <D.27717>; else goto <D.27718>;
  <D.27717>:
  {
    void * * __p;

    D.27708 = (long unsigned int) count;
    __p = mono_array_addr_with_size (res, 8, D.27708);
    D.27719 = &klass->byval_arg;
    D.27720 = mono_type_get_object (domain, D.27719);
    mono_gc_wbarrier_set_arrayref (res, __p, D.27720);
  }
  goto <D.27721>;
  <D.27718>:
  {
    struct MonoLoaderError * error;
    struct MonoException * ex;

    error = mono_loader_get_last_error ();
    D.27722 = error == 0B;
    D.27723 = (long int) D.27722;
    D.27724 = __builtin_expect (D.27723, 0);
    if (D.27724 != 0) goto <D.27725>; else goto <D.27726>;
    <D.27725>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 5142, "error != NULL");
    <D.27726>:
    ex = mono_loader_error_prepare_exception (error);
    {
      void * * __p;

      D.27727 = *exceptions;
      D.27708 = (long unsigned int) count;
      __p = mono_array_addr_with_size (D.27727, 8, D.27708);
      D.27727 = *exceptions;
      mono_gc_wbarrier_set_arrayref (D.27727, __p, ex);
    }
  }
  <D.27721>:
  D.27728 = mono_loader_get_last_error ();
  if (D.27728 != 0B) goto <D.27729>; else goto <D.27730>;
  <D.27729>:
  mono_loader_clear_error ();
  <D.27730>:
  count = count + 1;
  <D.27712>:
  i = i + 1;
  <D.22769>:
  D.27704 = tdef->rows;
  D.27705 = (int) D.27704;
  if (D.27705 > i) goto <D.22768>; else goto <D.22770>;
  <D.22770>:
  D.27731 = res;
  return D.27731;
}


ves_icall_System_Reflection_Module_GetPEKind (struct MonoImage * image, gint32 * pe_kind, gint32 * machine)
{
  long unsigned int D.27733;
  long unsigned int D.27734;
  unsigned int D.27737;
  int D.27738;
  unsigned int D.27739;
  int D.27740;
  void * D.27742;
  unsigned int D.27743;
  int D.27744;
  int D.27745;
  short unsigned int D.27746;
  int D.27747;

  D.27733 = BIT_FIELD_REF <*image, 64, 192>;
  D.27734 = D.27733 & 268435456;
  if (D.27734 != 0) goto <D.27735>; else goto <D.27736>;
  <D.27735>:
  {
    struct MonoDynamicImage * dyn;

    dyn = image;
    D.27737 = dyn->pe_kind;
    D.27738 = (int) D.27737;
    *pe_kind = D.27738;
    D.27739 = dyn->machine;
    D.27740 = (int) D.27739;
    *machine = D.27740;
  }
  goto <D.27741>;
  <D.27736>:
  D.27742 = image->image_info;
  D.27743 = MEM[(struct MonoCLIImageInfo *)D.27742].cli_cli_header.ch_flags;
  D.27744 = (int) D.27743;
  D.27745 = D.27744 & 3;
  *pe_kind = D.27745;
  D.27742 = image->image_info;
  D.27746 = MEM[(struct MonoCLIImageInfo *)D.27742].cli_header.coff.coff_machine;
  D.27747 = (int) D.27746;
  *machine = D.27747;
  <D.27741>:
}


ves_icall_System_Reflection_Module_GetMDStreamVersion (struct MonoImage * image)
{
  gint32 D.27748;
  short int D.27749;
  int D.27750;
  int D.27751;
  short int D.27752;
  int D.27753;

  D.27749 = image->md_version_major;
  D.27750 = (int) D.27749;
  D.27751 = D.27750 << 16;
  D.27752 = image->md_version_minor;
  D.27753 = (int) D.27752;
  D.27748 = D.27751 | D.27753;
  return D.27748;
}


ves_icall_System_Reflection_Module_GetHINSTANCE (struct MonoReflectionModule * module)
{
  void * D.27755;

  D.27755 = -1B;
  return D.27755;
}


ves_icall_System_Reflection_Module_GetGuidInternal (struct MonoReflectionModule * module)
{
  struct MonoVTable * D.27757;
  struct MonoImage * D.27758;
  _Bool D.27759;
  long int D.27760;
  long int D.27761;
  struct MonoString * D.27764;
  char * D.27765;
  struct MonoDomain * domain;

  D.27757 = MEM[(struct MonoObject *)module].vtable;
  domain = D.27757->domain;
  D.27758 = module->image;
  D.27759 = D.27758 == 0B;
  D.27760 = (long int) D.27759;
  D.27761 = __builtin_expect (D.27760, 0);
  if (D.27761 != 0) goto <D.27762>; else goto <D.27763>;
  <D.27762>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 5323, "module->image");
  <D.27763>:
  D.27758 = module->image;
  D.27765 = D.27758->guid;
  D.27764 = mono_string_new (domain, D.27765);
  return D.27764;
}


ves_icall_System_Reflection_Module_GetGlobalType (struct MonoReflectionModule * module)
{
  struct MonoVTable * D.27767;
  struct MonoImage * D.27768;
  _Bool D.27769;
  long int D.27770;
  long int D.27771;
  long unsigned int D.27774;
  long unsigned int D.27775;
  int D.27778;
  struct MonoReflectionType * D.27781;
  struct MonoType * D.27782;
  struct MonoDomain * domain;
  struct MonoClass * klass;

  D.27767 = MEM[(struct MonoObject *)module].vtable;
  domain = D.27767->domain;
  D.27768 = module->image;
  D.27769 = D.27768 == 0B;
  D.27770 = (long int) D.27769;
  D.27771 = __builtin_expect (D.27770, 0);
  if (D.27771 != 0) goto <D.27772>; else goto <D.27773>;
  <D.27772>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 5299, "module->image");
  <D.27773>:
  D.27768 = module->image;
  D.27774 = BIT_FIELD_REF <*D.27768, 64, 192>;
  D.27775 = D.27774 & 268435456;
  if (D.27775 != 0) goto <D.27776>; else goto <D.27777>;
  <D.27776>:
  D.27768 = module->image;
  D.27778 = MEM[(struct MonoDynamicImage *)D.27768].initial_image;
  if (D.27778 != 0) goto <D.27779>; else goto <D.27780>;
  <D.27779>:
  D.27781 = 0B;
  return D.27781;
  <D.27780>:
  <D.27777>:
  D.27768 = module->image;
  klass = mono_class_get (D.27768, 33554433);
  D.27782 = &klass->byval_arg;
  D.27781 = mono_type_get_object (domain, D.27782);
  return D.27781;
}


ves_icall_System_Reflection_Module_Close (struct MonoReflectionModule * module)
{

}


ves_icall_System_Reflection_MethodBase_GetMethodFromHandleInternalType (struct MonoMethod * method, struct MonoType * type)
{
  struct MonoClass * D.27786;
  struct MonoClass * D.27787;
  struct MonoClass * D.27788;
  struct MonoReflectionMethod * D.27791;
  struct MonoDomain * D.27797;
  struct MonoClass * klass;

  if (type != 0B) goto <D.27784>; else goto <D.27785>;
  <D.27784>:
  klass = mono_class_from_mono_type (type);
  D.27786 = method->klass;
  D.27787 = mono_class_get_generic_type_definition (D.27786);
  D.27788 = mono_class_get_generic_type_definition (klass);
  if (D.27787 != D.27788) goto <D.27789>; else goto <D.27790>;
  <D.27789>:
  D.27791 = 0B;
  return D.27791;
  <D.27790>:
  D.27786 = method->klass;
  if (D.27786 != klass) goto <D.27792>; else goto <D.27793>;
  <D.27792>:
  method = mono_method_get_equivalent_method (method, klass);
  if (method == 0B) goto <D.27794>; else goto <D.27795>;
  <D.27794>:
  D.27791 = 0B;
  return D.27791;
  <D.27795>:
  <D.27793>:
  goto <D.27796>;
  <D.27785>:
  klass = method->klass;
  <D.27796>:
  D.27797 = mono_domain_get ();
  D.27791 = mono_method_get_object (D.27797, method, klass);
  return D.27791;
}


mono_method_get_equivalent_method (struct MonoMethod * method, struct MonoClass * klass)
{
  long unsigned int D.27799;
  long unsigned int D.27800;
  struct MonoGenericInst * D.27803;
  struct MonoGenericInst * D.27806;
  struct MonoGenericInst * D.27807;
  struct MonoGenericClass * D.27808;
  struct MonoGenericInst * D.27811;
  struct MonoGenericContainer * D.27813;
  struct MonoGenericInst * D.27816;
  struct MonoMethod * D.27817;
  struct MonoMethod * D.27818;
  struct MonoClass * D.27819;
  unsigned char D.27820;
  struct MonoMethod * * D.27823;
  long unsigned int D.27824;
  long unsigned int D.27825;
  struct MonoMethod * * D.27826;
  struct MonoMethod * D.27827;
  unsigned int D.27830;
  unsigned int i.77;
  unsigned char D.27832;
  int iftmp.78;
  unsigned int D.27840;
  unsigned int offset.79;
  _Bool D.27842;
  long int D.27843;
  long int D.27844;
  struct MonoMethod * * D.27847;
  long unsigned int D.27848;
  long unsigned int D.27849;
  struct MonoMethod * * D.27850;
  int offset;
  int i;

  offset = -1;
  D.27799 = BIT_FIELD_REF <*method, 64, 256>;
  D.27800 = D.27799 & 2251799813685248;
  if (D.27800 != 0) goto <D.27801>; else goto <D.27802>;
  <D.27801>:
  D.27803 = MEM[(struct MonoMethodInflated *)method].context.method_inst;
  if (D.27803 != 0B) goto <D.27804>; else goto <D.27805>;
  <D.27804>:
  {
    struct MonoMethodInflated * inflated;
    struct MonoGenericContext ctx;

    try
      {
        inflated = method;
        D.27806 = inflated->context.method_inst;
        ctx.method_inst = D.27806;
        D.27807 = inflated->context.class_inst;
        ctx.class_inst = D.27807;
        D.27808 = klass->generic_class;
        if (D.27808 != 0B) goto <D.27809>; else goto <D.27810>;
        <D.27809>:
        D.27808 = klass->generic_class;
        D.27811 = D.27808->context.class_inst;
        ctx.class_inst = D.27811;
        goto <D.27812>;
        <D.27810>:
        D.27813 = klass->generic_container;
        if (D.27813 != 0B) goto <D.27814>; else goto <D.27815>;
        <D.27814>:
        D.27813 = klass->generic_container;
        D.27816 = D.27813->context.class_inst;
        ctx.class_inst = D.27816;
        <D.27815>:
        <D.27812>:
        D.27818 = inflated->declaring;
        D.27817 = mono_class_inflate_generic_method_full (D.27818, klass, &ctx);
        return D.27817;
      }
    finally
      {
        ctx = {CLOBBER};
      }
  }
  <D.27805>:
  <D.27802>:
  D.27819 = method->klass;
  mono_class_setup_methods (D.27819);
  D.27819 = method->klass;
  D.27820 = D.27819->exception_type;
  if (D.27820 != 0) goto <D.27821>; else goto <D.27822>;
  <D.27821>:
  D.27817 = 0B;
  return D.27817;
  <D.27822>:
  i = 0;
  goto <D.22651>;
  <D.22650>:
  D.27819 = method->klass;
  D.27823 = D.27819->methods;
  D.27824 = (long unsigned int) i;
  D.27825 = D.27824 * 8;
  D.27826 = D.27823 + D.27825;
  D.27827 = *D.27826;
  if (D.27827 == method) goto <D.27828>; else goto <D.27829>;
  <D.27828>:
  offset = i;
  goto <D.22649>;
  <D.27829>:
  i = i + 1;
  <D.22651>:
  D.27819 = method->klass;
  D.27830 = D.27819->method.count;
  i.77 = (unsigned int) i;
  if (D.27830 > i.77) goto <D.22650>; else goto <D.22649>;
  <D.22649>:
  mono_class_setup_methods (klass);
  D.27832 = klass->exception_type;
  if (D.27832 != 0) goto <D.27833>; else goto <D.27834>;
  <D.27833>:
  D.27817 = 0B;
  return D.27817;
  <D.27834>:
  if (offset < 0) goto <D.27836>; else goto <D.27839>;
  <D.27839>:
  D.27840 = klass->method.count;
  offset.79 = (unsigned int) offset;
  if (D.27840 <= offset.79) goto <D.27836>; else goto <D.27837>;
  <D.27836>:
  iftmp.78 = 1;
  goto <D.27838>;
  <D.27837>:
  iftmp.78 = 0;
  <D.27838>:
  D.27842 = iftmp.78 != 0;
  D.27843 = (long int) D.27842;
  D.27844 = __builtin_expect (D.27843, 0);
  if (D.27844 != 0) goto <D.27845>; else goto <D.27846>;
  <D.27845>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 4779, "offset >= 0 && offset < klass->method.count");
  <D.27846>:
  D.27847 = klass->methods;
  D.27848 = (long unsigned int) offset;
  D.27849 = D.27848 * 8;
  D.27850 = D.27847 + D.27849;
  D.27817 = *D.27850;
  return D.27817;
}


ves_icall_System_Reflection_MethodBase_GetMethodFromHandleInternal (struct MonoMethod * method)
{
  struct MonoReflectionMethod * D.27853;
  struct MonoDomain * D.27854;

  D.27854 = mono_domain_get ();
  D.27853 = mono_method_get_object (D.27854, method, 0B);
  return D.27853;
}


ves_icall_System_Reflection_MethodBase_GetMethodBodyInternal (struct MonoMethod * method)
{
  struct MonoReflectionMethodBody * D.27856;
  struct MonoDomain * D.27857;

  D.27857 = mono_domain_get ();
  D.27856 = mono_method_body_get_object (D.27857, method);
  return D.27856;
}


ves_icall_GetCurrentMethod ()
{
  long unsigned int D.27859;
  long unsigned int D.27860;
  struct MonoReflectionMethod * D.27861;
  struct MonoDomain * D.27862;
  struct MonoMethod * m;

  m = mono_method_get_last_managed ();
  goto <D.22639>;
  <D.22638>:
  m = MEM[(struct MonoMethodInflated *)m].declaring;
  <D.22639>:
  D.27859 = BIT_FIELD_REF <*m, 64, 256>;
  D.27860 = D.27859 & 2251799813685248;
  if (D.27860 != 0) goto <D.22638>; else goto <D.22640>;
  <D.22640>:
  D.27862 = mono_domain_get ();
  D.27861 = mono_method_get_object (D.27862, m, 0B);
  return D.27861;
}


ves_icall_System_Reflection_FieldInfo_internal_from_handle_type (struct MonoClassField * handle, struct MonoType * type)
{
  _Bool D.27864;
  long int D.27865;
  long int D.27866;
  struct MonoClass * D.27872;
  struct MonoReflectionField * D.27877;
  struct MonoDomain * D.27878;
  gboolean found;
  struct MonoClass * klass;
  struct MonoClass * k;

  found = 0;
  D.27864 = handle == 0B;
  D.27865 = (long int) D.27864;
  D.27866 = __builtin_expect (D.27865, 0);
  if (D.27866 != 0) goto <D.27867>; else goto <D.27868>;
  <D.27867>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 1637, "handle");
  <D.27868>:
  if (type == 0B) goto <D.27869>; else goto <D.27870>;
  <D.27869>:
  klass = handle->parent;
  goto <D.27871>;
  <D.27870>:
  klass = mono_class_from_mono_type (type);
  k = klass;
  goto <D.21499>;
  <D.21498>:
  D.27872 = handle->parent;
  if (D.27872 == k) goto <D.27873>; else goto <D.27874>;
  <D.27873>:
  found = 1;
  goto <D.21497>;
  <D.27874>:
  k = k->parent;
  <D.21499>:
  if (k != 0B) goto <D.21498>; else goto <D.21497>;
  <D.21497>:
  if (found == 0) goto <D.27875>; else goto <D.27876>;
  <D.27875>:
  D.27877 = 0B;
  return D.27877;
  <D.27876>:
  <D.27871>:
  D.27878 = mono_domain_get ();
  D.27877 = mono_field_get_object (D.27878, klass, handle);
  return D.27877;
}


ves_icall_System_Reflection_FieldInfo_get_marshal_info (struct MonoReflectionField * field)
{
  struct MonoClassField * D.27880;
  struct MonoGenericContainer * D.27883;
  struct MonoGenericClass * D.27885;
  struct MonoGenericInst * D.27887;
  long unsigned int D.27888;
  long unsigned int D.27889;
  struct MonoReflectionMarshalAsAttribute * D.27890;
  struct MonoClassField * D.27891;
  struct MonoMarshalSpec * D.27894;
  struct MonoVTable * D.27897;
  struct MonoDomain * D.27898;
  unsigned int D.27899;
  unsigned int i.80;
  struct MonoClass * klass;
  struct MonoMarshalType * info;
  int i;

  D.27880 = field->field;
  klass = D.27880->parent;
  D.27883 = klass->generic_container;
  if (D.27883 != 0B) goto <D.27881>; else goto <D.27884>;
  <D.27884>:
  D.27885 = klass->generic_class;
  if (D.27885 != 0B) goto <D.27886>; else goto <D.27882>;
  <D.27886>:
  D.27885 = klass->generic_class;
  D.27887 = D.27885->context.class_inst;
  D.27888 = BIT_FIELD_REF <*D.27887, 64, 0>;
  D.27889 = D.27888 & 512;
  if (D.27889 != 0) goto <D.27881>; else goto <D.27882>;
  <D.27881>:
  D.27890 = 0B;
  return D.27890;
  <D.27882>:
  info = mono_marshal_load_type_info (klass);
  i = 0;
  goto <D.21488>;
  <D.21487>:
  D.27891 = info->fields[i].field;
  D.27880 = field->field;
  if (D.27891 == D.27880) goto <D.27892>; else goto <D.27893>;
  <D.27892>:
  D.27894 = info->fields[i].mspec;
  if (D.27894 == 0B) goto <D.27895>; else goto <D.27896>;
  <D.27895>:
  D.27890 = 0B;
  return D.27890;
  <D.27896>:
  D.27897 = field->object.vtable;
  D.27898 = D.27897->domain;
  D.27894 = info->fields[i].mspec;
  D.27890 = mono_reflection_marshal_as_attribute_from_marshal_spec (D.27898, klass, D.27894);
  return D.27890;
  <D.27893>:
  i = i + 1;
  <D.21488>:
  D.27899 = info->num_fields;
  i.80 = (unsigned int) i;
  if (D.27899 > i.80) goto <D.21487>; else goto <D.21489>;
  <D.21489>:
  D.27890 = 0B;
  return D.27890;
}


ves_icall_System_Reflection_FieldInfo_GetTypeModifiers (struct MonoReflectionField * field, MonoBoolean optional)
{
  struct MonoClassField * D.27902;
  int D.27903;
  struct MonoArray * D.27906;
  struct MonoClass * D.27907;
  struct MonoImage * D.27908;
  int D.27909;
  struct MonoError error;
  struct MonoType * type;

  try
    {
      D.27902 = field->field;
      type = mono_field_get_type_checked (D.27902, &error);
      D.27903 = mono_error_ok (&error);
      if (D.27903 == 0) goto <D.27904>; else goto <D.27905>;
      <D.27904>:
      mono_error_raise_exception (&error);
      <D.27905>:
      D.27902 = field->field;
      D.27907 = D.27902->parent;
      D.27908 = D.27907->image;
      D.27909 = (int) optional;
      D.27906 = type_array_from_modifiers (D.27908, type, D.27909);
      return D.27906;
    }
  finally
    {
      error = {CLOBBER};
    }
}


ves_icall_TypeBuilder_get_IsGenericParameter (struct MonoReflectionTypeBuilder * tb)
{
  MonoBoolean D.27912;
  struct MonoType * D.27913;

  D.27913 = tb->type.type;
  D.27912 = is_generic_parameter (D.27913);
  return D.27912;
}


ves_icall_ModuleBuilder_getToken (struct MonoReflectionModuleBuilder * mb, struct MonoObject * obj, gboolean create_open_instance)
{
  _Bool D.27915;
  long int D.27916;
  long int D.27917;
  gint32 D.27922;
  struct MonoDynamicImage * D.27923;
  unsigned int D.27924;

  D.27915 = obj == 0B;
  D.27916 = (long int) D.27915;
  D.27917 = __builtin_expect (D.27916, 0);
  if (D.27917 != 0) goto <D.27918>; else goto <D.27919>;
  <D.27918>:
  {
    struct MonoException * ex;

    if (obj != 0B) goto <D.27920>; else goto <D.27921>;
    <D.27920>:
    <D.27921>:
    ex = mono_get_exception_argument_null ("obj");
    mono_raise_exception (ex);
  }
  <D.27919>:
  D.27923 = mb->dynamic_image;
  D.27924 = mono_image_create_token (D.27923, obj, create_open_instance, 1);
  D.27922 = (gint32) D.27924;
  return D.27922;
}


ves_icall_ModuleBuilder_getMethodToken (struct MonoReflectionModuleBuilder * mb, struct MonoReflectionMethod * method, struct MonoArray * opt_param_types)
{
  _Bool D.27926;
  long int D.27927;
  long int D.27928;
  gint32 D.27933;
  struct MonoDynamicImage * D.27934;
  unsigned int D.27935;

  D.27926 = method == 0B;
  D.27927 = (long int) D.27926;
  D.27928 = __builtin_expect (D.27927, 0);
  if (D.27928 != 0) goto <D.27929>; else goto <D.27930>;
  <D.27929>:
  {
    struct MonoException * ex;

    if (method != 0B) goto <D.27931>; else goto <D.27932>;
    <D.27931>:
    <D.27932>:
    ex = mono_get_exception_argument_null ("method");
    mono_raise_exception (ex);
  }
  <D.27930>:
  D.27934 = mb->dynamic_image;
  D.27935 = mono_image_create_method_token (D.27934, method, opt_param_types);
  D.27933 = (gint32) D.27935;
  return D.27933;
}


ves_icall_ModuleBuilder_create_modified_type (struct MonoReflectionTypeBuilder * tb, struct MonoString * smodifiers)
{
  struct MonoType * D.27937;
  char D.27938;
  int D.27939;
  struct MonoReflectionType * D.27942;
  struct MonoVTable * D.27943;
  struct MonoDomain * D.27944;
  struct MonoType * D.27945;
  struct MonoType * D.27946;
  unsigned int rank.81;
  struct MonoClass * klass;
  int isbyref;
  int rank;
  char * str;
  char * p;

  isbyref = 0;
  str = mono_string_to_utf8 (smodifiers);
  D.27937 = tb->type.type;
  klass = mono_class_from_mono_type (D.27937);
  p = str;
  goto <D.22969>;
  <D.22968>:
  D.27938 = *p;
  D.27939 = (int) D.27938;
  switch (D.27939) <default: <D.22967>, case 38: <D.22960>, case 42: <D.22961>, case 91: <D.22963>>
  <D.22960>:
  if (isbyref != 0) goto <D.27940>; else goto <D.27941>;
  <D.27940>:
  monoeg_g_free (str);
  D.27942 = 0B;
  return D.27942;
  <D.27941>:
  isbyref = 1;
  p = p + 1;
  monoeg_g_free (str);
  D.27943 = MEM[(struct MonoObject *)tb].vtable;
  D.27944 = D.27943->domain;
  D.27945 = &klass->this_arg;
  D.27942 = mono_type_get_object (D.27944, D.27945);
  return D.27942;
  <D.22961>:
  D.27946 = &klass->byval_arg;
  klass = mono_ptr_class_get (D.27946);
  mono_class_init (klass);
  p = p + 1;
  goto <D.22962>;
  <D.22963>:
  rank = 1;
  p = p + 1;
  goto <D.22966>;
  <D.22965>:
  D.27938 = *p;
  if (D.27938 == 93) goto <D.22964>; else goto <D.27947>;
  <D.27947>:
  D.27938 = *p;
  if (D.27938 == 44) goto <D.27948>; else goto <D.27949>;
  <D.27948>:
  rank = rank + 1;
  goto <D.27950>;
  <D.27949>:
  D.27938 = *p;
  if (D.27938 != 42) goto <D.27951>; else goto <D.27952>;
  <D.27951>:
  monoeg_g_free (str);
  D.27942 = 0B;
  return D.27942;
  <D.27952>:
  <D.27950>:
  p = p + 1;
  <D.22966>:
  D.27938 = *p;
  if (D.27938 != 0) goto <D.22965>; else goto <D.22964>;
  <D.22964>:
  D.27938 = *p;
  if (D.27938 != 93) goto <D.27953>; else goto <D.27954>;
  <D.27953>:
  monoeg_g_free (str);
  D.27942 = 0B;
  return D.27942;
  <D.27954>:
  p = p + 1;
  rank.81 = (unsigned int) rank;
  klass = mono_array_class_get (klass, rank.81);
  mono_class_init (klass);
  goto <D.22962>;
  <D.22967>:
  goto <D.22962>;
  <D.22962>:
  <D.22969>:
  D.27938 = *p;
  if (D.27938 != 0) goto <D.22968>; else goto <D.22970>;
  <D.22970>:
  monoeg_g_free (str);
  D.27943 = MEM[(struct MonoObject *)tb].vtable;
  D.27944 = D.27943->domain;
  D.27946 = &klass->byval_arg;
  D.27942 = mono_type_get_object (D.27944, D.27946);
  return D.27942;
}


ves_icall_ModuleBuilder_build_metadata (struct MonoReflectionModuleBuilder * mb)
{
  mono_image_build_metadata (mb);
}


ves_icall_ModuleBuilder_WriteToFile (struct MonoReflectionModuleBuilder * mb, void * file)
{
  mono_image_create_pefile (mb, file);
}


ves_icall_ModuleBuilder_RegisterToken (struct MonoReflectionModuleBuilder * mb, struct MonoObject * obj, guint32 token)
{
  struct MonoDynamicImage * D.27958;

  D.27958 = mb->dynamic_image;
  mono_image_register_token (D.27958, token, obj);
}


ves_icall_EnumBuilder_setup_enum_type (struct MonoReflectionType * enumtype, struct MonoReflectionType * t)
{
  struct MonoType * D.27959;

  D.27959 = t->type;
  enumtype->type = D.27959;
}


ves_icall_System_Reflection_AssemblyName_ParseName (struct MonoReflectionAssemblyName * name, struct MonoString * assname)
{
  struct MonoVTable * D.27960;
  int D.27961;
  const mono_byte * D.27964;
  gboolean D.27965;
  int is_version_defined.82;
  int is_token_defined.83;
  struct MonoAssemblyName aname;
  struct MonoDomain * domain;
  char * val;
  gboolean is_version_defined;
  gboolean is_token_defined;

  try
    {
      D.27960 = MEM[(struct MonoObject *)name].vtable;
      domain = D.27960->domain;
      aname.public_key = 0B;
      val = mono_string_to_utf8 (assname);
      D.27961 = mono_assembly_name_parse_full (val, &aname, 1, &is_version_defined, &is_token_defined);
      if (D.27961 == 0) goto <D.27962>; else goto <D.27963>;
      <D.27962>:
      D.27964 = aname.public_key;
      monoeg_g_free (D.27964);
      monoeg_g_free (val);
      D.27965 = 0;
      return D.27965;
      <D.27963>:
      is_version_defined.82 = is_version_defined;
      is_token_defined.83 = is_token_defined;
      fill_reflection_assembly_name (domain, name, &aname, "", is_version_defined.82, 0, is_token_defined.83);
      mono_assembly_name_free (&aname);
      D.27964 = aname.public_key;
      monoeg_g_free (D.27964);
      monoeg_g_free (val);
      D.27965 = 1;
      return D.27965;
    }
  finally
    {
      aname = {CLOBBER};
      is_version_defined = {CLOBBER};
      is_token_defined = {CLOBBER};
    }
}


fill_reflection_assembly_name (struct MonoDomain * domain, struct MonoReflectionAssemblyName * aname, struct MonoAssemblyName * name, const char * absolute, gboolean by_default_version, gboolean default_publickey, gboolean default_token)
{
  struct MonoString * * D.27970;
  const char * D.27971;
  struct MonoString * D.27972;
  short unsigned int D.27973;
  int D.27974;
  short unsigned int D.27975;
  int D.27976;
  short unsigned int D.27977;
  int D.27978;
  unsigned int D.27979;
  short unsigned int D.27980;
  int D.27981;
  unsigned int D.27982;
  short unsigned int D.27983;
  unsigned int D.27984;
  struct MonoObject * * D.27987;
  unsigned int D.27988;
  unsigned int D.27989;
  unsigned int D.27990;
  unsigned int D.27991;
  struct MonoObject * D.27992;
  char D.27995;
  struct MonoString * * D.28000;
  struct MonoString * D.28001;
  struct MonoMethod * create_culture.84;
  struct MonoImage * D.28005;
  struct MonoMethod * create_culture.85;
  _Bool D.28007;
  long int D.28008;
  long int D.28009;
  const char * D.28012;
  struct MonoString * D.28015;
  struct MonoObject * * D.28016;
  struct MonoObject * D.28017;
  const mono_byte * pkey_ptr.86;
  const char * pkey_ptr.87;
  struct MonoArray * * D.28022;
  struct MonoClass * D.28023;
  long unsigned int D.28024;
  struct MonoArray * D.28025;
  struct MonoArray * D.28026;
  char * D.28027;
  long unsigned int D.28028;
  unsigned int D.28029;
  unsigned int D.28030;
  struct MonoArray * D.28034;
  unsigned char D.28035;
  struct MonoArray * * D.28038;
  struct MonoArray * D.28039;
  struct MonoArray * D.28040;
  int j.88;
  unsigned char D.28042;
  int D.28043;
  char D.28044;
  char D.28045;
  int j.89;
  unsigned char D.28047;
  int D.28048;
  char D.28049;
  signed char D.28050;
  signed char D.28051;
  signed char D.28052;
  char D.28053;
  struct MonoArray * D.28057;
  static struct MonoMethod * create_culture = 0B;
  void * args[2];
  guint32 pkey_len;
  const char * pkey_ptr;
  gchar * codebase;
  MonoBoolean assembly_ref;

  try
    {
      assembly_ref = 0;
      D.27970 = &aname->name;
      D.27971 = name->name;
      D.27972 = mono_string_new (domain, D.27971);
      mono_gc_wbarrier_set_field (aname, D.27970, D.27972);
      D.27973 = name->major;
      D.27974 = (int) D.27973;
      aname->major = D.27974;
      D.27975 = name->minor;
      D.27976 = (int) D.27975;
      aname->minor = D.27976;
      D.27977 = name->build;
      D.27978 = (int) D.27977;
      aname->build = D.27978;
      D.27979 = name->flags;
      aname->flags = D.27979;
      D.27980 = name->revision;
      D.27981 = (int) D.27980;
      aname->revision = D.27981;
      D.27982 = name->hash_alg;
      aname->hashalg = D.27982;
      aname->versioncompat = 1;
      D.27983 = name->arch;
      D.27984 = (unsigned int) D.27983;
      aname->processor_architecture = D.27984;
      if (by_default_version != 0) goto <D.27985>; else goto <D.27986>;
      <D.27985>:
      D.27987 = &aname->version;
      D.27973 = name->major;
      D.27988 = (unsigned int) D.27973;
      D.27975 = name->minor;
      D.27989 = (unsigned int) D.27975;
      D.27977 = name->build;
      D.27990 = (unsigned int) D.27977;
      D.27980 = name->revision;
      D.27991 = (unsigned int) D.27980;
      D.27992 = create_version (domain, D.27988, D.27989, D.27990, D.27991);
      mono_gc_wbarrier_set_field (aname, D.27987, D.27992);
      <D.27986>:
      codebase = 0B;
      if (absolute != 0B) goto <D.27993>; else goto <D.27994>;
      <D.27993>:
      D.27995 = *absolute;
      if (D.27995 != 0) goto <D.27996>; else goto <D.27997>;
      <D.27996>:
      {
        const gchar * prepend;
        gchar * result;

        prepend = "file://";
        codebase = monoeg_strdup (absolute);
        result = monoeg_g_strconcat (prepend, codebase, 0B);
        monoeg_g_free (codebase);
        codebase = result;
      }
      <D.27997>:
      <D.27994>:
      if (codebase != 0B) goto <D.27998>; else goto <D.27999>;
      <D.27998>:
      D.28000 = &aname->codebase;
      D.28001 = mono_string_new (domain, codebase);
      mono_gc_wbarrier_set_field (aname, D.28000, D.28001);
      monoeg_g_free (codebase);
      <D.27999>:
      create_culture.84 = create_culture;
      if (create_culture.84 == 0B) goto <D.28003>; else goto <D.28004>;
      <D.28003>:
      {
        struct MonoMethodDesc * desc;

        desc = mono_method_desc_new ("System.Globalization.CultureInfo:CreateCulture(string,bool)", 1);
        D.28005 = mono_defaults.corlib;
        create_culture.85 = mono_method_desc_search_in_image (desc, D.28005);
        create_culture = create_culture.85;
        create_culture.84 = create_culture;
        D.28007 = create_culture.84 == 0B;
        D.28008 = (long int) D.28007;
        D.28009 = __builtin_expect (D.28008, 0);
        if (D.28009 != 0) goto <D.28010>; else goto <D.28011>;
        <D.28010>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 4954, "create_culture");
        <D.28011>:
        mono_method_desc_free (desc);
      }
      <D.28004>:
      D.28012 = name->culture;
      if (D.28012 != 0B) goto <D.28013>; else goto <D.28014>;
      <D.28013>:
      D.28012 = name->culture;
      D.28015 = mono_string_new (domain, D.28012);
      args[0] = D.28015;
      args[1] = &assembly_ref;
      D.28016 = &aname->cultureInfo;
      create_culture.84 = create_culture;
      D.28017 = mono_runtime_invoke (create_culture.84, 0B, &args, 0B);
      mono_gc_wbarrier_set_field (aname, D.28016, D.28017);
      <D.28014>:
      pkey_ptr.86 = name->public_key;
      if (pkey_ptr.86 != 0B) goto <D.28019>; else goto <D.28020>;
      <D.28019>:
      pkey_ptr.86 = name->public_key;
      pkey_ptr = pkey_ptr.86;
      pkey_ptr.87 = pkey_ptr;
      pkey_len = mono_metadata_decode_blob_size (pkey_ptr.87, &pkey_ptr);
      D.28022 = &aname->publicKey;
      D.28023 = mono_defaults.byte_class;
      D.28024 = (long unsigned int) pkey_len;
      D.28025 = mono_array_new (domain, D.28023, D.28024);
      mono_gc_wbarrier_set_field (aname, D.28022, D.28025);
      D.28026 = aname->publicKey;
      D.28027 = mono_array_addr_with_size (D.28026, 1, 0);
      pkey_ptr.87 = pkey_ptr;
      D.28028 = (long unsigned int) pkey_len;
      memcpy (D.28027, pkey_ptr.87, D.28028);
      D.28029 = aname->flags;
      D.28030 = D.28029 | 1;
      aname->flags = D.28030;
      goto <D.28031>;
      <D.28020>:
      if (default_publickey != 0) goto <D.28032>; else goto <D.28033>;
      <D.28032>:
      D.28022 = &aname->publicKey;
      D.28023 = mono_defaults.byte_class;
      D.28034 = mono_array_new (domain, D.28023, 0);
      mono_gc_wbarrier_set_field (aname, D.28022, D.28034);
      D.28029 = aname->flags;
      D.28030 = D.28029 | 1;
      aname->flags = D.28030;
      <D.28033>:
      <D.28031>:
      D.28035 = name->public_key_token[0];
      if (D.28035 != 0) goto <D.28036>; else goto <D.28037>;
      <D.28036>:
      {
        int i;
        int j;
        char * p;

        D.28038 = &aname->keyToken;
        D.28023 = mono_defaults.byte_class;
        D.28039 = mono_array_new (domain, D.28023, 8);
        mono_gc_wbarrier_set_field (aname, D.28038, D.28039);
        D.28040 = aname->keyToken;
        p = mono_array_addr_with_size (D.28040, 1, 0);
        i = 0;
        j = 0;
        goto <D.22711>;
        <D.22710>:
        j.88 = j;
        j = j.88 + 1;
        D.28042 = name->public_key_token[j.88];
        D.28043 = monoeg_g_ascii_xdigit_value (D.28042);
        D.28044 = (char) D.28043;
        D.28045 = D.28044 << 4;
        *p = D.28045;
        j.89 = j;
        j = j.89 + 1;
        D.28047 = name->public_key_token[j.89];
        D.28048 = monoeg_g_ascii_xdigit_value (D.28047);
        D.28049 = *p;
        D.28050 = (signed char) D.28049;
        D.28051 = (signed char) D.28048;
        D.28052 = D.28050 | D.28051;
        D.28053 = (char) D.28052;
        *p = D.28053;
        p = p + 1;
        i = i + 1;
        <D.22711>:
        if (i <= 7) goto <D.22710>; else goto <D.22712>;
        <D.22712>:
      }
      goto <D.28054>;
      <D.28037>:
      if (default_token != 0) goto <D.28055>; else goto <D.28056>;
      <D.28055>:
      D.28038 = &aname->keyToken;
      D.28023 = mono_defaults.byte_class;
      D.28057 = mono_array_new (domain, D.28023, 0);
      mono_gc_wbarrier_set_field (aname, D.28038, D.28057);
      <D.28056>:
      <D.28054>:
    }
  finally
    {
      args = {CLOBBER};
      pkey_ptr = {CLOBBER};
      assembly_ref = {CLOBBER};
    }
}


create_version (struct MonoDomain * domain, guint32 major, guint32 minor, guint32 build, guint32 revision)
{
  struct MonoClass * System_Version.90;
  struct MonoImage * D.28061;
  struct MonoClass * System_Version.91;
  _Bool D.28063;
  long int D.28064;
  long int D.28065;
  struct MonoMethod * create_version.92;
  struct MonoMethod * create_version.93;
  _Bool D.28072;
  long int D.28073;
  long int D.28074;
  struct MonoObject * D.28077;
  static struct MonoClass * System_Version = 0B;
  static struct MonoMethod * create_version = 0B;
  struct MonoObject * result;
  void * args[4];

  try
    {
      System_Version.90 = System_Version;
      if (System_Version.90 == 0B) goto <D.28059>; else goto <D.28060>;
      <D.28059>:
      D.28061 = mono_defaults.corlib;
      System_Version.91 = mono_class_from_name (D.28061, "System", "Version");
      System_Version = System_Version.91;
      System_Version.90 = System_Version;
      D.28063 = System_Version.90 == 0B;
      D.28064 = (long int) D.28063;
      D.28065 = __builtin_expect (D.28064, 0);
      if (D.28065 != 0) goto <D.28066>; else goto <D.28067>;
      <D.28066>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 4404, "System_Version");
      <D.28067>:
      <D.28060>:
      create_version.92 = create_version;
      if (create_version.92 == 0B) goto <D.28069>; else goto <D.28070>;
      <D.28069>:
      {
        struct MonoMethodDesc * desc;

        desc = mono_method_desc_new (":.ctor(int,int,int,int)", 0);
        System_Version.90 = System_Version;
        create_version.93 = mono_method_desc_search_in_class (desc, System_Version.90);
        create_version = create_version.93;
        create_version.92 = create_version;
        D.28072 = create_version.92 == 0B;
        D.28073 = (long int) D.28072;
        D.28074 = __builtin_expect (D.28073, 0);
        if (D.28074 != 0) goto <D.28075>; else goto <D.28076>;
        <D.28075>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 4410, "create_version");
        <D.28076>:
        mono_method_desc_free (desc);
      }
      <D.28070>:
      args[0] = &major;
      args[1] = &minor;
      args[2] = &build;
      args[3] = &revision;
      System_Version.90 = System_Version;
      result = mono_object_new (domain, System_Version.90);
      create_version.92 = create_version;
      mono_runtime_invoke (create_version.92, result, &args, 0B);
      D.28077 = result;
      return D.28077;
    }
  finally
    {
      args = {CLOBBER};
    }
}


ves_icall_System_Reflection_Assembly_load_with_partial_name (struct MonoString * mname, struct MonoObject * evidence)
{
  struct MonoReflectionAssembly * D.28082;
  struct MonoDomain * D.28083;
  gchar * name;
  struct MonoAssembly * res;
  MonoImageOpenStatus status;

  try
    {
      name = mono_string_to_utf8 (mname);
      res = mono_assembly_load_with_partial_name (name, &status);
      monoeg_g_free (name);
      if (res == 0B) goto <D.28080>; else goto <D.28081>;
      <D.28080>:
      D.28082 = 0B;
      return D.28082;
      <D.28081>:
      D.28083 = mono_domain_get ();
      D.28082 = mono_assembly_get_object (D.28083, res);
      return D.28082;
    }
  finally
    {
      status = {CLOBBER};
    }
}


ves_icall_System_Reflection_Assembly_get_location (struct MonoReflectionAssembly * assembly)
{
  struct MonoVTable * D.28086;
  struct MonoAssembly * D.28087;
  struct MonoImage * D.28088;
  const char * D.28089;
  struct MonoString * D.28090;
  struct MonoDomain * domain;
  struct MonoString * res;

  D.28086 = MEM[(struct MonoObject *)assembly].vtable;
  domain = D.28086->domain;
  D.28087 = assembly->assembly;
  D.28088 = D.28087->image;
  D.28089 = mono_image_get_filename (D.28088);
  res = mono_string_new (domain, D.28089);
  D.28090 = res;
  return D.28090;
}


ves_icall_System_Reflection_Assembly_get_global_assembly_cache (struct MonoReflectionAssembly * assembly)
{
  MonoBoolean D.28092;
  struct MonoAssembly * mass;

  mass = assembly->assembly;
  D.28092 = mass->in_gac;
  return D.28092;
}


ves_icall_System_Reflection_Assembly_get_fullName (struct MonoReflectionAssembly * assembly)
{
  struct MonoVTable * D.28094;
  struct MonoAssemblyName * D.28095;
  struct MonoString * D.28096;
  struct MonoDomain * domain;
  struct MonoAssembly * mass;
  struct MonoString * res;
  gchar * name;

  D.28094 = MEM[(struct MonoObject *)assembly].vtable;
  domain = D.28094->domain;
  mass = assembly->assembly;
  D.28095 = &mass->aname;
  name = mono_stringify_assembly_name (D.28095);
  res = mono_string_new (domain, name);
  monoeg_g_free (name);
  D.28096 = res;
  return D.28096;
}


ves_icall_System_Reflection_Assembly_get_code_base (struct MonoReflectionAssembly * assembly, MonoBoolean escaped)
{
  struct MonoVTable * D.28098;
  struct MonoImage * D.28099;
  char * D.28100;
  int D.28101;
  gchar * absolute.94;
  gchar * absolute.95;
  char * D.28107;
  gchar * absolute.96;
  struct MonoString * D.28114;
  struct MonoDomain * domain;
  struct MonoAssembly * mass;
  struct MonoString * res;
  gchar * uri;
  gchar * absolute;
  gchar * dirname;

  try
    {
      D.28098 = MEM[(struct MonoObject *)assembly].vtable;
      domain = D.28098->domain;
      mass = assembly->assembly;
      res = 0B;
      D.28099 = mass->image;
      D.28100 = D.28099->name;
      D.28101 = monoeg_g_path_is_absolute (D.28100);
      if (D.28101 != 0) goto <D.28102>; else goto <D.28103>;
      <D.28102>:
      D.28099 = mass->image;
      D.28100 = D.28099->name;
      absolute.94 = monoeg_strdup (D.28100);
      absolute = absolute.94;
      absolute.95 = absolute;
      dirname = monoeg_g_path_get_dirname (absolute.95);
      goto <D.28106>;
      <D.28103>:
      D.28107 = mass->basedir;
      D.28099 = mass->image;
      D.28100 = D.28099->name;
      absolute.96 = monoeg_g_build_path ("/", D.28107, D.28100, 0B);
      absolute = absolute.96;
      D.28107 = mass->basedir;
      dirname = monoeg_strdup (D.28107);
      <D.28106>:
      replace_shadow_path (domain, dirname, &absolute);
      monoeg_g_free (dirname);
      if (escaped != 0) goto <D.28109>; else goto <D.28110>;
      <D.28109>:
      absolute.95 = absolute;
      uri = monoeg_g_filename_to_uri (absolute.95, 0B, 0B);
      goto <D.28111>;
      <D.28110>:
      {
        const char * prepend;

        prepend = "file://";
        absolute.95 = absolute;
        uri = monoeg_g_strconcat (prepend, absolute.95, 0B);
      }
      <D.28111>:
      if (uri != 0B) goto <D.28112>; else goto <D.28113>;
      <D.28112>:
      res = mono_string_new (domain, uri);
      monoeg_g_free (uri);
      <D.28113>:
      absolute.95 = absolute;
      monoeg_g_free (absolute.95);
      D.28114 = res;
      return D.28114;
    }
  finally
    {
      absolute = {CLOBBER};
    }
}


replace_shadow_path (struct MonoDomain * domain, gchar * dirname, gchar * * filename)
{
  int D.28117;
  int D.28122;
  gchar * content.97;
  int D.28125;
  gchar * D.28130;
  gboolean D.28133;
  gchar * content;
  gchar * shadow_ini_file;
  gsize len;

  try
    {
      D.28117 = mono_is_shadow_copy_enabled (domain, dirname);
      if (D.28117 != 0) goto <D.28118>; else goto <D.28119>;
      <D.28118>:
      shadow_ini_file = monoeg_g_build_path ("/", dirname, "__AssemblyInfo__.ini", 0B);
      content = 0B;
      D.28122 = monoeg_g_file_get_contents (shadow_ini_file, &content, &len, 0B);
      if (D.28122 == 0) goto <D.28120>; else goto <D.28123>;
      <D.28123>:
      content.97 = content;
      D.28125 = monoeg_g_file_test (content.97, 1);
      if (D.28125 == 0) goto <D.28120>; else goto <D.28121>;
      <D.28120>:
      content.97 = content;
      if (content.97 != 0B) goto <D.28126>; else goto <D.28127>;
      <D.28126>:
      content.97 = content;
      monoeg_g_free (content.97);
      content = 0B;
      <D.28127>:
      <D.28121>:
      monoeg_g_free (shadow_ini_file);
      content.97 = content;
      if (content.97 != 0B) goto <D.28128>; else goto <D.28129>;
      <D.28128>:
      D.28130 = *filename;
      if (D.28130 != 0B) goto <D.28131>; else goto <D.28132>;
      <D.28131>:
      D.28130 = *filename;
      monoeg_g_free (D.28130);
      <D.28132>:
      content.97 = content;
      *filename = content.97;
      D.28133 = 1;
      return D.28133;
      <D.28129>:
      <D.28119>:
      D.28133 = 0;
      return D.28133;
    }
  finally
    {
      content = {CLOBBER};
      len = {CLOBBER};
    }
}


ves_icall_System_Reflection_Assembly_get_ReflectionOnly (struct MonoReflectionAssembly * assembly)
{
  MonoBoolean D.28136;
  struct MonoAssembly * D.28137;
  int D.28138;

  D.28137 = assembly->assembly;
  D.28138 = D.28137->ref_only;
  D.28136 = (MonoBoolean) D.28138;
  return D.28136;
}


ves_icall_System_Reflection_Assembly_get_EntryPoint (struct MonoReflectionAssembly * assembly)
{
  struct MonoAssembly * D.28140;
  struct MonoImage * D.28141;
  struct MonoReflectionMethod * D.28144;
  struct MonoVTable * D.28145;
  struct MonoDomain * D.28146;
  struct MonoMethod * D.28147;
  guint32 token;

  D.28140 = assembly->assembly;
  D.28141 = D.28140->image;
  token = mono_image_get_entry_point (D.28141);
  if (token == 0) goto <D.28142>; else goto <D.28143>;
  <D.28142>:
  D.28144 = 0B;
  return D.28144;
  <D.28143>:
  D.28145 = MEM[(struct MonoObject *)assembly].vtable;
  D.28146 = D.28145->domain;
  D.28140 = assembly->assembly;
  D.28141 = D.28140->image;
  D.28147 = mono_get_method (D.28141, token, 0B);
  D.28144 = mono_method_get_object (D.28146, D.28147, 0B);
  return D.28144;
}


ves_icall_MonoDebugger_GetMethodToken (struct MonoReflectionMethod * method)
{
  gint32 D.28149;
  struct MonoMethod * D.28150;
  unsigned int D.28151;

  D.28150 = method->method;
  D.28151 = D.28150->token;
  D.28149 = (gint32) D.28151;
  return D.28149;
}


ves_icall_System_Reflection_Assembly_LoadPermissions (struct MonoReflectionAssembly * assembly, char * * minimum, guint32 * minLength, char * * optional, guint32 * optLength, char * * refused, guint32 * refLength)
{
  struct MonoAssembly * D.28153;
  unsigned char D.28154;
  char * D.28157;
  unsigned int D.28158;
  unsigned char D.28159;
  unsigned char D.28162;
  MonoBoolean D.28165;
  MonoBoolean result;
  struct MonoDeclSecurityEntry entry;

  try
    {
      result = 0;
      D.28153 = assembly->assembly;
      D.28154 = mono_declsec_get_assembly_action (D.28153, 8, &entry);
      if (D.28154 != 0) goto <D.28155>; else goto <D.28156>;
      <D.28155>:
      D.28157 = entry.blob;
      *minimum = D.28157;
      D.28158 = entry.size;
      *minLength = D.28158;
      result = 1;
      <D.28156>:
      D.28153 = assembly->assembly;
      D.28159 = mono_declsec_get_assembly_action (D.28153, 9, &entry);
      if (D.28159 != 0) goto <D.28160>; else goto <D.28161>;
      <D.28160>:
      D.28157 = entry.blob;
      *optional = D.28157;
      D.28158 = entry.size;
      *optLength = D.28158;
      result = 1;
      <D.28161>:
      D.28153 = assembly->assembly;
      D.28162 = mono_declsec_get_assembly_action (D.28153, 10, &entry);
      if (D.28162 != 0) goto <D.28163>; else goto <D.28164>;
      <D.28163>:
      D.28157 = entry.blob;
      *refused = D.28157;
      D.28158 = entry.size;
      *refLength = D.28158;
      result = 1;
      <D.28164>:
      D.28165 = result;
      return D.28165;
    }
  finally
    {
      entry = {CLOBBER};
    }
}


ves_icall_System_Reflection_Assembly_InternalImageRuntimeVersion (struct MonoReflectionAssembly * assembly)
{
  struct MonoVTable * D.28168;
  struct MonoString * D.28169;
  struct MonoAssembly * D.28170;
  struct MonoImage * D.28171;
  char * D.28172;
  struct MonoDomain * domain;

  D.28168 = MEM[(struct MonoObject *)assembly].vtable;
  domain = D.28168->domain;
  D.28170 = assembly->assembly;
  D.28171 = D.28170->image;
  D.28172 = D.28171->version;
  D.28169 = mono_string_new (domain, D.28172);
  return D.28169;
}


ves_icall_System_Reflection_Assembly_InternalGetType (struct MonoReflectionAssembly * assembly, struct MonoReflectionModule * module, struct MonoString * name, MonoBoolean throwOnError, MonoBoolean ignoreCase)
{
  int D.28174;
  struct MonoException * D.28179;
  struct MonoReflectionType * D.28180;
  const char * D.28181;
  struct MonoClass * D.28186;
  struct MonoException * D.28189;
  struct MonoException * D.28191;
  struct MonoImage * D.28194;
  int D.28197;
  struct MonoAssembly * D.28200;
  unsigned char D.28201;
  struct MonoArray * D.28204;
  long unsigned int D.28207;
  char * D.28208;
  struct MonoDynamicImage * D.28209;
  struct MonoImage * D.28210;
  long unsigned int D.28212;
  struct MonoArray * D.28215;
  char * D.28218;
  struct MonoImage * D.28219;
  long unsigned int D.28221;
  struct MonoImage * D.28223;
  struct MonoLoaderError * D.28228;
  struct MonoLoaderError * D.28233;
  struct MonoLoaderError * D.28236;
  struct MonoLoaderError * D.28241;
  struct MonoException * D.28242;
  unsigned char D.28243;
  int D.28246;
  unsigned char D.28249;
  int D.28256;
  struct MonoVTable * D.28261;
  struct MonoDomain * D.28262;
  gchar * str;
  struct MonoType * type;
  struct MonoTypeNameParse info;
  gboolean type_resolve;

  try
    {
      type = 0B;
      type_resolve = 1;
      str = mono_string_to_utf8 (name);
      D.28174 = mono_reflection_parse_type (str, &info);
      if (D.28174 == 0) goto <D.28175>; else goto <D.28176>;
      <D.28175>:
      monoeg_g_free (str);
      mono_reflection_free_type_info (&info);
      if (throwOnError != 0) goto <D.28177>; else goto <D.28178>;
      <D.28177>:
      D.28179 = mono_get_exception_type_load (name, 0B);
      mono_raise_exception (D.28179);
      <D.28178>:
      D.28180 = 0B;
      return D.28180;
      <D.28176>:
      D.28181 = info.assembly.name;
      if (D.28181 != 0B) goto <D.28182>; else goto <D.28183>;
      <D.28182>:
      monoeg_g_free (str);
      mono_reflection_free_type_info (&info);
      if (throwOnError != 0) goto <D.28184>; else goto <D.28185>;
      <D.28184>:
      D.28186 = mono_defaults.generic_ilist_class;
      if (D.28186 != 0B) goto <D.28187>; else goto <D.28188>;
      <D.28187>:
      D.28189 = mono_get_exception_argument (0B, "Type names passed to Assembly.GetType() must not specify an assembly.");
      mono_raise_exception (D.28189);
      goto <D.28190>;
      <D.28188>:
      D.28191 = mono_get_exception_type_load (name, 0B);
      mono_raise_exception (D.28191);
      <D.28190>:
      <D.28185>:
      D.28180 = 0B;
      return D.28180;
      <D.28183>:
      if (module != 0B) goto <D.28192>; else goto <D.28193>;
      <D.28192>:
      D.28194 = module->image;
      if (D.28194 != 0B) goto <D.28195>; else goto <D.28196>;
      <D.28195>:
      D.28194 = module->image;
      D.28197 = (int) ignoreCase;
      type = mono_reflection_get_type (D.28194, &info, D.28197, &type_resolve);
      goto <D.28198>;
      <D.28196>:
      type = 0B;
      <D.28198>:
      goto <D.28199>;
      <D.28193>:
      D.28200 = assembly->assembly;
      D.28201 = D.28200->dynamic;
      if (D.28201 != 0) goto <D.28202>; else goto <D.28203>;
      <D.28202>:
      {
        struct MonoReflectionAssemblyBuilder * abuilder;
        int i;

        abuilder = assembly;
        type = 0B;
        D.28204 = abuilder->modules;
        if (D.28204 != 0B) goto <D.28205>; else goto <D.28206>;
        <D.28205>:
        i = 0;
        goto <D.22439>;
        <D.22438>:
        {
          struct MonoReflectionModuleBuilder * mb;

          D.28204 = abuilder->modules;
          D.28207 = (long unsigned int) i;
          D.28208 = mono_array_addr_with_size (D.28204, 8, D.28207);
          mb = MEM[(struct MonoReflectionModuleBuilder * *)D.28208];
          D.28209 = mb->dynamic_image;
          D.28210 = &D.28209->image;
          D.28197 = (int) ignoreCase;
          type = mono_reflection_get_type (D.28210, &info, D.28197, &type_resolve);
          if (type != 0B) goto <D.22437>; else goto <D.28211>;
          <D.28211>:
        }
        i = i + 1;
        <D.22439>:
        D.28207 = (long unsigned int) i;
        D.28204 = abuilder->modules;
        D.28212 = mono_array_length (D.28204);
        if (D.28207 < D.28212) goto <D.22438>; else goto <D.22437>;
        <D.22437>:
        <D.28206>:
        if (type == 0B) goto <D.28213>; else goto <D.28214>;
        <D.28213>:
        D.28215 = abuilder->loaded_modules;
        if (D.28215 != 0B) goto <D.28216>; else goto <D.28217>;
        <D.28216>:
        i = 0;
        goto <D.22443>;
        <D.22442>:
        {
          struct MonoReflectionModule * mod;

          D.28215 = abuilder->loaded_modules;
          D.28207 = (long unsigned int) i;
          D.28218 = mono_array_addr_with_size (D.28215, 8, D.28207);
          mod = MEM[(struct MonoReflectionModule * *)D.28218];
          D.28219 = mod->image;
          D.28197 = (int) ignoreCase;
          type = mono_reflection_get_type (D.28219, &info, D.28197, &type_resolve);
          if (type != 0B) goto <D.22441>; else goto <D.28220>;
          <D.28220>:
        }
        i = i + 1;
        <D.22443>:
        D.28207 = (long unsigned int) i;
        D.28215 = abuilder->loaded_modules;
        D.28221 = mono_array_length (D.28215);
        if (D.28207 < D.28221) goto <D.22442>; else goto <D.22441>;
        <D.22441>:
        <D.28217>:
        <D.28214>:
      }
      goto <D.28222>;
      <D.28203>:
      D.28200 = assembly->assembly;
      D.28223 = D.28200->image;
      D.28197 = (int) ignoreCase;
      type = mono_reflection_get_type (D.28223, &info, D.28197, &type_resolve);
      <D.28222>:
      <D.28199>:
      monoeg_g_free (str);
      mono_reflection_free_type_info (&info);
      if (type == 0B) goto <D.28224>; else goto <D.28225>;
      <D.28224>:
      {
        struct MonoException * e;

        e = 0B;
        if (throwOnError != 0) goto <D.28226>; else goto <D.28227>;
        <D.28226>:
        e = mono_get_exception_type_load (name, 0B);
        <D.28227>:
        D.28228 = mono_loader_get_last_error ();
        if (D.28228 != 0B) goto <D.28229>; else goto <D.28230>;
        <D.28229>:
        D.28186 = mono_defaults.generic_ilist_class;
        if (D.28186 != 0B) goto <D.28231>; else goto <D.28232>;
        <D.28231>:
        D.28233 = mono_loader_get_last_error ();
        e = mono_loader_error_prepare_exception (D.28233);
        <D.28232>:
        <D.28230>:
        mono_loader_clear_error ();
        if (e != 0B) goto <D.28234>; else goto <D.28235>;
        <D.28234>:
        mono_raise_exception (e);
        <D.28235>:
        D.28180 = 0B;
        return D.28180;
      }
      <D.28225>:
      D.28236 = mono_loader_get_last_error ();
      if (D.28236 != 0B) goto <D.28237>; else goto <D.28238>;
      <D.28237>:
      if (throwOnError != 0) goto <D.28239>; else goto <D.28240>;
      <D.28239>:
      D.28241 = mono_loader_get_last_error ();
      D.28242 = mono_loader_error_prepare_exception (D.28241);
      mono_raise_exception (D.28242);
      <D.28240>:
      mono_loader_clear_error ();
      <D.28238>:
      D.28243 = type->type;
      if (D.28243 == 18) goto <D.28244>; else goto <D.28245>;
      <D.28244>:
      {
        struct MonoClass * klass;

        klass = mono_type_get_class (type);
        D.28246 = mono_is_security_manager_active ();
        if (D.28246 != 0) goto <D.28247>; else goto <D.28248>;
        <D.28247>:
        D.28249 = klass->exception_type;
        if (D.28249 == 0) goto <D.28250>; else goto <D.28251>;
        <D.28250>:
        mono_class_setup_vtable (klass);
        <D.28251>:
        <D.28248>:
        if (throwOnError != 0) goto <D.28254>; else goto <D.28252>;
        <D.28254>:
        D.28249 = klass->exception_type;
        if (D.28249 != 0) goto <D.28255>; else goto <D.28252>;
        <D.28255>:
        {
          struct MonoException * exc;

          exc = mono_class_get_exception_for_failure (klass);
          mono_loader_clear_error ();
          mono_raise_exception (exc);
        }
        goto <D.28253>;
        <D.28252>:
        D.28256 = mono_is_security_manager_active ();
        if (D.28256 != 0) goto <D.28257>; else goto <D.28258>;
        <D.28257>:
        D.28249 = klass->exception_type;
        if (D.28249 == 2) goto <D.28259>; else goto <D.28260>;
        <D.28259>:
        D.28180 = 0B;
        return D.28180;
        <D.28260>:
        <D.28258>:
        <D.28253>:
      }
      <D.28245>:
      D.28261 = MEM[(struct MonoObject *)assembly].vtable;
      D.28262 = D.28261->domain;
      D.28180 = mono_type_get_object (D.28262, type);
      return D.28180;
    }
  finally
    {
      info = {CLOBBER};
      type_resolve = {CLOBBER};
    }
}


ves_icall_System_Reflection_Assembly_InternalGetAssemblyName (struct MonoString * fname, struct MonoReflectionAssemblyName * aname)
{
  char * filename.98;
  char * filename.99;
  struct MonoDomain * D.28267;
  <unnamed type> status.100;
  struct MonoException * D.28276;
  struct MonoDomain * D.28277;
  char * filename;
  MonoImageOpenStatus status;
  gboolean res;
  struct MonoImage * image;
  struct MonoAssemblyName name;
  char * dirname;

  try
    {
      status = 0;
      filename.98 = mono_string_to_utf8 (fname);
      filename = filename.98;
      filename.99 = filename;
      dirname = monoeg_g_path_get_dirname (filename.99);
      D.28267 = mono_domain_get ();
      replace_shadow_path (D.28267, dirname, &filename);
      monoeg_g_free (dirname);
      filename.99 = filename;
      image = mono_image_open (filename.99, &status);
      if (image == 0B) goto <D.28268>; else goto <D.28269>;
      <D.28268>:
      {
        struct MonoException * exc;

        filename.99 = filename;
        monoeg_g_free (filename.99);
        status.100 = status;
        if (status.100 == 3) goto <D.28271>; else goto <D.28272>;
        <D.28271>:
        exc = mono_get_exception_bad_image_format2 (0B, fname);
        goto <D.28273>;
        <D.28272>:
        exc = mono_get_exception_file_not_found2 (0B, fname);
        <D.28273>:
        mono_raise_exception (exc);
      }
      <D.28269>:
      res = mono_assembly_fill_assembly_name (image, &name);
      if (res == 0) goto <D.28274>; else goto <D.28275>;
      <D.28274>:
      mono_image_close (image);
      filename.99 = filename;
      monoeg_g_free (filename.99);
      D.28276 = mono_get_exception_argument ("assemblyFile", "The file does not contain a manifest");
      mono_raise_exception (D.28276);
      <D.28275>:
      D.28277 = mono_domain_get ();
      filename.99 = filename;
      fill_reflection_assembly_name (D.28277, aname, &name, filename.99, 1, 0, 1);
      filename.99 = filename;
      monoeg_g_free (filename.99);
      mono_image_close (image);
    }
  finally
    {
      filename = {CLOBBER};
      status = {CLOBBER};
      name = {CLOBBER};
    }
}


ves_icall_System_Reflection_Assembly_GetTypes (struct MonoReflectionAssembly * assembly, MonoBoolean exportedOnly)
{
  struct MonoVTable * D.28278;
  struct MonoAssembly * D.28279;
  unsigned char D.28280;
  _Bool D.28281;
  long int D.28282;
  long int D.28283;
  unsigned int D.28286;
  unsigned int D.28287;
  struct MonoAssembly * D.28290;
  int D.28291;
  unsigned int D.28292;
  long unsigned int D.28295;
  long unsigned int D.28298;
  long unsigned int D.28299;
  struct MonoClass * D.28300;
  unsigned int D.28301;
  long unsigned int D.28302;
  int len1.101;
  long unsigned int D.28304;
  int len2.102;
  struct MonoArray * exceptions.103;
  struct MonoArray * ex2.104;
  <unnamed-unsigned:24> D.28308;
  int D.28309;
  long unsigned int D.28310;
  long unsigned int D.28311;
  char * D.28312;
  struct MonoType * D.28315;
  unsigned char D.28318;
  unsigned int D.28325;
  unsigned int ex_count.105;
  unsigned int D.28327;
  struct MonoClass * D.28328;
  long unsigned int D.28329;
  void * D.28330;
  long unsigned int D.28331;
  char * D.28332;
  _Bool D.28335;
  long int D.28336;
  long int D.28337;
  long unsigned int D.28340;
  struct MonoArray * D.28341;
  struct MonoArray * res;
  struct MonoArray * exceptions;
  struct MonoImage * image;
  struct MonoTableInfo * table;
  struct MonoDomain * domain;
  struct GList * list;
  int i;
  int len;
  int ex_count;

  try
    {
      res = 0B;
      exceptions = 0B;
      image = 0B;
      table = 0B;
      list = 0B;
      D.28278 = MEM[(struct MonoObject *)assembly].vtable;
      domain = D.28278->domain;
      D.28279 = assembly->assembly;
      D.28280 = D.28279->dynamic;
      D.28281 = D.28280 != 0;
      D.28282 = (long int) D.28281;
      D.28283 = __builtin_expect (D.28282, 0);
      if (D.28283 != 0) goto <D.28284>; else goto <D.28285>;
      <D.28284>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 5171, "!assembly->assembly->dynamic");
      <D.28285>:
      D.28279 = assembly->assembly;
      image = D.28279->image;
      table = &image->tables[38];
      res = mono_module_get_types (domain, image, &exceptions, exportedOnly);
      i = 0;
      goto <D.22800>;
      <D.22799>:
      D.28286 = mono_metadata_decode_row_col (table, i, 0);
      D.28287 = D.28286 & 1;
      if (D.28287 == 0) goto <D.28288>; else goto <D.28289>;
      <D.28288>:
      {
        struct MonoImage * loaded_image;

        D.28290 = image->assembly;
        D.28291 = i + 1;
        D.28292 = (unsigned int) D.28291;
        loaded_image = mono_assembly_load_module (D.28290, D.28292);
        if (loaded_image != 0B) goto <D.28293>; else goto <D.28294>;
        <D.28293>:
        {
          struct MonoArray * ex2;
          struct MonoArray * res2;

          try
            {
              res2 = mono_module_get_types (domain, loaded_image, &ex2, exportedOnly);
              D.28295 = mono_array_length (res2);
              if (D.28295 != 0) goto <D.28296>; else goto <D.28297>;
              <D.28296>:
              {
                guint32 len1;
                guint32 len2;
                struct MonoArray * res3;
                struct MonoArray * ex3;

                D.28298 = mono_array_length (res);
                len1 = (guint32) D.28298;
                D.28299 = mono_array_length (res2);
                len2 = (guint32) D.28299;
                D.28300 = mono_defaults.monotype_class;
                D.28301 = len1 + len2;
                D.28302 = (long unsigned int) D.28301;
                res3 = mono_array_new (domain, D.28300, D.28302);
                {
                  void * * __p;
                  void * * __s;

                  __p = mono_array_addr_with_size (res3, 8, 0);
                  __s = mono_array_addr_with_size (res, 8, 0);
                  len1.101 = (int) len1;
                  mono_gc_wbarrier_arrayref_copy (__p, __s, len1.101);
                }
                {
                  void * * __p;
                  void * * __s;

                  D.28304 = (long unsigned int) len1;
                  __p = mono_array_addr_with_size (res3, 8, D.28304);
                  __s = mono_array_addr_with_size (res2, 8, 0);
                  len2.102 = (int) len2;
                  mono_gc_wbarrier_arrayref_copy (__p, __s, len2.102);
                }
                res = res3;
                D.28300 = mono_defaults.monotype_class;
                D.28301 = len1 + len2;
                D.28302 = (long unsigned int) D.28301;
                ex3 = mono_array_new (domain, D.28300, D.28302);
                {
                  void * * __p;
                  void * * __s;

                  __p = mono_array_addr_with_size (ex3, 8, 0);
                  exceptions.103 = exceptions;
                  __s = mono_array_addr_with_size (exceptions.103, 8, 0);
                  len1.101 = (int) len1;
                  mono_gc_wbarrier_arrayref_copy (__p, __s, len1.101);
                }
                {
                  void * * __p;
                  void * * __s;

                  D.28304 = (long unsigned int) len1;
                  __p = mono_array_addr_with_size (ex3, 8, D.28304);
                  ex2.104 = ex2;
                  __s = mono_array_addr_with_size (ex2.104, 8, 0);
                  len2.102 = (int) len2;
                  mono_gc_wbarrier_arrayref_copy (__p, __s, len2.102);
                }
                exceptions = ex3;
              }
              <D.28297>:
            }
          finally
            {
              ex2 = {CLOBBER};
            }
        }
        <D.28294>:
      }
      <D.28289>:
      i = i + 1;
      <D.22800>:
      D.28308 = table->rows;
      D.28309 = (int) D.28308;
      if (D.28309 > i) goto <D.22799>; else goto <D.22801>;
      <D.22801>:
      D.28310 = mono_array_length (res);
      len = (int) D.28310;
      ex_count = 0;
      i = 0;
      goto <D.22806>;
      <D.22805>:
      {
        struct MonoReflectionType * t;
        struct MonoClass * klass;

        D.28311 = (long unsigned int) i;
        D.28312 = mono_array_addr_with_size (res, 8, D.28311);
        t = MEM[(void * *)D.28312];
        if (t != 0B) goto <D.28313>; else goto <D.28314>;
        <D.28313>:
        D.28315 = t->type;
        klass = mono_type_get_class (D.28315);
        if (klass != 0B) goto <D.28316>; else goto <D.28317>;
        <D.28316>:
        D.28318 = klass->exception_type;
        if (D.28318 != 0) goto <D.28319>; else goto <D.28320>;
        <D.28319>:
        list = monoeg_g_list_append (list, klass);
        {
          void * * __p;

          D.28311 = (long unsigned int) i;
          __p = mono_array_addr_with_size (res, 8, D.28311);
          mono_gc_wbarrier_set_arrayref (res, __p, 0B);
        }
        <D.28320>:
        <D.28317>:
        goto <D.28321>;
        <D.28314>:
        ex_count = ex_count + 1;
        <D.28321>:
      }
      i = i + 1;
      <D.22806>:
      if (i < len) goto <D.22805>; else goto <D.22807>;
      <D.22807>:
      if (list != 0B) goto <D.28322>; else goto <D.28324>;
      <D.28324>:
      if (ex_count != 0) goto <D.28322>; else goto <D.28323>;
      <D.28322>:
      {
        struct GList * tmp;
        struct MonoException * exc;
        struct MonoArray * exl;
        int j;
        int length;

        tmp = 0B;
        exc = 0B;
        exl = 0B;
        D.28325 = monoeg_g_list_length (list);
        ex_count.105 = (unsigned int) ex_count;
        D.28327 = D.28325 + ex_count.105;
        length = (int) D.28327;
        mono_loader_clear_error ();
        D.28328 = mono_defaults.exception_class;
        D.28329 = (long unsigned int) length;
        exl = mono_array_new (domain, D.28328, D.28329);
        i = 0;
        tmp = list;
        goto <D.22816>;
        <D.22815>:
        {
          struct MonoException * exc;

          D.28330 = tmp->data;
          exc = mono_class_get_exception_for_failure (D.28330);
          {
            void * * __p;

            D.28311 = (long unsigned int) i;
            __p = mono_array_addr_with_size (exl, 8, D.28311);
            mono_gc_wbarrier_set_arrayref (exl, __p, exc);
          }
        }
        i = i + 1;
        tmp = tmp->next;
        <D.22816>:
        if (tmp != 0B) goto <D.22815>; else goto <D.22817>;
        <D.22817>:
        j = 0;
        goto <D.22821>;
        <D.22820>:
        {
          struct MonoException * exc;

          exceptions.103 = exceptions;
          D.28331 = (long unsigned int) j;
          D.28332 = mono_array_addr_with_size (exceptions.103, 8, D.28331);
          exc = MEM[(struct MonoException * *)D.28332];
          if (exc != 0B) goto <D.28333>; else goto <D.28334>;
          <D.28333>:
          D.28335 = i >= length;
          D.28336 = (long int) D.28335;
          D.28337 = __builtin_expect (D.28336, 0);
          if (D.28337 != 0) goto <D.28338>; else goto <D.28339>;
          <D.28338>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 5248, "i < length");
          <D.28339>:
          {
            void * * __p;

            D.28311 = (long unsigned int) i;
            __p = mono_array_addr_with_size (exl, 8, D.28311);
            mono_gc_wbarrier_set_arrayref (exl, __p, exc);
          }
          i = i + 1;
          <D.28334>:
        }
        j = j + 1;
        <D.22821>:
        D.28331 = (long unsigned int) j;
        exceptions.103 = exceptions;
        D.28340 = mono_array_length (exceptions.103);
        if (D.28331 < D.28340) goto <D.22820>; else goto <D.22822>;
        <D.22822>:
        monoeg_g_list_free (list);
        list = 0B;
        exc = mono_get_exception_reflection_type_load (res, exl);
        mono_loader_clear_error ();
        mono_raise_exception (exc);
      }
      <D.28323>:
      D.28341 = res;
      return D.28341;
    }
  finally
    {
      exceptions = {CLOBBER};
    }
}


ves_icall_System_Reflection_Assembly_GetReferencedAssemblies (struct MonoReflectionAssembly * assembly)
{
  struct MonoVTable * D.28344;
  struct MonoAssembly * D.28345;
  struct MonoClass * System_Reflection_AssemblyName.106;
  struct MonoImage * D.28349;
  struct MonoClass * System_Reflection_AssemblyName.107;
  struct MonoImage * D.28351;
  <unnamed-unsigned:24> D.28352;
  long unsigned int D.28353;
  struct MonoMethod * create_culture.108;
  struct MonoMethod * create_culture.109;
  _Bool D.28360;
  long int D.28361;
  long int D.28362;
  struct MonoString * * D.28365;
  unsigned int D.28366;
  const char * D.28367;
  struct MonoString * D.28368;
  unsigned int D.28369;
  int D.28370;
  unsigned int D.28371;
  int D.28372;
  unsigned int D.28373;
  int D.28374;
  unsigned int D.28375;
  int D.28376;
  unsigned int D.28377;
  struct MonoObject * * D.28378;
  int D.28379;
  unsigned int D.28380;
  int D.28381;
  unsigned int D.28382;
  int D.28383;
  unsigned int D.28384;
  int D.28385;
  unsigned int D.28386;
  struct MonoObject * D.28387;
  unsigned int D.28390;
  const char * D.28391;
  struct MonoString * D.28392;
  struct MonoObject * * D.28393;
  struct MonoObject * D.28394;
  unsigned int D.28395;
  const char * pkey_ptr.110;
  const gchar * pkey_ptr.111;
  unsigned int D.28400;
  struct MonoArray * * D.28403;
  struct MonoClass * D.28404;
  long unsigned int D.28405;
  struct MonoArray * D.28406;
  struct MonoArray * D.28407;
  char * D.28408;
  long unsigned int D.28409;
  struct MonoArray * * D.28411;
  struct MonoArray * D.28412;
  struct MonoArray * D.28413;
  char * D.28414;
  struct MonoArray * D.28416;
  long unsigned int D.28417;
  struct MonoArray * D.28418;
  static struct MonoClass * System_Reflection_AssemblyName;
  struct MonoArray * result;
  struct MonoDomain * domain;
  int i;
  int count;
  static struct MonoMethod * create_culture = 0B;
  struct MonoImage * image;
  struct MonoTableInfo * t;

  D.28344 = MEM[(struct MonoObject *)assembly].vtable;
  domain = D.28344->domain;
  count = 0;
  D.28345 = assembly->assembly;
  image = D.28345->image;
  System_Reflection_AssemblyName.106 = System_Reflection_AssemblyName;
  if (System_Reflection_AssemblyName.106 == 0B) goto <D.28347>; else goto <D.28348>;
  <D.28347>:
  D.28349 = mono_defaults.corlib;
  System_Reflection_AssemblyName.107 = mono_class_from_name (D.28349, "System.Reflection", "AssemblyName");
  System_Reflection_AssemblyName = System_Reflection_AssemblyName.107;
  <D.28348>:
  D.28345 = assembly->assembly;
  D.28351 = D.28345->image;
  t = &D.28351->tables[35];
  D.28352 = t->rows;
  count = (int) D.28352;
  System_Reflection_AssemblyName.106 = System_Reflection_AssemblyName;
  D.28353 = (long unsigned int) count;
  result = mono_array_new (domain, System_Reflection_AssemblyName.106, D.28353);
  if (count > 0) goto <D.28354>; else goto <D.28355>;
  <D.28354>:
  create_culture.108 = create_culture;
  if (create_culture.108 == 0B) goto <D.28357>; else goto <D.28358>;
  <D.28357>:
  {
    struct MonoMethodDesc * desc;

    desc = mono_method_desc_new ("System.Globalization.CultureInfo:CreateCulture(string,bool)", 1);
    D.28349 = mono_defaults.corlib;
    create_culture.109 = mono_method_desc_search_in_image (desc, D.28349);
    create_culture = create_culture.109;
    create_culture.108 = create_culture;
    D.28360 = create_culture.108 == 0B;
    D.28361 = (long int) D.28360;
    D.28362 = __builtin_expect (D.28361, 0);
    if (D.28362 != 0) goto <D.28363>; else goto <D.28364>;
    <D.28363>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 4450, "create_culture");
    <D.28364>:
    mono_method_desc_free (desc);
  }
  <D.28358>:
  <D.28355>:
  i = 0;
  goto <D.22539>;
  <D.22538>:
  {
    struct MonoReflectionAssemblyName * aname;
    guint32 cols[9];

    try
      {
        mono_metadata_decode_row (t, i, &cols, 9);
        System_Reflection_AssemblyName.106 = System_Reflection_AssemblyName;
        aname = mono_object_new (domain, System_Reflection_AssemblyName.106);
        D.28365 = &aname->name;
        D.28366 = cols[6];
        D.28367 = mono_metadata_string_heap (image, D.28366);
        D.28368 = mono_string_new (domain, D.28367);
        mono_gc_wbarrier_set_field (aname, D.28365, D.28368);
        D.28369 = cols[0];
        D.28370 = (int) D.28369;
        aname->major = D.28370;
        D.28371 = cols[1];
        D.28372 = (int) D.28371;
        aname->minor = D.28372;
        D.28373 = cols[2];
        D.28374 = (int) D.28373;
        aname->build = D.28374;
        D.28375 = cols[3];
        D.28376 = (int) D.28375;
        aname->revision = D.28376;
        D.28377 = cols[4];
        aname->flags = D.28377;
        aname->versioncompat = 1;
        aname->hashalg = 32772;
        D.28378 = &aname->version;
        D.28379 = aname->major;
        D.28380 = (unsigned int) D.28379;
        D.28381 = aname->minor;
        D.28382 = (unsigned int) D.28381;
        D.28383 = aname->build;
        D.28384 = (unsigned int) D.28383;
        D.28385 = aname->revision;
        D.28386 = (unsigned int) D.28385;
        D.28387 = create_version (domain, D.28380, D.28382, D.28384, D.28386);
        mono_gc_wbarrier_set_field (aname, D.28378, D.28387);
        create_culture.108 = create_culture;
        if (create_culture.108 != 0B) goto <D.28388>; else goto <D.28389>;
        <D.28388>:
        {
          void * args[2];
          MonoBoolean assembly_ref;

          try
            {
              assembly_ref = 1;
              D.28390 = cols[7];
              D.28391 = mono_metadata_string_heap (image, D.28390);
              D.28392 = mono_string_new (domain, D.28391);
              args[0] = D.28392;
              args[1] = &assembly_ref;
              D.28393 = &aname->cultureInfo;
              create_culture.108 = create_culture;
              D.28394 = mono_runtime_invoke (create_culture.108, 0B, &args, 0B);
              mono_gc_wbarrier_set_field (aname, D.28393, D.28394);
            }
          finally
            {
              args = {CLOBBER};
              assembly_ref = {CLOBBER};
            }
        }
        <D.28389>:
        D.28395 = cols[5];
        if (D.28395 != 0) goto <D.28396>; else goto <D.28397>;
        <D.28396>:
        {
          const gchar * pkey_ptr;
          guint32 pkey_len;

          try
            {
              D.28395 = cols[5];
              pkey_ptr.110 = mono_metadata_blob_heap (image, D.28395);
              pkey_ptr = pkey_ptr.110;
              pkey_ptr.111 = pkey_ptr;
              pkey_len = mono_metadata_decode_blob_size (pkey_ptr.111, &pkey_ptr);
              D.28377 = cols[4];
              D.28400 = D.28377 & 1;
              if (D.28400 != 0) goto <D.28401>; else goto <D.28402>;
              <D.28401>:
              D.28403 = &aname->publicKey;
              D.28404 = mono_defaults.byte_class;
              D.28405 = (long unsigned int) pkey_len;
              D.28406 = mono_array_new (domain, D.28404, D.28405);
              mono_gc_wbarrier_set_field (aname, D.28403, D.28406);
              D.28407 = aname->publicKey;
              D.28408 = mono_array_addr_with_size (D.28407, 1, 0);
              pkey_ptr.111 = pkey_ptr;
              D.28409 = (long unsigned int) pkey_len;
              memcpy (D.28408, pkey_ptr.111, D.28409);
              goto <D.28410>;
              <D.28402>:
              D.28411 = &aname->keyToken;
              D.28404 = mono_defaults.byte_class;
              D.28405 = (long unsigned int) pkey_len;
              D.28412 = mono_array_new (domain, D.28404, D.28405);
              mono_gc_wbarrier_set_field (aname, D.28411, D.28412);
              D.28413 = aname->keyToken;
              D.28414 = mono_array_addr_with_size (D.28413, 1, 0);
              pkey_ptr.111 = pkey_ptr;
              D.28409 = (long unsigned int) pkey_len;
              memcpy (D.28414, pkey_ptr.111, D.28409);
              <D.28410>:
            }
          finally
            {
              pkey_ptr = {CLOBBER};
            }
        }
        goto <D.28415>;
        <D.28397>:
        D.28411 = &aname->keyToken;
        D.28404 = mono_defaults.byte_class;
        D.28416 = mono_array_new (domain, D.28404, 0);
        mono_gc_wbarrier_set_field (aname, D.28411, D.28416);
        <D.28415>:
        {
          void * * __p;

          D.28417 = (long unsigned int) i;
          __p = mono_array_addr_with_size (result, 8, D.28417);
          mono_gc_wbarrier_set_arrayref (result, __p, aname);
        }
      }
    finally
      {
        cols = {CLOBBER};
      }
  }
  i = i + 1;
  <D.22539>:
  if (i < count) goto <D.22538>; else goto <D.22540>;
  <D.22540>:
  D.28418 = result;
  return D.28418;
}


ves_icall_System_Reflection_Assembly_GetModulesInternal (struct MonoReflectionAssembly * assembly)
{
  struct MonoAssembly * D.28420;
  _Bool D.28421;
  long int D.28422;
  long int D.28423;
  unsigned char D.28426;
  _Bool D.28427;
  long int D.28428;
  long int D.28429;
  <unnamed-unsigned:24> D.28432;
  long unsigned int D.28433;
  long unsigned int D.28434;
  struct MonoImage * * D.28435;
  struct MonoImage * D.28436;
  unsigned int i.112;
  struct MonoImage * D.28440;
  unsigned int file_count.113;
  unsigned int D.28442;
  unsigned int D.28443;
  long unsigned int D.28444;
  struct MonoReflectionModule * D.28445;
  long unsigned int D.28448;
  struct MonoReflectionModule * D.28449;
  unsigned int D.28450;
  struct MonoReflectionModule * D.28453;
  int D.28455;
  struct MonoDomain * D.28458;
  unsigned int D.28459;
  const char * D.28460;
  struct MonoException * D.28461;
  struct MonoReflectionModule * D.28462;
  struct MonoArray * D.28463;
  struct MonoDomain * domain;
  struct MonoArray * res;
  struct MonoClass * klass;
  int i;
  int j;
  int file_count;
  struct MonoImage * * modules;
  guint32 module_count;
  guint32 real_module_count;
  struct MonoTableInfo * table;
  guint32 cols[3];
  struct MonoImage * image;

  try
    {
      domain = mono_domain_get ();
      file_count = 0;
      D.28420 = assembly->assembly;
      image = D.28420->image;
      D.28421 = image == 0B;
      D.28422 = (long int) D.28421;
      D.28423 = __builtin_expect (D.28422, 0);
      if (D.28423 != 0) goto <D.28424>; else goto <D.28425>;
      <D.28424>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 4696, "image != NULL");
      <D.28425>:
      D.28420 = assembly->assembly;
      D.28426 = D.28420->dynamic;
      D.28427 = D.28426 != 0;
      D.28428 = (long int) D.28427;
      D.28429 = __builtin_expect (D.28428, 0);
      if (D.28429 != 0) goto <D.28430>; else goto <D.28431>;
      <D.28430>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 4697, "!assembly->assembly->dynamic");
      <D.28431>:
      table = &image->tables[38];
      D.28432 = table->rows;
      file_count = (int) D.28432;
      modules = image->modules;
      module_count = image->module_count;
      real_module_count = 0;
      i = 0;
      goto <D.22620>;
      <D.22619>:
      D.28433 = (long unsigned int) i;
      D.28434 = D.28433 * 8;
      D.28435 = modules + D.28434;
      D.28436 = *D.28435;
      if (D.28436 != 0B) goto <D.28437>; else goto <D.28438>;
      <D.28437>:
      real_module_count = real_module_count + 1;
      <D.28438>:
      i = i + 1;
      <D.22620>:
      i.112 = (unsigned int) i;
      if (i.112 < module_count) goto <D.22619>; else goto <D.22621>;
      <D.22621>:
      D.28440 = mono_defaults.corlib;
      klass = mono_class_from_name (D.28440, "System.Reflection", "Module");
      file_count.113 = (unsigned int) file_count;
      D.28442 = real_module_count + file_count.113;
      D.28443 = D.28442 + 1;
      D.28444 = (long unsigned int) D.28443;
      res = mono_array_new (domain, klass, D.28444);
      {
        void * * __p;

        __p = mono_array_addr_with_size (res, 8, 0);
        D.28445 = mono_module_get_object (domain, image);
        mono_gc_wbarrier_set_arrayref (res, __p, D.28445);
      }
      j = 1;
      i = 0;
      goto <D.22625>;
      <D.22624>:
      D.28433 = (long unsigned int) i;
      D.28434 = D.28433 * 8;
      D.28435 = modules + D.28434;
      D.28436 = *D.28435;
      if (D.28436 != 0B) goto <D.28446>; else goto <D.28447>;
      <D.28446>:
      {
        void * * __p;

        D.28448 = (long unsigned int) j;
        __p = mono_array_addr_with_size (res, 8, D.28448);
        D.28433 = (long unsigned int) i;
        D.28434 = D.28433 * 8;
        D.28435 = modules + D.28434;
        D.28436 = *D.28435;
        D.28449 = mono_module_get_object (domain, D.28436);
        mono_gc_wbarrier_set_arrayref (res, __p, D.28449);
      }
      j = j + 1;
      <D.28447>:
      i = i + 1;
      <D.22625>:
      i.112 = (unsigned int) i;
      if (i.112 < module_count) goto <D.22624>; else goto <D.22626>;
      <D.22626>:
      i = 0;
      goto <D.22632>;
      <D.22631>:
      mono_metadata_decode_row (table, i, &cols, 3);
      D.28450 = cols[0];
      if (D.28450 != 0) goto <D.28451>; else goto <D.28452>;
      <D.28451>:
      {
        void * * __p;

        D.28448 = (long unsigned int) j;
        __p = mono_array_addr_with_size (res, 8, D.28448);
        D.28453 = mono_module_file_get_object (domain, image, i);
        mono_gc_wbarrier_set_arrayref (res, __p, D.28453);
      }
      goto <D.28454>;
      <D.28452>:
      {
        struct MonoImage * m;

        D.28455 = i + 1;
        m = mono_image_load_file_for_image (image, D.28455);
        if (m == 0B) goto <D.28456>; else goto <D.28457>;
        <D.28456>:
        {
          struct MonoString * fname;

          D.28458 = mono_domain_get ();
          D.28459 = cols[1];
          D.28460 = mono_metadata_string_heap (image, D.28459);
          fname = mono_string_new (D.28458, D.28460);
          D.28461 = mono_get_exception_file_not_found2 (0B, fname);
          mono_raise_exception (D.28461);
        }
        <D.28457>:
        {
          void * * __p;

          D.28448 = (long unsigned int) j;
          __p = mono_array_addr_with_size (res, 8, D.28448);
          D.28462 = mono_module_get_object (domain, m);
          mono_gc_wbarrier_set_arrayref (res, __p, D.28462);
        }
      }
      <D.28454>:
      i = i + 1;
      j = j + 1;
      <D.22632>:
      if (i < file_count) goto <D.22631>; else goto <D.22633>;
      <D.22633>:
      D.28463 = res;
      return D.28463;
    }
  finally
    {
      cols = {CLOBBER};
    }
}


ves_icall_System_Reflection_Assembly_GetManifestResourceNames (struct MonoReflectionAssembly * assembly)
{
  struct MonoAssembly * D.28466;
  struct MonoImage * D.28467;
  struct MonoVTable * D.28468;
  struct MonoDomain * D.28469;
  struct MonoClass * D.28470;
  <unnamed-unsigned:24> D.28471;
  long unsigned int D.28472;
  unsigned int D.28473;
  long unsigned int D.28474;
  struct MonoString * D.28475;
  int D.28476;
  struct MonoArray * D.28477;
  struct MonoTableInfo * table;
  struct MonoArray * result;
  int i;
  const char * val;

  D.28466 = assembly->assembly;
  D.28467 = D.28466->image;
  table = &D.28467->tables[40];
  D.28468 = MEM[(struct MonoObject *)assembly].vtable;
  D.28469 = D.28468->domain;
  D.28470 = mono_defaults.string_class;
  D.28471 = table->rows;
  D.28472 = (long unsigned int) D.28471;
  result = mono_array_new (D.28469, D.28470, D.28472);
  i = 0;
  goto <D.22505>;
  <D.22504>:
  D.28466 = assembly->assembly;
  D.28467 = D.28466->image;
  D.28473 = mono_metadata_decode_row_col (table, i, 2);
  val = mono_metadata_string_heap (D.28467, D.28473);
  {
    void * * __p;

    D.28474 = (long unsigned int) i;
    __p = mono_array_addr_with_size (result, 8, D.28474);
    D.28468 = MEM[(struct MonoObject *)assembly].vtable;
    D.28469 = D.28468->domain;
    D.28475 = mono_string_new (D.28469, val);
    mono_gc_wbarrier_set_arrayref (result, __p, D.28475);
  }
  i = i + 1;
  <D.22505>:
  D.28471 = table->rows;
  D.28476 = (int) D.28471;
  if (D.28476 > i) goto <D.22504>; else goto <D.22506>;
  <D.22506>:
  D.28477 = result;
  return D.28477;
}


ves_icall_System_Reflection_Assembly_GetManifestResourceInternal (struct MonoReflectionAssembly * assembly, struct MonoString * name, gint32 * size, struct MonoReflectionModule * * ref_module)
{
  struct MonoAssembly * D.28479;
  struct MonoImage * D.28480;
  int i.114;
  unsigned int D.28482;
  int D.28483;
  <unnamed-unsigned:24> D.28485;
  unsigned int D.28486;
  void * D.28489;
  unsigned int D.28492;
  _Bool D.28493;
  long int D.28494;
  long int D.28495;
  int file_idx.115;
  struct MonoDomain * D.28502;
  struct MonoReflectionModule * D.28503;
  unsigned int D.28504;
  char * n;
  struct MonoTableInfo * table;
  guint32 i;
  guint32 cols[4];
  guint32 impl;
  guint32 file_idx;
  const char * val;
  struct MonoImage * module;

  try
    {
      n = mono_string_to_utf8 (name);
      D.28479 = assembly->assembly;
      D.28480 = D.28479->image;
      table = &D.28480->tables[40];
      i = 0;
      goto <D.22561>;
      <D.22560>:
      i.114 = (int) i;
      mono_metadata_decode_row (table, i.114, &cols, 4);
      D.28479 = assembly->assembly;
      D.28480 = D.28479->image;
      D.28482 = cols[2];
      val = mono_metadata_string_heap (D.28480, D.28482);
      D.28483 = strcmp (val, n);
      if (D.28483 == 0) goto <D.22559>; else goto <D.28484>;
      <D.28484>:
      i = i + 1;
      <D.22561>:
      D.28485 = table->rows;
      D.28486 = (unsigned int) D.28485;
      if (D.28486 > i) goto <D.22560>; else goto <D.22559>;
      <D.22559>:
      monoeg_g_free (n);
      D.28485 = table->rows;
      D.28486 = (unsigned int) D.28485;
      if (D.28486 == i) goto <D.28487>; else goto <D.28488>;
      <D.28487>:
      D.28489 = 0B;
      return D.28489;
      <D.28488>:
      impl = cols[3];
      if (impl != 0) goto <D.28490>; else goto <D.28491>;
      <D.28490>:
      D.28492 = impl & 3;
      D.28493 = D.28492 != 0;
      D.28494 = (long int) D.28493;
      D.28495 = __builtin_expect (D.28494, 0);
      if (D.28495 != 0) goto <D.28496>; else goto <D.28497>;
      <D.28496>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 4553, "(impl & MONO_IMPLEMENTATION_MASK) == MONO_IMPLEMENTATION_FILE");
      <D.28497>:
      file_idx = impl >> 2;
      D.28479 = assembly->assembly;
      D.28480 = D.28479->image;
      file_idx.115 = (int) file_idx;
      module = mono_image_load_file_for_image (D.28480, file_idx.115);
      if (module == 0B) goto <D.28499>; else goto <D.28500>;
      <D.28499>:
      D.28489 = 0B;
      return D.28489;
      <D.28500>:
      goto <D.28501>;
      <D.28491>:
      D.28479 = assembly->assembly;
      module = D.28479->image;
      <D.28501>:
      D.28502 = mono_domain_get ();
      D.28503 = mono_module_get_object (D.28502, module);
      mono_gc_wbarrier_generic_store (ref_module, D.28503);
      D.28504 = cols[0];
      D.28489 = mono_image_get_resource (module, D.28504, size);
      return D.28489;
    }
  finally
    {
      cols = {CLOBBER};
    }
}


ves_icall_System_Reflection_Assembly_GetManifestResourceInfoInternal (struct MonoReflectionAssembly * assembly, struct MonoString * name, struct MonoManifestResourceInfo * info)
{
  struct MonoAssembly * D.28507;
  struct MonoImage * D.28508;
  unsigned int D.28509;
  int D.28510;
  <unnamed-unsigned:24> D.28512;
  int D.28513;
  gboolean D.28516;
  unsigned int D.28517;
  unsigned int D.28521;
  unsigned int D.28522;
  int D.28523;
  unsigned int D.28524;
  struct MonoString * * D.28525;
  struct MonoVTable * D.28526;
  struct MonoDomain * D.28527;
  struct MonoString * D.28528;
  unsigned int D.28529;
  struct MonoAssembly * * D.28533;
  long unsigned int D.28534;
  long unsigned int D.28535;
  sizetype D.28536;
  struct MonoAssembly * * D.28537;
  struct MonoAssembly * D.28538;
  char * D.28541;
  struct MonoReflectionAssembly * * D.28542;
  struct MonoDomain * D.28543;
  struct MonoReflectionAssembly * D.28544;
  struct MonoReflectionAssembly * D.28545;
  unsigned int D.28546;
  unsigned int D.28547;
  struct MonoTableInfo * table;
  int i;
  guint32 cols[4];
  guint32 file_cols[3];
  const char * val;
  char * n;

  try
    {
      D.28507 = assembly->assembly;
      D.28508 = D.28507->image;
      table = &D.28508->tables[40];
      n = mono_string_to_utf8 (name);
      i = 0;
      goto <D.22575>;
      <D.22574>:
      mono_metadata_decode_row (table, i, &cols, 4);
      D.28507 = assembly->assembly;
      D.28508 = D.28507->image;
      D.28509 = cols[2];
      val = mono_metadata_string_heap (D.28508, D.28509);
      D.28510 = strcmp (val, n);
      if (D.28510 == 0) goto <D.22573>; else goto <D.28511>;
      <D.28511>:
      i = i + 1;
      <D.22575>:
      D.28512 = table->rows;
      D.28513 = (int) D.28512;
      if (D.28513 > i) goto <D.22574>; else goto <D.22573>;
      <D.22573>:
      monoeg_g_free (n);
      D.28512 = table->rows;
      D.28513 = (int) D.28512;
      if (D.28513 == i) goto <D.28514>; else goto <D.28515>;
      <D.28514>:
      D.28516 = 0;
      return D.28516;
      <D.28515>:
      D.28517 = cols[3];
      if (D.28517 == 0) goto <D.28518>; else goto <D.28519>;
      <D.28518>:
      info->location = 5;
      goto <D.28520>;
      <D.28519>:
      D.28517 = cols[3];
      D.28521 = D.28517 & 3;
      switch (D.28521) <default: <D.28548>, case 0: <D.22576>, case 1: <D.22578>, case 2: <D.22581>>
      <D.22576>:
      D.28517 = cols[3];
      D.28522 = D.28517 >> 2;
      i = (int) D.28522;
      D.28507 = assembly->assembly;
      D.28508 = D.28507->image;
      table = &D.28508->tables[38];
      D.28523 = i + -1;
      mono_metadata_decode_row (table, D.28523, &file_cols, 3);
      D.28507 = assembly->assembly;
      D.28508 = D.28507->image;
      D.28524 = file_cols[1];
      val = mono_metadata_string_heap (D.28508, D.28524);
      D.28525 = &info->filename;
      D.28526 = MEM[(struct MonoObject *)assembly].vtable;
      D.28527 = D.28526->domain;
      D.28528 = mono_string_new (D.28527, val);
      mono_gc_wbarrier_set_field (info, D.28525, D.28528);
      D.28529 = file_cols[0];
      if (D.28529 != 0) goto <D.28530>; else goto <D.28531>;
      <D.28530>:
      info->location = 0;
      goto <D.28532>;
      <D.28531>:
      info->location = 1;
      <D.28532>:
      goto <D.22577>;
      <D.22578>:
      D.28517 = cols[3];
      D.28522 = D.28517 >> 2;
      i = (int) D.28522;
      D.28507 = assembly->assembly;
      D.28508 = D.28507->image;
      D.28523 = i + -1;
      mono_assembly_load_reference (D.28508, D.28523);
      D.28507 = assembly->assembly;
      D.28508 = D.28507->image;
      D.28533 = D.28508->references;
      D.28534 = (long unsigned int) i;
      D.28535 = D.28534 * 8;
      D.28536 = D.28535 + 18446744073709551608;
      D.28537 = D.28533 + D.28536;
      D.28538 = *D.28537;
      if (D.28538 == -1B) goto <D.28539>; else goto <D.28540>;
      <D.28539>:
      {
        char * msg;
        struct MonoException * ex;

        D.28523 = i + -1;
        D.28507 = assembly->assembly;
        D.28508 = D.28507->image;
        D.28541 = D.28508->name;
        msg = monoeg_g_strdup_printf ("Assembly %d referenced from assembly %s not found ", D.28523, D.28541);
        ex = mono_get_exception_file_not_found2 (msg, 0B);
        monoeg_g_free (msg);
        mono_raise_exception (ex);
      }
      <D.28540>:
      D.28542 = &info->assembly;
      D.28543 = mono_domain_get ();
      D.28507 = assembly->assembly;
      D.28508 = D.28507->image;
      D.28533 = D.28508->references;
      D.28534 = (long unsigned int) i;
      D.28535 = D.28534 * 8;
      D.28536 = D.28535 + 18446744073709551608;
      D.28537 = D.28533 + D.28536;
      D.28538 = *D.28537;
      D.28544 = mono_assembly_get_object (D.28543, D.28538);
      mono_gc_wbarrier_set_field (info, D.28542, D.28544);
      D.28545 = info->assembly;
      ves_icall_System_Reflection_Assembly_GetManifestResourceInfoInternal (D.28545, name, info);
      D.28546 = info->location;
      D.28547 = D.28546 | 2;
      info->location = D.28547;
      goto <D.22577>;
      <D.22581>:
      monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "icall.c", 4625);
      <D.28548>:
      <D.22577>:
      <D.28520>:
      D.28516 = 1;
      return D.28516;
    }
  finally
    {
      cols = {CLOBBER};
      file_cols = {CLOBBER};
    }
}


ves_icall_System_Reflection_Assembly_GetManifestModuleInternal (struct MonoReflectionAssembly * assembly)
{
  struct MonoReflectionModule * D.28551;
  struct MonoVTable * D.28552;
  struct MonoDomain * D.28553;
  struct MonoAssembly * D.28554;
  struct MonoImage * D.28555;

  D.28552 = MEM[(struct MonoObject *)assembly].vtable;
  D.28553 = D.28552->domain;
  D.28554 = assembly->assembly;
  D.28555 = D.28554->image;
  D.28551 = mono_module_get_object (D.28553, D.28555);
  return D.28551;
}


ves_icall_System_Reflection_Assembly_GetFilesInternal (struct MonoReflectionAssembly * assembly, struct MonoString * name, MonoBoolean resource_modules)
{
  struct MonoAssembly * D.28557;
  struct MonoImage * D.28558;
  unsigned int D.28561;
  int D.28562;
  char * D.28565;
  struct MonoVTable * D.28566;
  struct MonoDomain * D.28567;
  struct MonoObject * D.28568;
  <unnamed-unsigned:24> D.28569;
  int D.28570;
  unsigned int D.28574;
  unsigned int D.28575;
  struct MonoClass * D.28576;
  long unsigned int D.28577;
  unsigned int D.28581;
  unsigned int D.28582;
  unsigned int D.28583;
  struct MonoString * D.28584;
  struct MonoTableInfo * table;
  struct MonoArray * result;
  int i;
  int count;
  const char * val;
  char * n;

  D.28557 = assembly->assembly;
  D.28558 = D.28557->image;
  table = &D.28558->tables[38];
  result = 0B;
  if (name != 0B) goto <D.28559>; else goto <D.28560>;
  <D.28559>:
  n = mono_string_to_utf8 (name);
  i = 0;
  goto <D.22595>;
  <D.22594>:
  D.28557 = assembly->assembly;
  D.28558 = D.28557->image;
  D.28561 = mono_metadata_decode_row_col (table, i, 1);
  val = mono_metadata_string_heap (D.28558, D.28561);
  D.28562 = strcmp (val, n);
  if (D.28562 == 0) goto <D.28563>; else goto <D.28564>;
  <D.28563>:
  {
    struct MonoString * fn;

    monoeg_g_free (n);
    D.28557 = assembly->assembly;
    D.28565 = D.28557->basedir;
    n = g_concat_dir_and_file (D.28565, val);
    D.28566 = MEM[(struct MonoObject *)assembly].vtable;
    D.28567 = D.28566->domain;
    fn = mono_string_new (D.28567, n);
    monoeg_g_free (n);
    D.28568 = fn;
    return D.28568;
  }
  <D.28564>:
  i = i + 1;
  <D.22595>:
  D.28569 = table->rows;
  D.28570 = (int) D.28569;
  if (D.28570 > i) goto <D.22594>; else goto <D.22596>;
  <D.22596>:
  monoeg_g_free (n);
  D.28568 = 0B;
  return D.28568;
  <D.28560>:
  count = 0;
  i = 0;
  goto <D.22598>;
  <D.22597>:
  if (resource_modules != 0) goto <D.28571>; else goto <D.28573>;
  <D.28573>:
  D.28574 = mono_metadata_decode_row_col (table, i, 0);
  D.28575 = D.28574 & 1;
  if (D.28575 == 0) goto <D.28571>; else goto <D.28572>;
  <D.28571>:
  count = count + 1;
  <D.28572>:
  i = i + 1;
  <D.22598>:
  D.28569 = table->rows;
  D.28570 = (int) D.28569;
  if (D.28570 > i) goto <D.22597>; else goto <D.22599>;
  <D.22599>:
  D.28566 = MEM[(struct MonoObject *)assembly].vtable;
  D.28567 = D.28566->domain;
  D.28576 = mono_defaults.string_class;
  D.28577 = (long unsigned int) count;
  result = mono_array_new (D.28567, D.28576, D.28577);
  count = 0;
  i = 0;
  goto <D.22602>;
  <D.22601>:
  if (resource_modules != 0) goto <D.28578>; else goto <D.28580>;
  <D.28580>:
  D.28581 = mono_metadata_decode_row_col (table, i, 0);
  D.28582 = D.28581 & 1;
  if (D.28582 == 0) goto <D.28578>; else goto <D.28579>;
  <D.28578>:
  D.28557 = assembly->assembly;
  D.28558 = D.28557->image;
  D.28583 = mono_metadata_decode_row_col (table, i, 1);
  val = mono_metadata_string_heap (D.28558, D.28583);
  D.28557 = assembly->assembly;
  D.28565 = D.28557->basedir;
  n = g_concat_dir_and_file (D.28565, val);
  {
    void * * __p;

    D.28577 = (long unsigned int) count;
    __p = mono_array_addr_with_size (result, 8, D.28577);
    D.28566 = MEM[(struct MonoObject *)assembly].vtable;
    D.28567 = D.28566->domain;
    D.28584 = mono_string_new (D.28567, n);
    mono_gc_wbarrier_set_arrayref (result, __p, D.28584);
  }
  monoeg_g_free (n);
  count = count + 1;
  <D.28579>:
  i = i + 1;
  <D.22602>:
  D.28569 = table->rows;
  D.28570 = (int) D.28569;
  if (D.28570 > i) goto <D.22601>; else goto <D.22603>;
  <D.22603>:
  D.28568 = result;
  return D.28568;
}


g_concat_dir_and_file (const char * dir, const char * file)
{
  char * D.28588;
  long unsigned int D.28591;
  sizetype D.28592;
  const char * D.28593;
  char D.28594;

  if (dir == 0B) goto <D.28586>; else goto <D.28587>;
  <D.28586>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "icall.c", 4511, "dir != NULL");
  D.28588 = 0B;
  return D.28588;
  <D.28587>:
  if (file == 0B) goto <D.28589>; else goto <D.28590>;
  <D.28589>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "icall.c", 4512, "file != NULL");
  D.28588 = 0B;
  return D.28588;
  <D.28590>:
  D.28591 = __strlen_g (dir);
  D.28592 = D.28591 + 18446744073709551615;
  D.28593 = dir + D.28592;
  D.28594 = *D.28593;
  if (D.28594 != 47) goto <D.28595>; else goto <D.28596>;
  <D.28595>:
  D.28588 = monoeg_g_strconcat (dir, "/", file, 0B);
  return D.28588;
  <D.28596>:
  D.28588 = monoeg_g_strconcat (dir, file, 0B);
  return D.28588;
}


ves_icall_System_Reflection_Assembly_GetExecutingAssembly ()
{
  struct MonoMethod * dest.116;
  _Bool D.28599;
  long int D.28600;
  long int D.28601;
  struct MonoReflectionAssembly * D.28604;
  struct MonoDomain * D.28605;
  struct MonoClass * D.28606;
  struct MonoImage * D.28607;
  struct MonoAssembly * D.28608;
  struct MonoMethod * dest;

  try
    {
      dest = 0B;
      mono_stack_walk_no_il (get_executing, &dest);
      dest.116 = dest;
      D.28599 = dest.116 == 0B;
      D.28600 = (long int) D.28599;
      D.28601 = __builtin_expect (D.28600, 0);
      if (D.28601 != 0) goto <D.28602>; else goto <D.28603>;
      <D.28602>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 4821, "dest");
      <D.28603>:
      D.28605 = mono_domain_get ();
      dest.116 = dest;
      D.28606 = dest.116->klass;
      D.28607 = D.28606->image;
      D.28608 = D.28607->assembly;
      D.28604 = mono_assembly_get_object (D.28605, D.28608);
      return D.28604;
    }
  finally
    {
      dest = {CLOBBER};
    }
}


get_executing (struct MonoMethod * m, gint32 no, gint32 ilo, gboolean managed, void * data)
{
  gboolean D.28613;
  struct MonoMethod * D.28614;
  struct MonoClass * D.28617;
  const char * D.28618;
  int D.28619;
  struct MonoMethod * * dest;

  dest = data;
  if (managed == 0) goto <D.28611>; else goto <D.28612>;
  <D.28611>:
  D.28613 = 0;
  return D.28613;
  <D.28612>:
  D.28614 = *dest;
  if (D.28614 == 0B) goto <D.28615>; else goto <D.28616>;
  <D.28615>:
  D.28617 = m->klass;
  D.28618 = D.28617->name_space;
  D.28619 = strcmp (D.28618, "System.Reflection");
  if (D.28619 == 0) goto <D.28620>; else goto <D.28621>;
  <D.28620>:
  D.28613 = 0;
  return D.28613;
  <D.28621>:
  *dest = m;
  D.28613 = 1;
  return D.28613;
  <D.28616>:
  D.28613 = 0;
  return D.28613;
}


ves_icall_System_Reflection_Assembly_GetEntryAssembly ()
{
  struct MonoAssembly * D.28623;
  struct MonoReflectionAssembly * D.28626;
  struct MonoDomain * domain;

  domain = mono_domain_get ();
  D.28623 = domain->entry_assembly;
  if (D.28623 == 0B) goto <D.28624>; else goto <D.28625>;
  <D.28624>:
  D.28626 = 0B;
  return D.28626;
  <D.28625>:
  D.28623 = domain->entry_assembly;
  D.28626 = mono_assembly_get_object (domain, D.28623);
  return D.28626;
}


ves_icall_System_Reflection_Assembly_GetCallingAssembly ()
{
  struct MonoMethod * dest.117;
  struct MonoReflectionAssembly * D.28631;
  struct MonoDomain * D.28632;
  struct MonoClass * D.28633;
  struct MonoImage * D.28634;
  struct MonoAssembly * D.28635;
  struct MonoMethod * m;
  struct MonoMethod * dest;

  try
    {
      dest = 0B;
      mono_stack_walk_no_il (get_executing, &dest);
      m = dest;
      mono_stack_walk_no_il (get_caller, &dest);
      dest.117 = dest;
      if (dest.117 == 0B) goto <D.28629>; else goto <D.28630>;
      <D.28629>:
      dest = m;
      <D.28630>:
      D.28632 = mono_domain_get ();
      dest.117 = dest;
      D.28633 = dest.117->klass;
      D.28634 = D.28633->image;
      D.28635 = D.28634->assembly;
      D.28631 = mono_assembly_get_object (D.28632, D.28635);
      return D.28631;
    }
  finally
    {
      dest = {CLOBBER};
    }
}


get_caller (struct MonoMethod * m, gint32 no, gint32 ilo, gboolean managed, void * data)
{
  gboolean D.28640;
  struct MonoMethod * D.28641;
  struct MonoMethod * * dest;

  dest = data;
  if (managed == 0) goto <D.28638>; else goto <D.28639>;
  <D.28638>:
  D.28640 = 0;
  return D.28640;
  <D.28639>:
  D.28641 = *dest;
  if (D.28641 == m) goto <D.28642>; else goto <D.28643>;
  <D.28642>:
  *dest = 0B;
  D.28640 = 0;
  return D.28640;
  <D.28643>:
  D.28641 = *dest;
  if (D.28641 == 0B) goto <D.28644>; else goto <D.28645>;
  <D.28644>:
  *dest = m;
  D.28640 = 1;
  return D.28640;
  <D.28645>:
  D.28640 = 0;
  return D.28640;
}


ves_icall_System_Reflection_Assembly_FillName (struct MonoReflectionAssembly * assembly, struct MonoReflectionAssemblyName * aname)
{
  struct MonoImage * D.28647;
  char * D.28648;
  int D.28649;
  struct MonoVTable * D.28652;
  struct MonoDomain * D.28653;
  struct MonoAssemblyName * D.28654;
  char * D.28655;
  gchar * absolute;
  struct MonoAssembly * mass;

  mass = assembly->assembly;
  D.28647 = mass->image;
  D.28648 = D.28647->name;
  D.28649 = monoeg_g_path_is_absolute (D.28648);
  if (D.28649 != 0) goto <D.28650>; else goto <D.28651>;
  <D.28650>:
  D.28652 = MEM[(struct MonoObject *)assembly].vtable;
  D.28653 = D.28652->domain;
  D.28654 = &mass->aname;
  D.28647 = mass->image;
  D.28648 = D.28647->name;
  fill_reflection_assembly_name (D.28653, aname, D.28654, D.28648, 1, 1, 1);
  return;
  <D.28651>:
  D.28655 = mass->basedir;
  D.28647 = mass->image;
  D.28648 = D.28647->name;
  absolute = monoeg_g_build_path ("/", D.28655, D.28648, 0B);
  D.28652 = MEM[(struct MonoObject *)assembly].vtable;
  D.28653 = D.28652->domain;
  D.28654 = &mass->aname;
  fill_reflection_assembly_name (D.28653, aname, D.28654, absolute, 1, 1, 1);
  monoeg_g_free (absolute);
}


ves_icall_System_Object_obj_address (struct MonoObject * this)
{
  void * D.28657;

  D.28657 = this;
  return D.28657;
}


ves_icall_System_Object_MemberwiseClone (struct MonoObject * this)
{
  struct MonoObject * D.28659;

  D.28659 = mono_object_clone (this);
  return D.28659;
}


ves_icall_System_Object_GetType (struct MonoObject * obj)
{
  struct MonoVTable * D.28661;
  struct MonoClass * D.28662;
  struct MonoClass * D.28663;
  struct MonoReflectionType * D.28666;
  struct MonoDomain * D.28667;
  struct MonoRemoteClass * D.28668;
  struct MonoClass * D.28669;
  struct MonoType * D.28670;
  struct MonoType * D.28671;

  D.28661 = obj->vtable;
  D.28662 = D.28661->klass;
  D.28663 = mono_defaults.transparent_proxy_class;
  if (D.28662 == D.28663) goto <D.28664>; else goto <D.28665>;
  <D.28664>:
  D.28661 = obj->vtable;
  D.28667 = D.28661->domain;
  D.28668 = MEM[(struct MonoTransparentProxy *)obj].remote_class;
  D.28669 = D.28668->proxy_class;
  D.28670 = &D.28669->byval_arg;
  D.28666 = mono_type_get_object (D.28667, D.28670);
  return D.28666;
  <D.28665>:
  D.28661 = obj->vtable;
  D.28667 = D.28661->domain;
  D.28661 = obj->vtable;
  D.28662 = D.28661->klass;
  D.28671 = &D.28662->byval_arg;
  D.28666 = mono_type_get_object (D.28667, D.28671);
  return D.28666;
}


ves_icall_System_NumberFormatter_GetFormatterTables (const guint64 * * mantissas, const gint32 * * exponents, const gunichar2 * * digitLowerTable, const gunichar2 * * digitUpperTable, const gint64 * * tenPowersList, const gint32 * * decHexDigits)
{
  *mantissas = &Formatter_MantissaBitsTable;
  *exponents = &Formatter_TensExponentTable;
  *digitLowerTable = &Formatter_DigitLowerTable;
  *digitUpperTable = &Formatter_DigitUpperTable;
  *tenPowersList = &Formatter_TenPowersList;
  *decHexDigits = &Formatter_DecHexDigits;
}


mono_type_type_from_obj (struct MonoReflectionType * mtype, struct MonoObject * obj)
{
  struct MonoVTable * D.28673;
  struct MonoClass * D.28674;
  struct MonoType * D.28675;
  struct MonoType * D.28676;
  unsigned char D.28677;
  _Bool D.28678;
  long int D.28679;
  long int D.28680;

  D.28673 = obj->vtable;
  D.28674 = D.28673->klass;
  D.28675 = &D.28674->byval_arg;
  mtype->type = D.28675;
  D.28676 = mtype->type;
  D.28677 = D.28676->type;
  D.28678 = D.28677 == 0;
  D.28679 = (long int) D.28678;
  D.28680 = __builtin_expect (D.28679, 0);
  if (D.28680 != 0) goto <D.28681>; else goto <D.28682>;
  <D.28681>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 1149, "mtype->type->type");
  <D.28682>:
}


vell_icall_MonoType_get_core_clr_security_level (struct MonoReflectionType * this)
{
  struct MonoType * D.28683;
  int D.28684;
  <unnamed type> D.28685;
  struct MonoClass * klass;

  D.28683 = this->type;
  klass = mono_class_from_mono_type (D.28683);
  mono_class_init_or_throw (klass);
  D.28685 = mono_security_core_clr_class_level (klass);
  D.28684 = (int) D.28685;
  return D.28684;
}


ves_icall_get_attributes (struct MonoReflectionType * type)
{
  struct MonoType * D.28687;
  guint32 D.28688;
  struct MonoClass * klass;

  D.28687 = type->type;
  klass = mono_class_from_mono_type (D.28687);
  D.28688 = klass->flags;
  return D.28688;
}


ves_icall_MonoType_get_Namespace (struct MonoReflectionType * type)
{
  struct MonoType * D.28690;
  struct MonoClass * D.28691;
  const char * D.28692;
  char D.28693;
  struct MonoString * D.28696;
  struct MonoDomain * domain;
  struct MonoClass * class;

  domain = mono_domain_get ();
  D.28690 = type->type;
  class = mono_class_from_mono_type (D.28690);
  goto <D.21774>;
  <D.21773>:
  class = class->nested_in;
  <D.21774>:
  D.28691 = class->nested_in;
  if (D.28691 != 0B) goto <D.21773>; else goto <D.21775>;
  <D.21775>:
  D.28692 = class->name_space;
  D.28693 = *D.28692;
  if (D.28693 == 0) goto <D.28694>; else goto <D.28695>;
  <D.28694>:
  D.28696 = 0B;
  return D.28696;
  <D.28695>:
  D.28692 = class->name_space;
  D.28696 = mono_string_new (domain, D.28692);
  return D.28696;
}


ves_icall_MonoType_get_Name (struct MonoReflectionType * type)
{
  struct MonoType * D.28698;
  long unsigned int D.28699;
  long unsigned int D.28700;
  const char * D.28703;
  struct MonoString * D.28704;
  struct MonoDomain * domain;
  struct MonoClass * class;

  domain = mono_domain_get ();
  D.28698 = type->type;
  class = mono_class_from_mono_type (D.28698);
  D.28698 = type->type;
  D.28699 = BIT_FIELD_REF <*D.28698, 64, 64>;
  D.28700 = D.28699 & 8589934592;
  if (D.28700 != 0) goto <D.28701>; else goto <D.28702>;
  <D.28701>:
  {
    char * n;
    struct MonoString * res;

    D.28703 = class->name;
    n = monoeg_g_strdup_printf ("%s&", D.28703);
    res = mono_string_new (domain, n);
    monoeg_g_free (n);
    D.28704 = res;
    return D.28704;
  }
  <D.28702>:
  D.28703 = class->name;
  D.28704 = mono_string_new (domain, D.28703);
  return D.28704;
}


ves_icall_MonoType_get_Module (struct MonoReflectionType * type)
{
  struct MonoType * D.28706;
  struct MonoReflectionModule * D.28707;
  struct MonoVTable * D.28708;
  struct MonoDomain * D.28709;
  struct MonoImage * D.28710;
  struct MonoClass * class;

  D.28706 = type->type;
  class = mono_class_from_mono_type (D.28706);
  D.28708 = MEM[(struct MonoObject *)type].vtable;
  D.28709 = D.28708->domain;
  D.28710 = class->image;
  D.28707 = mono_module_get_object (D.28709, D.28710);
  return D.28707;
}


ves_icall_MonoType_get_IsGenericParameter (struct MonoReflectionType * type)
{
  MonoBoolean D.28712;
  struct MonoType * D.28713;

  D.28713 = type->type;
  D.28712 = is_generic_parameter (D.28713);
  return D.28712;
}


ves_icall_MonoType_get_DeclaringType (struct MonoReflectionType * type)
{
  struct MonoType * D.28715;
  long unsigned int D.28716;
  long unsigned int D.28717;
  struct MonoReflectionType * D.28720;
  unsigned char D.28721;
  struct MonoGenericParam * D.28724;
  struct MonoGenericContainer * D.28725;
  struct MonoMethod * D.28729;
  struct MonoClass * D.28731;
  struct MonoReflectionType * iftmp.118;
  struct MonoType * D.28735;
  struct MonoDomain * domain;
  struct MonoClass * class;

  domain = mono_domain_get ();
  D.28715 = type->type;
  D.28716 = BIT_FIELD_REF <*D.28715, 64, 64>;
  D.28717 = D.28716 & 8589934592;
  if (D.28717 != 0) goto <D.28718>; else goto <D.28719>;
  <D.28718>:
  D.28720 = 0B;
  return D.28720;
  <D.28719>:
  D.28715 = type->type;
  D.28721 = D.28715->type;
  if (D.28721 == 19) goto <D.28722>; else goto <D.28723>;
  <D.28722>:
  D.28715 = type->type;
  D.28724 = D.28715->data.generic_param;
  D.28725 = D.28724->owner;
  class = D.28725->owner.klass;
  goto <D.28726>;
  <D.28723>:
  D.28715 = type->type;
  D.28721 = D.28715->type;
  if (D.28721 == 30) goto <D.28727>; else goto <D.28728>;
  <D.28727>:
  D.28715 = type->type;
  D.28724 = D.28715->data.generic_param;
  D.28725 = D.28724->owner;
  D.28729 = D.28725->owner.method;
  class = D.28729->klass;
  goto <D.28730>;
  <D.28728>:
  D.28715 = type->type;
  D.28731 = mono_class_from_mono_type (D.28715);
  class = D.28731->nested_in;
  <D.28730>:
  <D.28726>:
  if (class != 0B) goto <D.28733>; else goto <D.28734>;
  <D.28733>:
  D.28735 = &class->byval_arg;
  iftmp.118 = mono_type_get_object (domain, D.28735);
  goto <D.28736>;
  <D.28734>:
  iftmp.118 = 0B;
  <D.28736>:
  D.28720 = iftmp.118;
  return D.28720;
}


ves_icall_MonoType_get_DeclaringMethod (struct MonoReflectionType * ref_type)
{
  long unsigned int D.28740;
  long unsigned int D.28741;
  unsigned char D.28743;
  struct MonoException * D.28745;
  struct MonoReflectionMethod * D.28748;
  struct MonoGenericParam * D.28749;
  struct MonoGenericContainer * D.28750;
  _Bool D.28751;
  long int D.28752;
  long int D.28753;
  struct MonoVTable * D.28756;
  struct MonoDomain * D.28757;
  struct MonoClass * D.28758;
  struct MonoMethod * method;
  struct MonoType * type;

  type = ref_type->type;
  D.28740 = BIT_FIELD_REF <*type, 64, 64>;
  D.28741 = D.28740 & 8589934592;
  if (D.28741 != 0) goto <D.28738>; else goto <D.28742>;
  <D.28742>:
  D.28743 = type->type;
  if (D.28743 != 30) goto <D.28744>; else goto <D.28739>;
  <D.28744>:
  D.28743 = type->type;
  if (D.28743 != 19) goto <D.28738>; else goto <D.28739>;
  <D.28738>:
  D.28745 = mono_get_exception_invalid_operation ("DeclaringMethod can only be used on generic arguments");
  mono_raise_exception (D.28745);
  <D.28739>:
  D.28743 = type->type;
  if (D.28743 == 19) goto <D.28746>; else goto <D.28747>;
  <D.28746>:
  D.28748 = 0B;
  return D.28748;
  <D.28747>:
  D.28749 = type->data.generic_param;
  D.28750 = D.28749->owner;
  method = D.28750->owner.method;
  D.28751 = method == 0B;
  D.28752 = (long int) D.28751;
  D.28753 = __builtin_expect (D.28752, 0);
  if (D.28753 != 0) goto <D.28754>; else goto <D.28755>;
  <D.28754>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 2570, "method");
  <D.28755>:
  D.28756 = MEM[(struct MonoObject *)ref_type].vtable;
  D.28757 = D.28756->domain;
  D.28758 = method->klass;
  D.28748 = mono_method_get_object (D.28757, method, D.28758);
  return D.28748;
}


ves_icall_get_type_parent (struct MonoReflectionType * type)
{
  struct MonoType * D.28760;
  struct MonoReflectionType * D.28761;
  struct MonoReflectionType * iftmp.119;
  struct MonoClass * D.28763;
  struct MonoVTable * D.28766;
  struct MonoDomain * D.28767;
  struct MonoType * D.28768;
  struct MonoClass * class;

  D.28760 = type->type;
  class = mono_class_from_mono_type (D.28760);
  D.28763 = class->parent;
  if (D.28763 != 0B) goto <D.28764>; else goto <D.28765>;
  <D.28764>:
  D.28766 = MEM[(struct MonoObject *)type].vtable;
  D.28767 = D.28766->domain;
  D.28763 = class->parent;
  D.28768 = &D.28763->byval_arg;
  iftmp.119 = mono_type_get_object (D.28767, D.28768);
  goto <D.28769>;
  <D.28765>:
  iftmp.119 = 0B;
  <D.28769>:
  D.28761 = iftmp.119;
  return D.28761;
}


ves_icall_MonoType_get_Assembly (struct MonoReflectionType * type)
{
  struct MonoType * D.28771;
  struct MonoReflectionAssembly * D.28772;
  struct MonoImage * D.28773;
  struct MonoAssembly * D.28774;
  struct MonoDomain * domain;
  struct MonoClass * class;

  domain = mono_domain_get ();
  D.28771 = type->type;
  class = mono_class_from_mono_type (D.28771);
  D.28773 = class->image;
  D.28774 = D.28773->assembly;
  D.28772 = mono_assembly_get_object (domain, D.28774);
  return D.28772;
}


ves_icall_System_MonoType_getFullName (struct MonoReflectionType * object, gboolean full_name, gboolean assembly_qualified)
{
  struct MonoVTable * D.28776;
  MonoTypeNameFormat iftmp.120;
  struct MonoType * D.28784;
  struct MonoString * D.28787;
  unsigned char D.28792;
  struct MonoDomain * domain;
  MonoTypeNameFormat format;
  struct MonoString * res;
  gchar * name;

  D.28776 = MEM[(struct MonoObject *)object].vtable;
  domain = D.28776->domain;
  if (full_name != 0) goto <D.28777>; else goto <D.28778>;
  <D.28777>:
  if (assembly_qualified != 0) goto <D.28780>; else goto <D.28781>;
  <D.28780>:
  iftmp.120 = 3;
  goto <D.28782>;
  <D.28781>:
  iftmp.120 = 2;
  <D.28782>:
  format = iftmp.120;
  goto <D.28783>;
  <D.28778>:
  format = 1;
  <D.28783>:
  D.28784 = object->type;
  name = mono_type_get_name_full (D.28784, format);
  if (name == 0B) goto <D.28785>; else goto <D.28786>;
  <D.28785>:
  D.28787 = 0B;
  return D.28787;
  <D.28786>:
  if (full_name != 0) goto <D.28790>; else goto <D.28791>;
  <D.28790>:
  D.28784 = object->type;
  D.28792 = D.28784->type;
  if (D.28792 == 19) goto <D.28788>; else goto <D.28793>;
  <D.28793>:
  D.28784 = object->type;
  D.28792 = D.28784->type;
  if (D.28792 == 30) goto <D.28788>; else goto <D.28789>;
  <D.28788>:
  monoeg_g_free (name);
  D.28787 = 0B;
  return D.28787;
  <D.28789>:
  <D.28791>:
  res = mono_string_new (domain, name);
  monoeg_g_free (name);
  D.28787 = res;
  return D.28787;
}


ves_icall_type_isprimitive (struct MonoReflectionType * type)
{
  MonoBoolean D.28795;
  int iftmp.121;
  struct MonoType * D.28800;
  long unsigned int D.28801;
  long unsigned int D.28802;
  unsigned char D.28804;
  unsigned char D.28805;

  D.28800 = type->type;
  D.28801 = BIT_FIELD_REF <*D.28800, 64, 64>;
  D.28802 = D.28801 & 8589934592;
  if (D.28802 == 0) goto <D.28803>; else goto <D.28797>;
  <D.28803>:
  D.28800 = type->type;
  D.28804 = D.28800->type;
  D.28805 = D.28804 + 254;
  if (D.28805 <= 11) goto <D.28798>; else goto <D.28806>;
  <D.28806>:
  D.28800 = type->type;
  D.28804 = D.28800->type;
  if (D.28804 == 24) goto <D.28798>; else goto <D.28807>;
  <D.28807>:
  D.28800 = type->type;
  D.28804 = D.28800->type;
  if (D.28804 == 25) goto <D.28798>; else goto <D.28797>;
  <D.28798>:
  iftmp.121 = 1;
  goto <D.28799>;
  <D.28797>:
  iftmp.121 = 0;
  <D.28799>:
  D.28795 = (MonoBoolean) iftmp.121;
  return D.28795;
}


ves_icall_type_ispointer (struct MonoReflectionType * type)
{
  MonoBoolean D.28809;
  struct MonoType * D.28810;
  unsigned char D.28811;
  _Bool D.28812;

  D.28810 = type->type;
  D.28811 = D.28810->type;
  D.28812 = D.28811 == 15;
  D.28809 = (MonoBoolean) D.28812;
  return D.28809;
}


ves_icall_type_iscomobject (struct MonoReflectionType * type)
{
  struct MonoType * D.28814;
  MonoBoolean D.28815;
  <unnamed-unsigned:1> D.28816;
  struct MonoClass * klass;

  D.28814 = type->type;
  klass = mono_class_from_mono_type (D.28814);
  mono_class_init_or_throw (klass);
  D.28816 = klass->is_com_object;
  D.28815 = (MonoBoolean) D.28816;
  return D.28815;
}


ves_icall_type_isbyref (struct MonoReflectionType * type)
{
  MonoBoolean D.28818;
  struct MonoType * D.28819;
  <unnamed-unsigned:1> D.28820;

  D.28819 = type->type;
  D.28820 = D.28819->byref;
  D.28818 = (MonoBoolean) D.28820;
  return D.28818;
}


ves_icall_MonoType_GetEvent (struct MonoReflectionType * type, struct MonoString * name, guint32 bflags)
{
  struct MonoType * D.28822;
  long unsigned int D.28823;
  long unsigned int D.28824;
  struct MonoReflectionEvent * D.28827;
  struct MonoVTable * D.28828;
  int (*<T3b2a>) (const char *, const char *) iftmp.122;
  unsigned int D.28830;
  unsigned char D.28834;
  struct MonoException * D.28837;
  const char * D.28838;
  int D.28839;
  short unsigned int D.28848;
  int D.28849;
  int D.28850;
  unsigned int D.28853;
  unsigned int D.28857;
  int D.28864;
  unsigned int D.28867;
  unsigned int D.28870;
  unsigned int D.28876;
  unsigned int D.28882;
  struct MonoDomain * domain;
  struct MonoClass * klass;
  struct MonoClass * startklass;
  void * iter;
  struct MonoEvent * event;
  struct MonoMethod * method;
  gchar * event_name;
  int (*<T3b2a>) (const char *, const char *) compare_func;
  void handle_parent = <<< error >>>;

  try
    {
      event_name = mono_string_to_utf8 (name);
      D.28822 = type->type;
      D.28823 = BIT_FIELD_REF <*D.28822, 64, 64>;
      D.28824 = D.28823 & 8589934592;
      if (D.28824 != 0) goto <D.28825>; else goto <D.28826>;
      <D.28825>:
      D.28827 = 0B;
      return D.28827;
      <D.28826>:
      D.28822 = type->type;
      startklass = mono_class_from_mono_type (D.28822);
      klass = startklass;
      D.28828 = MEM[(struct MonoObject *)type].vtable;
      domain = D.28828->domain;
      mono_class_init_or_throw (klass);
      D.28830 = bflags & 1;
      if (D.28830 != 0) goto <D.28831>; else goto <D.28832>;
      <D.28831>:
      iftmp.122 = monoeg_ascii_strcasecmp;
      goto <D.28833>;
      <D.28832>:
      iftmp.122 = strcmp;
      <D.28833>:
      compare_func = iftmp.122;
      handle_parent:
      D.28834 = klass->exception_type;
      if (D.28834 != 0) goto <D.28835>; else goto <D.28836>;
      <D.28835>:
      D.28837 = mono_class_get_exception_for_failure (klass);
      mono_raise_exception (D.28837);
      <D.28836>:
      iter = 0B;
      goto <D.22351>;
      <D.22352>:
      D.28838 = event->name;
      D.28839 = compare_func (D.28838, event_name);
      if (D.28839 != 0) goto <D.28840>; else goto <D.28841>;
      <D.28840>:
      // predicted unlikely by continue predictor.
      goto <D.22351>;
      <D.28841>:
      method = event->add;
      if (method == 0B) goto <D.28842>; else goto <D.28843>;
      <D.28842>:
      method = event->remove;
      <D.28843>:
      if (method == 0B) goto <D.28844>; else goto <D.28845>;
      <D.28844>:
      method = event->raise;
      <D.28845>:
      if (method != 0B) goto <D.28846>; else goto <D.28847>;
      <D.28846>:
      D.28848 = method->flags;
      D.28849 = (int) D.28848;
      D.28850 = D.28849 & 7;
      if (D.28850 == 6) goto <D.28851>; else goto <D.28852>;
      <D.28851>:
      D.28853 = bflags & 16;
      if (D.28853 == 0) goto <D.28854>; else goto <D.28855>;
      <D.28854>:
      // predicted unlikely by continue predictor.
      goto <D.22351>;
      <D.28855>:
      goto <D.28856>;
      <D.28852>:
      D.28857 = bflags & 32;
      if (D.28857 == 0) goto <D.28858>; else goto <D.28859>;
      <D.28858>:
      // predicted unlikely by continue predictor.
      goto <D.22351>;
      <D.28859>:
      if (klass != startklass) goto <D.28860>; else goto <D.28861>;
      <D.28860>:
      D.28848 = method->flags;
      D.28849 = (int) D.28848;
      D.28850 = D.28849 & 7;
      if (D.28850 == 1) goto <D.28862>; else goto <D.28863>;
      <D.28862>:
      // predicted unlikely by continue predictor.
      goto <D.22351>;
      <D.28863>:
      <D.28861>:
      <D.28856>:
      D.28848 = method->flags;
      D.28849 = (int) D.28848;
      D.28864 = D.28849 & 16;
      if (D.28864 != 0) goto <D.28865>; else goto <D.28866>;
      <D.28865>:
      D.28867 = bflags & 8;
      if (D.28867 == 0) goto <D.28868>; else goto <D.28869>;
      <D.28868>:
      // predicted unlikely by continue predictor.
      goto <D.22351>;
      <D.28869>:
      D.28870 = bflags & 64;
      if (D.28870 == 0) goto <D.28871>; else goto <D.28872>;
      <D.28871>:
      if (klass != startklass) goto <D.28873>; else goto <D.28874>;
      <D.28873>:
      // predicted unlikely by continue predictor.
      goto <D.22351>;
      <D.28874>:
      <D.28872>:
      goto <D.28875>;
      <D.28866>:
      D.28876 = bflags & 4;
      if (D.28876 == 0) goto <D.28877>; else goto <D.28878>;
      <D.28877>:
      // predicted unlikely by continue predictor.
      goto <D.22351>;
      <D.28878>:
      <D.28875>:
      goto <D.28879>;
      <D.28847>:
      D.28857 = bflags & 32;
      if (D.28857 == 0) goto <D.28880>; else goto <D.28881>;
      <D.28880>:
      // predicted unlikely by continue predictor.
      goto <D.22351>;
      <D.28881>:
      <D.28879>:
      monoeg_g_free (event_name);
      D.28827 = mono_event_get_object (domain, startklass, event);
      return D.28827;
      <D.22351>:
      event = mono_class_get_events (klass, &iter);
      if (event != 0B) goto <D.22352>; else goto <D.22353>;
      <D.22353>:
      D.28882 = bflags & 2;
      if (D.28882 == 0) goto <D.28883>; else goto <D.28884>;
      <D.28883>:
      klass = klass->parent;
      if (klass != 0B) goto handle_parent; else goto <D.28885>;
      <D.28885>:
      <D.28884>:
      monoeg_g_free (event_name);
      D.28827 = 0B;
      return D.28827;
    }
  finally
    {
      iter = {CLOBBER};
    }
}


ves_icall_Type_GetPropertiesByName (struct MonoReflectionType * type, struct MonoString * name, guint32 bflags, MonoBoolean ignore_case, struct MonoReflectionType * reftype)
{
  void * D.28888;
  struct MonoClass * System_Reflection_PropertyInfo.123;
  struct MonoImage * D.28892;
  struct MonoClass * System_Reflection_PropertyInfo.124;
  struct MonoVTable * D.28894;
  struct MonoType * D.28895;
  long unsigned int D.28896;
  long unsigned int D.28897;
  struct MonoArray * D.28900;
  struct MonoClass * D.22322;
  struct MonoClass * tmp_klass.125;
  struct MonoClass * tmp_klass.126;
  _Bool D.28905;
  long int D.28906;
  long int D.28907;
  struct MonoVTable * D.28910;
  int (*<T3b2a>) (const char *, const char *) iftmp.127;
  unsigned char D.28917;
  struct MonoLoaderError * D.28919;
  short unsigned int D.28925;
  struct MonoMethod * D.28931;
  short unsigned int D.28933;
  int D.28934;
  int D.28935;
  struct MonoMethod * D.28936;
  short unsigned int D.28938;
  int D.28939;
  int D.28940;
  unsigned int D.28941;
  unsigned int D.28944;
  _Bool D.28949;
  int D.28950;
  int D.28951;
  int D.28953;
  unsigned int D.28956;
  unsigned int D.28959;
  unsigned int D.28964;
  unsigned int D.28967;
  const char * D.28974;
  int D.28975;
  void * D.28978;
  int D.28981;
  int D.28982;
  long unsigned int D.28985;
  long unsigned int D.28986;
  int D.28987;
  void * D.28988;
  void * * D.28989;
  long unsigned int D.28990;
  int D.28993;
  int D.28994;
  long unsigned int D.28995;
  long unsigned int D.28996;
  void * * D.28997;
  struct MonoReflectionProperty * D.28998;
  unsigned int D.28999;
  struct MonoClass * D.22330;
  struct MonoClass * tmp_klass.128;
  struct MonoClass * tmp_klass.129;
  _Bool D.29007;
  long int D.29008;
  long int D.29009;
  struct MonoVTable * D.29012;
  long unsigned int D.29013;
  long unsigned int D.29014;
  long unsigned int D.29015;
  long unsigned int D.29016;
  void * * D.29017;
  void * D.29018;
  struct MonoLoaderError * D.29030;
  struct MonoException * ex;
  struct MonoDomain * domain;
  static struct MonoClass * System_Reflection_PropertyInfo;
  struct MonoClass * startklass;
  struct MonoClass * klass;
  struct MonoArray * res;
  struct MonoMethod * method;
  struct MonoProperty * prop;
  int i;
  int match;
  guint32 flags;
  gchar * propname;
  int (*<T3b2a>) (const char *, const char *) compare_func;
  void * iter;
  struct GHashTable * properties;
  struct MonoPtrArray tmp_array;
  void handle_parent = <<< error >>>;
  void loader_error = <<< error >>>;

  try
    {
      propname = 0B;
      compare_func = 0B;
      properties = 0B;
      tmp_array.size = 0;
      tmp_array.capacity = 16;
      D.28888 = __builtin_alloca (128);
      tmp_array.data = D.28888;
      System_Reflection_PropertyInfo.123 = System_Reflection_PropertyInfo;
      if (System_Reflection_PropertyInfo.123 == 0B) goto <D.28890>; else goto <D.28891>;
      <D.28890>:
      D.28892 = mono_defaults.corlib;
      System_Reflection_PropertyInfo.124 = mono_class_from_name (D.28892, "System.Reflection", "PropertyInfo");
      System_Reflection_PropertyInfo = System_Reflection_PropertyInfo.124;
      <D.28891>:
      D.28894 = MEM[(struct MonoObject *)type].vtable;
      domain = D.28894->domain;
      D.28895 = type->type;
      D.28896 = BIT_FIELD_REF <*D.28895, 64, 64>;
      D.28897 = D.28896 & 8589934592;
      if (D.28897 != 0) goto <D.28898>; else goto <D.28899>;
      <D.28898>:
      {
        static struct MonoClass * tmp_klass;

        {
          tmp_klass.125 = tmp_klass;
          if (tmp_klass.125 == 0B) goto <D.28902>; else goto <D.28903>;
          <D.28902>:
          System_Reflection_PropertyInfo.123 = System_Reflection_PropertyInfo;
          tmp_klass.126 = mono_array_class_get (System_Reflection_PropertyInfo.123, 1);
          tmp_klass = tmp_klass.126;
          tmp_klass.125 = tmp_klass;
          D.28905 = tmp_klass.125 == 0B;
          D.28906 = (long int) D.28905;
          D.28907 = __builtin_expect (D.28906, 0);
          if (D.28907 != 0) goto <D.28908>; else goto <D.28909>;
          <D.28908>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 3725, "tmp_klass");
          <D.28909>:
          <D.28903>:
        }
        D.22322 = tmp_klass;
      }
      D.28910 = mono_class_vtable (domain, D.22322);
      D.28900 = mono_array_new_specific (D.28910, 0);
      return D.28900;
      <D.28899>:
      D.28895 = type->type;
      startklass = mono_class_from_mono_type (D.28895);
      klass = startklass;
      if (name != 0B) goto <D.28911>; else goto <D.28912>;
      <D.28911>:
      propname = mono_string_to_utf8 (name);
      if (ignore_case != 0) goto <D.28914>; else goto <D.28915>;
      <D.28914>:
      iftmp.127 = monoeg_ascii_strcasecmp;
      goto <D.28916>;
      <D.28915>:
      iftmp.127 = strcmp;
      <D.28916>:
      compare_func = iftmp.127;
      <D.28912>:
      properties = monoeg_g_hash_table_new (property_hash, property_equal);
      handle_parent:
      mono_class_setup_vtable (klass);
      D.28917 = klass->exception_type;
      if (D.28917 != 0) goto loader_error; else goto <D.28918>;
      <D.28918>:
      D.28919 = mono_loader_get_last_error ();
      if (D.28919 != 0B) goto loader_error; else goto <D.28920>;
      <D.28920>:
      iter = 0B;
      goto <D.22325>;
      <D.22327>:
      match = 0;
      method = prop->get;
      if (method == 0B) goto <D.28921>; else goto <D.28922>;
      <D.28921>:
      method = prop->set;
      <D.28922>:
      if (method != 0B) goto <D.28923>; else goto <D.28924>;
      <D.28923>:
      D.28925 = method->flags;
      flags = (guint32) D.28925;
      goto <D.28926>;
      <D.28924>:
      flags = 0;
      <D.28926>:
      D.28931 = prop->get;
      if (D.28931 != 0B) goto <D.28932>; else goto <D.28927>;
      <D.28932>:
      D.28931 = prop->get;
      D.28933 = D.28931->flags;
      D.28934 = (int) D.28933;
      D.28935 = D.28934 & 7;
      if (D.28935 == 6) goto <D.28928>; else goto <D.28927>;
      <D.28927>:
      D.28936 = prop->set;
      if (D.28936 != 0B) goto <D.28937>; else goto <D.28929>;
      <D.28937>:
      D.28936 = prop->set;
      D.28938 = D.28936->flags;
      D.28939 = (int) D.28938;
      D.28940 = D.28939 & 7;
      if (D.28940 == 6) goto <D.28928>; else goto <D.28929>;
      <D.28928>:
      D.28941 = bflags & 16;
      if (D.28941 != 0) goto <D.28942>; else goto <D.28943>;
      <D.28942>:
      match = match + 1;
      <D.28943>:
      goto <D.28930>;
      <D.28929>:
      D.28944 = bflags & 32;
      if (D.28944 != 0) goto <D.28945>; else goto <D.28946>;
      <D.28945>:
      D.28931 = prop->get;
      D.28949 = startklass == klass;
      D.28950 = (int) D.28949;
      D.28951 = property_accessor_nonpublic (D.28931, D.28950);
      if (D.28951 != 0) goto <D.28947>; else goto <D.28952>;
      <D.28952>:
      D.28936 = prop->set;
      D.28949 = startklass == klass;
      D.28950 = (int) D.28949;
      D.28953 = property_accessor_nonpublic (D.28936, D.28950);
      if (D.28953 != 0) goto <D.28947>; else goto <D.28948>;
      <D.28947>:
      match = match + 1;
      <D.28948>:
      <D.28946>:
      <D.28930>:
      if (match == 0) goto <D.28954>; else goto <D.28955>;
      <D.28954>:
      // predicted unlikely by continue predictor.
      goto <D.22325>;
      <D.28955>:
      match = 0;
      D.28956 = flags & 16;
      if (D.28956 != 0) goto <D.28957>; else goto <D.28958>;
      <D.28957>:
      D.28959 = bflags & 8;
      if (D.28959 != 0) goto <D.28960>; else goto <D.28961>;
      <D.28960>:
      D.28964 = bflags & 64;
      if (D.28964 != 0) goto <D.28962>; else goto <D.28965>;
      <D.28965>:
      if (klass == startklass) goto <D.28962>; else goto <D.28963>;
      <D.28962>:
      match = match + 1;
      <D.28963>:
      <D.28961>:
      goto <D.28966>;
      <D.28958>:
      D.28967 = bflags & 4;
      if (D.28967 != 0) goto <D.28968>; else goto <D.28969>;
      <D.28968>:
      match = match + 1;
      <D.28969>:
      <D.28966>:
      if (match == 0) goto <D.28970>; else goto <D.28971>;
      <D.28970>:
      // predicted unlikely by continue predictor.
      goto <D.22325>;
      <D.28971>:
      match = 0;
      if (name != 0B) goto <D.28972>; else goto <D.28973>;
      <D.28972>:
      D.28974 = prop->name;
      D.28975 = compare_func (propname, D.28974);
      if (D.28975 != 0) goto <D.28976>; else goto <D.28977>;
      <D.28976>:
      // predicted unlikely by continue predictor.
      goto <D.22325>;
      <D.28977>:
      <D.28973>:
      D.28978 = monoeg_g_hash_table_lookup (properties, prop);
      if (D.28978 != 0B) goto <D.28979>; else goto <D.28980>;
      <D.28979>:
      // predicted unlikely by continue predictor.
      goto <D.22325>;
      <D.28980>:
      D.28981 = tmp_array.size;
      D.28982 = tmp_array.capacity;
      if (D.28981 >= D.28982) goto <D.28983>; else goto <D.28984>;
      <D.28983>:
      {
        void * __tmp;

        D.28982 = tmp_array.capacity;
        D.28985 = (long unsigned int) D.28982;
        D.28986 = D.28985 * 16;
        D.28982 = tmp_array.capacity;
        D.28987 = D.28982 * 2;
        D.28988 = mono_gc_make_root_descr_all_refs (D.28987);
        __tmp = mono_gc_alloc_fixed (D.28986, D.28988);
        D.28989 = tmp_array.data;
        D.28982 = tmp_array.capacity;
        D.28985 = (long unsigned int) D.28982;
        D.28990 = D.28985 * 8;
        mono_gc_memmove_aligned (__tmp, D.28989, D.28990);
        D.28982 = tmp_array.capacity;
        if (D.28982 > 16) goto <D.28991>; else goto <D.28992>;
        <D.28991>:
        D.28989 = tmp_array.data;
        mono_gc_free_fixed (D.28989);
        <D.28992>:
        tmp_array.data = __tmp;
        D.28982 = tmp_array.capacity;
        D.28987 = D.28982 * 2;
        tmp_array.capacity = D.28987;
      }
      <D.28984>:
      D.28989 = tmp_array.data;
      D.28981 = tmp_array.size;
      D.28993 = D.28981;
      D.28994 = D.28993 + 1;
      tmp_array.size = D.28994;
      D.28995 = (long unsigned int) D.28993;
      D.28996 = D.28995 * 8;
      D.28997 = D.28989 + D.28996;
      D.28998 = mono_property_get_object (domain, startklass, prop);
      *D.28997 = D.28998;
      monoeg_g_hash_table_insert_replace (properties, prop, prop, 0);
      <D.22325>:
      prop = mono_class_get_properties (klass, &iter);
      if (prop != 0B) goto <D.22327>; else goto <D.22328>;
      <D.22328>:
      D.28999 = bflags & 2;
      if (D.28999 == 0) goto <D.29000>; else goto <D.29001>;
      <D.29000>:
      klass = klass->parent;
      if (klass != 0B) goto handle_parent; else goto <D.29002>;
      <D.29002>:
      <D.29001>:
      monoeg_g_hash_table_destroy (properties);
      monoeg_g_free (propname);
      {
        static struct MonoClass * tmp_klass;

        {
          tmp_klass.128 = tmp_klass;
          if (tmp_klass.128 == 0B) goto <D.29004>; else goto <D.29005>;
          <D.29004>:
          System_Reflection_PropertyInfo.123 = System_Reflection_PropertyInfo;
          tmp_klass.129 = mono_array_class_get (System_Reflection_PropertyInfo.123, 1);
          tmp_klass = tmp_klass.129;
          tmp_klass.128 = tmp_klass;
          D.29007 = tmp_klass.128 == 0B;
          D.29008 = (long int) D.29007;
          D.29009 = __builtin_expect (D.29008, 0);
          if (D.29009 != 0) goto <D.29010>; else goto <D.29011>;
          <D.29010>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 3793, "tmp_klass");
          <D.29011>:
          <D.29005>:
        }
        D.22330 = tmp_klass;
      }
      D.29012 = mono_class_vtable (domain, D.22330);
      D.28981 = tmp_array.size;
      D.29013 = (long unsigned int) D.28981;
      res = mono_array_new_specific (D.29012, D.29013);
      i = 0;
      goto <D.22333>;
      <D.22332>:
      {
        void * * __p;

        D.29014 = (long unsigned int) i;
        __p = mono_array_addr_with_size (res, 8, D.29014);
        D.28989 = tmp_array.data;
        D.29015 = (long unsigned int) i;
        D.29016 = D.29015 * 8;
        D.29017 = D.28989 + D.29016;
        D.29018 = *D.29017;
        mono_gc_wbarrier_set_arrayref (res, __p, D.29018);
      }
      i = i + 1;
      <D.22333>:
      D.28981 = tmp_array.size;
      if (D.28981 > i) goto <D.22332>; else goto <D.22334>;
      <D.22334>:
      D.28982 = tmp_array.capacity;
      if (D.28982 > 16) goto <D.29019>; else goto <D.29020>;
      <D.29019>:
      D.28989 = tmp_array.data;
      mono_gc_free_fixed (D.28989);
      <D.29020>:
      D.28900 = res;
      return D.28900;
      loader_error:
      if (properties != 0B) goto <D.29021>; else goto <D.29022>;
      <D.29021>:
      monoeg_g_hash_table_destroy (properties);
      <D.29022>:
      if (name != 0B) goto <D.29023>; else goto <D.29024>;
      <D.29023>:
      monoeg_g_free (propname);
      <D.29024>:
      D.28982 = tmp_array.capacity;
      if (D.28982 > 16) goto <D.29025>; else goto <D.29026>;
      <D.29025>:
      D.28989 = tmp_array.data;
      mono_gc_free_fixed (D.28989);
      <D.29026>:
      D.28917 = klass->exception_type;
      if (D.28917 != 0) goto <D.29027>; else goto <D.29028>;
      <D.29027>:
      ex = mono_class_get_exception_for_failure (klass);
      goto <D.29029>;
      <D.29028>:
      D.29030 = mono_loader_get_last_error ();
      ex = mono_loader_error_prepare_exception (D.29030);
      mono_loader_clear_error ();
      <D.29029>:
      mono_raise_exception (ex);
      D.28900 = 0B;
      return D.28900;
    }
  finally
    {
      iter = {CLOBBER};
      tmp_array = {CLOBBER};
    }
}


property_equal (struct MonoProperty * prop1, struct MonoProperty * prop2)
{
  const char * D.29033;
  const char * D.29034;
  int D.29035;
  gboolean D.29038;
  struct MonoMethod * D.29039;
  struct MonoMethod * D.29042;
  struct MonoMethodSignature * D.29045;
  struct MonoMethodSignature * D.29046;
  int D.29047;
  struct MonoMethod * D.29050;
  struct MonoMethod * D.29053;
  struct MonoMethodSignature * D.29056;
  struct MonoMethodSignature * D.29057;
  int D.29058;

  D.29033 = prop1->name;
  D.29034 = prop2->name;
  D.29035 = monoeg_g_str_equal (D.29033, D.29034);
  if (D.29035 == 0) goto <D.29036>; else goto <D.29037>;
  <D.29036>:
  D.29038 = 0;
  return D.29038;
  <D.29037>:
  D.29039 = prop1->get;
  if (D.29039 != 0B) goto <D.29040>; else goto <D.29041>;
  <D.29040>:
  D.29042 = prop2->get;
  if (D.29042 != 0B) goto <D.29043>; else goto <D.29044>;
  <D.29043>:
  D.29039 = prop1->get;
  D.29045 = mono_method_signature (D.29039);
  D.29042 = prop2->get;
  D.29046 = mono_method_signature (D.29042);
  D.29047 = mono_metadata_signature_equal (D.29045, D.29046);
  if (D.29047 == 0) goto <D.29048>; else goto <D.29049>;
  <D.29048>:
  D.29038 = 0;
  return D.29038;
  <D.29049>:
  <D.29044>:
  <D.29041>:
  D.29050 = prop1->set;
  if (D.29050 != 0B) goto <D.29051>; else goto <D.29052>;
  <D.29051>:
  D.29053 = prop2->set;
  if (D.29053 != 0B) goto <D.29054>; else goto <D.29055>;
  <D.29054>:
  D.29050 = prop1->set;
  D.29056 = mono_method_signature (D.29050);
  D.29053 = prop2->set;
  D.29057 = mono_method_signature (D.29053);
  D.29058 = mono_metadata_signature_equal (D.29056, D.29057);
  if (D.29058 == 0) goto <D.29059>; else goto <D.29060>;
  <D.29059>:
  D.29038 = 0;
  return D.29038;
  <D.29060>:
  <D.29055>:
  <D.29052>:
  D.29038 = 1;
  return D.29038;
}


property_hash (const void * data)
{
  guint D.29062;
  const char * D.29063;
  struct MonoProperty * prop;

  prop = data;
  D.29063 = prop->name;
  D.29062 = monoeg_g_str_hash (D.29063);
  return D.29062;
}


property_accessor_nonpublic (struct MonoMethod * accessor, gboolean start_klass)
{
  gboolean D.29067;

  if (accessor == 0B) goto <D.29065>; else goto <D.29066>;
  <D.29065>:
  D.29067 = 0;
  return D.29067;
  <D.29066>:
  D.29067 = method_nonpublic (accessor, start_klass);
  return D.29067;
}


ves_icall_Type_GetNestedTypes (struct MonoReflectionType * type, guint32 bflags)
{
  struct MonoVTable * D.29069;
  struct MonoType * D.29070;
  long unsigned int D.29071;
  long unsigned int D.29072;
  struct MonoArray * D.29075;
  struct MonoClass * D.29076;
  struct MonoGenericClass * D.29077;
  void * D.29080;
  unsigned int D.29081;
  unsigned int D.29082;
  unsigned int D.29085;
  unsigned int D.29089;
  struct MonoType * D.29094;
  int D.29095;
  int D.29096;
  long unsigned int D.29099;
  long unsigned int D.29100;
  int D.29101;
  void * D.29102;
  void * * D.29103;
  long unsigned int D.29104;
  int D.29107;
  int D.29108;
  long unsigned int D.29109;
  long unsigned int D.29110;
  void * * D.29111;
  struct MonoClass * D.22418;
  struct MonoClass * tmp_klass.130;
  struct MonoClass * tmp_klass.131;
  _Bool D.29116;
  long int D.29117;
  long int D.29118;
  struct MonoVTable * D.29121;
  long unsigned int D.29122;
  long unsigned int D.29123;
  long unsigned int D.29124;
  long unsigned int D.29125;
  void * * D.29126;
  void * D.29127;
  struct MonoDomain * domain;
  struct MonoClass * klass;
  struct MonoArray * res;
  struct MonoObject * member;
  int i;
  int match;
  struct MonoClass * nested;
  void * iter;
  struct MonoPtrArray tmp_array;

  try
    {
      D.29069 = MEM[(struct MonoObject *)type].vtable;
      domain = D.29069->domain;
      D.29070 = type->type;
      D.29071 = BIT_FIELD_REF <*D.29070, 64, 64>;
      D.29072 = D.29071 & 8589934592;
      if (D.29072 != 0) goto <D.29073>; else goto <D.29074>;
      <D.29073>:
      D.29076 = mono_defaults.monotype_class;
      D.29075 = mono_array_new (domain, D.29076, 0);
      return D.29075;
      <D.29074>:
      D.29070 = type->type;
      klass = mono_class_from_mono_type (D.29070);
      D.29077 = klass->generic_class;
      if (D.29077 != 0B) goto <D.29078>; else goto <D.29079>;
      <D.29078>:
      D.29077 = klass->generic_class;
      klass = D.29077->container_class;
      <D.29079>:
      tmp_array.size = 0;
      tmp_array.capacity = 16;
      D.29080 = __builtin_alloca (128);
      tmp_array.data = D.29080;
      iter = 0B;
      goto <D.22413>;
      <D.22415>:
      match = 0;
      D.29081 = nested->flags;
      D.29082 = D.29081 & 7;
      if (D.29082 == 2) goto <D.29083>; else goto <D.29084>;
      <D.29083>:
      D.29085 = bflags & 16;
      if (D.29085 != 0) goto <D.29086>; else goto <D.29087>;
      <D.29086>:
      match = match + 1;
      <D.29087>:
      goto <D.29088>;
      <D.29084>:
      D.29089 = bflags & 32;
      if (D.29089 != 0) goto <D.29090>; else goto <D.29091>;
      <D.29090>:
      match = match + 1;
      <D.29091>:
      <D.29088>:
      if (match == 0) goto <D.29092>; else goto <D.29093>;
      <D.29092>:
      // predicted unlikely by continue predictor.
      goto <D.22413>;
      <D.29093>:
      D.29094 = &nested->byval_arg;
      member = mono_type_get_object (domain, D.29094);
      D.29095 = tmp_array.size;
      D.29096 = tmp_array.capacity;
      if (D.29095 >= D.29096) goto <D.29097>; else goto <D.29098>;
      <D.29097>:
      {
        void * __tmp;

        D.29096 = tmp_array.capacity;
        D.29099 = (long unsigned int) D.29096;
        D.29100 = D.29099 * 16;
        D.29096 = tmp_array.capacity;
        D.29101 = D.29096 * 2;
        D.29102 = mono_gc_make_root_descr_all_refs (D.29101);
        __tmp = mono_gc_alloc_fixed (D.29100, D.29102);
        D.29103 = tmp_array.data;
        D.29096 = tmp_array.capacity;
        D.29099 = (long unsigned int) D.29096;
        D.29104 = D.29099 * 8;
        mono_gc_memmove_aligned (__tmp, D.29103, D.29104);
        D.29096 = tmp_array.capacity;
        if (D.29096 > 16) goto <D.29105>; else goto <D.29106>;
        <D.29105>:
        D.29103 = tmp_array.data;
        mono_gc_free_fixed (D.29103);
        <D.29106>:
        tmp_array.data = __tmp;
        D.29096 = tmp_array.capacity;
        D.29101 = D.29096 * 2;
        tmp_array.capacity = D.29101;
      }
      <D.29098>:
      D.29103 = tmp_array.data;
      D.29095 = tmp_array.size;
      D.29107 = D.29095;
      D.29108 = D.29107 + 1;
      tmp_array.size = D.29108;
      D.29109 = (long unsigned int) D.29107;
      D.29110 = D.29109 * 8;
      D.29111 = D.29103 + D.29110;
      *D.29111 = member;
      <D.22413>:
      nested = mono_class_get_nested_types (klass, &iter);
      if (nested != 0B) goto <D.22415>; else goto <D.22416>;
      <D.22416>:
      {
        static struct MonoClass * tmp_klass;

        {
          tmp_klass.130 = tmp_klass;
          if (tmp_klass.130 == 0B) goto <D.29113>; else goto <D.29114>;
          <D.29113>:
          D.29076 = mono_defaults.monotype_class;
          tmp_klass.131 = mono_array_class_get (D.29076, 1);
          tmp_klass = tmp_klass.131;
          tmp_klass.130 = tmp_klass;
          D.29116 = tmp_klass.130 == 0B;
          D.29117 = (long int) D.29116;
          D.29118 = __builtin_expect (D.29117, 0);
          if (D.29118 != 0) goto <D.29119>; else goto <D.29120>;
          <D.29119>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 4094, "tmp_klass");
          <D.29120>:
          <D.29114>:
        }
        D.22418 = tmp_klass;
      }
      D.29121 = mono_class_vtable (domain, D.22418);
      D.29095 = tmp_array.size;
      D.29122 = (long unsigned int) D.29095;
      res = mono_array_new_specific (D.29121, D.29122);
      i = 0;
      goto <D.22421>;
      <D.22420>:
      {
        void * * __p;

        D.29123 = (long unsigned int) i;
        __p = mono_array_addr_with_size (res, 8, D.29123);
        D.29103 = tmp_array.data;
        D.29124 = (long unsigned int) i;
        D.29125 = D.29124 * 8;
        D.29126 = D.29103 + D.29125;
        D.29127 = *D.29126;
        mono_gc_wbarrier_set_arrayref (res, __p, D.29127);
      }
      i = i + 1;
      <D.22421>:
      D.29095 = tmp_array.size;
      if (D.29095 > i) goto <D.22420>; else goto <D.22422>;
      <D.22422>:
      D.29096 = tmp_array.capacity;
      if (D.29096 > 16) goto <D.29128>; else goto <D.29129>;
      <D.29128>:
      D.29103 = tmp_array.data;
      mono_gc_free_fixed (D.29103);
      <D.29129>:
      D.29075 = res;
      return D.29075;
    }
  finally
    {
      iter = {CLOBBER};
      tmp_array = {CLOBBER};
    }
}


ves_icall_Type_GetNestedType (struct MonoReflectionType * type, struct MonoString * name, guint32 bflags)
{
  struct MonoException * D.29134;
  struct MonoVTable * D.29135;
  struct MonoType * D.29136;
  long unsigned int D.29137;
  long unsigned int D.29138;
  struct MonoReflectionType * D.29141;
  unsigned char D.29142;
  struct MonoException * D.29145;
  struct MonoGenericClass * D.29146;
  unsigned int D.29149;
  unsigned int D.29150;
  unsigned int D.29153;
  unsigned int D.29157;
  const char * D.29162;
  int D.29163;
  struct MonoType * D.29166;
  unsigned int D.29167;
  struct MonoDomain * domain;
  struct MonoClass * klass;
  struct MonoClass * nested;
  char * str;
  void * iter;
  void handle_parent = <<< error >>>;

  try
    {
      if (name == 0B) goto <D.29132>; else goto <D.29133>;
      <D.29132>:
      D.29134 = mono_get_exception_argument_null ("name");
      mono_raise_exception (D.29134);
      <D.29133>:
      D.29135 = MEM[(struct MonoObject *)type].vtable;
      domain = D.29135->domain;
      D.29136 = type->type;
      D.29137 = BIT_FIELD_REF <*D.29136, 64, 64>;
      D.29138 = D.29137 & 8589934592;
      if (D.29138 != 0) goto <D.29139>; else goto <D.29140>;
      <D.29139>:
      D.29141 = 0B;
      return D.29141;
      <D.29140>:
      D.29136 = type->type;
      klass = mono_class_from_mono_type (D.29136);
      str = mono_string_to_utf8 (name);
      handle_parent:
      D.29142 = klass->exception_type;
      if (D.29142 != 0) goto <D.29143>; else goto <D.29144>;
      <D.29143>:
      D.29145 = mono_class_get_exception_for_failure (klass);
      mono_raise_exception (D.29145);
      <D.29144>:
      D.29146 = klass->generic_class;
      if (D.29146 != 0B) goto <D.29147>; else goto <D.29148>;
      <D.29147>:
      D.29146 = klass->generic_class;
      klass = D.29146->container_class;
      <D.29148>:
      iter = 0B;
      goto <D.22397>;
      <D.22398>:
      {
        int match;

        match = 0;
        D.29149 = nested->flags;
        D.29150 = D.29149 & 7;
        if (D.29150 == 2) goto <D.29151>; else goto <D.29152>;
        <D.29151>:
        D.29153 = bflags & 16;
        if (D.29153 != 0) goto <D.29154>; else goto <D.29155>;
        <D.29154>:
        match = match + 1;
        <D.29155>:
        goto <D.29156>;
        <D.29152>:
        D.29157 = bflags & 32;
        if (D.29157 != 0) goto <D.29158>; else goto <D.29159>;
        <D.29158>:
        match = match + 1;
        <D.29159>:
        <D.29156>:
        if (match == 0) goto <D.29160>; else goto <D.29161>;
        <D.29160>:
        // predicted unlikely by continue predictor.
        goto <D.22397>;
        <D.29161>:
        D.29162 = nested->name;
        D.29163 = strcmp (D.29162, str);
        if (D.29163 == 0) goto <D.29164>; else goto <D.29165>;
        <D.29164>:
        monoeg_g_free (str);
        D.29166 = &nested->byval_arg;
        D.29141 = mono_type_get_object (domain, D.29166);
        return D.29141;
        <D.29165>:
      }
      <D.22397>:
      nested = mono_class_get_nested_types (klass, &iter);
      if (nested != 0B) goto <D.22398>; else goto <D.22399>;
      <D.22399>:
      D.29167 = bflags & 2;
      if (D.29167 == 0) goto <D.29168>; else goto <D.29169>;
      <D.29168>:
      klass = klass->parent;
      if (klass != 0B) goto handle_parent; else goto <D.29170>;
      <D.29170>:
      <D.29169>:
      monoeg_g_free (str);
      D.29141 = 0B;
      return D.29141;
    }
  finally
    {
      iter = {CLOBBER};
    }
}


ves_icall_Type_GetMethodsByName (struct MonoReflectionType * type, struct MonoString * name, guint32 bflags, MonoBoolean ignore_case, struct MonoReflectionType * reftype)
{
  struct MonoClass * MethodInfo_array.132;
  struct MonoClass * D.29176;
  struct MonoType * D.29177;
  struct MonoType * D.29178;
  struct MonoVTable * D.29179;
  long unsigned int D.29180;
  long unsigned int D.29181;
  struct MonoArray * D.29184;
  int D.29187;
  struct MonoException * ex.133;
  unsigned int D.29191;
  long unsigned int D.29192;
  void * * D.29193;
  long unsigned int D.29194;
  long unsigned int D.29195;
  void * * D.29196;
  long unsigned int D.29197;
  struct MonoReflectionMethod * D.29198;
  unsigned int i.134;
  static struct MonoClass * MethodInfo_array;
  struct MonoDomain * domain;
  struct MonoArray * res;
  struct MonoVTable * array_vtable;
  struct MonoException * ex;
  const char * mname;
  struct GPtrArray * method_array;
  struct MonoClass * klass;
  struct MonoClass * refklass;
  int i;

  try
    {
      ex = 0B;
      mname = 0B;
      MethodInfo_array.132 = MethodInfo_array;
      if (MethodInfo_array.132 == 0B) goto <D.29174>; else goto <D.29175>;
      <D.29174>:
      {
        struct MonoClass * klass;

        D.29176 = mono_defaults.method_info_class;
        klass = mono_array_class_get (D.29176, 1);
        mono_memory_barrier ();
        MethodInfo_array = klass;
      }
      <D.29175>:
      D.29177 = type->type;
      klass = mono_class_from_mono_type (D.29177);
      D.29178 = reftype->type;
      refklass = mono_class_from_mono_type (D.29178);
      D.29179 = MEM[(struct MonoObject *)type].vtable;
      domain = D.29179->domain;
      MethodInfo_array.132 = MethodInfo_array;
      array_vtable = mono_class_vtable_full (domain, MethodInfo_array.132, 1);
      D.29177 = type->type;
      D.29180 = BIT_FIELD_REF <*D.29177, 64, 64>;
      D.29181 = D.29180 & 8589934592;
      if (D.29181 != 0) goto <D.29182>; else goto <D.29183>;
      <D.29182>:
      D.29184 = mono_array_new_specific (array_vtable, 0);
      return D.29184;
      <D.29183>:
      if (name != 0B) goto <D.29185>; else goto <D.29186>;
      <D.29185>:
      mname = mono_string_to_utf8 (name);
      <D.29186>:
      D.29187 = (int) ignore_case;
      method_array = mono_class_get_methods_by_name (klass, mname, bflags, D.29187, 0, &ex);
      monoeg_g_free (mname);
      ex.133 = ex;
      if (ex.133 != 0B) goto <D.29189>; else goto <D.29190>;
      <D.29189>:
      ex.133 = ex;
      mono_raise_exception (ex.133);
      <D.29190>:
      D.29191 = method_array->len;
      D.29192 = (long unsigned int) D.29191;
      res = mono_array_new_specific (array_vtable, D.29192);
      i = 0;
      goto <D.22253>;
      <D.22252>:
      {
        struct MonoMethod * method;

        D.29193 = method_array->pdata;
        D.29194 = (long unsigned int) i;
        D.29195 = D.29194 * 8;
        D.29196 = D.29193 + D.29195;
        method = *D.29196;
        {
          void * * __p;

          D.29197 = (long unsigned int) i;
          __p = mono_array_addr_with_size (res, 8, D.29197);
          D.29198 = mono_method_get_object (domain, method, refklass);
          mono_gc_wbarrier_set_arrayref (res, __p, D.29198);
        }
      }
      i = i + 1;
      <D.22253>:
      D.29191 = method_array->len;
      i.134 = (unsigned int) i;
      if (D.29191 > i.134) goto <D.22252>; else goto <D.22254>;
      <D.22254>:
      monoeg_g_ptr_array_free (method_array, 1);
      D.29184 = res;
      return D.29184;
    }
  finally
    {
      ex = {CLOBBER};
    }
}


mono_memory_barrier ()
{
  __sync_synchronize ();
}


ves_icall_Type_GetInterfaces (struct MonoReflectionType * type)
{
  struct MonoType * D.29202;
  struct MonoGenericClass * D.29203;
  struct MonoGenericInst * D.29206;
  long unsigned int D.29207;
  long unsigned int D.29208;
  struct MonoGenericContext * D.29211;
  int D.29212;
  int D.29214;
  struct MonoVTable * D.29216;
  struct MonoDomain * D.29217;
  unsigned int D.29218;
  struct MonoDomain * D.29221;
  struct MonoArray * D.29222;
  struct MonoClass * D.21695;
  struct MonoClass * tmp_klass.135;
  struct MonoClass * D.29228;
  struct MonoClass * tmp_klass.136;
  _Bool D.29230;
  long int D.29231;
  long int D.29232;
  struct MonoVTable * D.29235;
  struct MonoArray * D.29236;
  struct MonoArray * D.29237;
  struct MonoClass * D.21697;
  struct MonoClass * tmp_klass.137;
  struct MonoClass * tmp_klass.138;
  _Bool D.29242;
  long int D.29243;
  long int D.29244;
  struct MonoVTable * D.29247;
  long unsigned int D.29248;
  struct MonoArray * D.29249;
  int D.29250;
  struct MonoError error;
  struct MonoClass * class;
  struct MonoClass * parent;
  struct FillIfaceArrayData data;
  int len;
  struct GHashTable * iface_hash;
  void fail = <<< error >>>;

  try
    {
      D.29202 = type->type;
      class = mono_class_from_mono_type (D.29202);
      data = {};
      iface_hash = monoeg_g_hash_table_new (0B, 0B);
      D.29203 = class->generic_class;
      if (D.29203 != 0B) goto <D.29204>; else goto <D.29205>;
      <D.29204>:
      D.29203 = class->generic_class;
      D.29206 = D.29203->context.class_inst;
      D.29207 = BIT_FIELD_REF <*D.29206, 64, 0>;
      D.29208 = D.29207 & 512;
      if (D.29208 != 0) goto <D.29209>; else goto <D.29210>;
      <D.29209>:
      D.29211 = mono_class_get_context (class);
      data.context = D.29211;
      D.29203 = class->generic_class;
      class = D.29203->container_class;
      <D.29210>:
      <D.29205>:
      parent = class;
      goto <D.21692>;
      <D.21691>:
      mono_class_setup_interfaces (parent, &error);
      D.29212 = mono_error_ok (&error);
      if (D.29212 == 0) goto fail; else goto <D.29213>;
      <D.29213>:
      collect_interfaces (parent, iface_hash, &error);
      D.29214 = mono_error_ok (&error);
      if (D.29214 == 0) goto fail; else goto <D.29215>;
      <D.29215>:
      parent = parent->parent;
      <D.21692>:
      if (parent != 0B) goto <D.21691>; else goto <D.21693>;
      <D.21693>:
      data.error = &error;
      D.29216 = MEM[(struct MonoObject *)type].vtable;
      D.29217 = D.29216->domain;
      data.domain = D.29217;
      D.29218 = monoeg_g_hash_table_size (iface_hash);
      len = (int) D.29218;
      if (len == 0) goto <D.29219>; else goto <D.29220>;
      <D.29219>:
      monoeg_g_hash_table_destroy (iface_hash);
      D.29221 = data.domain;
      D.29222 = D.29221->empty_types;
      if (D.29222 == 0B) goto <D.29223>; else goto <D.29224>;
      <D.29223>:
      D.29221 = data.domain;
      D.29221 = data.domain;
      {
        static struct MonoClass * tmp_klass;

        {
          tmp_klass.135 = tmp_klass;
          if (tmp_klass.135 == 0B) goto <D.29226>; else goto <D.29227>;
          <D.29226>:
          D.29228 = mono_defaults.monotype_class;
          tmp_klass.136 = mono_array_class_get (D.29228, 1);
          tmp_klass = tmp_klass.136;
          tmp_klass.135 = tmp_klass;
          D.29230 = tmp_klass.135 == 0B;
          D.29231 = (long int) D.29230;
          D.29232 = __builtin_expect (D.29231, 0);
          if (D.29232 != 0) goto <D.29233>; else goto <D.29234>;
          <D.29233>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 2107, "tmp_klass");
          <D.29234>:
          <D.29227>:
        }
        D.21695 = tmp_klass;
      }
      D.29235 = mono_class_vtable (D.29221, D.21695);
      D.29236 = mono_array_new_specific (D.29235, 0);
      D.29221->empty_types = D.29236;
      <D.29224>:
      D.29221 = data.domain;
      D.29237 = D.29221->empty_types;
      return D.29237;
      <D.29220>:
      D.29221 = data.domain;
      {
        static struct MonoClass * tmp_klass;

        {
          tmp_klass.137 = tmp_klass;
          if (tmp_klass.137 == 0B) goto <D.29239>; else goto <D.29240>;
          <D.29239>:
          D.29228 = mono_defaults.monotype_class;
          tmp_klass.138 = mono_array_class_get (D.29228, 1);
          tmp_klass = tmp_klass.138;
          tmp_klass.137 = tmp_klass;
          D.29242 = tmp_klass.137 == 0B;
          D.29243 = (long int) D.29242;
          D.29244 = __builtin_expect (D.29243, 0);
          if (D.29244 != 0) goto <D.29245>; else goto <D.29246>;
          <D.29245>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 2111, "tmp_klass");
          <D.29246>:
          <D.29240>:
        }
        D.21697 = tmp_klass;
      }
      D.29247 = mono_class_vtable (D.29221, D.21697);
      D.29248 = (long unsigned int) len;
      D.29249 = mono_array_new_specific (D.29247, D.29248);
      data.iface_array = D.29249;
      monoeg_g_hash_table_foreach (iface_hash, fill_iface_array, &data);
      D.29250 = mono_error_ok (&error);
      if (D.29250 == 0) goto fail; else goto <D.29251>;
      <D.29251>:
      monoeg_g_hash_table_destroy (iface_hash);
      D.29237 = data.iface_array;
      return D.29237;
      fail:
      monoeg_g_hash_table_destroy (iface_hash);
      mono_error_raise_exception (&error);
      D.29237 = 0B;
      return D.29237;
    }
  finally
    {
      error = {CLOBBER};
      data = {CLOBBER};
    }
}


fill_iface_array (void * key, void * value, void * user_data)
{
  struct MonoError * D.29254;
  int D.29255;
  struct MonoGenericContext * D.29258;
  struct MonoGenericClass * D.29261;
  struct MonoGenericInst * D.29264;
  long unsigned int D.29265;
  long unsigned int D.29266;
  int D.29269;
  struct MonoArray * D.29272;
  int D.29273;
  int D.29274;
  int D.29275;
  long unsigned int D.29276;
  struct MonoDomain * D.29277;
  struct MonoReflectionType * D.29278;
  struct FillIfaceArrayData * data;
  struct MonoClass * ic;
  struct MonoType * ret;
  struct MonoType * inflated;

  data = user_data;
  ic = key;
  ret = &ic->byval_arg;
  inflated = 0B;
  D.29254 = data->error;
  D.29255 = mono_error_ok (D.29254);
  if (D.29255 == 0) goto <D.29256>; else goto <D.29257>;
  <D.29256>:
  return;
  <D.29257>:
  D.29258 = data->context;
  if (D.29258 != 0B) goto <D.29259>; else goto <D.29260>;
  <D.29259>:
  D.29261 = ic->generic_class;
  if (D.29261 != 0B) goto <D.29262>; else goto <D.29263>;
  <D.29262>:
  D.29261 = ic->generic_class;
  D.29264 = D.29261->context.class_inst;
  D.29265 = BIT_FIELD_REF <*D.29264, 64, 0>;
  D.29266 = D.29265 & 512;
  if (D.29266 != 0) goto <D.29267>; else goto <D.29268>;
  <D.29267>:
  D.29258 = data->context;
  D.29254 = data->error;
  ret = mono_class_inflate_generic_type_checked (ret, D.29258, D.29254);
  inflated = ret;
  D.29254 = data->error;
  D.29269 = mono_error_ok (D.29254);
  if (D.29269 == 0) goto <D.29270>; else goto <D.29271>;
  <D.29270>:
  return;
  <D.29271>:
  <D.29268>:
  <D.29263>:
  <D.29260>:
  {
    void * * __p;

    D.29272 = data->iface_array;
    D.29273 = data->next_idx;
    D.29274 = D.29273;
    D.29275 = D.29274 + 1;
    data->next_idx = D.29275;
    D.29276 = (long unsigned int) D.29274;
    __p = mono_array_addr_with_size (D.29272, 8, D.29276);
    D.29272 = data->iface_array;
    D.29277 = data->domain;
    D.29278 = mono_type_get_object (D.29277, ret);
    mono_gc_wbarrier_set_arrayref (D.29272, __p, D.29278);
  }
  if (inflated != 0B) goto <D.29279>; else goto <D.29280>;
  <D.29279>:
  mono_metadata_free_type (inflated);
  <D.29280>:
}


collect_interfaces (struct MonoClass * klass, struct GHashTable * ifaces, struct MonoError * error)
{
  int D.29282;
  struct MonoClass * * D.29285;
  long unsigned int D.29286;
  long unsigned int D.29287;
  struct MonoClass * * D.29288;
  int D.29289;
  short unsigned int D.29292;
  int D.29293;
  int i;
  struct MonoClass * ic;

  mono_class_setup_interfaces (klass, error);
  D.29282 = mono_error_ok (error);
  if (D.29282 == 0) goto <D.29283>; else goto <D.29284>;
  <D.29283>:
  return;
  <D.29284>:
  i = 0;
  goto <D.21662>;
  <D.21661>:
  D.29285 = klass->interfaces;
  D.29286 = (long unsigned int) i;
  D.29287 = D.29286 * 8;
  D.29288 = D.29285 + D.29287;
  ic = *D.29288;
  monoeg_g_hash_table_insert_replace (ifaces, ic, ic, 0);
  collect_interfaces (ic, ifaces, error);
  D.29289 = mono_error_ok (error);
  if (D.29289 == 0) goto <D.29290>; else goto <D.29291>;
  <D.29290>:
  return;
  <D.29291>:
  i = i + 1;
  <D.21662>:
  D.29292 = klass->interface_count;
  D.29293 = (int) D.29292;
  if (D.29293 > i) goto <D.21661>; else goto <D.21663>;
  <D.21663>:
}


ves_icall_MonoType_GetGenericArguments (struct MonoReflectionType * type)
{
  struct MonoVTable * D.29295;
  struct MonoClass * D.21789;
  struct MonoClass * tmp_klass.139;
  struct MonoClass * D.29299;
  struct MonoClass * tmp_klass.140;
  _Bool D.29301;
  long int D.29302;
  long int D.29303;
  struct MonoType * D.29306;
  struct MonoGenericContainer * D.29307;
  <unnamed-signed:31> D.29310;
  long unsigned int D.29311;
  struct MonoGenericParamFull * D.29312;
  long unsigned int D.29313;
  long unsigned int D.29314;
  struct MonoGenericParamFull * D.29315;
  struct MonoImage * D.29316;
  long unsigned int D.29317;
  struct MonoType * D.29318;
  struct MonoReflectionType * D.29319;
  int D.29320;
  struct MonoGenericClass * D.29322;
  <unnamed-unsigned:22> D.29325;
  long unsigned int D.29326;
  struct MonoType * D.29327;
  struct MonoReflectionType * D.29328;
  int D.29329;
  struct MonoArray * D.29331;
  struct MonoArray * res;
  struct MonoClass * klass;
  struct MonoClass * pklass;
  struct MonoDomain * domain;
  struct MonoVTable * array_vtable;
  int i;

  D.29295 = MEM[(struct MonoObject *)type].vtable;
  domain = D.29295->domain;
  {
    static struct MonoClass * tmp_klass;

    {
      tmp_klass.139 = tmp_klass;
      if (tmp_klass.139 == 0B) goto <D.29297>; else goto <D.29298>;
      <D.29297>:
      D.29299 = mono_defaults.systemtype_class;
      tmp_klass.140 = mono_array_class_get (D.29299, 1);
      tmp_klass = tmp_klass.140;
      tmp_klass.139 = tmp_klass;
      D.29301 = tmp_klass.139 == 0B;
      D.29302 = (long int) D.29301;
      D.29303 = __builtin_expect (D.29302, 0);
      if (D.29303 != 0) goto <D.29304>; else goto <D.29305>;
      <D.29304>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 2329, "tmp_klass");
      <D.29305>:
      <D.29298>:
    }
    D.21789 = tmp_klass;
  }
  array_vtable = mono_class_vtable_full (domain, D.21789, 1);
  D.29306 = type->type;
  klass = mono_class_from_mono_type (D.29306);
  D.29307 = klass->generic_container;
  if (D.29307 != 0B) goto <D.29308>; else goto <D.29309>;
  <D.29308>:
  {
    struct MonoGenericContainer * container;

    container = klass->generic_container;
    D.29310 = container->type_argc;
    D.29311 = (long unsigned int) D.29310;
    res = mono_array_new_specific (array_vtable, D.29311);
    i = 0;
    goto <D.21794>;
    <D.21793>:
    D.29312 = container->type_params;
    D.29313 = (long unsigned int) i;
    D.29314 = D.29313 * 56;
    D.29315 = D.29312 + D.29314;
    D.29316 = klass->image;
    pklass = mono_class_from_generic_parameter (D.29315, D.29316, 0);
    {
      void * * __p;

      D.29317 = (long unsigned int) i;
      __p = mono_array_addr_with_size (res, 8, D.29317);
      D.29318 = &pklass->byval_arg;
      D.29319 = mono_type_get_object (domain, D.29318);
      mono_gc_wbarrier_set_arrayref (res, __p, D.29319);
    }
    i = i + 1;
    <D.21794>:
    D.29310 = container->type_argc;
    D.29320 = (int) D.29310;
    if (D.29320 > i) goto <D.21793>; else goto <D.21795>;
    <D.21795>:
  }
  goto <D.29321>;
  <D.29309>:
  D.29322 = klass->generic_class;
  if (D.29322 != 0B) goto <D.29323>; else goto <D.29324>;
  <D.29323>:
  {
    struct MonoGenericInst * inst;

    D.29322 = klass->generic_class;
    inst = D.29322->context.class_inst;
    D.29325 = inst->type_argc;
    D.29326 = (long unsigned int) D.29325;
    res = mono_array_new_specific (array_vtable, D.29326);
    i = 0;
    goto <D.21799>;
    <D.21798>:
    {
      void * * __p;

      D.29317 = (long unsigned int) i;
      __p = mono_array_addr_with_size (res, 8, D.29317);
      D.29327 = inst->type_argv[i];
      D.29328 = mono_type_get_object (domain, D.29327);
      mono_gc_wbarrier_set_arrayref (res, __p, D.29328);
    }
    i = i + 1;
    <D.21799>:
    D.29325 = inst->type_argc;
    D.29329 = (int) D.29325;
    if (D.29329 > i) goto <D.21798>; else goto <D.21800>;
    <D.21800>:
  }
  goto <D.29330>;
  <D.29324>:
  res = mono_array_new_specific (array_vtable, 0);
  <D.29330>:
  <D.29321>:
  D.29331 = res;
  return D.29331;
}


ves_icall_Type_GetFields_internal (struct MonoReflectionType * type, guint32 bflags, struct MonoReflectionType * reftype)
{
  struct MonoVTable * D.29333;
  struct MonoType * D.29334;
  long unsigned int D.29335;
  long unsigned int D.29336;
  struct MonoArray * D.29339;
  struct MonoClass * D.29340;
  struct MonoType * D.29341;
  void * D.29342;
  unsigned char D.29343;
  int D.29346;
  void * * D.29349;
  struct MonoException * D.29350;
  unsigned int D.29351;
  const char * D.29354;
  int D.29355;
  unsigned int D.29358;
  unsigned int D.29361;
  unsigned int D.29368;
  unsigned int D.29373;
  unsigned int D.29376;
  unsigned int D.29381;
  unsigned int D.29384;
  int D.29389;
  long unsigned int D.29392;
  long unsigned int D.29393;
  int D.29394;
  void * D.29395;
  long unsigned int D.29396;
  int D.29399;
  int D.29400;
  long unsigned int D.29401;
  long unsigned int D.29402;
  void * * D.29403;
  unsigned int D.29404;
  struct MonoClass * D.22194;
  struct MonoClass * tmp_klass.141;
  struct MonoClass * tmp_klass.142;
  _Bool D.29412;
  long int D.29413;
  long int D.29414;
  struct MonoVTable * D.29417;
  long unsigned int D.29418;
  long unsigned int D.29419;
  long unsigned int D.29420;
  long unsigned int D.29421;
  void * * D.29422;
  void * D.29423;
  struct MonoDomain * domain;
  struct MonoClass * startklass;
  struct MonoClass * klass;
  struct MonoClass * refklass;
  struct MonoArray * res;
  struct MonoObject * member;
  int i;
  int match;
  void * iter;
  struct MonoClassField * field;
  struct MonoPtrArray tmp_array;
  void handle_parent = <<< error >>>;

  try
    {
      D.29333 = MEM[(struct MonoObject *)type].vtable;
      domain = D.29333->domain;
      D.29334 = type->type;
      D.29335 = BIT_FIELD_REF <*D.29334, 64, 64>;
      D.29336 = D.29335 & 8589934592;
      if (D.29336 != 0) goto <D.29337>; else goto <D.29338>;
      <D.29337>:
      D.29340 = mono_defaults.field_info_class;
      D.29339 = mono_array_new (domain, D.29340, 0);
      return D.29339;
      <D.29338>:
      D.29334 = type->type;
      startklass = mono_class_from_mono_type (D.29334);
      klass = startklass;
      D.29341 = reftype->type;
      refklass = mono_class_from_mono_type (D.29341);
      tmp_array.size = 0;
      tmp_array.capacity = 16;
      D.29342 = __builtin_alloca (128);
      tmp_array.data = D.29342;
      handle_parent:
      D.29343 = klass->exception_type;
      if (D.29343 != 0) goto <D.29344>; else goto <D.29345>;
      <D.29344>:
      D.29346 = tmp_array.capacity;
      if (D.29346 > 16) goto <D.29347>; else goto <D.29348>;
      <D.29347>:
      D.29349 = tmp_array.data;
      mono_gc_free_fixed (D.29349);
      <D.29348>:
      D.29350 = mono_class_get_exception_for_failure (klass);
      mono_raise_exception (D.29350);
      <D.29345>:
      iter = 0B;
      goto <D.22189>;
      <D.22191>:
      {
        guint32 flags;

        flags = mono_field_get_flags (field);
        match = 0;
        D.29351 = flags & 1536;
        if (D.29351 != 0) goto <D.29352>; else goto <D.29353>;
        <D.29352>:
        D.29354 = mono_field_get_name (field);
        D.29355 = strcmp (D.29354, "_Deleted");
        if (D.29355 == 0) goto <D.29356>; else goto <D.29357>;
        <D.29356>:
        // predicted unlikely by continue predictor.
        goto <D.22189>;
        <D.29357>:
        <D.29353>:
        D.29358 = flags & 7;
        if (D.29358 == 6) goto <D.29359>; else goto <D.29360>;
        <D.29359>:
        D.29361 = bflags & 16;
        if (D.29361 != 0) goto <D.29362>; else goto <D.29363>;
        <D.29362>:
        match = match + 1;
        <D.29363>:
        goto <D.29364>;
        <D.29360>:
        if (klass == startklass) goto <D.29365>; else goto <D.29367>;
        <D.29367>:
        D.29358 = flags & 7;
        if (D.29358 != 1) goto <D.29365>; else goto <D.29366>;
        <D.29365>:
        D.29368 = bflags & 32;
        if (D.29368 != 0) goto <D.29369>; else goto <D.29370>;
        <D.29369>:
        match = match + 1;
        <D.29370>:
        <D.29366>:
        <D.29364>:
        if (match == 0) goto <D.29371>; else goto <D.29372>;
        <D.29371>:
        // predicted unlikely by continue predictor.
        goto <D.22189>;
        <D.29372>:
        match = 0;
        D.29373 = flags & 16;
        if (D.29373 != 0) goto <D.29374>; else goto <D.29375>;
        <D.29374>:
        D.29376 = bflags & 8;
        if (D.29376 != 0) goto <D.29377>; else goto <D.29378>;
        <D.29377>:
        D.29381 = bflags & 64;
        if (D.29381 != 0) goto <D.29379>; else goto <D.29382>;
        <D.29382>:
        if (klass == startklass) goto <D.29379>; else goto <D.29380>;
        <D.29379>:
        match = match + 1;
        <D.29380>:
        <D.29378>:
        goto <D.29383>;
        <D.29375>:
        D.29384 = bflags & 4;
        if (D.29384 != 0) goto <D.29385>; else goto <D.29386>;
        <D.29385>:
        match = match + 1;
        <D.29386>:
        <D.29383>:
        if (match == 0) goto <D.29387>; else goto <D.29388>;
        <D.29387>:
        // predicted unlikely by continue predictor.
        goto <D.22189>;
        <D.29388>:
        member = mono_field_get_object (domain, refklass, field);
        D.29389 = tmp_array.size;
        D.29346 = tmp_array.capacity;
        if (D.29389 >= D.29346) goto <D.29390>; else goto <D.29391>;
        <D.29390>:
        {
          void * __tmp;

          D.29346 = tmp_array.capacity;
          D.29392 = (long unsigned int) D.29346;
          D.29393 = D.29392 * 16;
          D.29346 = tmp_array.capacity;
          D.29394 = D.29346 * 2;
          D.29395 = mono_gc_make_root_descr_all_refs (D.29394);
          __tmp = mono_gc_alloc_fixed (D.29393, D.29395);
          D.29349 = tmp_array.data;
          D.29346 = tmp_array.capacity;
          D.29392 = (long unsigned int) D.29346;
          D.29396 = D.29392 * 8;
          mono_gc_memmove_aligned (__tmp, D.29349, D.29396);
          D.29346 = tmp_array.capacity;
          if (D.29346 > 16) goto <D.29397>; else goto <D.29398>;
          <D.29397>:
          D.29349 = tmp_array.data;
          mono_gc_free_fixed (D.29349);
          <D.29398>:
          tmp_array.data = __tmp;
          D.29346 = tmp_array.capacity;
          D.29394 = D.29346 * 2;
          tmp_array.capacity = D.29394;
        }
        <D.29391>:
        D.29349 = tmp_array.data;
        D.29389 = tmp_array.size;
        D.29399 = D.29389;
        D.29400 = D.29399 + 1;
        tmp_array.size = D.29400;
        D.29401 = (long unsigned int) D.29399;
        D.29402 = D.29401 * 8;
        D.29403 = D.29349 + D.29402;
        *D.29403 = member;
      }
      <D.22189>:
      field = mono_class_get_fields_lazy (klass, &iter);
      if (field != 0B) goto <D.22191>; else goto <D.22192>;
      <D.22192>:
      D.29404 = bflags & 2;
      if (D.29404 == 0) goto <D.29405>; else goto <D.29406>;
      <D.29405>:
      klass = klass->parent;
      if (klass != 0B) goto handle_parent; else goto <D.29407>;
      <D.29407>:
      <D.29406>:
      {
        static struct MonoClass * tmp_klass;

        {
          tmp_klass.141 = tmp_klass;
          if (tmp_klass.141 == 0B) goto <D.29409>; else goto <D.29410>;
          <D.29409>:
          D.29340 = mono_defaults.field_info_class;
          tmp_klass.142 = mono_array_class_get (D.29340, 1);
          tmp_klass = tmp_klass.142;
          tmp_klass.141 = tmp_klass;
          D.29412 = tmp_klass.141 == 0B;
          D.29413 = (long int) D.29412;
          D.29414 = __builtin_expect (D.29413, 0);
          if (D.29414 != 0) goto <D.29415>; else goto <D.29416>;
          <D.29415>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 3414, "tmp_klass");
          <D.29416>:
          <D.29410>:
        }
        D.22194 = tmp_klass;
      }
      D.29417 = mono_class_vtable (domain, D.22194);
      D.29389 = tmp_array.size;
      D.29418 = (long unsigned int) D.29389;
      res = mono_array_new_specific (D.29417, D.29418);
      i = 0;
      goto <D.22197>;
      <D.22196>:
      {
        void * * __p;

        D.29419 = (long unsigned int) i;
        __p = mono_array_addr_with_size (res, 8, D.29419);
        D.29349 = tmp_array.data;
        D.29420 = (long unsigned int) i;
        D.29421 = D.29420 * 8;
        D.29422 = D.29349 + D.29421;
        D.29423 = *D.29422;
        mono_gc_wbarrier_set_arrayref (res, __p, D.29423);
      }
      i = i + 1;
      <D.22197>:
      D.29389 = tmp_array.size;
      if (D.29389 > i) goto <D.22196>; else goto <D.22198>;
      <D.22198>:
      D.29346 = tmp_array.capacity;
      if (D.29346 > 16) goto <D.29424>; else goto <D.29425>;
      <D.29424>:
      D.29349 = tmp_array.data;
      mono_gc_free_fixed (D.29349);
      <D.29425>:
      D.29339 = res;
      return D.29339;
    }
  finally
    {
      iter = {CLOBBER};
      tmp_array = {CLOBBER};
    }
}


ves_icall_Type_GetField (struct MonoReflectionType * type, struct MonoString * name, guint32 bflags)
{
  struct MonoVTable * D.29428;
  struct MonoType * D.29429;
  struct MonoException * D.29432;
  long unsigned int D.29433;
  long unsigned int D.29434;
  struct MonoReflectionField * D.29437;
  int (*<T3b2a>) (const char *, const char *) iftmp.143;
  unsigned int D.29439;
  unsigned char D.29443;
  struct MonoException * D.29446;
  unsigned int D.29447;
  const char * D.29450;
  int D.29451;
  unsigned int D.29454;
  unsigned int D.29457;
  unsigned int D.29464;
  unsigned int D.29469;
  unsigned int D.29472;
  unsigned int D.29477;
  unsigned int D.29480;
  const char * D.29485;
  int D.29486;
  unsigned int D.29489;
  struct MonoDomain * domain;
  struct MonoClass * startklass;
  struct MonoClass * klass;
  int match;
  struct MonoClassField * field;
  void * iter;
  char * utf8_name;
  int (*<T3b2a>) (const char *, const char *) compare_func;
  void handle_parent = <<< error >>>;

  try
    {
      compare_func = 0B;
      D.29428 = MEM[(struct MonoObject *)type].vtable;
      domain = D.29428->domain;
      D.29429 = type->type;
      startklass = mono_class_from_mono_type (D.29429);
      klass = startklass;
      if (name == 0B) goto <D.29430>; else goto <D.29431>;
      <D.29430>:
      D.29432 = mono_get_exception_argument_null ("name");
      mono_raise_exception (D.29432);
      <D.29431>:
      D.29429 = type->type;
      D.29433 = BIT_FIELD_REF <*D.29429, 64, 64>;
      D.29434 = D.29433 & 8589934592;
      if (D.29434 != 0) goto <D.29435>; else goto <D.29436>;
      <D.29435>:
      D.29437 = 0B;
      return D.29437;
      <D.29436>:
      D.29439 = bflags & 1;
      if (D.29439 != 0) goto <D.29440>; else goto <D.29441>;
      <D.29440>:
      iftmp.143 = monoeg_ascii_strcasecmp;
      goto <D.29442>;
      <D.29441>:
      iftmp.143 = strcmp;
      <D.29442>:
      compare_func = iftmp.143;
      handle_parent:
      D.29443 = klass->exception_type;
      if (D.29443 != 0) goto <D.29444>; else goto <D.29445>;
      <D.29444>:
      D.29446 = mono_class_get_exception_for_failure (klass);
      mono_raise_exception (D.29446);
      <D.29445>:
      iter = 0B;
      goto <D.22168>;
      <D.22169>:
      {
        guint32 flags;

        flags = mono_field_get_flags (field);
        match = 0;
        D.29447 = flags & 1536;
        if (D.29447 != 0) goto <D.29448>; else goto <D.29449>;
        <D.29448>:
        D.29450 = mono_field_get_name (field);
        D.29451 = strcmp (D.29450, "_Deleted");
        if (D.29451 == 0) goto <D.29452>; else goto <D.29453>;
        <D.29452>:
        // predicted unlikely by continue predictor.
        goto <D.22168>;
        <D.29453>:
        <D.29449>:
        D.29454 = flags & 7;
        if (D.29454 == 6) goto <D.29455>; else goto <D.29456>;
        <D.29455>:
        D.29457 = bflags & 16;
        if (D.29457 != 0) goto <D.29458>; else goto <D.29459>;
        <D.29458>:
        match = match + 1;
        <D.29459>:
        goto <D.29460>;
        <D.29456>:
        if (klass == startklass) goto <D.29461>; else goto <D.29463>;
        <D.29463>:
        D.29454 = flags & 7;
        if (D.29454 != 1) goto <D.29461>; else goto <D.29462>;
        <D.29461>:
        D.29464 = bflags & 32;
        if (D.29464 != 0) goto <D.29465>; else goto <D.29466>;
        <D.29465>:
        match = match + 1;
        <D.29466>:
        <D.29462>:
        <D.29460>:
        if (match == 0) goto <D.29467>; else goto <D.29468>;
        <D.29467>:
        // predicted unlikely by continue predictor.
        goto <D.22168>;
        <D.29468>:
        match = 0;
        D.29469 = flags & 16;
        if (D.29469 != 0) goto <D.29470>; else goto <D.29471>;
        <D.29470>:
        D.29472 = bflags & 8;
        if (D.29472 != 0) goto <D.29473>; else goto <D.29474>;
        <D.29473>:
        D.29477 = bflags & 64;
        if (D.29477 != 0) goto <D.29475>; else goto <D.29478>;
        <D.29478>:
        if (klass == startklass) goto <D.29475>; else goto <D.29476>;
        <D.29475>:
        match = match + 1;
        <D.29476>:
        <D.29474>:
        goto <D.29479>;
        <D.29471>:
        D.29480 = bflags & 4;
        if (D.29480 != 0) goto <D.29481>; else goto <D.29482>;
        <D.29481>:
        match = match + 1;
        <D.29482>:
        <D.29479>:
        if (match == 0) goto <D.29483>; else goto <D.29484>;
        <D.29483>:
        // predicted unlikely by continue predictor.
        goto <D.22168>;
        <D.29484>:
        utf8_name = mono_string_to_utf8 (name);
        D.29485 = mono_field_get_name (field);
        D.29486 = compare_func (D.29485, utf8_name);
        if (D.29486 != 0) goto <D.29487>; else goto <D.29488>;
        <D.29487>:
        monoeg_g_free (utf8_name);
        // predicted unlikely by continue predictor.
        goto <D.22168>;
        <D.29488>:
        monoeg_g_free (utf8_name);
        D.29437 = mono_field_get_object (domain, klass, field);
        return D.29437;
      }
      <D.22168>:
      field = mono_class_get_fields_lazy (klass, &iter);
      if (field != 0B) goto <D.22169>; else goto <D.22170>;
      <D.22170>:
      D.29489 = bflags & 2;
      if (D.29489 == 0) goto <D.29490>; else goto <D.29491>;
      <D.29490>:
      klass = klass->parent;
      if (klass != 0B) goto handle_parent; else goto <D.29492>;
      <D.29492>:
      <D.29491>:
      D.29437 = 0B;
      return D.29437;
    }
  finally
    {
      iter = {CLOBBER};
    }
}


ves_icall_Type_GetEvents_internal (struct MonoReflectionType * type, guint32 bflags, struct MonoReflectionType * reftype)
{
  void * D.29495;
  struct MonoClass * System_Reflection_EventInfo.144;
  struct MonoImage * D.29499;
  struct MonoClass * System_Reflection_EventInfo.145;
  struct MonoVTable * D.29501;
  struct MonoType * D.29502;
  long unsigned int D.29503;
  long unsigned int D.29504;
  struct MonoArray * D.29507;
  struct MonoClass * D.22372;
  struct MonoClass * tmp_klass.146;
  struct MonoClass * tmp_klass.147;
  _Bool D.29512;
  long int D.29513;
  long int D.29514;
  struct MonoVTable * D.29517;
  unsigned char D.29518;
  struct MonoLoaderError * D.29520;
  short unsigned int D.29528;
  int D.29529;
  int D.29530;
  unsigned int D.29533;
  unsigned int D.29540;
  int D.29550;
  unsigned int D.29553;
  unsigned int D.29558;
  unsigned int D.29561;
  int D.29569;
  int D.29570;
  long unsigned int D.29573;
  long unsigned int D.29574;
  int D.29575;
  void * D.29576;
  void * * D.29577;
  long unsigned int D.29578;
  int D.29581;
  int D.29582;
  long unsigned int D.29583;
  long unsigned int D.29584;
  void * * D.29585;
  struct MonoReflectionEvent * D.29586;
  unsigned int D.29587;
  struct MonoClass * D.22380;
  struct MonoClass * tmp_klass.148;
  struct MonoClass * tmp_klass.149;
  _Bool D.29595;
  long int D.29596;
  long int D.29597;
  struct MonoVTable * D.29600;
  long unsigned int D.29601;
  long unsigned int D.29602;
  long unsigned int D.29603;
  long unsigned int D.29604;
  void * * D.29605;
  void * D.29606;
  struct MonoLoaderError * D.29614;
  struct MonoException * ex;
  struct MonoDomain * domain;
  static struct MonoClass * System_Reflection_EventInfo;
  struct MonoClass * startklass;
  struct MonoClass * klass;
  struct MonoArray * res;
  struct MonoMethod * method;
  struct MonoEvent * event;
  int i;
  int match;
  void * iter;
  struct MonoPtrArray tmp_array;
  void handle_parent = <<< error >>>;
  void loader_error = <<< error >>>;

  try
    {
      tmp_array.size = 0;
      tmp_array.capacity = 16;
      D.29495 = __builtin_alloca (128);
      tmp_array.data = D.29495;
      System_Reflection_EventInfo.144 = System_Reflection_EventInfo;
      if (System_Reflection_EventInfo.144 == 0B) goto <D.29497>; else goto <D.29498>;
      <D.29497>:
      D.29499 = mono_defaults.corlib;
      System_Reflection_EventInfo.145 = mono_class_from_name (D.29499, "System.Reflection", "EventInfo");
      System_Reflection_EventInfo = System_Reflection_EventInfo.145;
      <D.29498>:
      D.29501 = MEM[(struct MonoObject *)type].vtable;
      domain = D.29501->domain;
      D.29502 = type->type;
      D.29503 = BIT_FIELD_REF <*D.29502, 64, 64>;
      D.29504 = D.29503 & 8589934592;
      if (D.29504 != 0) goto <D.29505>; else goto <D.29506>;
      <D.29505>:
      {
        static struct MonoClass * tmp_klass;

        {
          tmp_klass.146 = tmp_klass;
          if (tmp_klass.146 == 0B) goto <D.29509>; else goto <D.29510>;
          <D.29509>:
          System_Reflection_EventInfo.144 = System_Reflection_EventInfo;
          tmp_klass.147 = mono_array_class_get (System_Reflection_EventInfo.144, 1);
          tmp_klass = tmp_klass.147;
          tmp_klass.146 = tmp_klass;
          D.29512 = tmp_klass.146 == 0B;
          D.29513 = (long int) D.29512;
          D.29514 = __builtin_expect (D.29513, 0);
          if (D.29514 != 0) goto <D.29515>; else goto <D.29516>;
          <D.29515>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 3914, "tmp_klass");
          <D.29516>:
          <D.29510>:
        }
        D.22372 = tmp_klass;
      }
      D.29517 = mono_class_vtable (domain, D.22372);
      D.29507 = mono_array_new_specific (D.29517, 0);
      return D.29507;
      <D.29506>:
      D.29502 = type->type;
      startklass = mono_class_from_mono_type (D.29502);
      klass = startklass;
      handle_parent:
      mono_class_setup_vtable (klass);
      D.29518 = klass->exception_type;
      if (D.29518 != 0) goto loader_error; else goto <D.29519>;
      <D.29519>:
      D.29520 = mono_loader_get_last_error ();
      if (D.29520 != 0B) goto loader_error; else goto <D.29521>;
      <D.29521>:
      iter = 0B;
      goto <D.22375>;
      <D.22377>:
      match = 0;
      method = event->add;
      if (method == 0B) goto <D.29522>; else goto <D.29523>;
      <D.29522>:
      method = event->remove;
      <D.29523>:
      if (method == 0B) goto <D.29524>; else goto <D.29525>;
      <D.29524>:
      method = event->raise;
      <D.29525>:
      if (method != 0B) goto <D.29526>; else goto <D.29527>;
      <D.29526>:
      D.29528 = method->flags;
      D.29529 = (int) D.29528;
      D.29530 = D.29529 & 7;
      if (D.29530 == 6) goto <D.29531>; else goto <D.29532>;
      <D.29531>:
      D.29533 = bflags & 16;
      if (D.29533 != 0) goto <D.29534>; else goto <D.29535>;
      <D.29534>:
      match = match + 1;
      <D.29535>:
      goto <D.29536>;
      <D.29532>:
      if (klass == startklass) goto <D.29537>; else goto <D.29539>;
      <D.29539>:
      D.29528 = method->flags;
      D.29529 = (int) D.29528;
      D.29530 = D.29529 & 7;
      if (D.29530 != 1) goto <D.29537>; else goto <D.29538>;
      <D.29537>:
      D.29540 = bflags & 32;
      if (D.29540 != 0) goto <D.29541>; else goto <D.29542>;
      <D.29541>:
      match = match + 1;
      <D.29542>:
      <D.29538>:
      <D.29536>:
      goto <D.29543>;
      <D.29527>:
      D.29540 = bflags & 32;
      if (D.29540 != 0) goto <D.29544>; else goto <D.29545>;
      <D.29544>:
      match = match + 1;
      <D.29545>:
      <D.29543>:
      if (match == 0) goto <D.29546>; else goto <D.29547>;
      <D.29546>:
      // predicted unlikely by continue predictor.
      goto <D.22375>;
      <D.29547>:
      match = 0;
      if (method != 0B) goto <D.29548>; else goto <D.29549>;
      <D.29548>:
      D.29528 = method->flags;
      D.29529 = (int) D.29528;
      D.29550 = D.29529 & 16;
      if (D.29550 != 0) goto <D.29551>; else goto <D.29552>;
      <D.29551>:
      D.29553 = bflags & 8;
      if (D.29553 != 0) goto <D.29554>; else goto <D.29555>;
      <D.29554>:
      D.29558 = bflags & 64;
      if (D.29558 != 0) goto <D.29556>; else goto <D.29559>;
      <D.29559>:
      if (klass == startklass) goto <D.29556>; else goto <D.29557>;
      <D.29556>:
      match = match + 1;
      <D.29557>:
      <D.29555>:
      goto <D.29560>;
      <D.29552>:
      D.29561 = bflags & 4;
      if (D.29561 != 0) goto <D.29562>; else goto <D.29563>;
      <D.29562>:
      match = match + 1;
      <D.29563>:
      <D.29560>:
      goto <D.29564>;
      <D.29549>:
      D.29561 = bflags & 4;
      if (D.29561 != 0) goto <D.29565>; else goto <D.29566>;
      <D.29565>:
      match = match + 1;
      <D.29566>:
      <D.29564>:
      if (match == 0) goto <D.29567>; else goto <D.29568>;
      <D.29567>:
      // predicted unlikely by continue predictor.
      goto <D.22375>;
      <D.29568>:
      D.29569 = tmp_array.size;
      D.29570 = tmp_array.capacity;
      if (D.29569 >= D.29570) goto <D.29571>; else goto <D.29572>;
      <D.29571>:
      {
        void * __tmp;

        D.29570 = tmp_array.capacity;
        D.29573 = (long unsigned int) D.29570;
        D.29574 = D.29573 * 16;
        D.29570 = tmp_array.capacity;
        D.29575 = D.29570 * 2;
        D.29576 = mono_gc_make_root_descr_all_refs (D.29575);
        __tmp = mono_gc_alloc_fixed (D.29574, D.29576);
        D.29577 = tmp_array.data;
        D.29570 = tmp_array.capacity;
        D.29573 = (long unsigned int) D.29570;
        D.29578 = D.29573 * 8;
        mono_gc_memmove_aligned (__tmp, D.29577, D.29578);
        D.29570 = tmp_array.capacity;
        if (D.29570 > 16) goto <D.29579>; else goto <D.29580>;
        <D.29579>:
        D.29577 = tmp_array.data;
        mono_gc_free_fixed (D.29577);
        <D.29580>:
        tmp_array.data = __tmp;
        D.29570 = tmp_array.capacity;
        D.29575 = D.29570 * 2;
        tmp_array.capacity = D.29575;
      }
      <D.29572>:
      D.29577 = tmp_array.data;
      D.29569 = tmp_array.size;
      D.29581 = D.29569;
      D.29582 = D.29581 + 1;
      tmp_array.size = D.29582;
      D.29583 = (long unsigned int) D.29581;
      D.29584 = D.29583 * 8;
      D.29585 = D.29577 + D.29584;
      D.29586 = mono_event_get_object (domain, startklass, event);
      *D.29585 = D.29586;
      <D.22375>:
      event = mono_class_get_events (klass, &iter);
      if (event != 0B) goto <D.22377>; else goto <D.22378>;
      <D.22378>:
      D.29587 = bflags & 2;
      if (D.29587 == 0) goto <D.29588>; else goto <D.29589>;
      <D.29588>:
      klass = klass->parent;
      if (klass != 0B) goto handle_parent; else goto <D.29590>;
      <D.29590>:
      <D.29589>:
      {
        static struct MonoClass * tmp_klass;

        {
          tmp_klass.148 = tmp_klass;
          if (tmp_klass.148 == 0B) goto <D.29592>; else goto <D.29593>;
          <D.29592>:
          System_Reflection_EventInfo.144 = System_Reflection_EventInfo;
          tmp_klass.149 = mono_array_class_get (System_Reflection_EventInfo.144, 1);
          tmp_klass = tmp_klass.149;
          tmp_klass.148 = tmp_klass;
          D.29595 = tmp_klass.148 == 0B;
          D.29596 = (long int) D.29595;
          D.29597 = __builtin_expect (D.29596, 0);
          if (D.29597 != 0) goto <D.29598>; else goto <D.29599>;
          <D.29598>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 3965, "tmp_klass");
          <D.29599>:
          <D.29593>:
        }
        D.22380 = tmp_klass;
      }
      D.29600 = mono_class_vtable (domain, D.22380);
      D.29569 = tmp_array.size;
      D.29601 = (long unsigned int) D.29569;
      res = mono_array_new_specific (D.29600, D.29601);
      i = 0;
      goto <D.22383>;
      <D.22382>:
      {
        void * * __p;

        D.29602 = (long unsigned int) i;
        __p = mono_array_addr_with_size (res, 8, D.29602);
        D.29577 = tmp_array.data;
        D.29603 = (long unsigned int) i;
        D.29604 = D.29603 * 8;
        D.29605 = D.29577 + D.29604;
        D.29606 = *D.29605;
        mono_gc_wbarrier_set_arrayref (res, __p, D.29606);
      }
      i = i + 1;
      <D.22383>:
      D.29569 = tmp_array.size;
      if (D.29569 > i) goto <D.22382>; else goto <D.22384>;
      <D.22384>:
      D.29570 = tmp_array.capacity;
      if (D.29570 > 16) goto <D.29607>; else goto <D.29608>;
      <D.29607>:
      D.29577 = tmp_array.data;
      mono_gc_free_fixed (D.29577);
      <D.29608>:
      D.29507 = res;
      return D.29507;
      loader_error:
      D.29570 = tmp_array.capacity;
      if (D.29570 > 16) goto <D.29609>; else goto <D.29610>;
      <D.29609>:
      D.29577 = tmp_array.data;
      mono_gc_free_fixed (D.29577);
      <D.29610>:
      D.29518 = klass->exception_type;
      if (D.29518 != 0) goto <D.29611>; else goto <D.29612>;
      <D.29611>:
      ex = mono_class_get_exception_for_failure (klass);
      goto <D.29613>;
      <D.29612>:
      D.29614 = mono_loader_get_last_error ();
      ex = mono_loader_error_prepare_exception (D.29614);
      mono_loader_clear_error ();
      <D.29613>:
      mono_raise_exception (ex);
      D.29507 = 0B;
      return D.29507;
    }
  finally
    {
      iter = {CLOBBER};
      tmp_array = {CLOBBER};
    }
}


ves_icall_MonoType_GetElementType (struct MonoReflectionType * type)
{
  struct MonoType * D.29617;
  long unsigned int D.29618;
  long unsigned int D.29619;
  struct MonoReflectionType * D.29622;
  struct MonoVTable * D.29623;
  struct MonoDomain * D.29624;
  struct MonoClass * D.29625;
  struct MonoType * D.29626;
  long unsigned int D.29627;
  struct MonoType * D.29630;
  struct MonoClass * D.29632;
  unsigned char D.29634;
  struct MonoType * D.29636;
  unsigned char D.29639;
  struct MonoClass * class;

  D.29617 = type->type;
  D.29618 = BIT_FIELD_REF <*D.29617, 64, 64>;
  D.29619 = D.29618 & 280384055017472;
  if (D.29619 == 31885837205504) goto <D.29620>; else goto <D.29621>;
  <D.29620>:
  D.29623 = MEM[(struct MonoObject *)type].vtable;
  D.29624 = D.29623->domain;
  D.29617 = type->type;
  D.29625 = D.29617->data.klass;
  D.29626 = &D.29625->byval_arg;
  D.29622 = mono_type_get_object (D.29624, D.29626);
  return D.29622;
  <D.29621>:
  D.29617 = type->type;
  class = mono_class_from_mono_type (D.29617);
  mono_class_init_or_throw (class);
  D.29617 = type->type;
  D.29618 = BIT_FIELD_REF <*D.29617, 64, 64>;
  D.29627 = D.29618 & 8589934592;
  if (D.29627 != 0) goto <D.29628>; else goto <D.29629>;
  <D.29628>:
  D.29623 = MEM[(struct MonoObject *)type].vtable;
  D.29624 = D.29623->domain;
  D.29630 = &class->byval_arg;
  D.29622 = mono_type_get_object (D.29624, D.29630);
  return D.29622;
  <D.29629>:
  D.29632 = class->element_class;
  if (D.29632 != 0B) goto <D.29633>; else goto <D.29631>;
  <D.29633>:
  D.29634 = class->rank;
  if (D.29634 != 0) goto <D.29635>; else goto <D.29631>;
  <D.29635>:
  D.29623 = MEM[(struct MonoObject *)type].vtable;
  D.29624 = D.29623->domain;
  D.29632 = class->element_class;
  D.29636 = &D.29632->byval_arg;
  D.29622 = mono_type_get_object (D.29624, D.29636);
  return D.29622;
  <D.29631>:
  D.29632 = class->element_class;
  if (D.29632 != 0B) goto <D.29638>; else goto <D.29637>;
  <D.29638>:
  D.29617 = type->type;
  D.29639 = D.29617->type;
  if (D.29639 == 15) goto <D.29640>; else goto <D.29637>;
  <D.29640>:
  D.29623 = MEM[(struct MonoObject *)type].vtable;
  D.29624 = D.29623->domain;
  D.29632 = class->element_class;
  D.29636 = &D.29632->byval_arg;
  D.29622 = mono_type_get_object (D.29624, D.29636);
  return D.29622;
  <D.29637>:
  D.29622 = 0B;
  return D.29622;
}


ves_icall_MonoType_GetCorrespondingInflatedMethod (struct MonoReflectionType * type, struct MonoReflectionMethod * generic)
{
  struct MonoVTable * D.29642;
  struct MonoType * D.29643;
  unsigned int D.29644;
  struct MonoMethod * D.29645;
  unsigned int D.29646;
  struct MonoReflectionMethod * D.29649;
  struct MonoDomain * domain;
  struct MonoClass * klass;
  struct MonoMethod * method;
  void * iter;

  try
    {
      D.29642 = MEM[(struct MonoObject *)type].vtable;
      domain = D.29642->domain;
      D.29643 = type->type;
      klass = mono_class_from_mono_type (D.29643);
      mono_class_init_or_throw (klass);
      iter = 0B;
      goto <D.21873>;
      <D.21872>:
      D.29644 = method->token;
      D.29645 = generic->method;
      D.29646 = D.29645->token;
      if (D.29644 == D.29646) goto <D.29647>; else goto <D.29648>;
      <D.29647>:
      D.29649 = mono_method_get_object (domain, method, klass);
      return D.29649;
      <D.29648>:
      <D.21873>:
      method = mono_class_get_methods (klass, &iter);
      if (method != 0B) goto <D.21872>; else goto <D.21874>;
      <D.21874>:
      D.29649 = 0B;
      return D.29649;
    }
  finally
    {
      iter = {CLOBBER};
    }
}


ves_icall_Type_GetConstructors_internal (struct MonoReflectionType * type, guint32 bflags, struct MonoReflectionType * reftype)
{
  void * D.29652;
  struct MonoVTable * D.29653;
  struct MonoType * D.29654;
  long unsigned int D.29655;
  long unsigned int D.29656;
  struct MonoArray * D.29659;
  struct MonoClass * D.22273;
  struct MonoClass * tmp_klass.150;
  struct MonoClass * D.29663;
  struct MonoClass * tmp_klass.151;
  _Bool D.29665;
  long int D.29666;
  long int D.29667;
  struct MonoVTable * D.29670;
  struct MonoType * D.29671;
  struct MonoClass * System_Reflection_ConstructorInfo.152;
  struct MonoImage * D.29675;
  struct MonoClass * System_Reflection_ConstructorInfo.153;
  const char * D.29677;
  int D.29678;
  int D.29681;
  short unsigned int D.29684;
  int D.29685;
  int D.29686;
  unsigned int D.29689;
  unsigned int D.29693;
  int D.29698;
  unsigned int D.29701;
  unsigned int D.29706;
  unsigned int D.29709;
  int D.29714;
  int D.29715;
  long unsigned int D.29718;
  long unsigned int D.29719;
  int D.29720;
  void * D.29721;
  void * * D.29722;
  long unsigned int D.29723;
  int D.29726;
  int D.29727;
  long unsigned int D.29728;
  long unsigned int D.29729;
  void * * D.29730;
  struct MonoClass * D.22279;
  struct MonoClass * tmp_klass.154;
  struct MonoClass * tmp_klass.155;
  _Bool D.29735;
  long int D.29736;
  long int D.29737;
  struct MonoVTable * D.29740;
  long unsigned int D.29741;
  long unsigned int D.29742;
  long unsigned int D.29743;
  long unsigned int D.29744;
  void * * D.29745;
  void * D.29746;
  struct MonoDomain * domain;
  static struct MonoClass * System_Reflection_ConstructorInfo;
  struct MonoClass * startklass;
  struct MonoClass * klass;
  struct MonoClass * refklass;
  struct MonoArray * res;
  struct MonoMethod * method;
  struct MonoObject * member;
  int i;
  int match;
  void * iter;
  struct MonoPtrArray tmp_array;

  try
    {
      iter = 0B;
      tmp_array.size = 0;
      tmp_array.capacity = 16;
      D.29652 = __builtin_alloca (128);
      tmp_array.data = D.29652;
      D.29653 = MEM[(struct MonoObject *)type].vtable;
      domain = D.29653->domain;
      D.29654 = type->type;
      D.29655 = BIT_FIELD_REF <*D.29654, 64, 64>;
      D.29656 = D.29655 & 8589934592;
      if (D.29656 != 0) goto <D.29657>; else goto <D.29658>;
      <D.29657>:
      {
        static struct MonoClass * tmp_klass;

        {
          tmp_klass.150 = tmp_klass;
          if (tmp_klass.150 == 0B) goto <D.29661>; else goto <D.29662>;
          <D.29661>:
          D.29663 = mono_defaults.method_info_class;
          tmp_klass.151 = mono_array_class_get (D.29663, 1);
          tmp_klass = tmp_klass.151;
          tmp_klass.150 = tmp_klass;
          D.29665 = tmp_klass.150 == 0B;
          D.29666 = (long int) D.29665;
          D.29667 = __builtin_expect (D.29666, 0);
          if (D.29667 != 0) goto <D.29668>; else goto <D.29669>;
          <D.29668>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 3617, "tmp_klass");
          <D.29669>:
          <D.29662>:
        }
        D.22273 = tmp_klass;
      }
      D.29670 = mono_class_vtable (domain, D.22273);
      D.29659 = mono_array_new_specific (D.29670, 0);
      return D.29659;
      <D.29658>:
      D.29654 = type->type;
      startklass = mono_class_from_mono_type (D.29654);
      klass = startklass;
      D.29671 = reftype->type;
      refklass = mono_class_from_mono_type (D.29671);
      System_Reflection_ConstructorInfo.152 = System_Reflection_ConstructorInfo;
      if (System_Reflection_ConstructorInfo.152 == 0B) goto <D.29673>; else goto <D.29674>;
      <D.29673>:
      D.29675 = mono_defaults.corlib;
      System_Reflection_ConstructorInfo.153 = mono_class_from_name (D.29675, "System.Reflection", "ConstructorInfo");
      System_Reflection_ConstructorInfo = System_Reflection_ConstructorInfo.153;
      <D.29674>:
      iter = 0B;
      goto <D.22274>;
      <D.22276>:
      match = 0;
      D.29677 = method->name;
      D.29678 = strcmp (D.29677, ".ctor");
      if (D.29678 != 0) goto <D.29679>; else goto <D.29680>;
      <D.29679>:
      D.29677 = method->name;
      D.29681 = strcmp (D.29677, ".cctor");
      if (D.29681 != 0) goto <D.29682>; else goto <D.29683>;
      <D.29682>:
      // predicted unlikely by continue predictor.
      goto <D.22274>;
      <D.29683>:
      <D.29680>:
      D.29684 = method->flags;
      D.29685 = (int) D.29684;
      D.29686 = D.29685 & 7;
      if (D.29686 == 6) goto <D.29687>; else goto <D.29688>;
      <D.29687>:
      D.29689 = bflags & 16;
      if (D.29689 != 0) goto <D.29690>; else goto <D.29691>;
      <D.29690>:
      match = match + 1;
      <D.29691>:
      goto <D.29692>;
      <D.29688>:
      D.29693 = bflags & 32;
      if (D.29693 != 0) goto <D.29694>; else goto <D.29695>;
      <D.29694>:
      match = match + 1;
      <D.29695>:
      <D.29692>:
      if (match == 0) goto <D.29696>; else goto <D.29697>;
      <D.29696>:
      // predicted unlikely by continue predictor.
      goto <D.22274>;
      <D.29697>:
      match = 0;
      D.29684 = method->flags;
      D.29685 = (int) D.29684;
      D.29698 = D.29685 & 16;
      if (D.29698 != 0) goto <D.29699>; else goto <D.29700>;
      <D.29699>:
      D.29701 = bflags & 8;
      if (D.29701 != 0) goto <D.29702>; else goto <D.29703>;
      <D.29702>:
      D.29706 = bflags & 64;
      if (D.29706 != 0) goto <D.29704>; else goto <D.29707>;
      <D.29707>:
      if (klass == startklass) goto <D.29704>; else goto <D.29705>;
      <D.29704>:
      match = match + 1;
      <D.29705>:
      <D.29703>:
      goto <D.29708>;
      <D.29700>:
      D.29709 = bflags & 4;
      if (D.29709 != 0) goto <D.29710>; else goto <D.29711>;
      <D.29710>:
      match = match + 1;
      <D.29711>:
      <D.29708>:
      if (match == 0) goto <D.29712>; else goto <D.29713>;
      <D.29712>:
      // predicted unlikely by continue predictor.
      goto <D.22274>;
      <D.29713>:
      member = mono_method_get_object (domain, method, refklass);
      D.29714 = tmp_array.size;
      D.29715 = tmp_array.capacity;
      if (D.29714 >= D.29715) goto <D.29716>; else goto <D.29717>;
      <D.29716>:
      {
        void * __tmp;

        D.29715 = tmp_array.capacity;
        D.29718 = (long unsigned int) D.29715;
        D.29719 = D.29718 * 16;
        D.29715 = tmp_array.capacity;
        D.29720 = D.29715 * 2;
        D.29721 = mono_gc_make_root_descr_all_refs (D.29720);
        __tmp = mono_gc_alloc_fixed (D.29719, D.29721);
        D.29722 = tmp_array.data;
        D.29715 = tmp_array.capacity;
        D.29718 = (long unsigned int) D.29715;
        D.29723 = D.29718 * 8;
        mono_gc_memmove_aligned (__tmp, D.29722, D.29723);
        D.29715 = tmp_array.capacity;
        if (D.29715 > 16) goto <D.29724>; else goto <D.29725>;
        <D.29724>:
        D.29722 = tmp_array.data;
        mono_gc_free_fixed (D.29722);
        <D.29725>:
        tmp_array.data = __tmp;
        D.29715 = tmp_array.capacity;
        D.29720 = D.29715 * 2;
        tmp_array.capacity = D.29720;
      }
      <D.29717>:
      D.29722 = tmp_array.data;
      D.29714 = tmp_array.size;
      D.29726 = D.29714;
      D.29727 = D.29726 + 1;
      tmp_array.size = D.29727;
      D.29728 = (long unsigned int) D.29726;
      D.29729 = D.29728 * 8;
      D.29730 = D.29722 + D.29729;
      *D.29730 = member;
      <D.22274>:
      method = mono_class_get_methods (klass, &iter);
      if (method != 0B) goto <D.22276>; else goto <D.22277>;
      <D.22277>:
      {
        static struct MonoClass * tmp_klass;

        {
          tmp_klass.154 = tmp_klass;
          if (tmp_klass.154 == 0B) goto <D.29732>; else goto <D.29733>;
          <D.29732>:
          System_Reflection_ConstructorInfo.152 = System_Reflection_ConstructorInfo;
          tmp_klass.155 = mono_array_class_get (System_Reflection_ConstructorInfo.152, 1);
          tmp_klass = tmp_klass.155;
          tmp_klass.154 = tmp_klass;
          D.29735 = tmp_klass.154 == 0B;
          D.29736 = (long int) D.29735;
          D.29737 = __builtin_expect (D.29736, 0);
          if (D.29737 != 0) goto <D.29738>; else goto <D.29739>;
          <D.29738>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 3656, "tmp_klass");
          <D.29739>:
          <D.29733>:
        }
        D.22279 = tmp_klass;
      }
      D.29740 = mono_class_vtable (domain, D.22279);
      D.29714 = tmp_array.size;
      D.29741 = (long unsigned int) D.29714;
      res = mono_array_new_specific (D.29740, D.29741);
      i = 0;
      goto <D.22282>;
      <D.22281>:
      {
        void * * __p;

        D.29742 = (long unsigned int) i;
        __p = mono_array_addr_with_size (res, 8, D.29742);
        D.29722 = tmp_array.data;
        D.29743 = (long unsigned int) i;
        D.29744 = D.29743 * 8;
        D.29745 = D.29722 + D.29744;
        D.29746 = *D.29745;
        mono_gc_wbarrier_set_arrayref (res, __p, D.29746);
      }
      i = i + 1;
      <D.22282>:
      D.29714 = tmp_array.size;
      if (D.29714 > i) goto <D.22281>; else goto <D.22283>;
      <D.22283>:
      D.29715 = tmp_array.capacity;
      if (D.29715 > 16) goto <D.29747>; else goto <D.29748>;
      <D.29747>:
      D.29722 = tmp_array.data;
      mono_gc_free_fixed (D.29722);
      <D.29748>:
      D.29659 = res;
      return D.29659;
    }
  finally
    {
      iter = {CLOBBER};
      tmp_array = {CLOBBER};
    }
}


ves_icall_MonoType_GetArrayRank (struct MonoReflectionType * type)
{
  struct MonoType * D.29751;
  unsigned char D.29752;
  struct MonoException * D.29757;
  gint32 D.29758;
  unsigned char D.29759;
  struct MonoClass * class;

  D.29751 = type->type;
  D.29752 = D.29751->type;
  if (D.29752 != 20) goto <D.29753>; else goto <D.29754>;
  <D.29753>:
  D.29751 = type->type;
  D.29752 = D.29751->type;
  if (D.29752 != 29) goto <D.29755>; else goto <D.29756>;
  <D.29755>:
  D.29757 = mono_get_exception_argument ("type", "Type must be an array type");
  mono_raise_exception (D.29757);
  <D.29756>:
  <D.29754>:
  D.29751 = type->type;
  class = mono_class_from_mono_type (D.29751);
  D.29759 = class->rank;
  D.29758 = (gint32) D.29759;
  return D.29758;
}


ves_icall_get_enum_info (struct MonoReflectionType * type, struct MonoEnumInfo * info)
{
  struct MonoVTable * D.29761;
  struct MonoType * D.29762;
  struct MonoReflectionType * * D.29763;
  struct MonoType * D.29764;
  struct MonoReflectionType * D.29765;
  guint iftmp.156;
  int D.29767;
  int D.29770;
  int D.29771;
  struct MonoArray * * D.29773;
  struct MonoClass * D.29774;
  long unsigned int D.29775;
  struct MonoArray * D.29776;
  struct MonoArray * * D.29777;
  struct MonoArray * D.29778;
  struct MonoType * D.29779;
  short unsigned int D.29780;
  int D.29781;
  int D.29782;
  const char * D.29785;
  int D.29786;
  int D.29789;
  const char * D.29792;
  int D.29793;
  struct MonoArray * D.29796;
  long unsigned int D.29797;
  const char * D.29798;
  struct MonoString * D.29799;
  const char * p.157;
  const char * p.158;
  unsigned int D.29802;
  struct MonoType * D.29803;
  unsigned char D.29804;
  int D.29805;
  struct MonoArray * D.29806;
  char D.29807;
  short unsigned int D.29808;
  short unsigned int D.29809;
  short int D.29810;
  int D.29811;
  int D.29812;
  short int D.29813;
  short int D.29814;
  unsigned int D.29815;
  unsigned int D.29816;
  unsigned int D.29817;
  unsigned int D.29818;
  unsigned int D.29819;
  unsigned int D.29820;
  unsigned int D.29821;
  unsigned int D.29822;
  unsigned int D.29823;
  unsigned int D.29824;
  int D.29825;
  long unsigned int D.29826;
  unsigned int D.29827;
  unsigned int D.29828;
  unsigned int D.29829;
  unsigned int D.29830;
  unsigned int D.29831;
  unsigned int D.29832;
  unsigned int D.29833;
  unsigned int D.29834;
  unsigned int D.29835;
  unsigned int D.29836;
  long unsigned int D.29837;
  long unsigned int D.29838;
  long unsigned int D.29839;
  unsigned int D.29840;
  unsigned int D.29841;
  unsigned int D.29842;
  unsigned int D.29843;
  unsigned int D.29844;
  unsigned int D.29845;
  unsigned int D.29846;
  unsigned int D.29847;
  unsigned int D.29848;
  unsigned int D.29849;
  long unsigned int D.29850;
  long unsigned int D.29851;
  long int D.29852;
  struct MonoType * D.29853;
  unsigned char D.29854;
  int D.29855;
  struct MonoDomain * domain;
  struct MonoClass * enumc;
  guint j;
  guint nvalues;
  guint crow;
  void * iter;
  struct MonoClassField * field;

  try
    {
      D.29761 = MEM[(struct MonoObject *)type].vtable;
      domain = D.29761->domain;
      D.29762 = type->type;
      enumc = mono_class_from_mono_type (D.29762);
      j = 0;
      mono_class_init_or_throw (enumc);
      D.29763 = &info->utype;
      D.29764 = mono_class_enum_basetype (enumc);
      D.29765 = mono_type_get_object (domain, D.29764);
      mono_gc_wbarrier_generic_store (D.29763, D.29765);
      D.29767 = mono_class_num_fields (enumc);
      if (D.29767 != 0) goto <D.29768>; else goto <D.29769>;
      <D.29768>:
      D.29770 = mono_class_num_fields (enumc);
      D.29771 = D.29770 + -1;
      iftmp.156 = (guint) D.29771;
      goto <D.29772>;
      <D.29769>:
      iftmp.156 = 0;
      <D.29772>:
      nvalues = iftmp.156;
      D.29773 = &info->names;
      D.29774 = mono_defaults.string_class;
      D.29775 = (long unsigned int) nvalues;
      D.29776 = mono_array_new (domain, D.29774, D.29775);
      mono_gc_wbarrier_generic_store (D.29773, D.29776);
      D.29777 = &info->values;
      D.29775 = (long unsigned int) nvalues;
      D.29778 = mono_array_new (domain, enumc, D.29775);
      mono_gc_wbarrier_generic_store (D.29777, D.29778);
      crow = 4294967295;
      iter = 0B;
      goto <D.22114>;
      <D.22132>:
      {
        const char * p;
        int len;
        MonoTypeEnum def_type;

        try
          {
            D.29779 = field->type;
            D.29780 = D.29779->attrs;
            D.29781 = (int) D.29780;
            D.29782 = D.29781 & 16;
            if (D.29782 == 0) goto <D.29783>; else goto <D.29784>;
            <D.29783>:
            // predicted unlikely by continue predictor.
            goto <D.22114>;
            <D.29784>:
            D.29785 = mono_field_get_name (field);
            D.29786 = strcmp ("value__", D.29785);
            if (D.29786 == 0) goto <D.29787>; else goto <D.29788>;
            <D.29787>:
            // predicted unlikely by continue predictor.
            goto <D.22114>;
            <D.29788>:
            D.29779 = field->type;
            D.29780 = D.29779->attrs;
            D.29781 = (int) D.29780;
            D.29789 = D.29781 & 1536;
            if (D.29789 != 0) goto <D.29790>; else goto <D.29791>;
            <D.29790>:
            D.29792 = mono_field_get_name (field);
            D.29793 = strcmp (D.29792, "_Deleted");
            if (D.29793 == 0) goto <D.29794>; else goto <D.29795>;
            <D.29794>:
            // predicted unlikely by continue predictor.
            goto <D.22114>;
            <D.29795>:
            <D.29791>:
            {
              void * * __p;

              D.29796 = info->names;
              D.29797 = (long unsigned int) j;
              __p = mono_array_addr_with_size (D.29796, 8, D.29797);
              D.29796 = info->names;
              D.29798 = mono_field_get_name (field);
              D.29799 = mono_string_new (domain, D.29798);
              mono_gc_wbarrier_set_arrayref (D.29796, __p, D.29799);
            }
            p.157 = mono_class_get_field_default_value (field, &def_type);
            p = p.157;
            p.158 = p;
            D.29802 = mono_metadata_decode_blob_size (p.158, &p);
            len = (int) D.29802;
            D.29803 = mono_class_enum_basetype (enumc);
            D.29804 = D.29803->type;
            D.29805 = (int) D.29804;
            switch (D.29805) <default: <D.22130>, case 3: <D.22120>, case 4: <D.22117>, case 5: <D.22116>, case 6: <D.22122>, case 7: <D.22121>, case 8: <D.22125>, case 9: <D.22124>, case 10: <D.22128>, case 11: <D.22127>>
            <D.22116>:
            <D.22117>:
            {
              gchar * __p;

              D.29806 = info->values;
              D.29797 = (long unsigned int) j;
              __p = mono_array_addr_with_size (D.29806, 1, D.29797);
              p.158 = p;
              D.29807 = *p.158;
              *__p = D.29807;
            }
            goto <D.22119>;
            <D.22120>:
            <D.22121>:
            <D.22122>:
            {
              gint16 * __p;

              D.29806 = info->values;
              D.29797 = (long unsigned int) j;
              __p = mono_array_addr_with_size (D.29806, 2, D.29797);
              p.158 = p;
              D.29808 = MEM[(const guint16 *)p.158];
              D.29809 = D.29808 >> 8;
              D.29810 = (short int) D.29809;
              p.158 = p;
              D.29808 = MEM[(const guint16 *)p.158];
              D.29811 = (int) D.29808;
              D.29812 = D.29811 << 8;
              D.29813 = (short int) D.29812;
              D.29814 = D.29810 | D.29813;
              *__p = D.29814;
            }
            goto <D.22119>;
            <D.22124>:
            <D.22125>:
            {
              gint32 * __p;

              D.29806 = info->values;
              D.29797 = (long unsigned int) j;
              __p = mono_array_addr_with_size (D.29806, 4, D.29797);
              p.158 = p;
              D.29815 = MEM[(const guint32 *)p.158];
              D.29816 = D.29815 << 24;
              p.158 = p;
              D.29815 = MEM[(const guint32 *)p.158];
              D.29817 = D.29815 >> 8;
              D.29818 = D.29817 & 65280;
              D.29819 = D.29816 | D.29818;
              p.158 = p;
              D.29815 = MEM[(const guint32 *)p.158];
              D.29820 = D.29815 << 8;
              D.29821 = D.29820 & 16711680;
              D.29822 = D.29819 | D.29821;
              p.158 = p;
              D.29815 = MEM[(const guint32 *)p.158];
              D.29823 = D.29815 >> 24;
              D.29824 = D.29822 | D.29823;
              D.29825 = (int) D.29824;
              *__p = D.29825;
            }
            goto <D.22119>;
            <D.22127>:
            <D.22128>:
            {
              gint64 * __p;

              D.29806 = info->values;
              D.29797 = (long unsigned int) j;
              __p = mono_array_addr_with_size (D.29806, 8, D.29797);
              p.158 = p;
              D.29826 = MEM[(const guint64 *)p.158];
              D.29827 = (unsigned int) D.29826;
              D.29828 = D.29827 << 24;
              p.158 = p;
              D.29826 = MEM[(const guint64 *)p.158];
              D.29827 = (unsigned int) D.29826;
              D.29829 = D.29827 >> 8;
              D.29830 = D.29829 & 65280;
              D.29831 = D.29828 | D.29830;
              p.158 = p;
              D.29826 = MEM[(const guint64 *)p.158];
              D.29827 = (unsigned int) D.29826;
              D.29832 = D.29827 << 8;
              D.29833 = D.29832 & 16711680;
              D.29834 = D.29831 | D.29833;
              p.158 = p;
              D.29826 = MEM[(const guint64 *)p.158];
              D.29827 = (unsigned int) D.29826;
              D.29835 = D.29827 >> 24;
              D.29836 = D.29834 | D.29835;
              D.29837 = (long unsigned int) D.29836;
              D.29838 = D.29837 << 32;
              p.158 = p;
              D.29826 = MEM[(const guint64 *)p.158];
              D.29839 = D.29826 >> 32;
              D.29840 = (unsigned int) D.29839;
              D.29841 = D.29840 << 24;
              p.158 = p;
              D.29826 = MEM[(const guint64 *)p.158];
              D.29839 = D.29826 >> 32;
              D.29840 = (unsigned int) D.29839;
              D.29842 = D.29840 >> 8;
              D.29843 = D.29842 & 65280;
              D.29844 = D.29841 | D.29843;
              p.158 = p;
              D.29826 = MEM[(const guint64 *)p.158];
              D.29839 = D.29826 >> 32;
              D.29840 = (unsigned int) D.29839;
              D.29845 = D.29840 << 8;
              D.29846 = D.29845 & 16711680;
              D.29847 = D.29844 | D.29846;
              p.158 = p;
              D.29826 = MEM[(const guint64 *)p.158];
              D.29839 = D.29826 >> 32;
              D.29840 = (unsigned int) D.29839;
              D.29848 = D.29840 >> 24;
              D.29849 = D.29847 | D.29848;
              D.29850 = (long unsigned int) D.29849;
              D.29851 = D.29838 | D.29850;
              D.29852 = (long int) D.29851;
              *__p = D.29852;
            }
            goto <D.22119>;
            <D.22130>:
            D.29853 = mono_class_enum_basetype (enumc);
            D.29854 = D.29853->type;
            D.29855 = (int) D.29854;
            monoeg_g_log (0B, 4, "Implement type 0x%02x in get_enum_info", D.29855);
            <D.22131>:
            goto <D.22131>;
            <D.22119>:
            j = j + 1;
          }
        finally
          {
            p = {CLOBBER};
            def_type = {CLOBBER};
          }
      }
      <D.22114>:
      field = mono_class_get_fields (enumc, &iter);
      if (field != 0B) goto <D.22132>; else goto <D.22133>;
      <D.22133>:
    }
  finally
    {
      iter = {CLOBBER};
    }
}


custom_attrs_defined_internal (struct MonoObject * obj, struct MonoReflectionType * attr_type)
{
  struct MonoType * D.29858;
  MonoBoolean D.29861;
  int D.29862;
  struct MonoClass * attr_class;
  struct MonoCustomAttrInfo * cinfo;
  gboolean found;

  D.29858 = attr_type->type;
  attr_class = mono_class_from_mono_type (D.29858);
  mono_class_init_or_throw (attr_class);
  cinfo = mono_reflection_get_custom_attrs_info (obj);
  if (cinfo == 0B) goto <D.29859>; else goto <D.29860>;
  <D.29859>:
  D.29861 = 0;
  return D.29861;
  <D.29860>:
  found = mono_custom_attrs_has_attr (cinfo, attr_class);
  D.29862 = cinfo->cached;
  if (D.29862 == 0) goto <D.29863>; else goto <D.29864>;
  <D.29863>:
  mono_custom_attrs_free (cinfo);
  <D.29864>:
  D.29861 = (MonoBoolean) found;
  return D.29861;
}


custom_attrs_get_by_type (struct MonoObject * obj, struct MonoReflectionType * attr_type)
{
  struct MonoClass * iftmp.159;
  struct MonoType * D.29869;
  int D.29873;
  struct MonoLoaderError * D.29876;
  struct MonoLoaderError * D.29879;
  struct MonoException * D.29880;
  struct MonoArray * D.29881;
  struct MonoClass * attr_class;
  struct MonoArray * res;
  struct MonoError error;

  try
    {
      if (attr_type != 0B) goto <D.29867>; else goto <D.29868>;
      <D.29867>:
      D.29869 = attr_type->type;
      iftmp.159 = mono_class_from_mono_type (D.29869);
      goto <D.29870>;
      <D.29868>:
      iftmp.159 = 0B;
      <D.29870>:
      attr_class = iftmp.159;
      if (attr_class != 0B) goto <D.29871>; else goto <D.29872>;
      <D.29871>:
      mono_class_init_or_throw (attr_class);
      <D.29872>:
      res = mono_reflection_get_custom_attrs_by_type (obj, attr_class, &error);
      D.29873 = mono_error_ok (&error);
      if (D.29873 == 0) goto <D.29874>; else goto <D.29875>;
      <D.29874>:
      mono_error_raise_exception (&error);
      <D.29875>:
      D.29876 = mono_loader_get_last_error ();
      if (D.29876 != 0B) goto <D.29877>; else goto <D.29878>;
      <D.29877>:
      D.29879 = mono_loader_get_last_error ();
      D.29880 = mono_loader_error_prepare_exception (D.29879);
      mono_raise_exception (D.29880);
      monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "icall.c", 7569);
      D.29881 = 0B;
      return D.29881;
      <D.29878>:
      D.29881 = res;
      return D.29881;
    }
  finally
    {
      error = {CLOBBER};
    }
}


ves_icall_System_IO_get_temp_path ()
{
  struct MonoString * D.29884;
  struct MonoDomain * D.29885;
  const gchar * D.29886;

  D.29885 = mono_domain_get ();
  D.29886 = monoeg_g_get_tmp_dir ();
  D.29884 = mono_string_new (D.29885, D.29886);
  return D.29884;
}


ves_icall_System_IO_DriveInfo_GetDriveType (struct MonoString * root_path_name)
{
  guint32 D.29888;
  mono_unichar2 * D.29889;

  D.29889 = mono_string_chars (root_path_name);
  D.29888 = GetDriveType (D.29889);
  return D.29888;
}


ves_icall_System_IO_DriveInfo_GetDriveFormat (struct MonoString * path)
{
  mono_unichar2 * D.29891;
  int D.29892;
  struct MonoString * D.29895;
  gunichar2 volume_name[261];

  try
    {
      D.29891 = mono_string_chars (path);
      D.29892 = GetVolumeInformation (D.29891, 0B, 0, 0B, 0B, 0B, &volume_name, 261);
      if (D.29892 == 0) goto <D.29893>; else goto <D.29894>;
      <D.29893>:
      D.29895 = 0B;
      return D.29895;
      <D.29894>:
      D.29895 = mono_string_from_utf16 (&volume_name);
      return D.29895;
    }
  finally
    {
      volume_name = {CLOBBER};
    }
}


ves_icall_System_IO_DriveInfo_GetDiskFreeSpace (struct MonoString * path_name, guint64 * free_bytes_avail, guint64 * total_number_of_bytes, guint64 * total_number_of_free_bytes, gint32 * error)
{
  mono_unichar2 * D.29898;
  long unsigned int D.29901;
  long unsigned int D.29902;
  long unsigned int D.29903;
  unsigned int D.29905;
  int D.29906;
  MonoBoolean D.29907;
  gboolean result;
  union ULARGE_INTEGER wapi_free_bytes_avail;
  union ULARGE_INTEGER wapi_total_number_of_bytes;
  union ULARGE_INTEGER wapi_total_number_of_free_bytes;

  try
    {
      *error = 0;
      D.29898 = mono_string_chars (path_name);
      result = GetDiskFreeSpaceEx (D.29898, &wapi_free_bytes_avail, &wapi_total_number_of_bytes, &wapi_total_number_of_free_bytes);
      if (result != 0) goto <D.29899>; else goto <D.29900>;
      <D.29899>:
      D.29901 = wapi_free_bytes_avail.QuadPart;
      *free_bytes_avail = D.29901;
      D.29902 = wapi_total_number_of_bytes.QuadPart;
      *total_number_of_bytes = D.29902;
      D.29903 = wapi_total_number_of_free_bytes.QuadPart;
      *total_number_of_free_bytes = D.29903;
      goto <D.29904>;
      <D.29900>:
      *free_bytes_avail = 0;
      *total_number_of_bytes = 0;
      *total_number_of_free_bytes = 0;
      D.29905 = GetLastError ();
      D.29906 = (int) D.29905;
      *error = D.29906;
      <D.29904>:
      D.29907 = (MonoBoolean) result;
      return D.29907;
    }
  finally
    {
      wapi_free_bytes_avail = {CLOBBER};
      wapi_total_number_of_bytes = {CLOBBER};
      wapi_total_number_of_free_bytes = {CLOBBER};
    }
}


ves_icall_System_Environment_InternalGetHome ()
{
  struct MonoString * D.29910;
  struct MonoDomain * D.29911;
  const gchar * D.29912;

  D.29911 = mono_domain_get ();
  D.29912 = monoeg_g_get_home_dir ();
  D.29910 = mono_string_new (D.29911, D.29912);
  return D.29910;
}


ves_icall_System_Environment_GetGacPath ()
{
  struct MonoString * D.29914;
  struct MonoDomain * D.29915;
  const char * D.29916;

  D.29915 = mono_domain_get ();
  D.29916 = mono_assembly_getrootdir ();
  D.29914 = mono_string_new (D.29915, D.29916);
  return D.29914;
}


ves_icall_System_Environment_GetEnvironmentVariable (struct MonoString * name)
{
  struct MonoString * D.29920;
  struct MonoDomain * D.29923;
  const gchar * value;
  gchar * utf8_name;

  if (name == 0B) goto <D.29918>; else goto <D.29919>;
  <D.29918>:
  D.29920 = 0B;
  return D.29920;
  <D.29919>:
  utf8_name = mono_string_to_utf8 (name);
  value = monoeg_g_getenv (utf8_name);
  monoeg_g_free (utf8_name);
  if (value == 0B) goto <D.29921>; else goto <D.29922>;
  <D.29921>:
  D.29920 = 0B;
  return D.29920;
  <D.29922>:
  D.29923 = mono_domain_get ();
  D.29920 = mono_string_new (D.29923, value);
  return D.29920;
}


ves_icall_System_Environment_BroadcastSettingChange ()
{

}


ves_icall_System_Environment_get_Platform ()
{
  int D.29925;

  D.29925 = 4;
  return D.29925;
}


ves_icall_System_Environment_get_MachineName ()
{
  int D.29927;
  struct MonoDomain * D.29930;
  struct MonoString * D.29932;
  gchar buf[256];
  struct MonoString * result;

  try
    {
      D.29927 = gethostname (&buf, 256);
      if (D.29927 == 0) goto <D.29928>; else goto <D.29929>;
      <D.29928>:
      D.29930 = mono_domain_get ();
      result = mono_string_new (D.29930, &buf);
      goto <D.29931>;
      <D.29929>:
      result = 0B;
      <D.29931>:
      D.29932 = result;
      return D.29932;
    }
  finally
    {
      buf = {CLOBBER};
    }
}


__attribute__((__artificial__, __gnu_inline__, __always_inline__, __leaf__, __nothrow__))
gethostname (char * __buf, size_t __buflen)
{
  long unsigned int D.29935;
  int D.29938;
  int D.29941;
  long unsigned int D.29942;
  long unsigned int D.29943;
  long unsigned int D.29946;

  D.29935 = __builtin_object_size (__buf, 1);
  if (D.29935 != 18446744073709551615) goto <D.29936>; else goto <D.29937>;
  <D.29936>:
  D.29938 = __builtin_constant_p (__buflen);
  if (D.29938 == 0) goto <D.29939>; else goto <D.29940>;
  <D.29939>:
  D.29942 = __builtin_object_size (__buf, 1);
  D.29941 = __gethostname_chk (__buf, __buflen, D.29942);
  return D.29941;
  <D.29940>:
  D.29943 = __builtin_object_size (__buf, 1);
  if (D.29943 < __buflen) goto <D.29944>; else goto <D.29945>;
  <D.29944>:
  D.29946 = __builtin_object_size (__buf, 1);
  D.29941 = __gethostname_chk_warn (__buf, __buflen, D.29946);
  return D.29941;
  <D.29945>:
  <D.29937>:
  D.29941 = __gethostname_alias (__buf, __buflen);
  return D.29941;
}


ves_icall_System_Environment_get_HasShutdownStarted ()
{
  int D.29948;
  MonoBoolean D.29951;
  struct MonoDomain * D.29952;
  int D.29953;

  D.29948 = mono_runtime_is_shutting_down ();
  if (D.29948 != 0) goto <D.29949>; else goto <D.29950>;
  <D.29949>:
  D.29951 = 1;
  return D.29951;
  <D.29950>:
  D.29952 = mono_domain_get ();
  D.29953 = mono_domain_is_unloading (D.29952);
  if (D.29953 != 0) goto <D.29954>; else goto <D.29955>;
  <D.29954>:
  D.29951 = 1;
  return D.29951;
  <D.29955>:
  D.29951 = 0;
  return D.29951;
}


ves_icall_System_Environment_InternalSetEnvironmentVariable (struct MonoString * name, struct MonoString * value)
{
  int D.29960;
  mono_unichar2 * D.29962;
  short unsigned int D.29963;
  int D.29964;
  struct MonoError error;
  gchar * utf8_name;
  gchar * utf8_value;

  try
    {
      utf8_name = mono_string_to_utf8 (name);
      if (value == 0B) goto <D.29957>; else goto <D.29959>;
      <D.29959>:
      D.29960 = mono_string_length (value);
      if (D.29960 == 0) goto <D.29957>; else goto <D.29961>;
      <D.29961>:
      D.29962 = mono_string_chars (value);
      D.29963 = *D.29962;
      if (D.29963 == 0) goto <D.29957>; else goto <D.29958>;
      <D.29957>:
      monoeg_g_unsetenv (utf8_name);
      monoeg_g_free (utf8_name);
      return;
      <D.29958>:
      utf8_value = mono_string_to_utf8_checked (value, &error);
      D.29964 = mono_error_ok (&error);
      if (D.29964 == 0) goto <D.29965>; else goto <D.29966>;
      <D.29965>:
      monoeg_g_free (utf8_name);
      mono_error_raise_exception (&error);
      <D.29966>:
      monoeg_g_setenv (utf8_name, utf8_value, 1);
      monoeg_g_free (utf8_name);
      monoeg_g_free (utf8_value);
    }
  finally
    {
      error = {CLOBBER};
    }
}


ves_icall_System_Environment_GetWindowsFolderPath (int folder)
{
  struct MonoString * D.29970;
  struct MonoDomain * D.29971;

  monoeg_g_log (0B, 16, "ves_icall_System_Environment_GetWindowsFolderPath should only be called on Windows!");
  D.29971 = mono_domain_get ();
  D.29970 = mono_string_new (D.29971, "");
  return D.29970;
}


ves_icall_System_Environment_get_NewLine ()
{
  struct MonoString * D.29973;
  struct MonoDomain * D.29974;

  D.29974 = mono_domain_get ();
  D.29973 = mono_string_new (D.29974, "\n");
  return D.29973;
}


ves_icall_System_Environment_GetLogicalDrives ()
{
  int D.29976;
  unsigned int D.29981;
  long unsigned int D.29982;
  long unsigned int D.29983;
  gunichar2 * dname.160;
  short unsigned int D.29985;
  short unsigned int D.29986;
  struct MonoClass * D.29987;
  long unsigned int D.29988;
  short unsigned int D.29989;
  int ndrives.161;
  long unsigned int D.29991;
  gunichar2 * dname.162;
  short unsigned int D.29993;
  struct MonoArray * D.29996;
  gunichar2 buf[256];
  gunichar2 * ptr;
  gunichar2 * dname;
  gunichar2 * u16;
  guint initial_size;
  guint size;
  gint ndrives;
  struct MonoArray * result;
  struct MonoString * drivestr;
  struct MonoDomain * domain;
  gint len;

  try
    {
      initial_size = 127;
      size = 128;
      domain = mono_domain_get ();
      buf[0] = 0;
      ptr = &buf;
      goto <D.23189>;
      <D.23188>:
      D.29976 = GetLogicalDriveStrings (initial_size, ptr);
      size = (guint) D.29976;
      if (size > initial_size) goto <D.29977>; else goto <D.29978>;
      <D.29977>:
      if (&buf != ptr) goto <D.29979>; else goto <D.29980>;
      <D.29979>:
      monoeg_g_free (ptr);
      <D.29980>:
      D.29981 = size + 1;
      D.29982 = (long unsigned int) D.29981;
      D.29983 = D.29982 * 2;
      ptr = monoeg_malloc0 (D.29983);
      initial_size = size;
      size = size + 1;
      <D.29978>:
      <D.23189>:
      if (size > initial_size) goto <D.23188>; else goto <D.23190>;
      <D.23190>:
      dname = ptr;
      ndrives = 0;
      <D.23194>:
      goto <D.23192>;
      <D.23191>:
      <D.23192>:
      dname.160 = dname;
      dname = dname.160 + 2;
      D.29985 = *dname.160;
      if (D.29985 != 0) goto <D.23191>; else goto <D.23193>;
      <D.23193>:
      ndrives = ndrives + 1;
      D.29986 = *dname;
      if (D.29986 != 0) goto <D.23194>; else goto <D.23195>;
      <D.23195>:
      dname = ptr;
      D.29987 = mono_defaults.string_class;
      D.29988 = (long unsigned int) ndrives;
      result = mono_array_new (domain, D.29987, D.29988);
      ndrives = 0;
      <D.23203>:
      len = 0;
      u16 = dname;
      goto <D.23197>;
      <D.23196>:
      u16 = u16 + 2;
      len = len + 1;
      <D.23197>:
      D.29989 = *u16;
      if (D.29989 != 0) goto <D.23196>; else goto <D.23198>;
      <D.23198>:
      drivestr = mono_string_new_utf16 (domain, dname, len);
      {
        void * * __p;

        ndrives.161 = ndrives;
        ndrives = ndrives.161 + 1;
        D.29991 = (long unsigned int) ndrives.161;
        __p = mono_array_addr_with_size (result, 8, D.29991);
        mono_gc_wbarrier_set_arrayref (result, __p, drivestr);
      }
      goto <D.23201>;
      <D.23200>:
      <D.23201>:
      dname.162 = dname;
      dname = dname.162 + 2;
      D.29993 = *dname.162;
      if (D.29993 != 0) goto <D.23200>; else goto <D.23202>;
      <D.23202>:
      D.29986 = *dname;
      if (D.29986 != 0) goto <D.23203>; else goto <D.23204>;
      <D.23204>:
      if (&buf != ptr) goto <D.29994>; else goto <D.29995>;
      <D.29994>:
      monoeg_g_free (ptr);
      <D.29995>:
      D.29996 = result;
      return D.29996;
    }
  finally
    {
      buf = {CLOBBER};
    }
}


ves_icall_System_Environment_GetEnvironmentVariableNames ()
{
  gchar * D.29999;
  struct MonoClass * D.30000;
  long unsigned int D.30001;
  gchar * D.30002;
  struct MonoArray * D.30005;
  struct MonoArray * names;
  struct MonoDomain * domain;
  struct MonoString * str;
  gchar * * e;
  gchar * * parts;
  int n;

  n = 0;
  e = environ;
  goto <D.23152>;
  <D.23151>:
  n = n + 1;
  e = e + 8;
  <D.23152>:
  D.29999 = *e;
  if (D.29999 != 0B) goto <D.23151>; else goto <D.23153>;
  <D.23153>:
  domain = mono_domain_get ();
  D.30000 = mono_defaults.string_class;
  D.30001 = (long unsigned int) n;
  names = mono_array_new (domain, D.30000, D.30001);
  n = 0;
  e = environ;
  goto <D.23156>;
  <D.23155>:
  D.29999 = *e;
  parts = monoeg_g_strsplit (D.29999, "=", 2);
  D.30002 = *parts;
  if (D.30002 != 0B) goto <D.30003>; else goto <D.30004>;
  <D.30003>:
  D.30002 = *parts;
  str = mono_string_new (domain, D.30002);
  {
    void * * __p;

    D.30001 = (long unsigned int) n;
    __p = mono_array_addr_with_size (names, 8, D.30001);
    mono_gc_wbarrier_set_arrayref (names, __p, str);
  }
  <D.30004>:
  monoeg_g_strfreev (parts);
  n = n + 1;
  e = e + 8;
  <D.23156>:
  D.29999 = *e;
  if (D.29999 != 0B) goto <D.23155>; else goto <D.23157>;
  <D.23157>:
  D.30005 = names;
  return D.30005;
}


ves_icall_System_Environment_Exit (int result)
{
  int D.30007;

  mono_environment_exitcode_set (result);
  D.30007 = mono_runtime_try_shutdown ();
  if (D.30007 == 0) goto <D.30008>; else goto <D.30009>;
  <D.30008>:
  mono_thread_exit ();
  <D.30009>:
  mono_thread_suspend_all_other_threads ();
  mono_runtime_quit ();
  exit (result);
}


ves_icall_System_Enum_get_value (struct MonoObject * this)
{
  struct MonoObject * D.30012;
  struct MonoVTable * D.30013;
  struct MonoClass * D.30014;
  long unsigned int D.30015;
  long unsigned int D.30016;
  _Bool D.30017;
  long int D.30018;
  long int D.30019;
  struct MonoType * D.30022;
  struct MonoDomain * D.30023;
  long unsigned int D.30024;
  struct MonoObject * res;
  struct MonoClass * enumc;
  void * dst;
  void * src;
  int size;

  if (this == 0B) goto <D.30010>; else goto <D.30011>;
  <D.30010>:
  D.30012 = 0B;
  return D.30012;
  <D.30011>:
  D.30013 = this->vtable;
  D.30014 = D.30013->klass;
  D.30015 = BIT_FIELD_REF <*D.30014, 64, 256>;
  D.30016 = D.30015 & 576460752303423488;
  D.30017 = D.30016 == 0;
  D.30018 = (long int) D.30017;
  D.30019 = __builtin_expect (D.30018, 0);
  if (D.30019 != 0) goto <D.30020>; else goto <D.30021>;
  <D.30020>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 3088, "this->vtable->klass->enumtype");
  <D.30021>:
  D.30013 = this->vtable;
  D.30014 = D.30013->klass;
  D.30022 = mono_class_enum_basetype (D.30014);
  enumc = mono_class_from_mono_type (D.30022);
  D.30013 = this->vtable;
  D.30023 = D.30013->domain;
  res = mono_object_new (D.30023, enumc);
  dst = res + 16;
  src = this + 16;
  size = mono_class_value_size (enumc, 0B);
  D.30024 = (long unsigned int) size;
  memcpy (dst, src, D.30024);
  D.30012 = res;
  return D.30012;
}


ves_icall_System_Enum_get_underlying_type (struct MonoReflectionType * type)
{
  struct MonoType * D.30026;
  struct MonoException * D.30029;
  struct MonoReflectionType * D.30030;
  struct MonoVTable * D.30031;
  struct MonoDomain * D.30032;
  struct MonoType * etype;
  struct MonoClass * klass;

  D.30026 = type->type;
  klass = mono_class_from_mono_type (D.30026);
  mono_class_init_or_throw (klass);
  etype = mono_class_enum_basetype (klass);
  if (etype == 0B) goto <D.30027>; else goto <D.30028>;
  <D.30027>:
  D.30029 = mono_get_exception_argument ("Type must be a type provided by the runtime.", "enumType");
  mono_raise_exception (D.30029);
  <D.30028>:
  D.30031 = MEM[(struct MonoObject *)type].vtable;
  D.30032 = D.30031->domain;
  D.30030 = mono_type_get_object (D.30032, etype);
  return D.30030;
}


ves_icall_System_Enum_get_hashcode (struct MonoObject * this)
{
  struct MonoVTable * D.30034;
  struct MonoClass * D.30035;
  _Bool D.30036;
  long int D.30037;
  long int D.30038;
  unsigned char D.30041;
  int D.30042;
  int D.30043;
  signed char D.30044;
  unsigned char D.30045;
  short unsigned int D.30046;
  short int D.30047;
  unsigned int D.30048;
  int D.30049;
  long int D.30050;
  int D.30051;
  void * data;
  struct MonoType * basetype;

  data = this + 16;
  D.30034 = this->vtable;
  D.30035 = D.30034->klass;
  basetype = mono_class_enum_basetype (D.30035);
  D.30036 = basetype == 0B;
  D.30037 = (long int) D.30036;
  D.30038 = __builtin_expect (D.30037, 0);
  if (D.30038 != 0) goto <D.30039>; else goto <D.30040>;
  <D.30039>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 3175, "basetype");
  <D.30040>:
  D.30041 = basetype->type;
  D.30042 = (int) D.30041;
  switch (D.30042) <default: <D.22098>, case 3: <D.22090>, case 4: <D.22088>, case 5: <D.22089>, case 6: <D.22092>, case 7: <D.22091>, case 8: <D.22094>, case 9: <D.22093>, case 10: <D.22096>, case 11: <D.22095>>
  <D.22088>:
  D.30044 = MEM[(gint8 *)data];
  D.30043 = (int) D.30044;
  return D.30043;
  <D.22089>:
  D.30045 = MEM[(guint8 *)data];
  D.30043 = (int) D.30045;
  return D.30043;
  <D.22090>:
  <D.22091>:
  D.30046 = MEM[(guint16 *)data];
  D.30043 = (int) D.30046;
  return D.30043;
  <D.22092>:
  D.30047 = MEM[(gint16 *)data];
  D.30043 = (int) D.30047;
  return D.30043;
  <D.22093>:
  D.30048 = MEM[(guint32 *)data];
  D.30043 = (int) D.30048;
  return D.30043;
  <D.22094>:
  D.30043 = MEM[(gint32 *)data];
  return D.30043;
  <D.22095>:
  <D.22096>:
  {
    gint64 value;

    value = MEM[(gint64 *)data];
    D.30049 = (int) value;
    D.30050 = value >> 32;
    D.30051 = (int) D.30050;
    D.30043 = D.30049 ^ D.30051;
    return D.30043;
  }
  <D.22098>:
  D.30041 = basetype->type;
  D.30042 = (int) D.30041;
  monoeg_g_log (0B, 4, "Implement type 0x%02x in get_hashcode", D.30042);
  <D.22099>:
  goto <D.22099>;
  D.30043 = 0;
  return D.30043;
}


ves_icall_System_Enum_compare_value_to (struct MonoObject * this, struct MonoObject * other)
{
  struct MonoVTable * D.30053;
  struct MonoClass * D.30054;
  _Bool D.30055;
  long int D.30056;
  long int D.30057;
  unsigned char D.30060;
  int D.30061;
  int D.30064;
  int iftmp.163;
  int iftmp.164;
  int D.30077;
  int D.30078;
  int iftmp.165;
  int iftmp.166;
  int iftmp.167;
  int iftmp.168;
  int iftmp.169;
  void * tdata;
  void * odata;
  struct MonoType * basetype;

  tdata = this + 16;
  odata = other + 16;
  D.30053 = this->vtable;
  D.30054 = D.30053->klass;
  basetype = mono_class_enum_basetype (D.30054);
  D.30055 = basetype == 0B;
  D.30056 = (long int) D.30055;
  D.30057 = __builtin_expect (D.30056, 0);
  if (D.30057 != 0) goto <D.30058>; else goto <D.30059>;
  <D.30058>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 3126, "basetype");
  <D.30059>:
  D.30060 = basetype->type;
  D.30061 = (int) D.30060;
  switch (D.30061) <default: <D.22081>, case 3: <D.22062>, case 4: <D.22059>, case 5: <D.22056>, case 6: <D.22066>, case 7: <D.22063>, case 8: <D.22072>, case 9: <D.22069>, case 10: <D.22078>, case 11: <D.22075>>
  <D.22056>:
  {
    guint8 me;
    guint8 other;

    me = MEM[(guint8 *)tdata];
    other = MEM[(guint8 *)odata];
    if (me == other) goto <D.30062>; else goto <D.30063>;
    <D.30062>:
    D.30064 = 0;
    return D.30064;
    <D.30063>:
    if (me > other) goto <D.30066>; else goto <D.30067>;
    <D.30066>:
    iftmp.163 = 1;
    goto <D.30068>;
    <D.30067>:
    iftmp.163 = -1;
    <D.30068>:
    D.30064 = iftmp.163;
    return D.30064;
  }
  <D.22059>:
  {
    gint8 me;
    gint8 other;

    me = MEM[(gint8 *)tdata];
    other = MEM[(gint8 *)odata];
    if (me == other) goto <D.30069>; else goto <D.30070>;
    <D.30069>:
    D.30064 = 0;
    return D.30064;
    <D.30070>:
    if (me > other) goto <D.30072>; else goto <D.30073>;
    <D.30072>:
    iftmp.164 = 1;
    goto <D.30074>;
    <D.30073>:
    iftmp.164 = -1;
    <D.30074>:
    D.30064 = iftmp.164;
    return D.30064;
  }
  <D.22062>:
  <D.22063>:
  {
    guint16 me;
    guint16 other;

    me = MEM[(guint16 *)tdata];
    other = MEM[(guint16 *)odata];
    if (me == other) goto <D.30075>; else goto <D.30076>;
    <D.30075>:
    D.30064 = 0;
    return D.30064;
    <D.30076>:
    D.30077 = (int) me;
    D.30078 = (int) other;
    D.30064 = D.30077 - D.30078;
    return D.30064;
  }
  <D.22066>:
  {
    gint16 me;
    gint16 other;

    me = MEM[(gint16 *)tdata];
    other = MEM[(gint16 *)odata];
    if (me == other) goto <D.30079>; else goto <D.30080>;
    <D.30079>:
    D.30064 = 0;
    return D.30064;
    <D.30080>:
    if (me > other) goto <D.30082>; else goto <D.30083>;
    <D.30082>:
    iftmp.165 = 1;
    goto <D.30084>;
    <D.30083>:
    iftmp.165 = -1;
    <D.30084>:
    D.30064 = iftmp.165;
    return D.30064;
  }
  <D.22069>:
  {
    guint32 me;
    guint32 other;

    me = MEM[(guint32 *)tdata];
    other = MEM[(guint32 *)odata];
    if (me == other) goto <D.30085>; else goto <D.30086>;
    <D.30085>:
    D.30064 = 0;
    return D.30064;
    <D.30086>:
    if (me > other) goto <D.30088>; else goto <D.30089>;
    <D.30088>:
    iftmp.166 = 1;
    goto <D.30090>;
    <D.30089>:
    iftmp.166 = -1;
    <D.30090>:
    D.30064 = iftmp.166;
    return D.30064;
  }
  <D.22072>:
  {
    gint32 me;
    gint32 other;

    me = MEM[(gint32 *)tdata];
    other = MEM[(gint32 *)odata];
    if (me == other) goto <D.30091>; else goto <D.30092>;
    <D.30091>:
    D.30064 = 0;
    return D.30064;
    <D.30092>:
    if (me > other) goto <D.30094>; else goto <D.30095>;
    <D.30094>:
    iftmp.167 = 1;
    goto <D.30096>;
    <D.30095>:
    iftmp.167 = -1;
    <D.30096>:
    D.30064 = iftmp.167;
    return D.30064;
  }
  <D.22075>:
  {
    guint64 me;
    guint64 other;

    me = MEM[(guint64 *)tdata];
    other = MEM[(guint64 *)odata];
    if (me == other) goto <D.30097>; else goto <D.30098>;
    <D.30097>:
    D.30064 = 0;
    return D.30064;
    <D.30098>:
    if (me > other) goto <D.30100>; else goto <D.30101>;
    <D.30100>:
    iftmp.168 = 1;
    goto <D.30102>;
    <D.30101>:
    iftmp.168 = -1;
    <D.30102>:
    D.30064 = iftmp.168;
    return D.30064;
  }
  <D.22078>:
  {
    gint64 me;
    gint64 other;

    me = MEM[(gint64 *)tdata];
    other = MEM[(gint64 *)odata];
    if (me == other) goto <D.30103>; else goto <D.30104>;
    <D.30103>:
    D.30064 = 0;
    return D.30064;
    <D.30104>:
    if (me > other) goto <D.30106>; else goto <D.30107>;
    <D.30106>:
    iftmp.169 = 1;
    goto <D.30108>;
    <D.30107>:
    iftmp.169 = -1;
    <D.30108>:
    D.30064 = iftmp.169;
    return D.30064;
  }
  <D.22081>:
  D.30060 = basetype->type;
  D.30061 = (int) D.30060;
  monoeg_g_log (0B, 4, "Implement type 0x%02x in get_hashcode", D.30061);
  <D.22082>:
  goto <D.22082>;
  D.30064 = 0;
  return D.30064;
}


ves_icall_System_Enum_ToObject (struct MonoReflectionType * enumType, struct MonoObject * value)
{
  _Bool D.30110;
  long int D.30111;
  long int D.30112;
  _Bool D.30117;
  long int D.30118;
  long int D.30119;
  struct MonoVTable * D.30124;
  struct MonoType * D.30125;
  struct MonoVTable * D.30126;
  long unsigned int D.30127;
  long unsigned int D.30128;
  struct MonoException * D.30131;
  long unsigned int D.30132;
  long unsigned int D.30133;
  unsigned char D.30136;
  unsigned char D.30137;
  struct MonoException * D.30140;
  struct MonoException * D.30143;
  char * D.30144;
  int iftmp.170;
  struct MonoType * D.30148;
  unsigned char D.30149;
  char * D.30151;
  unsigned char D.30152;
  int D.30153;
  struct MonoObject * D.30154;
  struct MonoDomain * domain;
  struct MonoClass * enumc;
  struct MonoClass * objc;
  struct MonoObject * res;
  struct MonoType * etype;
  guint64 val;

  D.30110 = enumType == 0B;
  D.30111 = (long int) D.30110;
  D.30112 = __builtin_expect (D.30111, 0);
  if (D.30112 != 0) goto <D.30113>; else goto <D.30114>;
  <D.30113>:
  {
    struct MonoException * ex;

    if (enumType != 0B) goto <D.30115>; else goto <D.30116>;
    <D.30115>:
    <D.30116>:
    ex = mono_get_exception_argument_null ("enumType");
    mono_raise_exception (ex);
  }
  <D.30114>:
  D.30117 = value == 0B;
  D.30118 = (long int) D.30117;
  D.30119 = __builtin_expect (D.30118, 0);
  if (D.30119 != 0) goto <D.30120>; else goto <D.30121>;
  <D.30120>:
  {
    struct MonoException * ex;

    if (value != 0B) goto <D.30122>; else goto <D.30123>;
    <D.30122>:
    <D.30123>:
    ex = mono_get_exception_argument_null ("value");
    mono_raise_exception (ex);
  }
  <D.30121>:
  D.30124 = MEM[(struct MonoObject *)enumType].vtable;
  domain = D.30124->domain;
  D.30125 = enumType->type;
  enumc = mono_class_from_mono_type (D.30125);
  mono_class_init_or_throw (enumc);
  D.30126 = value->vtable;
  objc = D.30126->klass;
  D.30127 = BIT_FIELD_REF <*enumc, 64, 256>;
  D.30128 = D.30127 & 576460752303423488;
  if (D.30128 == 0) goto <D.30129>; else goto <D.30130>;
  <D.30129>:
  D.30131 = mono_get_exception_argument ("enumType", "Type provided must be an Enum.");
  mono_raise_exception (D.30131);
  <D.30130>:
  D.30132 = BIT_FIELD_REF <*objc, 64, 256>;
  D.30133 = D.30132 & 576460752303423488;
  if (D.30133 == 0) goto <D.30134>; else goto <D.30135>;
  <D.30134>:
  D.30136 = objc->byval_arg.type;
  D.30137 = D.30136 + 252;
  if (D.30137 > 7) goto <D.30138>; else goto <D.30139>;
  <D.30138>:
  D.30140 = mono_get_exception_argument ("value", "The value passed in must be an enum base or an underlying type for an enum, such as an Int32.");
  mono_raise_exception (D.30140);
  <D.30139>:
  <D.30135>:
  etype = mono_class_enum_basetype (enumc);
  if (etype == 0B) goto <D.30141>; else goto <D.30142>;
  <D.30141>:
  D.30143 = mono_get_exception_argument ("Type must be a type provided by the runtime.", "enumType");
  mono_raise_exception (D.30143);
  <D.30142>:
  res = mono_object_new (domain, enumc);
  D.30144 = value + 16;
  D.30132 = BIT_FIELD_REF <*objc, 64, 256>;
  D.30133 = D.30132 & 576460752303423488;
  if (D.30133 != 0) goto <D.30146>; else goto <D.30147>;
  <D.30146>:
  D.30148 = mono_class_enum_basetype (objc);
  D.30149 = D.30148->type;
  iftmp.170 = (int) D.30149;
  goto <D.30150>;
  <D.30147>:
  D.30136 = objc->byval_arg.type;
  iftmp.170 = (int) D.30136;
  <D.30150>:
  val = read_enum_value (D.30144, iftmp.170);
  D.30151 = res + 16;
  D.30152 = etype->type;
  D.30153 = (int) D.30152;
  write_enum_value (D.30151, D.30153, val);
  D.30154 = res;
  return D.30154;
}


read_enum_value (char * mem, int type)
{
  guint64 D.30156;
  unsigned char D.30157;
  signed char D.30158;
  short unsigned int D.30159;
  short int D.30160;
  unsigned int D.30161;
  int D.30162;
  long int D.30163;

  switch (type) <default: <D.22004>, case 4: <D.21997>, case 5: <D.21996>, case 6: <D.21999>, case 7: <D.21998>, case 8: <D.22001>, case 9: <D.22000>, case 10: <D.22003>, case 11: <D.22002>>
  <D.21996>:
  D.30157 = MEM[(guint8 *)mem];
  D.30156 = (guint64) D.30157;
  return D.30156;
  <D.21997>:
  D.30158 = MEM[(gint8 *)mem];
  D.30156 = (guint64) D.30158;
  return D.30156;
  <D.21998>:
  D.30159 = MEM[(guint16 *)mem];
  D.30156 = (guint64) D.30159;
  return D.30156;
  <D.21999>:
  D.30160 = MEM[(gint16 *)mem];
  D.30156 = (guint64) D.30160;
  return D.30156;
  <D.22000>:
  D.30161 = MEM[(guint32 *)mem];
  D.30156 = (guint64) D.30161;
  return D.30156;
  <D.22001>:
  D.30162 = MEM[(gint32 *)mem];
  D.30156 = (guint64) D.30162;
  return D.30156;
  <D.22002>:
  D.30156 = MEM[(guint64 *)mem];
  return D.30156;
  <D.22003>:
  D.30163 = MEM[(gint64 *)mem];
  D.30156 = (guint64) D.30163;
  return D.30156;
  <D.22004>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "icall.c", 2997);
  D.30156 = 0;
  return D.30156;
}


write_enum_value (char * mem, int type, guint64 value)
{
  unsigned char D.30165;
  short unsigned int D.30166;
  unsigned int D.30167;

  switch (type) <default: <D.22023>, case 4: <D.22011>, case 5: <D.22010>, case 6: <D.22015>, case 7: <D.22014>, case 8: <D.22018>, case 9: <D.22017>, case 10: <D.22021>, case 11: <D.22020>>
  <D.22010>:
  <D.22011>:
  {
    guint8 * p;

    p = mem;
    D.30165 = (unsigned char) value;
    *p = D.30165;
    goto <D.22013>;
  }
  <D.22014>:
  <D.22015>:
  {
    guint16 * p;

    p = mem;
    D.30166 = (short unsigned int) value;
    *p = D.30166;
    goto <D.22013>;
  }
  <D.22017>:
  <D.22018>:
  {
    guint32 * p;

    p = mem;
    D.30167 = (unsigned int) value;
    *p = D.30167;
    goto <D.22013>;
  }
  <D.22020>:
  <D.22021>:
  {
    guint64 * p;

    p = mem;
    *p = value;
    goto <D.22013>;
  }
  <D.22023>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "icall.c", 3031);
  <D.22013>:
  return;
}


mono_double_ParseImpl (char * ptr, double * result)
{
  char D.30169;
  _Bool D.30174;
  long int D.30175;
  long int D.30176;
  double D.30179;
  _Bool D.30182;
  long int D.30183;
  long int D.30184;
  gchar * endptr.171;
  char D.30192;
  gboolean D.30193;
  gchar * endptr;

  try
    {
      endptr = 0B;
      *result = 0.0;
      D.30169 = *ptr;
      if (D.30169 != 0) goto <D.30170>; else goto <D.30171>;
      <D.30170>:
      {
        int ret;

        ret = pthread_mutex_lock (&mono_strtod_mutex.mutex);
        if (ret != 0) goto <D.30172>; else goto <D.30173>;
        <D.30172>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
        <D.30173>:
        D.30174 = ret != 0;
        D.30175 = (long int) D.30174;
        D.30176 = __builtin_expect (D.30175, 0);
        if (D.30176 != 0) goto <D.30177>; else goto <D.30178>;
        <D.30177>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 133, "ret == 0");
        <D.30178>:
      }
      D.30179 = mono_strtod (ptr, &endptr);
      *result = D.30179;
      {
        int ret;

        ret = pthread_mutex_unlock (&mono_strtod_mutex.mutex);
        if (ret != 0) goto <D.30180>; else goto <D.30181>;
        <D.30180>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.30181>:
        D.30182 = ret != 0;
        D.30183 = (long int) D.30182;
        D.30184 = __builtin_expect (D.30183, 0);
        if (D.30184 != 0) goto <D.30185>; else goto <D.30186>;
        <D.30185>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 135, "ret == 0");
        <D.30186>:
      }
      <D.30171>:
      D.30169 = *ptr;
      if (D.30169 == 0) goto <D.30187>; else goto <D.30189>;
      <D.30189>:
      endptr.171 = endptr;
      if (endptr.171 != 0B) goto <D.30191>; else goto <D.30188>;
      <D.30191>:
      endptr.171 = endptr;
      D.30192 = *endptr.171;
      if (D.30192 != 0) goto <D.30187>; else goto <D.30188>;
      <D.30187>:
      D.30193 = 0;
      return D.30193;
      <D.30188>:
      D.30193 = 1;
      return D.30193;
    }
  finally
    {
      endptr = {CLOBBER};
    }
}


ves_icall_System_Diagnostics_DefaultTraceListener_WriteWindowsDebugString (struct MonoString * message)
{
  monoeg_g_log (0B, 16, "WriteWindowsDebugString called and HOST_WIN32 not defined!\n");
}


ves_icall_System_Diagnostics_Debugger_Log (int level, struct MonoString * category, struct MonoString * message)
{
  struct MonoRuntimeCallbacks * D.30196;
  void (*<T2908>) (int, struct MonoString *, struct MonoString *) D.30197;
  struct MonoRuntimeCallbacks * D.30200;
  void (*<T2908>) (int, struct MonoString *, struct MonoString *) D.30201;

  D.30196 = mono_get_runtime_callbacks ();
  D.30197 = D.30196->debug_log;
  if (D.30197 != 0B) goto <D.30198>; else goto <D.30199>;
  <D.30198>:
  D.30200 = mono_get_runtime_callbacks ();
  D.30201 = D.30200->debug_log;
  D.30201 (level, category, message);
  <D.30199>:
}


ves_icall_System_Diagnostics_Debugger_IsLogging ()
{
  struct MonoRuntimeCallbacks * D.30202;
  gboolean (*<T290c>) (void) D.30203;
  MonoBoolean D.30206;
  struct MonoRuntimeCallbacks * D.30207;
  gboolean (*<T290c>) (void) D.30208;
  int D.30209;

  D.30202 = mono_get_runtime_callbacks ();
  D.30203 = D.30202->debug_log_is_enabled;
  if (D.30203 != 0B) goto <D.30204>; else goto <D.30205>;
  <D.30204>:
  D.30207 = mono_get_runtime_callbacks ();
  D.30208 = D.30207->debug_log_is_enabled;
  D.30209 = D.30208 ();
  D.30206 = (MonoBoolean) D.30209;
  return D.30206;
  <D.30205>:
  D.30206 = 0;
  return D.30206;
}


ves_icall_System_Diagnostics_Debugger_IsAttached_internal ()
{
  MonoBoolean D.30211;
  int D.30212;

  D.30212 = mono_is_debugger_attached ();
  D.30211 = (MonoBoolean) D.30212;
  return D.30211;
}


ves_icall_System_Delegate_SetMulticastInvoke (struct MonoDelegate * this)
{
  struct MonoVTable * D.30214;
  struct MonoClass * D.30215;
  void * D.30216;

  D.30214 = this->object.vtable;
  D.30215 = D.30214->klass;
  D.30216 = mono_runtime_create_delegate_trampoline (D.30215);
  this->invoke_impl = D.30216;
}


ves_icall_System_Delegate_CreateDelegate_internal (struct MonoReflectionType * type, struct MonoObject * target, struct MonoReflectionMethod * info, MonoBoolean throwOnBindFailure)
{
  struct MonoType * D.30217;
  struct MonoClass * D.30218;
  struct MonoClass * D.30219;
  <unnamed type> D.30222;
  int D.30225;
  int D.30226;
  struct MonoObject * D.30229;
  struct MonoVTable * D.30230;
  struct MonoDomain * D.30231;
  long unsigned int D.30232;
  long unsigned int D.30233;
  short unsigned int D.30239;
  int D.30240;
  int D.30241;
  struct MonoClass * D.30244;
  struct MonoVTable * D.30245;
  struct MonoClass * D.30246;
  struct MonoDomain * D.30249;
  struct MonoDomain * D.30250;
  void * D.30251;
  struct MonoClass * delegate_class;
  struct MonoObject * delegate;
  void * func;
  struct MonoMethod * method;
  static const char __PRETTY_FUNCTION__[50] = "ves_icall_System_Delegate_CreateDelegate_internal";

  D.30217 = type->type;
  delegate_class = mono_class_from_mono_type (D.30217);
  method = info->method;
  mono_class_init_or_throw (delegate_class);
  D.30218 = delegate_class->parent;
  D.30219 = mono_defaults.multicastdelegate_class;
  if (D.30218 != D.30219) goto <D.30220>; else goto <D.30221>;
  <D.30220>:
  {
    struct MonoException * ex;
    char * msg;

    msg = monoeg_g_strdup_printf ("file %s: line %d (%s): assertion failed: (%s)", "icall.c", 5817, &__PRETTY_FUNCTION__, "delegate_class->parent == mono_defaults.multicastdelegate_class");
    ex = mono_get_exception_execution_engine (msg);
    monoeg_g_free (msg);
    mono_raise_exception (ex);
  }
  <D.30221>:
  D.30222 = mono_security_get_mode ();
  if (D.30222 == 1) goto <D.30223>; else goto <D.30224>;
  <D.30223>:
  D.30225 = (int) throwOnBindFailure;
  D.30226 = mono_security_core_clr_ensure_delegate_creation (method, D.30225);
  if (D.30226 == 0) goto <D.30227>; else goto <D.30228>;
  <D.30227>:
  D.30229 = 0B;
  return D.30229;
  <D.30228>:
  <D.30224>:
  D.30230 = MEM[(struct MonoObject *)type].vtable;
  D.30231 = D.30230->domain;
  delegate = mono_object_new (D.30231, delegate_class);
  D.30232 = BIT_FIELD_REF <*method, 64, 256>;
  D.30233 = D.30232 & 18014398509481984;
  if (D.30233 != 0) goto <D.30234>; else goto <D.30235>;
  <D.30234>:
  func = mono_compile_method (method);
  goto <D.30236>;
  <D.30235>:
  if (target != 0B) goto <D.30237>; else goto <D.30238>;
  <D.30237>:
  D.30239 = method->flags;
  D.30240 = (int) D.30239;
  D.30241 = D.30240 & 64;
  if (D.30241 != 0) goto <D.30242>; else goto <D.30243>;
  <D.30242>:
  D.30244 = method->klass;
  D.30245 = target->vtable;
  D.30246 = D.30245->klass;
  if (D.30244 != D.30246) goto <D.30247>; else goto <D.30248>;
  <D.30247>:
  method = mono_object_get_virtual_method (target, method);
  <D.30248>:
  <D.30243>:
  <D.30238>:
  D.30249 = mono_domain_get ();
  D.30250 = mono_domain_get ();
  D.30251 = mono_runtime_create_jump_trampoline (D.30250, method, 1);
  func = mono_create_ftnptr (D.30249, D.30251);
  <D.30236>:
  mono_delegate_ctor_with_method (delegate, target, func, method);
  D.30229 = delegate;
  return D.30229;
}


ves_icall_System_CurrentSystemTimeZone_GetTimeZoneData (guint32 year, struct MonoArray * * data, struct MonoArray * * names)
{
  _Bool D.30253;
  long int D.30254;
  long int D.30255;
  _Bool D.30260;
  long int D.30261;
  long int D.30262;
  struct MonoClass * D.30267;
  struct MonoArray * D.30268;
  struct MonoClass * D.30269;
  struct MonoArray * D.30270;
  unsigned int D.30271;
  int D.30272;
  long int t.172;
  unsigned int D.30276;
  long int t.173;
  long int t.174;
  struct tm * D.30280;
  struct MonoArray * D.30281;
  struct MonoString * D.30282;
  struct MonoString * D.30283;
  guint32 D.30284;
  int D.30285;
  long int t.175;
  struct tm * D.30287;
  int D.30288;
  long int t1.176;
  long int t1.177;
  struct tm * D.30293;
  int D.30294;
  long int D.30295;
  long int t1.178;
  struct tm * D.30297;
  int D.30298;
  long int D.30299;
  long int t1.179;
  int D.30301;
  struct MonoString * D.30304;
  struct MonoArray * D.30305;
  long unsigned int t1.180;
  long unsigned int D.30307;
  long unsigned int D.30308;
  long int D.30309;
  struct MonoString * D.30313;
  int D.30316;
  long int D.30319;
  long int D.30320;
  long int D.30321;
  int D.30322;
  struct MonoString * D.30326;
  struct MonoString * D.30327;
  long int D.30328;
  struct MonoDomain * domain;
  struct tm start;
  struct tm tt;
  time_t t;
  long int gmtoff;
  long int gmtoff_after;
  long int gmtoff_st;
  long int gmtoff_ds;
  int day;
  int transitioned;
  char tzone[64];

  try
    {
      domain = mono_domain_get ();
      transitioned = 0;
      gmtoff_ds = 0;
      gmtoff_st = gmtoff_ds;
      D.30253 = data == 0B;
      D.30254 = (long int) D.30253;
      D.30255 = __builtin_expect (D.30254, 0);
      if (D.30255 != 0) goto <D.30256>; else goto <D.30257>;
      <D.30256>:
      {
        struct MonoException * ex;

        if (data != 0B) goto <D.30258>; else goto <D.30259>;
        <D.30258>:
        <D.30259>:
        ex = mono_get_exception_argument_null ("data");
        mono_raise_exception (ex);
      }
      <D.30257>:
      D.30260 = names == 0B;
      D.30261 = (long int) D.30260;
      D.30262 = __builtin_expect (D.30261, 0);
      if (D.30262 != 0) goto <D.30263>; else goto <D.30264>;
      <D.30263>:
      {
        struct MonoException * ex;

        if (names != 0B) goto <D.30265>; else goto <D.30266>;
        <D.30265>:
        <D.30266>:
        ex = mono_get_exception_argument_null ("names");
        mono_raise_exception (ex);
      }
      <D.30264>:
      D.30267 = mono_defaults.int64_class;
      D.30268 = mono_array_new (domain, D.30267, 4);
      mono_gc_wbarrier_generic_store (data, D.30268);
      D.30269 = mono_defaults.string_class;
      D.30270 = mono_array_new (domain, D.30269, 2);
      mono_gc_wbarrier_generic_store (names, D.30270);
      memset (&start, 0, 56);
      start.tm_mday = 1;
      D.30271 = year + 4294965396;
      D.30272 = (int) D.30271;
      start.tm_year = D.30272;
      t.172 = mktime (&start);
      t = t.172;
      D.30276 = year + 4294965326;
      if (D.30276 > 67) goto <D.30274>; else goto <D.30277>;
      <D.30277>:
      t.173 = t;
      if (t.173 == -1) goto <D.30274>; else goto <D.30275>;
      <D.30274>:
      t.174 = time (0B);
      t = t.174;
      D.30280 = localtime (&t);
      tt = *D.30280;
      strftime (&tzone, 64, "%Z", &tt);
      {
        void * * __p;

        D.30281 = *names;
        __p = mono_array_addr_with_size (D.30281, 8, 0);
        D.30281 = *names;
        D.30282 = mono_string_new (domain, &tzone);
        mono_gc_wbarrier_set_arrayref (D.30281, __p, D.30282);
      }
      {
        void * * __p;

        D.30281 = *names;
        __p = mono_array_addr_with_size (D.30281, 8, 1);
        D.30281 = *names;
        D.30283 = mono_string_new (domain, &tzone);
        mono_gc_wbarrier_set_arrayref (D.30281, __p, D.30283);
      }
      D.30284 = 1;
      return D.30284;
      <D.30275>:
      t.173 = t;
      D.30285 = gmt_offset (&start, t.173);
      gmtoff = (long int) D.30285;
      day = 0;
      goto <D.23050>;
      <D.23049>:
      t.173 = t;
      t.175 = t.173 + 86400;
      t = t.175;
      D.30287 = localtime (&t);
      tt = *D.30287;
      t.173 = t;
      D.30288 = gmt_offset (&tt, t.173);
      gmtoff_after = (long int) D.30288;
      if (gmtoff_after != gmtoff) goto <D.30289>; else goto <D.30290>;
      <D.30289>:
      {
        struct tm tt1;
        time_t t1;

        try
          {
            t.173 = t;
            t1 = t.173;
            <D.23038>:
            t1.176 = t1;
            t1.177 = t1.176 + -3600;
            t1 = t1.177;
            D.30293 = localtime (&t1);
            tt1 = *D.30293;
            t1.176 = t1;
            D.30294 = gmt_offset (&tt1, t1.176);
            D.30295 = (long int) D.30294;
            if (D.30295 != gmtoff) goto <D.23038>; else goto <D.23039>;
            <D.23039>:
            <D.23040>:
            t1.176 = t1;
            t1.178 = t1.176 + 60;
            t1 = t1.178;
            D.30297 = localtime (&t1);
            tt1 = *D.30297;
            t1.176 = t1;
            D.30298 = gmt_offset (&tt1, t1.176);
            D.30299 = (long int) D.30298;
            if (D.30299 == gmtoff) goto <D.23040>; else goto <D.23041>;
            <D.23041>:
            t1.176 = t1;
            t1.179 = t1.176 + gmtoff;
            t1 = t1.179;
            strftime (&tzone, 64, "%Z", &tt);
            D.30301 = tt.tm_isdst;
            if (D.30301 != 0) goto <D.30302>; else goto <D.30303>;
            <D.30302>:
            {
              void * * __p;

              D.30281 = *names;
              __p = mono_array_addr_with_size (D.30281, 8, 1);
              D.30281 = *names;
              D.30304 = mono_string_new (domain, &tzone);
              mono_gc_wbarrier_set_arrayref (D.30281, __p, D.30304);
            }
            {
              gint64 * __p;

              D.30305 = *data;
              __p = mono_array_addr_with_size (D.30305, 8, 0);
              t1.176 = t1;
              t1.180 = (long unsigned int) t1.176;
              D.30307 = t1.180 * 10000000;
              D.30308 = D.30307 + 621355968000000000;
              D.30309 = (long int) D.30308;
              *__p = D.30309;
            }
            if (gmtoff_ds == 0) goto <D.30310>; else goto <D.30311>;
            <D.30310>:
            gmtoff_st = gmtoff;
            gmtoff_ds = gmtoff_after;
            <D.30311>:
            transitioned = transitioned + 1;
            goto <D.30312>;
            <D.30303>:
            {
              time_t te;

              te = mktime (&tt);
              {
                void * * __p;

                D.30281 = *names;
                __p = mono_array_addr_with_size (D.30281, 8, 0);
                D.30281 = *names;
                D.30313 = mono_string_new (domain, &tzone);
                mono_gc_wbarrier_set_arrayref (D.30281, __p, D.30313);
              }
              {
                gint64 * __p;

                D.30305 = *data;
                __p = mono_array_addr_with_size (D.30305, 8, 1);
                t1.176 = t1;
                t1.180 = (long unsigned int) t1.176;
                D.30307 = t1.180 * 10000000;
                D.30308 = D.30307 + 621355968000000000;
                D.30309 = (long int) D.30308;
                *__p = D.30309;
              }
              if (gmtoff_ds == 0) goto <D.30314>; else goto <D.30315>;
              <D.30314>:
              gmtoff_st = gmtoff_after;
              gmtoff_ds = gmtoff;
              <D.30315>:
              transitioned = transitioned + 1;
            }
            <D.30312>:
            D.30316 = tt1.tm_isdst;
            if (D.30316 != 0) goto <D.30317>; else goto <D.30318>;
            <D.30317>:
            {
              gint64 * __p;

              D.30305 = *data;
              __p = mono_array_addr_with_size (D.30305, 8, 2);
              D.30319 = gmtoff_st * 10000000;
              *__p = D.30319;
            }
            {
              gint64 * __p;

              D.30305 = *data;
              __p = mono_array_addr_with_size (D.30305, 8, 3);
              D.30320 = gmtoff_ds - gmtoff_st;
              D.30321 = D.30320 * 10000000;
              *__p = D.30321;
            }
            <D.30318>:
            t.173 = t;
            D.30322 = gmt_offset (&tt, t.173);
            gmtoff = (long int) D.30322;
          }
        finally
          {
            tt1 = {CLOBBER};
            t1 = {CLOBBER};
          }
      }
      <D.30290>:
      day = day + 1;
      <D.23050>:
      if (day <= 364) goto <D.30323>; else goto <D.23051>;
      <D.30323>:
      if (transitioned <= 1) goto <D.23049>; else goto <D.23051>;
      <D.23051>:
      if (transitioned <= 1) goto <D.30324>; else goto <D.30325>;
      <D.30324>:
      strftime (&tzone, 64, "%Z", &tt);
      {
        void * * __p;

        D.30281 = *names;
        __p = mono_array_addr_with_size (D.30281, 8, 0);
        D.30281 = *names;
        D.30326 = mono_string_new (domain, &tzone);
        mono_gc_wbarrier_set_arrayref (D.30281, __p, D.30326);
      }
      {
        void * * __p;

        D.30281 = *names;
        __p = mono_array_addr_with_size (D.30281, 8, 1);
        D.30281 = *names;
        D.30327 = mono_string_new (domain, &tzone);
        mono_gc_wbarrier_set_arrayref (D.30281, __p, D.30327);
      }
      {
        gint64 * __p;

        D.30305 = *data;
        __p = mono_array_addr_with_size (D.30305, 8, 0);
        *__p = 0;
      }
      {
        gint64 * __p;

        D.30305 = *data;
        __p = mono_array_addr_with_size (D.30305, 8, 1);
        *__p = 0;
      }
      {
        gint64 * __p;

        D.30305 = *data;
        __p = mono_array_addr_with_size (D.30305, 8, 2);
        D.30328 = gmtoff * 10000000;
        *__p = D.30328;
      }
      {
        gint64 * __p;

        D.30305 = *data;
        __p = mono_array_addr_with_size (D.30305, 8, 3);
        *__p = 0;
      }
      <D.30325>:
      D.30284 = 1;
      return D.30284;
    }
  finally
    {
      start = {CLOBBER};
      tt = {CLOBBER};
      t = {CLOBBER};
      tzone = {CLOBBER};
    }
}


gmt_offset (struct tm * tm, time_t t)
{
  int D.30331;
  long int D.30332;

  D.30332 = tm->tm_gmtoff;
  D.30331 = (int) D.30332;
  return D.30331;
}


InternalFromBase64String (struct MonoString * str, MonoBoolean allowWhitespaceOnly)
{
  struct MonoArray * D.30334;
  mono_unichar2 * D.30335;
  int D.30336;

  D.30335 = mono_string_chars (str);
  D.30336 = mono_string_length (str);
  D.30334 = base64_to_byte_array (D.30335, D.30336, allowWhitespaceOnly);
  return D.30334;
}


base64_to_byte_array (gunichar2 * start, gint ilength, MonoBoolean allowWhitespaceOnly)
{
  long unsigned int D.30338;
  long unsigned int D.30339;
  gunichar2 * D.30340;
  struct MonoImage * D.30343;
  const short unsigned int * * D.30345;
  const short unsigned int * D.30346;
  long unsigned int D.30347;
  long unsigned int D.30348;
  const short unsigned int * D.30349;
  short unsigned int D.30350;
  int D.30351;
  int D.30352;
  struct MonoImage * D.30360;
  struct MonoArray * D.30367;
  struct MonoDomain * D.30368;
  struct MonoClass * D.30369;
  int D.30372;
  struct MonoImage * D.30374;
  struct MonoImage * D.30377;
  int D.30378;
  struct MonoDomain * D.30383;
  long unsigned int D.30384;
  int i.181;
  long unsigned int D.30386;
  long unsigned int D.30387;
  gunichar2 * D.30388;
  unsigned char D.30391;
  int D.30392;
  int D.30393;
  unsigned char D.30394;
  int D.30395;
  int D.30396;
  int D.30397;
  struct MonoImage * D.30400;
  guchar * res_ptr.182;
  int D.30403;
  int D.30404;
  signed char D.30405;
  int D.30406;
  int D.30407;
  signed char D.30408;
  signed char D.30409;
  unsigned char D.30410;
  int D.30411;
  guchar * res_ptr.183;
  int D.30415;
  signed char D.30416;
  int D.30417;
  int D.30418;
  signed char D.30419;
  signed char D.30420;
  unsigned char D.30421;
  int D.30422;
  guchar * res_ptr.184;
  int D.30426;
  signed char D.30427;
  int D.30428;
  signed char D.30429;
  signed char D.30430;
  unsigned char D.30431;
  short unsigned int D.30433;
  long unsigned int D.30434;
  long unsigned int D.30435;
  const short unsigned int * D.30436;
  short unsigned int D.30437;
  int D.30438;
  int D.30439;
  gint ignored;
  gint i;
  gunichar2 c;
  gunichar2 last;
  gunichar2 prev_last;
  gunichar2 prev2_last;
  gint olength;
  struct MonoArray * result;
  guchar * res_ptr;
  gint a[4];
  gint b[4];
  struct MonoException * exc;
  int havePadding;

  try
    {
      havePadding = 0;
      ignored = 0;
      prev_last = 0;
      last = prev_last;
      prev2_last = 0;
      i = 0;
      goto <D.23546>;
      <D.23545>:
      D.30338 = (long unsigned int) i;
      D.30339 = D.30338 * 2;
      D.30340 = start + D.30339;
      c = *D.30340;
      if (c > 122) goto <D.30341>; else goto <D.30342>;
      <D.30341>:
      D.30343 = mono_get_corlib ();
      exc = mono_exception_from_name_msg (D.30343, "System", "FormatException", "Invalid character found.");
      mono_raise_exception (exc);
      goto <D.30344>;
      <D.30342>:
      D.30345 = __ctype_b_loc ();
      D.30346 = *D.30345;
      D.30347 = (long unsigned int) c;
      D.30348 = D.30347 * 2;
      D.30349 = D.30346 + D.30348;
      D.30350 = *D.30349;
      D.30351 = (int) D.30350;
      D.30352 = D.30351 & 32;
      if (D.30352 != 0) goto <D.30353>; else goto <D.30354>;
      <D.30353>:
      ignored = ignored + 1;
      goto <D.30355>;
      <D.30354>:
      if (havePadding != 0) goto <D.30358>; else goto <D.30356>;
      <D.30358>:
      if (c != 61) goto <D.30359>; else goto <D.30356>;
      <D.30359>:
      D.30360 = mono_get_corlib ();
      exc = mono_exception_from_name_msg (D.30360, "System", "FormatException", "Invalid character found.");
      mono_raise_exception (exc);
      goto <D.30357>;
      <D.30356>:
      if (c == 61) goto <D.30361>; else goto <D.30362>;
      <D.30361>:
      havePadding = 1;
      <D.30362>:
      prev2_last = prev_last;
      prev_last = last;
      last = c;
      <D.30357>:
      <D.30355>:
      <D.30344>:
      i = i + 1;
      <D.23546>:
      if (i < ilength) goto <D.23545>; else goto <D.23547>;
      <D.23547>:
      olength = ilength - ignored;
      if (allowWhitespaceOnly != 0) goto <D.30363>; else goto <D.30364>;
      <D.30363>:
      if (olength == 0) goto <D.30365>; else goto <D.30366>;
      <D.30365>:
      D.30368 = mono_domain_get ();
      D.30369 = mono_defaults.byte_class;
      D.30367 = mono_array_new (D.30368, D.30369, 0);
      return D.30367;
      <D.30366>:
      <D.30364>:
      D.30372 = olength & 3;
      if (D.30372 != 0) goto <D.30370>; else goto <D.30373>;
      <D.30373>:
      if (olength <= 0) goto <D.30370>; else goto <D.30371>;
      <D.30370>:
      D.30374 = mono_get_corlib ();
      exc = mono_exception_from_name_msg (D.30374, "System", "FormatException", "Invalid length.");
      mono_raise_exception (exc);
      <D.30371>:
      if (prev2_last == 61) goto <D.30375>; else goto <D.30376>;
      <D.30375>:
      D.30377 = mono_get_corlib ();
      exc = mono_exception_from_name_msg (D.30377, "System", "FormatException", "Invalid format.");
      mono_raise_exception (exc);
      <D.30376>:
      D.30378 = olength * 3;
      olength = D.30378 / 4;
      if (last == 61) goto <D.30379>; else goto <D.30380>;
      <D.30379>:
      olength = olength + -1;
      <D.30380>:
      if (prev_last == 61) goto <D.30381>; else goto <D.30382>;
      <D.30381>:
      olength = olength + -1;
      <D.30382>:
      D.30383 = mono_domain_get ();
      D.30369 = mono_defaults.byte_class;
      D.30384 = (long unsigned int) olength;
      result = mono_array_new (D.30383, D.30369, D.30384);
      res_ptr = mono_array_addr_with_size (result, 1, 0);
      i = 0;
      goto <D.23556>;
      <D.23555>:
      {
        int k;

        k = 0;
        goto <D.23549>;
        <D.23550>:
        i.181 = i;
        i = i.181 + 1;
        D.30386 = (long unsigned int) i.181;
        D.30387 = D.30386 * 2;
        D.30388 = start + D.30387;
        c = *D.30388;
        D.30345 = __ctype_b_loc ();
        D.30346 = *D.30345;
        D.30347 = (long unsigned int) c;
        D.30348 = D.30347 * 2;
        D.30349 = D.30346 + D.30348;
        D.30350 = *D.30349;
        D.30351 = (int) D.30350;
        D.30352 = D.30351 & 32;
        if (D.30352 != 0) goto <D.30389>; else goto <D.30390>;
        <D.30389>:
        // predicted unlikely by continue predictor.
        goto <D.23549>;
        <D.30390>:
        D.30391 = (unsigned char) c;
        D.30392 = (int) D.30391;
        a[k] = D.30392;
        D.30393 = (int) c;
        D.30394 = dbase64[D.30393];
        D.30395 = (int) D.30394;
        b[k] = D.30395;
        D.30396 = b[k];
        D.30397 = D.30396 & 128;
        if (D.30397 != 0) goto <D.30398>; else goto <D.30399>;
        <D.30398>:
        D.30400 = mono_get_corlib ();
        exc = mono_exception_from_name_msg (D.30400, "System", "FormatException", "Invalid character found.");
        mono_raise_exception (exc);
        <D.30399>:
        k = k + 1;
        <D.23549>:
        if (k <= 3) goto <D.30401>; else goto <D.23551>;
        <D.30401>:
        if (i < ilength) goto <D.23550>; else goto <D.23551>;
        <D.23551>:
        res_ptr.182 = res_ptr;
        res_ptr = res_ptr.182 + 1;
        D.30403 = b[0];
        D.30404 = D.30403 << 2;
        D.30405 = (signed char) D.30404;
        D.30406 = b[1];
        D.30407 = D.30406 >> 4;
        D.30408 = (signed char) D.30407;
        D.30409 = D.30405 | D.30408;
        D.30410 = (unsigned char) D.30409;
        *res_ptr.182 = D.30410;
        D.30411 = a[2];
        if (D.30411 != 61) goto <D.30412>; else goto <D.30413>;
        <D.30412>:
        res_ptr.183 = res_ptr;
        res_ptr = res_ptr.183 + 1;
        D.30406 = b[1];
        D.30415 = D.30406 << 4;
        D.30416 = (signed char) D.30415;
        D.30417 = b[2];
        D.30418 = D.30417 >> 2;
        D.30419 = (signed char) D.30418;
        D.30420 = D.30416 | D.30419;
        D.30421 = (unsigned char) D.30420;
        *res_ptr.183 = D.30421;
        <D.30413>:
        D.30422 = a[3];
        if (D.30422 != 61) goto <D.30423>; else goto <D.30424>;
        <D.30423>:
        res_ptr.184 = res_ptr;
        res_ptr = res_ptr.184 + 1;
        D.30417 = b[2];
        D.30426 = D.30417 << 6;
        D.30427 = (signed char) D.30426;
        D.30428 = b[3];
        D.30429 = (signed char) D.30428;
        D.30430 = D.30427 | D.30429;
        D.30431 = (unsigned char) D.30430;
        *res_ptr.184 = D.30431;
        <D.30424>:
        goto <D.23553>;
        <D.23552>:
        i = i + 1;
        <D.23553>:
        if (i < ilength) goto <D.30432>; else goto <D.23554>;
        <D.30432>:
        D.30345 = __ctype_b_loc ();
        D.30346 = *D.30345;
        D.30338 = (long unsigned int) i;
        D.30339 = D.30338 * 2;
        D.30340 = start + D.30339;
        D.30433 = *D.30340;
        D.30434 = (long unsigned int) D.30433;
        D.30435 = D.30434 * 2;
        D.30436 = D.30346 + D.30435;
        D.30437 = *D.30436;
        D.30438 = (int) D.30437;
        D.30439 = D.30438 & 32;
        if (D.30439 != 0) goto <D.23552>; else goto <D.23554>;
        <D.23554>:
      }
      <D.23556>:
      if (i < ilength) goto <D.23555>; else goto <D.23557>;
      <D.23557>:
      D.30367 = result;
      return D.30367;
    }
  finally
    {
      a = {CLOBBER};
      b = {CLOBBER};
    }
}


InternalFromBase64CharArray (struct MonoArray * input, gint offset, gint length)
{
  struct MonoArray * D.30442;
  long unsigned int D.30443;
  char * D.30444;

  D.30443 = (long unsigned int) offset;
  D.30444 = mono_array_addr_with_size (input, 2, D.30443);
  D.30442 = base64_to_byte_array (D.30444, length, 0);
  return D.30442;
}


get_bundled_app_config ()
{
  struct MonoAppDomainSetup * D.30446;
  struct MonoString * D.30449;
  long unsigned int D.30452;
  long unsigned int D.30453;
  long unsigned int D.30454;
  struct MonoDomain * D.30459;
  const gchar * app_config;
  struct MonoDomain * domain;
  struct MonoString * file;
  gchar * config_file_name;
  gchar * config_file_path;
  gsize len;
  gchar * module;

  domain = mono_domain_get ();
  D.30446 = domain->setup;
  file = D.30446->configuration_file;
  if (file == 0B) goto <D.30447>; else goto <D.30448>;
  <D.30447>:
  D.30449 = 0B;
  return D.30449;
  <D.30448>:
  config_file_name = mono_string_to_utf8 (file);
  config_file_path = mono_portability_find_file (config_file_name, 1);
  if (config_file_path == 0B) goto <D.30450>; else goto <D.30451>;
  <D.30450>:
  config_file_path = config_file_name;
  <D.30451>:
  D.30452 = __strlen_g (config_file_path);
  D.30453 = __strlen_g (".config");
  len = D.30452 - D.30453;
  D.30454 = len + 1;
  module = monoeg_malloc0 (D.30454);
  memcpy (module, config_file_path, len);
  app_config = mono_config_string_for_assembly_file (module);
  monoeg_g_free (module);
  if (config_file_name != config_file_path) goto <D.30455>; else goto <D.30456>;
  <D.30455>:
  monoeg_g_free (config_file_name);
  <D.30456>:
  monoeg_g_free (config_file_path);
  if (app_config == 0B) goto <D.30457>; else goto <D.30458>;
  <D.30457>:
  D.30449 = 0B;
  return D.30449;
  <D.30458>:
  D.30459 = mono_domain_get ();
  D.30449 = mono_string_new (D.30459, app_config);
  return D.30449;
}


ves_icall_System_Configuration_DefaultConfig_get_machine_config_path ()
{
  const char * D.30461;
  const struct MonoRuntimeInfo * D.30462;
  const char[4] * D.30463;
  struct MonoDomain * D.30464;
  struct MonoString * D.30465;
  struct MonoString * mcpath;
  gchar * path;

  D.30461 = mono_get_config_dir ();
  D.30462 = mono_get_runtime_info ();
  D.30463 = &D.30462->framework_version;
  path = monoeg_g_build_path ("/", D.30461, "mono", D.30463, "machine.config", 0B);
  D.30464 = mono_domain_get ();
  mcpath = mono_string_new (D.30464, path);
  monoeg_g_free (path);
  D.30465 = mcpath;
  return D.30465;
}


get_bundled_machine_config ()
{
  struct MonoString * D.30469;
  struct MonoDomain * D.30470;
  const gchar * machine_config;

  machine_config = mono_get_machine_config ();
  if (machine_config == 0B) goto <D.30467>; else goto <D.30468>;
  <D.30467>:
  D.30469 = 0B;
  return D.30469;
  <D.30468>:
  D.30470 = mono_domain_get ();
  D.30469 = mono_string_new (D.30470, machine_config);
  return D.30469;
}


ves_icall_System_ComponentModel_Win32Exception_W32ErrorMessage (guint32 code)
{
  struct MonoDomain * D.30474;
  struct MonoDomain * D.30476;
  int ret.185;
  struct MonoString * D.30478;
  struct MonoString * message;
  guint32 ret;
  gunichar2 buf[256];

  try
    {
      ret = FormatMessage (4608, 0B, code, 0, &buf, 255, 0B);
      if (ret == 0) goto <D.30472>; else goto <D.30473>;
      <D.30472>:
      D.30474 = mono_domain_get ();
      message = mono_string_new (D.30474, "Error looking up error string");
      goto <D.30475>;
      <D.30473>:
      D.30476 = mono_domain_get ();
      ret.185 = (int) ret;
      message = mono_string_new_utf16 (D.30476, &buf, ret.185);
      <D.30475>:
      D.30478 = message;
      return D.30478;
    }
  finally
    {
      buf = {CLOBBER};
    }
}


ves_icall_System_Char_GetDataTablePointers (int category_data_version, const guint8 * * category_data, const guint16 * * category_astral_index, const guint8 * * numeric_data, const gdouble * * numeric_data_values, const guint16 * * to_lower_data_low, const guint16 * * to_lower_data_high, const guint16 * * to_upper_data_low, const guint16 * * to_upper_data_high)
{
  get_category_data (category_data_version, category_data, category_astral_index);
  *numeric_data = &NumericData;
  *numeric_data_values = &NumericDataValues;
  *to_lower_data_low = &ToLowerDataLow;
  *to_lower_data_high = &ToLowerDataHigh;
  *to_upper_data_low = &ToUpperDataLow;
  *to_upper_data_high = &ToUpperDataHigh;
}


get_category_data (int version, const guint8 * * category_data, const guint16 * * category_astral_index)
{
  *category_astral_index = 0B;
  if (version == 4) goto <D.30481>; else goto <D.30482>;
  <D.30481>:
  *category_data = &CategoryData_v4;
  *category_astral_index = &CategoryData_v4_astral_index;
  return;
  <D.30482>:
  *category_data = &CategoryData_v2;
  *category_astral_index = &CategoryData_v2_astral_index;
}


ves_icall_System_Buffer_SetByteInternal (struct MonoArray * array, gint32 idx, gint8 value)
{
  long unsigned int D.30484;

  {
    gint8 * __p;

    D.30484 = (long unsigned int) idx;
    __p = mono_array_addr_with_size (array, 1, D.30484);
    *__p = value;
  }
}


ves_icall_System_Buffer_GetByteInternal (struct MonoArray * array, gint32 idx)
{
  gint8 D.30485;
  long unsigned int D.30486;
  char * D.30487;

  D.30486 = (long unsigned int) idx;
  D.30487 = mono_array_addr_with_size (array, 1, D.30486);
  D.30485 = MEM[(gint8 *)D.30487];
  return D.30485;
}


ves_icall_System_Buffer_ByteLengthInternal (struct MonoArray * array)
{
  gint32 D.30489;

  D.30489 = mono_array_get_byte_length (array);
  return D.30489;
}


mono_array_get_byte_length (struct MonoArray * array)
{
  struct MonoVTable * D.30491;
  struct MonoArrayBounds * D.30492;
  unsigned int D.30495;
  long unsigned int D.30497;
  long unsigned int D.30498;
  struct MonoArrayBounds * D.30499;
  unsigned int D.30500;
  unsigned int length.186;
  unsigned int D.30502;
  unsigned char D.30503;
  int D.30504;
  struct MonoClass * D.30505;
  unsigned char D.30506;
  int D.30507;
  gint32 D.30508;
  unsigned int length.187;
  unsigned int D.30510;
  struct MonoClass * klass;
  int length;
  int i;

  D.30491 = array->obj.vtable;
  klass = D.30491->klass;
  D.30492 = array->bounds;
  if (D.30492 == 0B) goto <D.30493>; else goto <D.30494>;
  <D.30493>:
  D.30495 = array->max_length;
  length = (int) D.30495;
  goto <D.30496>;
  <D.30494>:
  length = 1;
  i = 0;
  goto <D.23068>;
  <D.23067>:
  D.30492 = array->bounds;
  D.30497 = (long unsigned int) i;
  D.30498 = D.30497 * 8;
  D.30499 = D.30492 + D.30498;
  D.30500 = D.30499->length;
  length.186 = (unsigned int) length;
  D.30502 = D.30500 * length.186;
  length = (int) D.30502;
  i = i + 1;
  <D.23068>:
  D.30503 = klass->rank;
  D.30504 = (int) D.30503;
  if (D.30504 > i) goto <D.23067>; else goto <D.23069>;
  <D.23069>:
  <D.30496>:
  D.30505 = klass->element_class;
  D.30506 = D.30505->byval_arg.type;
  D.30507 = (int) D.30506;
  switch (D.30507) <default: <D.23084>, case 2: <D.23072>, case 3: <D.23075>, case 4: <D.23070>, case 5: <D.23071>, case 6: <D.23073>, case 7: <D.23074>, case 8: <D.23076>, case 9: <D.23077>, case 10: <D.23081>, case 11: <D.23082>, case 12: <D.23078>, case 13: <D.23083>, case 24: <D.23079>, case 25: <D.23080>>
  <D.23070>:
  <D.23071>:
  <D.23072>:
  D.30508 = length;
  return D.30508;
  <D.23073>:
  <D.23074>:
  <D.23075>:
  D.30508 = length << 1;
  return D.30508;
  <D.23076>:
  <D.23077>:
  <D.23078>:
  D.30508 = length << 2;
  return D.30508;
  <D.23079>:
  <D.23080>:
  length.187 = (unsigned int) length;
  D.30510 = length.187 * 8;
  D.30508 = (gint32) D.30510;
  return D.30508;
  <D.23081>:
  <D.23082>:
  <D.23083>:
  D.30508 = length << 3;
  return D.30508;
  <D.23084>:
  D.30508 = -1;
  return D.30508;
}


ves_icall_System_Buffer_BlockCopyInternal (struct MonoArray * src, gint32 src_offset, struct MonoArray * dest, gint32 dest_offset, gint32 count)
{
  _Bool D.30512;
  long int D.30513;
  long int D.30514;
  _Bool D.30519;
  long int D.30520;
  long int D.30521;
  int D.30528;
  int D.30529;
  int D.30531;
  int D.30532;
  MonoBoolean D.30533;
  double[0:] * D.30534;
  sizetype D.30535;
  double[0:] * D.30536;
  sizetype D.30537;
  long unsigned int D.30540;
  guint8 * src_buf;
  guint8 * dest_buf;

  D.30512 = src == 0B;
  D.30513 = (long int) D.30512;
  D.30514 = __builtin_expect (D.30513, 0);
  if (D.30514 != 0) goto <D.30515>; else goto <D.30516>;
  <D.30515>:
  {
    struct MonoException * ex;

    if (src != 0B) goto <D.30517>; else goto <D.30518>;
    <D.30517>:
    <D.30518>:
    ex = mono_get_exception_argument_null ("src");
    mono_raise_exception (ex);
  }
  <D.30516>:
  D.30519 = dest == 0B;
  D.30520 = (long int) D.30519;
  D.30521 = __builtin_expect (D.30520, 0);
  if (D.30521 != 0) goto <D.30522>; else goto <D.30523>;
  <D.30522>:
  {
    struct MonoException * ex;

    if (dest != 0B) goto <D.30524>; else goto <D.30525>;
    <D.30524>:
    <D.30525>:
    ex = mono_get_exception_argument_null ("dest");
    mono_raise_exception (ex);
  }
  <D.30523>:
  D.30528 = mono_array_get_byte_length (src);
  D.30529 = D.30528 - count;
  if (D.30529 < src_offset) goto <D.30526>; else goto <D.30530>;
  <D.30530>:
  D.30531 = mono_array_get_byte_length (dest);
  D.30532 = D.30531 - count;
  if (D.30532 < dest_offset) goto <D.30526>; else goto <D.30527>;
  <D.30526>:
  D.30533 = 0;
  return D.30533;
  <D.30527>:
  D.30534 = &src->vector;
  D.30535 = (sizetype) src_offset;
  src_buf = D.30534 + D.30535;
  D.30536 = &dest->vector;
  D.30537 = (sizetype) dest_offset;
  dest_buf = D.30536 + D.30537;
  if (src != dest) goto <D.30538>; else goto <D.30539>;
  <D.30538>:
  D.30540 = (long unsigned int) count;
  memcpy (dest_buf, src_buf, D.30540);
  goto <D.30541>;
  <D.30539>:
  D.30540 = (long unsigned int) count;
  memmove (dest_buf, src_buf, D.30540);
  <D.30541>:
  D.30533 = 1;
  return D.30533;
}


__attribute__((__artificial__, __gnu_inline__, __always_inline__, __nothrow__, __leaf__))
memmove (void * __dest, const void * __src, size_t __len)
{
  void * D.30543;
  long unsigned int D.30544;

  D.30544 = __builtin_object_size (__dest, 0);
  D.30543 = __builtin___memmove_chk (__dest, __src, __len, D.30544);
  return D.30543;
}


ves_icall_System_Array_SetValueImpl (struct MonoArray * this, struct MonoObject * value, guint32 pos)
{
  struct MonoVTable * D.30548;
  struct MonoVTable * D.30550;
  double[0:] * D.30551;
  unsigned int esize.188;
  unsigned int D.30553;
  sizetype D.30554;
  int D.30555;
  long unsigned int D.30560;
  unsigned char D.30561;
  int D.30562;
  unsigned char D.30563;
  int D.30564;
  struct MonoRuntimeCallbacks * D.30565;
  void (*<T2904>) (struct MonoClass *, struct MonoClass *) D.30566;
  struct MonoException * D.30567;
  struct MonoException * D.30568;
  struct MonoRuntimeCallbacks * D.30569;
  void (*<T2904>) (struct MonoClass *, struct MonoClass *) D.30570;
  struct MonoException * D.30571;
  long unsigned int D.30573;
  long unsigned int D.30574;
  struct MonoObject * D.30577;
  struct MonoRuntimeCallbacks * D.30580;
  void (*<T2904>) (struct MonoClass *, struct MonoClass *) D.30581;
  struct MonoException * D.30582;
  struct MonoObject * D.30583;
  long unsigned int D.30586;
  void * D.30589;
  const void * D.30591;
  long unsigned int D.30592;
  long unsigned int D.30593;
  struct MonoRuntimeCallbacks * D.30596;
  void (*<T2904>) (struct MonoClass *, struct MonoClass *) D.30597;
  struct MonoException * D.30598;
  int D.30599;
  unsigned int D.30600;
  unsigned int D.30601;
  struct MonoClass * D.30604;
  long unsigned int D.30605;
  long unsigned int D.30606;
  struct MonoType * D.30609;
  unsigned char D.30610;
  struct MonoClass * D.30613;
  long unsigned int D.30614;
  long unsigned int D.30615;
  struct MonoType * D.30618;
  unsigned char D.30619;
  unsigned char D.30620;
  short unsigned int D.30621;
  unsigned int D.30622;
  signed char D.30623;
  short int D.30624;
  int D.30625;
  float D.30626;
  struct MonoException * D.30627;
  struct MonoRuntimeCallbacks * D.30628;
  void (*<T2904>) (struct MonoClass *, struct MonoClass *) D.30629;
  struct MonoException * D.30630;
  struct MonoException * D.30634;
  short unsigned int D.30635;
  struct MonoException * D.30636;
  struct MonoException * D.30640;
  unsigned char D.30641;
  struct MonoException * D.30642;
  struct MonoException * D.30646;
  struct MonoException * D.30647;
  struct MonoException * D.30651;
  unsigned int D.30652;
  struct MonoException * D.30653;
  struct MonoException * D.30657;
  struct MonoException * D.30658;
  struct MonoException * D.30662;
  signed char D.30663;
  struct MonoException * D.30666;
  signed char D.30667;
  struct MonoException * D.30668;
  struct MonoException * D.30672;
  short int D.30673;
  struct MonoException * D.30676;
  short int D.30677;
  struct MonoException * D.30678;
  struct MonoException * D.30682;
  int D.30683;
  struct MonoException * D.30686;
  int D.30687;
  struct MonoException * D.30688;
  struct MonoException * D.30692;
  struct MonoException * D.30695;
  long int u64.189;
  struct MonoException * D.30697;
  struct MonoException * D.30701;
  float D.30702;
  float D.30703;
  float D.30704;
  struct MonoException * D.30708;
  double D.30709;
  double D.30710;
  struct MonoRuntimeCallbacks * D.30713;
  void (*<T2904>) (struct MonoClass *, struct MonoClass *) D.30714;
  struct MonoException * D.30715;
  struct MonoClass * ac;
  struct MonoClass * vc;
  struct MonoClass * ec;
  gint32 esize;
  gint32 vsize;
  void * * ea;
  void * * va;
  int et;
  int vt;
  guint64 u64;
  gint64 i64;
  gdouble r64;

  u64 = 0;
  i64 = 0;
  r64 = 0.0;
  if (value != 0B) goto <D.30546>; else goto <D.30547>;
  <D.30546>:
  D.30548 = value->vtable;
  vc = D.30548->klass;
  goto <D.30549>;
  <D.30547>:
  vc = 0B;
  <D.30549>:
  D.30550 = this->obj.vtable;
  ac = D.30550->klass;
  ec = ac->element_class;
  esize = mono_array_element_size (ac);
  D.30551 = &this->vector;
  esize.188 = (unsigned int) esize;
  D.30553 = pos * esize.188;
  D.30554 = (sizetype) D.30553;
  ea = D.30551 + D.30554;
  va = value + 16;
  D.30555 = mono_class_is_nullable (ec);
  if (D.30555 != 0) goto <D.30556>; else goto <D.30557>;
  <D.30556>:
  mono_nullable_init (ea, value, ec);
  return;
  <D.30557>:
  if (value == 0B) goto <D.30558>; else goto <D.30559>;
  <D.30558>:
  D.30560 = (long unsigned int) esize;
  mono_gc_bzero_atomic (ea, D.30560);
  return;
  <D.30559>:
  D.30561 = ec->byval_arg.type;
  D.30562 = (int) D.30561;
  switch (D.30562) <default: <D.30572>, case 2: <D.20885>, case 14: <D.20880>>
  <D.20880>:
  D.30563 = vc->byval_arg.type;
  D.30564 = (int) D.30563;
  switch (D.30564) <default: <D.20883>, case 14: <D.20881>>
  <D.20881>:
  goto <D.20882>;
  <D.20883>:
  D.30565 = mono_get_runtime_callbacks ();
  D.30566 = D.30565->set_cast_details;
  D.30566 (vc, ec);
  D.30567 = mono_get_exception_invalid_cast ();
  mono_raise_exception (D.30567);
  <D.20882>:
  goto <D.20884>;
  <D.20885>:
  D.30563 = vc->byval_arg.type;
  D.30564 = (int) D.30563;
  switch (D.30564) <default: <D.20899>, case 2: <D.20886>, case 3: <D.20888>, case 4: <D.20893>, case 5: <D.20889>, case 6: <D.20894>, case 7: <D.20890>, case 8: <D.20895>, case 9: <D.20891>, case 10: <D.20896>, case 11: <D.20892>, case 12: <D.20897>, case 13: <D.20898>>
  <D.20886>:
  goto <D.20887>;
  <D.20888>:
  <D.20889>:
  <D.20890>:
  <D.20891>:
  <D.20892>:
  <D.20893>:
  <D.20894>:
  <D.20895>:
  <D.20896>:
  <D.20897>:
  <D.20898>:
  D.30568 = mono_get_exception_argument ("value", "not a widening conversion");
  mono_raise_exception (D.30568);
  <D.20899>:
  D.30569 = mono_get_runtime_callbacks ();
  D.30570 = D.30569->set_cast_details;
  D.30570 (vc, ec);
  D.30571 = mono_get_exception_invalid_cast ();
  mono_raise_exception (D.30571);
  <D.20887>:
  goto <D.20884>;
  <D.30572>:
  <D.20884>:
  D.30573 = BIT_FIELD_REF <*ec, 64, 256>;
  D.30574 = D.30573 & 1152921504606846976;
  if (D.30574 == 0) goto <D.30575>; else goto <D.30576>;
  <D.30575>:
  D.30577 = mono_object_isinst (value, ec);
  if (D.30577 == 0B) goto <D.30578>; else goto <D.30579>;
  <D.30578>:
  D.30580 = mono_get_runtime_callbacks ();
  D.30581 = D.30580->set_cast_details;
  D.30581 (vc, ec);
  D.30582 = mono_get_exception_invalid_cast ();
  mono_raise_exception (D.30582);
  <D.30579>:
  mono_gc_wbarrier_set_arrayref (this, ea, value);
  return;
  <D.30576>:
  D.30583 = mono_object_isinst (value, ec);
  if (D.30583 != 0B) goto <D.30584>; else goto <D.30585>;
  <D.30584>:
  D.30573 = BIT_FIELD_REF <*ec, 64, 256>;
  D.30586 = D.30573 & 68719476736;
  if (D.30586 != 0) goto <D.30587>; else goto <D.30588>;
  <D.30587>:
  D.30589 = value + 16;
  mono_value_copy (ea, D.30589, ec);
  goto <D.30590>;
  <D.30588>:
  D.30591 = value + 16;
  D.30560 = (long unsigned int) esize;
  mono_gc_memmove_atomic (ea, D.30591, D.30560);
  <D.30590>:
  return;
  <D.30585>:
  D.30592 = BIT_FIELD_REF <*vc, 64, 256>;
  D.30593 = D.30592 & 1152921504606846976;
  if (D.30593 == 0) goto <D.30594>; else goto <D.30595>;
  <D.30594>:
  D.30596 = mono_get_runtime_callbacks ();
  D.30597 = D.30596->set_cast_details;
  D.30597 (vc, ec);
  D.30598 = mono_get_exception_invalid_cast ();
  mono_raise_exception (D.30598);
  <D.30595>:
  D.30599 = mono_class_instance_size (vc);
  D.30600 = (unsigned int) D.30599;
  D.30601 = D.30600 + 4294967280;
  vsize = (gint32) D.30601;
  D.30561 = ec->byval_arg.type;
  et = (int) D.30561;
  if (et == 17) goto <D.30602>; else goto <D.30603>;
  <D.30602>:
  D.30604 = ec->byval_arg.data.klass;
  D.30605 = BIT_FIELD_REF <*D.30604, 64, 256>;
  D.30606 = D.30605 & 576460752303423488;
  if (D.30606 != 0) goto <D.30607>; else goto <D.30608>;
  <D.30607>:
  D.30604 = ec->byval_arg.data.klass;
  D.30609 = mono_class_enum_basetype (D.30604);
  D.30610 = D.30609->type;
  et = (int) D.30610;
  <D.30608>:
  <D.30603>:
  D.30563 = vc->byval_arg.type;
  vt = (int) D.30563;
  if (vt == 17) goto <D.30611>; else goto <D.30612>;
  <D.30611>:
  D.30613 = vc->byval_arg.data.klass;
  D.30614 = BIT_FIELD_REF <*D.30613, 64, 256>;
  D.30615 = D.30614 & 576460752303423488;
  if (D.30615 != 0) goto <D.30616>; else goto <D.30617>;
  <D.30616>:
  D.30613 = vc->byval_arg.data.klass;
  D.30618 = mono_class_enum_basetype (D.30613);
  D.30619 = D.30618->type;
  vt = (int) D.30619;
  <D.30617>:
  <D.30612>:
  switch (vt) <default: <D.30631>, case 2: <D.20912>, case 3: <D.20911>, case 4: <D.20905>, case 5: <D.20900>, case 6: <D.20906>, case 7: <D.20902>, case 8: <D.20907>, case 9: <D.20903>, case 10: <D.20908>, case 11: <D.20904>, case 12: <D.20909>, case 13: <D.20910>>
  <D.20900>:
  D.30620 = MEM[(guint8 *)va];
  u64 = (guint64) D.30620;
  goto <D.20901>;
  <D.20902>:
  D.30621 = MEM[(guint16 *)va];
  u64 = (guint64) D.30621;
  goto <D.20901>;
  <D.20903>:
  D.30622 = MEM[(guint32 *)va];
  u64 = (guint64) D.30622;
  goto <D.20901>;
  <D.20904>:
  u64 = MEM[(guint64 *)va];
  goto <D.20901>;
  <D.20905>:
  D.30623 = MEM[(gint8 *)va];
  i64 = (gint64) D.30623;
  goto <D.20901>;
  <D.20906>:
  D.30624 = MEM[(gint16 *)va];
  i64 = (gint64) D.30624;
  goto <D.20901>;
  <D.20907>:
  D.30625 = MEM[(gint32 *)va];
  i64 = (gint64) D.30625;
  goto <D.20901>;
  <D.20908>:
  i64 = MEM[(gint64 *)va];
  goto <D.20901>;
  <D.20909>:
  D.30626 = MEM[(gfloat *)va];
  r64 = (gdouble) D.30626;
  goto <D.20901>;
  <D.20910>:
  r64 = MEM[(gdouble *)va];
  goto <D.20901>;
  <D.20911>:
  D.30621 = MEM[(guint16 *)va];
  u64 = (guint64) D.30621;
  goto <D.20901>;
  <D.20912>:
  switch (et) <default: <D.20924>, case 3: <D.20913>, case 4: <D.20918>, case 5: <D.20914>, case 6: <D.20919>, case 7: <D.20915>, case 8: <D.20920>, case 9: <D.20916>, case 10: <D.20921>, case 11: <D.20917>, case 12: <D.20922>, case 13: <D.20923>>
  <D.20913>:
  <D.20914>:
  <D.20915>:
  <D.20916>:
  <D.20917>:
  <D.20918>:
  <D.20919>:
  <D.20920>:
  <D.20921>:
  <D.20922>:
  <D.20923>:
  D.30627 = mono_get_exception_argument ("value", "not a widening conversion");
  mono_raise_exception (D.30627);
  <D.20924>:
  D.30628 = mono_get_runtime_callbacks ();
  D.30629 = D.30628->set_cast_details;
  D.30629 (vc, ec);
  D.30630 = mono_get_exception_invalid_cast ();
  mono_raise_exception (D.30630);
  goto <D.20901>;
  <D.30631>:
  <D.20901>:
  switch (et) <default: <D.30712>, case 3: <D.20925>, case 4: <D.20985>, case 5: <D.20937>, case 6: <D.20997>, case 7: <D.20949>, case 8: <D.21009>, case 9: <D.20961>, case 10: <D.21021>, case 11: <D.20973>, case 12: <D.21033>, case 13: <D.21045>>
  <D.20925>:
  switch (vt) <default: <D.30637>, case 3: <D.20930>, case 4: <D.20931>, case 5: <D.20926>, case 6: <D.20932>, case 7: <D.20927>, case 8: <D.20933>, case 9: <D.20928>, case 10: <D.20934>, case 11: <D.20929>, case 12: <D.20935>, case 13: <D.20936>>
  <D.20926>:
  <D.20927>:
  <D.20928>:
  <D.20929>:
  <D.20930>:
  if (esize < vsize) goto <D.30632>; else goto <D.30633>;
  <D.30632>:
  D.30634 = mono_get_exception_argument ("value", "not a widening conversion");
  mono_raise_exception (D.30634);
  <D.30633>:
  D.30635 = (short unsigned int) u64;
  MEM[(guint16 *)ea] = D.30635;
  return;
  <D.20931>:
  <D.20932>:
  <D.20933>:
  <D.20934>:
  <D.20935>:
  <D.20936>:
  D.30636 = mono_get_exception_argument ("value", "not a widening conversion");
  mono_raise_exception (D.30636);
  <D.30637>:
  <D.20937>:
  switch (vt) <default: <D.30643>, case 3: <D.20942>, case 4: <D.20943>, case 5: <D.20938>, case 6: <D.20944>, case 7: <D.20939>, case 8: <D.20945>, case 9: <D.20940>, case 10: <D.20946>, case 11: <D.20941>, case 12: <D.20947>, case 13: <D.20948>>
  <D.20938>:
  <D.20939>:
  <D.20940>:
  <D.20941>:
  <D.20942>:
  if (esize < vsize) goto <D.30638>; else goto <D.30639>;
  <D.30638>:
  D.30640 = mono_get_exception_argument ("value", "not a widening conversion");
  mono_raise_exception (D.30640);
  <D.30639>:
  D.30641 = (unsigned char) u64;
  MEM[(guint8 *)ea] = D.30641;
  return;
  <D.20943>:
  <D.20944>:
  <D.20945>:
  <D.20946>:
  <D.20947>:
  <D.20948>:
  D.30642 = mono_get_exception_argument ("value", "not a widening conversion");
  mono_raise_exception (D.30642);
  <D.30643>:
  <D.20949>:
  switch (vt) <default: <D.30648>, case 3: <D.20954>, case 4: <D.20955>, case 5: <D.20950>, case 6: <D.20956>, case 7: <D.20951>, case 8: <D.20957>, case 9: <D.20952>, case 10: <D.20958>, case 11: <D.20953>, case 12: <D.20959>, case 13: <D.20960>>
  <D.20950>:
  <D.20951>:
  <D.20952>:
  <D.20953>:
  <D.20954>:
  if (esize < vsize) goto <D.30644>; else goto <D.30645>;
  <D.30644>:
  D.30646 = mono_get_exception_argument ("value", "not a widening conversion");
  mono_raise_exception (D.30646);
  <D.30645>:
  D.30635 = (short unsigned int) u64;
  MEM[(guint16 *)ea] = D.30635;
  return;
  <D.20955>:
  <D.20956>:
  <D.20957>:
  <D.20958>:
  <D.20959>:
  <D.20960>:
  D.30647 = mono_get_exception_argument ("value", "not a widening conversion");
  mono_raise_exception (D.30647);
  <D.30648>:
  <D.20961>:
  switch (vt) <default: <D.30654>, case 3: <D.20966>, case 4: <D.20967>, case 5: <D.20962>, case 6: <D.20968>, case 7: <D.20963>, case 8: <D.20969>, case 9: <D.20964>, case 10: <D.20970>, case 11: <D.20965>, case 12: <D.20971>, case 13: <D.20972>>
  <D.20962>:
  <D.20963>:
  <D.20964>:
  <D.20965>:
  <D.20966>:
  if (esize < vsize) goto <D.30649>; else goto <D.30650>;
  <D.30649>:
  D.30651 = mono_get_exception_argument ("value", "not a widening conversion");
  mono_raise_exception (D.30651);
  <D.30650>:
  D.30652 = (unsigned int) u64;
  MEM[(guint32 *)ea] = D.30652;
  return;
  <D.20967>:
  <D.20968>:
  <D.20969>:
  <D.20970>:
  <D.20971>:
  <D.20972>:
  D.30653 = mono_get_exception_argument ("value", "not a widening conversion");
  mono_raise_exception (D.30653);
  <D.30654>:
  <D.20973>:
  switch (vt) <default: <D.30659>, case 3: <D.20978>, case 4: <D.20979>, case 5: <D.20974>, case 6: <D.20980>, case 7: <D.20975>, case 8: <D.20981>, case 9: <D.20976>, case 10: <D.20982>, case 11: <D.20977>, case 12: <D.20983>, case 13: <D.20984>>
  <D.20974>:
  <D.20975>:
  <D.20976>:
  <D.20977>:
  <D.20978>:
  if (esize < vsize) goto <D.30655>; else goto <D.30656>;
  <D.30655>:
  D.30657 = mono_get_exception_argument ("value", "not a widening conversion");
  mono_raise_exception (D.30657);
  <D.30656>:
  MEM[(guint64 *)ea] = u64;
  return;
  <D.20979>:
  <D.20980>:
  <D.20981>:
  <D.20982>:
  <D.20983>:
  <D.20984>:
  D.30658 = mono_get_exception_argument ("value", "not a widening conversion");
  mono_raise_exception (D.30658);
  <D.30659>:
  <D.20985>:
  switch (vt) <default: <D.30669>, case 3: <D.20994>, case 4: <D.20986>, case 5: <D.20990>, case 6: <D.20987>, case 7: <D.20991>, case 8: <D.20988>, case 9: <D.20992>, case 10: <D.20989>, case 11: <D.20993>, case 12: <D.20995>, case 13: <D.20996>>
  <D.20986>:
  <D.20987>:
  <D.20988>:
  <D.20989>:
  if (esize < vsize) goto <D.30660>; else goto <D.30661>;
  <D.30660>:
  D.30662 = mono_get_exception_argument ("value", "not a widening conversion");
  mono_raise_exception (D.30662);
  <D.30661>:
  D.30663 = (signed char) i64;
  MEM[(gint8 *)ea] = D.30663;
  return;
  <D.20990>:
  <D.20991>:
  <D.20992>:
  <D.20993>:
  <D.20994>:
  if (vsize >= esize) goto <D.30664>; else goto <D.30665>;
  <D.30664>:
  D.30666 = mono_get_exception_argument ("value", "not a widening conversion");
  mono_raise_exception (D.30666);
  <D.30665>:
  D.30667 = (signed char) u64;
  MEM[(gint8 *)ea] = D.30667;
  return;
  <D.20995>:
  <D.20996>:
  D.30668 = mono_get_exception_argument ("value", "not a widening conversion");
  mono_raise_exception (D.30668);
  <D.30669>:
  <D.20997>:
  switch (vt) <default: <D.30679>, case 3: <D.21006>, case 4: <D.20998>, case 5: <D.21002>, case 6: <D.20999>, case 7: <D.21003>, case 8: <D.21000>, case 9: <D.21004>, case 10: <D.21001>, case 11: <D.21005>, case 12: <D.21007>, case 13: <D.21008>>
  <D.20998>:
  <D.20999>:
  <D.21000>:
  <D.21001>:
  if (esize < vsize) goto <D.30670>; else goto <D.30671>;
  <D.30670>:
  D.30672 = mono_get_exception_argument ("value", "not a widening conversion");
  mono_raise_exception (D.30672);
  <D.30671>:
  D.30673 = (short int) i64;
  MEM[(gint16 *)ea] = D.30673;
  return;
  <D.21002>:
  <D.21003>:
  <D.21004>:
  <D.21005>:
  <D.21006>:
  if (vsize >= esize) goto <D.30674>; else goto <D.30675>;
  <D.30674>:
  D.30676 = mono_get_exception_argument ("value", "not a widening conversion");
  mono_raise_exception (D.30676);
  <D.30675>:
  D.30677 = (short int) u64;
  MEM[(gint16 *)ea] = D.30677;
  return;
  <D.21007>:
  <D.21008>:
  D.30678 = mono_get_exception_argument ("value", "not a widening conversion");
  mono_raise_exception (D.30678);
  <D.30679>:
  <D.21009>:
  switch (vt) <default: <D.30689>, case 3: <D.21018>, case 4: <D.21010>, case 5: <D.21014>, case 6: <D.21011>, case 7: <D.21015>, case 8: <D.21012>, case 9: <D.21016>, case 10: <D.21013>, case 11: <D.21017>, case 12: <D.21019>, case 13: <D.21020>>
  <D.21010>:
  <D.21011>:
  <D.21012>:
  <D.21013>:
  if (esize < vsize) goto <D.30680>; else goto <D.30681>;
  <D.30680>:
  D.30682 = mono_get_exception_argument ("value", "not a widening conversion");
  mono_raise_exception (D.30682);
  <D.30681>:
  D.30683 = (int) i64;
  MEM[(gint32 *)ea] = D.30683;
  return;
  <D.21014>:
  <D.21015>:
  <D.21016>:
  <D.21017>:
  <D.21018>:
  if (vsize >= esize) goto <D.30684>; else goto <D.30685>;
  <D.30684>:
  D.30686 = mono_get_exception_argument ("value", "not a widening conversion");
  mono_raise_exception (D.30686);
  <D.30685>:
  D.30687 = (int) u64;
  MEM[(gint32 *)ea] = D.30687;
  return;
  <D.21019>:
  <D.21020>:
  D.30688 = mono_get_exception_argument ("value", "not a widening conversion");
  mono_raise_exception (D.30688);
  <D.30689>:
  <D.21021>:
  switch (vt) <default: <D.30698>, case 3: <D.21030>, case 4: <D.21022>, case 5: <D.21026>, case 6: <D.21023>, case 7: <D.21027>, case 8: <D.21024>, case 9: <D.21028>, case 10: <D.21025>, case 11: <D.21029>, case 12: <D.21031>, case 13: <D.21032>>
  <D.21022>:
  <D.21023>:
  <D.21024>:
  <D.21025>:
  if (esize < vsize) goto <D.30690>; else goto <D.30691>;
  <D.30690>:
  D.30692 = mono_get_exception_argument ("value", "not a widening conversion");
  mono_raise_exception (D.30692);
  <D.30691>:
  MEM[(gint64 *)ea] = i64;
  return;
  <D.21026>:
  <D.21027>:
  <D.21028>:
  <D.21029>:
  <D.21030>:
  if (vsize >= esize) goto <D.30693>; else goto <D.30694>;
  <D.30693>:
  D.30695 = mono_get_exception_argument ("value", "not a widening conversion");
  mono_raise_exception (D.30695);
  <D.30694>:
  u64.189 = (long int) u64;
  MEM[(gint64 *)ea] = u64.189;
  return;
  <D.21031>:
  <D.21032>:
  D.30697 = mono_get_exception_argument ("value", "not a widening conversion");
  mono_raise_exception (D.30697);
  <D.30698>:
  <D.21033>:
  switch (vt) <default: <D.30705>, case 3: <D.21044>, case 4: <D.21036>, case 5: <D.21040>, case 6: <D.21037>, case 7: <D.21041>, case 8: <D.21038>, case 9: <D.21042>, case 10: <D.21039>, case 11: <D.21043>, case 12: <D.21034>, case 13: <D.21035>>
  <D.21034>:
  <D.21035>:
  if (esize < vsize) goto <D.30699>; else goto <D.30700>;
  <D.30699>:
  D.30701 = mono_get_exception_argument ("value", "not a widening conversion");
  mono_raise_exception (D.30701);
  <D.30700>:
  D.30702 = (float) r64;
  MEM[(gfloat *)ea] = D.30702;
  return;
  <D.21036>:
  <D.21037>:
  <D.21038>:
  <D.21039>:
  D.30703 = (float) i64;
  MEM[(gfloat *)ea] = D.30703;
  return;
  <D.21040>:
  <D.21041>:
  <D.21042>:
  <D.21043>:
  <D.21044>:
  D.30704 = (float) u64;
  MEM[(gfloat *)ea] = D.30704;
  return;
  <D.30705>:
  <D.21045>:
  switch (vt) <default: <D.30711>, case 3: <D.21056>, case 4: <D.21048>, case 5: <D.21052>, case 6: <D.21049>, case 7: <D.21053>, case 8: <D.21050>, case 9: <D.21054>, case 10: <D.21051>, case 11: <D.21055>, case 12: <D.21046>, case 13: <D.21047>>
  <D.21046>:
  <D.21047>:
  if (esize < vsize) goto <D.30706>; else goto <D.30707>;
  <D.30706>:
  D.30708 = mono_get_exception_argument ("value", "not a widening conversion");
  mono_raise_exception (D.30708);
  <D.30707>:
  MEM[(gdouble *)ea] = r64;
  return;
  <D.21048>:
  <D.21049>:
  <D.21050>:
  <D.21051>:
  D.30709 = (double) i64;
  MEM[(gdouble *)ea] = D.30709;
  return;
  <D.21052>:
  <D.21053>:
  <D.21054>:
  <D.21055>:
  <D.21056>:
  D.30710 = (double) u64;
  MEM[(gdouble *)ea] = D.30710;
  return;
  <D.30711>:
  <D.30712>:
  D.30713 = mono_get_runtime_callbacks ();
  D.30714 = D.30713->set_cast_details;
  D.30714 (vc, ec);
  D.30715 = mono_get_exception_invalid_cast ();
  mono_raise_exception (D.30715);
  return;
}


ves_icall_System_Array_SetValue (struct MonoArray * this, struct MonoObject * value, struct MonoArray * idxs)
{
  _Bool D.30719;
  long int D.30720;
  long int D.30721;
  struct MonoVTable * D.30726;
  struct MonoVTable * D.30727;
  unsigned char D.30728;
  _Bool D.30729;
  long int D.30730;
  long int D.30731;
  struct MonoArrayBounds * D.30736;
  unsigned int D.30738;
  unsigned char D.30739;
  unsigned int D.30740;
  struct MonoException * D.30741;
  struct MonoArrayBounds * D.30742;
  int D.30747;
  unsigned int D.30749;
  unsigned int D.30750;
  struct MonoException * D.30751;
  unsigned int D.30752;
  long unsigned int D.30755;
  long unsigned int D.30756;
  gint32 * D.30757;
  int D.30758;
  long unsigned int D.30759;
  struct MonoArrayBounds * D.30760;
  int D.30761;
  unsigned int D.30763;
  int D.30764;
  int D.30765;
  struct MonoException * D.30766;
  int D.30767;
  int D.30768;
  unsigned int pos.190;
  unsigned int D.30770;
  unsigned int D.30771;
  unsigned int D.30772;
  unsigned int D.30773;
  unsigned int D.30774;
  unsigned int pos.191;
  struct MonoClass * ac;
  struct MonoClass * ic;
  gint32 i;
  gint32 pos;
  gint32 * ind;

  D.30719 = idxs == 0B;
  D.30720 = (long int) D.30719;
  D.30721 = __builtin_expect (D.30720, 0);
  if (D.30721 != 0) goto <D.30722>; else goto <D.30723>;
  <D.30722>:
  {
    struct MonoException * ex;

    if (idxs != 0B) goto <D.30724>; else goto <D.30725>;
    <D.30724>:
    <D.30725>:
    ex = mono_get_exception_argument_null ("idxs");
    mono_raise_exception (ex);
  }
  <D.30723>:
  D.30726 = idxs->obj.vtable;
  ic = D.30726->klass;
  D.30727 = this->obj.vtable;
  ac = D.30727->klass;
  D.30728 = ic->rank;
  D.30729 = D.30728 != 1;
  D.30730 = (long int) D.30729;
  D.30731 = __builtin_expect (D.30730, 0);
  if (D.30731 != 0) goto <D.30732>; else goto <D.30733>;
  <D.30732>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 502, "ic->rank == 1");
  <D.30733>:
  D.30736 = idxs->bounds;
  if (D.30736 != 0B) goto <D.30734>; else goto <D.30737>;
  <D.30737>:
  D.30738 = idxs->max_length;
  D.30739 = ac->rank;
  D.30740 = (unsigned int) D.30739;
  if (D.30738 != D.30740) goto <D.30734>; else goto <D.30735>;
  <D.30734>:
  D.30741 = mono_get_exception_argument (0B, 0B);
  mono_raise_exception (D.30741);
  <D.30735>:
  ind = &idxs->vector;
  D.30742 = this->bounds;
  if (D.30742 == 0B) goto <D.30743>; else goto <D.30744>;
  <D.30743>:
  D.30747 = *ind;
  if (D.30747 < 0) goto <D.30745>; else goto <D.30748>;
  <D.30748>:
  D.30747 = *ind;
  D.30749 = (unsigned int) D.30747;
  D.30750 = this->max_length;
  if (D.30749 >= D.30750) goto <D.30745>; else goto <D.30746>;
  <D.30745>:
  D.30751 = mono_get_exception_index_out_of_range ();
  mono_raise_exception (D.30751);
  <D.30746>:
  D.30747 = *ind;
  D.30752 = (unsigned int) D.30747;
  ves_icall_System_Array_SetValueImpl (this, value, D.30752);
  return;
  <D.30744>:
  i = 0;
  goto <D.21069>;
  <D.21068>:
  D.30755 = (long unsigned int) i;
  D.30756 = D.30755 * 4;
  D.30757 = ind + D.30756;
  D.30758 = *D.30757;
  D.30742 = this->bounds;
  D.30755 = (long unsigned int) i;
  D.30759 = D.30755 * 8;
  D.30760 = D.30742 + D.30759;
  D.30761 = D.30760->lower_bound;
  if (D.30758 < D.30761) goto <D.30753>; else goto <D.30762>;
  <D.30762>:
  D.30755 = (long unsigned int) i;
  D.30756 = D.30755 * 4;
  D.30757 = ind + D.30756;
  D.30758 = *D.30757;
  D.30742 = this->bounds;
  D.30755 = (long unsigned int) i;
  D.30759 = D.30755 * 8;
  D.30760 = D.30742 + D.30759;
  D.30763 = D.30760->length;
  D.30764 = (int) D.30763;
  D.30742 = this->bounds;
  D.30755 = (long unsigned int) i;
  D.30759 = D.30755 * 8;
  D.30760 = D.30742 + D.30759;
  D.30761 = D.30760->lower_bound;
  D.30765 = D.30764 + D.30761;
  if (D.30758 >= D.30765) goto <D.30753>; else goto <D.30754>;
  <D.30753>:
  D.30766 = mono_get_exception_index_out_of_range ();
  mono_raise_exception (D.30766);
  <D.30754>:
  i = i + 1;
  <D.21069>:
  D.30739 = ac->rank;
  D.30767 = (int) D.30739;
  if (D.30767 > i) goto <D.21068>; else goto <D.21070>;
  <D.21070>:
  D.30747 = *ind;
  D.30742 = this->bounds;
  D.30768 = D.30742->lower_bound;
  pos = D.30747 - D.30768;
  i = 1;
  goto <D.21072>;
  <D.21071>:
  D.30742 = this->bounds;
  D.30755 = (long unsigned int) i;
  D.30759 = D.30755 * 8;
  D.30760 = D.30742 + D.30759;
  D.30763 = D.30760->length;
  pos.190 = (unsigned int) pos;
  D.30770 = D.30763 * pos.190;
  D.30755 = (long unsigned int) i;
  D.30756 = D.30755 * 4;
  D.30757 = ind + D.30756;
  D.30758 = *D.30757;
  D.30771 = (unsigned int) D.30758;
  D.30772 = D.30770 + D.30771;
  D.30742 = this->bounds;
  D.30755 = (long unsigned int) i;
  D.30759 = D.30755 * 8;
  D.30760 = D.30742 + D.30759;
  D.30761 = D.30760->lower_bound;
  D.30773 = (unsigned int) D.30761;
  D.30774 = D.30772 - D.30773;
  pos = (gint32) D.30774;
  i = i + 1;
  <D.21072>:
  D.30739 = ac->rank;
  D.30767 = (int) D.30739;
  if (D.30767 > i) goto <D.21071>; else goto <D.21073>;
  <D.21073>:
  pos.191 = (unsigned int) pos;
  ves_icall_System_Array_SetValueImpl (this, value, pos.191);
}


ves_icall_System_Array_SetGenericValueImpl (struct MonoObject * this, guint32 pos, void * value)
{
  struct MonoVTable * D.30777;
  double[0:] * D.30778;
  unsigned int esize.192;
  unsigned int D.30780;
  sizetype D.30781;
  struct MonoType * D.30782;
  int D.30783;
  _Bool D.30786;
  long int D.30787;
  long int D.30788;
  void * D.30791;
  long unsigned int D.30793;
  signed long D.30794;
  _Bool D.30795;
  long int D.30796;
  long int D.30797;
  int D.30800;
  _Bool D.30801;
  long int D.30802;
  long int D.30803;
  long unsigned int D.30806;
  long unsigned int D.30810;
  struct MonoClass * ac;
  struct MonoClass * ec;
  struct MonoArray * ao;
  gint32 esize;
  void * * ea;

  ao = this;
  D.30777 = ao->obj.vtable;
  ac = D.30777->klass;
  ec = ac->element_class;
  esize = mono_array_element_size (ac);
  D.30778 = &ao->vector;
  esize.192 = (unsigned int) esize;
  D.30780 = pos * esize.192;
  D.30781 = (sizetype) D.30780;
  ea = D.30778 + D.30781;
  D.30782 = &ec->byval_arg;
  D.30783 = mono_type_is_reference (D.30782);
  if (D.30783 != 0) goto <D.30784>; else goto <D.30785>;
  <D.30784>:
  D.30786 = esize != 8;
  D.30787 = (long int) D.30786;
  D.30788 = __builtin_expect (D.30787, 0);
  if (D.30788 != 0) goto <D.30789>; else goto <D.30790>;
  <D.30789>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 793, "esize == sizeof (gpointer)");
  <D.30790>:
  D.30791 = MEM[(void * *)value];
  mono_gc_wbarrier_generic_store (ea, D.30791);
  goto <D.30792>;
  <D.30785>:
  D.30793 = BIT_FIELD_REF <*ec, 64, 256>;
  D.30794 = (signed long) D.30793;
  D.30795 = D.30794 >= 0;
  D.30796 = (long int) D.30795;
  D.30797 = __builtin_expect (D.30796, 0);
  if (D.30797 != 0) goto <D.30798>; else goto <D.30799>;
  <D.30798>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 796, "ec->inited");
  <D.30799>:
  D.30800 = mono_class_value_size (ec, 0B);
  D.30801 = D.30800 != esize;
  D.30802 = (long int) D.30801;
  D.30803 = __builtin_expect (D.30802, 0);
  if (D.30803 != 0) goto <D.30804>; else goto <D.30805>;
  <D.30804>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 797, "esize == mono_class_value_size (ec, NULL)");
  <D.30805>:
  D.30793 = BIT_FIELD_REF <*ec, 64, 256>;
  D.30806 = D.30793 & 68719476736;
  if (D.30806 != 0) goto <D.30807>; else goto <D.30808>;
  <D.30807>:
  mono_gc_wbarrier_value_copy (ea, value, 1, ec);
  goto <D.30809>;
  <D.30808>:
  D.30810 = (long unsigned int) esize;
  mono_gc_memmove_atomic (ea, value, D.30810);
  <D.30809>:
  <D.30792>:
}


ves_icall_System_Array_GetValueImpl (struct MonoObject * this, guint32 pos)
{
  struct MonoVTable * D.30811;
  double[0:] * D.30812;
  unsigned int esize.193;
  unsigned int D.30814;
  sizetype D.30815;
  struct MonoClass * D.30816;
  long unsigned int D.30817;
  long unsigned int D.30818;
  struct MonoObject * D.30821;
  struct MonoVTable * D.30822;
  struct MonoDomain * D.30823;
  struct MonoClass * ac;
  struct MonoArray * ao;
  gint32 esize;
  void * * ea;

  ao = this;
  D.30811 = ao->obj.vtable;
  ac = D.30811->klass;
  esize = mono_array_element_size (ac);
  D.30812 = &ao->vector;
  esize.193 = (unsigned int) esize;
  D.30814 = pos * esize.193;
  D.30815 = (sizetype) D.30814;
  ea = D.30812 + D.30815;
  D.30816 = ac->element_class;
  D.30817 = BIT_FIELD_REF <*D.30816, 64, 256>;
  D.30818 = D.30817 & 1152921504606846976;
  if (D.30818 != 0) goto <D.30819>; else goto <D.30820>;
  <D.30819>:
  D.30822 = this->vtable;
  D.30823 = D.30822->domain;
  D.30816 = ac->element_class;
  D.30821 = mono_value_box (D.30823, D.30816, ea);
  return D.30821;
  <D.30820>:
  D.30821 = *ea;
  return D.30821;
}


ves_icall_System_Array_GetValue (struct MonoObject * this, struct MonoObject * idxs)
{
  _Bool D.30825;
  long int D.30826;
  long int D.30827;
  struct MonoVTable * D.30832;
  struct MonoVTable * D.30833;
  unsigned char D.30834;
  _Bool D.30835;
  long int D.30836;
  long int D.30837;
  struct MonoArrayBounds * D.30842;
  unsigned int D.30844;
  unsigned char D.30845;
  unsigned int D.30846;
  struct MonoException * D.30847;
  struct MonoArrayBounds * D.30848;
  int D.30853;
  unsigned int D.30855;
  unsigned int D.30856;
  struct MonoException * D.30857;
  struct MonoObject * D.30858;
  unsigned int D.30859;
  long unsigned int D.30862;
  long unsigned int D.30863;
  gint32 * D.30864;
  int D.30865;
  long unsigned int D.30866;
  struct MonoArrayBounds * D.30867;
  int D.30868;
  unsigned int D.30870;
  int D.30871;
  int D.30872;
  struct MonoException * D.30873;
  int D.30874;
  int D.30875;
  unsigned int pos.194;
  unsigned int D.30877;
  unsigned int D.30878;
  unsigned int D.30879;
  unsigned int D.30880;
  unsigned int D.30881;
  unsigned int pos.195;
  struct MonoClass * ac;
  struct MonoClass * ic;
  struct MonoArray * ao;
  struct MonoArray * io;
  gint32 i;
  gint32 pos;
  gint32 * ind;

  D.30825 = idxs == 0B;
  D.30826 = (long int) D.30825;
  D.30827 = __builtin_expect (D.30826, 0);
  if (D.30827 != 0) goto <D.30828>; else goto <D.30829>;
  <D.30828>:
  {
    struct MonoException * ex;

    if (idxs != 0B) goto <D.30830>; else goto <D.30831>;
    <D.30830>:
    <D.30831>:
    ex = mono_get_exception_argument_null ("idxs");
    mono_raise_exception (ex);
  }
  <D.30829>:
  io = idxs;
  D.30832 = io->obj.vtable;
  ic = D.30832->klass;
  ao = this;
  D.30833 = ao->obj.vtable;
  ac = D.30833->klass;
  D.30834 = ic->rank;
  D.30835 = D.30834 != 1;
  D.30836 = (long int) D.30835;
  D.30837 = __builtin_expect (D.30836, 0);
  if (D.30837 != 0) goto <D.30838>; else goto <D.30839>;
  <D.30838>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 184, "ic->rank == 1");
  <D.30839>:
  D.30842 = io->bounds;
  if (D.30842 != 0B) goto <D.30840>; else goto <D.30843>;
  <D.30843>:
  D.30844 = io->max_length;
  D.30845 = ac->rank;
  D.30846 = (unsigned int) D.30845;
  if (D.30844 != D.30846) goto <D.30840>; else goto <D.30841>;
  <D.30840>:
  D.30847 = mono_get_exception_argument (0B, 0B);
  mono_raise_exception (D.30847);
  <D.30841>:
  ind = &io->vector;
  D.30848 = ao->bounds;
  if (D.30848 == 0B) goto <D.30849>; else goto <D.30850>;
  <D.30849>:
  D.30853 = *ind;
  if (D.30853 < 0) goto <D.30851>; else goto <D.30854>;
  <D.30854>:
  D.30853 = *ind;
  D.30855 = (unsigned int) D.30853;
  D.30856 = ao->max_length;
  if (D.30855 >= D.30856) goto <D.30851>; else goto <D.30852>;
  <D.30851>:
  D.30857 = mono_get_exception_index_out_of_range ();
  mono_raise_exception (D.30857);
  <D.30852>:
  D.30853 = *ind;
  D.30859 = (unsigned int) D.30853;
  D.30858 = ves_icall_System_Array_GetValueImpl (this, D.30859);
  return D.30858;
  <D.30850>:
  i = 0;
  goto <D.20858>;
  <D.20857>:
  D.30862 = (long unsigned int) i;
  D.30863 = D.30862 * 4;
  D.30864 = ind + D.30863;
  D.30865 = *D.30864;
  D.30848 = ao->bounds;
  D.30862 = (long unsigned int) i;
  D.30866 = D.30862 * 8;
  D.30867 = D.30848 + D.30866;
  D.30868 = D.30867->lower_bound;
  if (D.30865 < D.30868) goto <D.30860>; else goto <D.30869>;
  <D.30869>:
  D.30862 = (long unsigned int) i;
  D.30863 = D.30862 * 4;
  D.30864 = ind + D.30863;
  D.30865 = *D.30864;
  D.30848 = ao->bounds;
  D.30862 = (long unsigned int) i;
  D.30866 = D.30862 * 8;
  D.30867 = D.30848 + D.30866;
  D.30870 = D.30867->length;
  D.30871 = (int) D.30870;
  D.30848 = ao->bounds;
  D.30862 = (long unsigned int) i;
  D.30866 = D.30862 * 8;
  D.30867 = D.30848 + D.30866;
  D.30868 = D.30867->lower_bound;
  D.30872 = D.30871 + D.30868;
  if (D.30865 >= D.30872) goto <D.30860>; else goto <D.30861>;
  <D.30860>:
  D.30873 = mono_get_exception_index_out_of_range ();
  mono_raise_exception (D.30873);
  <D.30861>:
  i = i + 1;
  <D.20858>:
  D.30845 = ac->rank;
  D.30874 = (int) D.30845;
  if (D.30874 > i) goto <D.20857>; else goto <D.20859>;
  <D.20859>:
  D.30853 = *ind;
  D.30848 = ao->bounds;
  D.30875 = D.30848->lower_bound;
  pos = D.30853 - D.30875;
  i = 1;
  goto <D.20861>;
  <D.20860>:
  D.30848 = ao->bounds;
  D.30862 = (long unsigned int) i;
  D.30866 = D.30862 * 8;
  D.30867 = D.30848 + D.30866;
  D.30870 = D.30867->length;
  pos.194 = (unsigned int) pos;
  D.30877 = D.30870 * pos.194;
  D.30862 = (long unsigned int) i;
  D.30863 = D.30862 * 4;
  D.30864 = ind + D.30863;
  D.30865 = *D.30864;
  D.30878 = (unsigned int) D.30865;
  D.30879 = D.30877 + D.30878;
  D.30848 = ao->bounds;
  D.30862 = (long unsigned int) i;
  D.30866 = D.30862 * 8;
  D.30867 = D.30848 + D.30866;
  D.30868 = D.30867->lower_bound;
  D.30880 = (unsigned int) D.30868;
  D.30881 = D.30879 - D.30880;
  pos = (gint32) D.30881;
  i = i + 1;
  <D.20861>:
  D.30845 = ac->rank;
  D.30874 = (int) D.30845;
  if (D.30874 > i) goto <D.20860>; else goto <D.20862>;
  <D.20862>:
  pos.195 = (unsigned int) pos;
  D.30858 = ves_icall_System_Array_GetValueImpl (this, pos.195);
  return D.30858;
}


ves_icall_System_Array_GetRank (struct MonoObject * this)
{
  gint32 D.30884;
  struct MonoVTable * D.30885;
  struct MonoClass * D.30886;
  unsigned char D.30887;

  D.30885 = this->vtable;
  D.30886 = D.30885->klass;
  D.30887 = D.30886->rank;
  D.30884 = (gint32) D.30887;
  return D.30884;
}


ves_icall_System_Array_GetLowerBound (struct MonoArray * this, gint32 dimension)
{
  struct MonoVTable * D.30889;
  struct MonoClass * D.30890;
  unsigned char D.30891;
  struct MonoException * D.30895;
  struct MonoArrayBounds * D.30896;
  gint32 D.30899;
  long unsigned int D.30900;
  long unsigned int D.30901;
  struct MonoArrayBounds * D.30902;
  gint32 rank;

  D.30889 = MEM[(struct MonoObject *)this].vtable;
  D.30890 = D.30889->klass;
  D.30891 = D.30890->rank;
  rank = (gint32) D.30891;
  if (dimension < 0) goto <D.30892>; else goto <D.30894>;
  <D.30894>:
  if (dimension >= rank) goto <D.30892>; else goto <D.30893>;
  <D.30892>:
  D.30895 = mono_get_exception_index_out_of_range ();
  mono_raise_exception (D.30895);
  <D.30893>:
  D.30896 = this->bounds;
  if (D.30896 == 0B) goto <D.30897>; else goto <D.30898>;
  <D.30897>:
  D.30899 = 0;
  return D.30899;
  <D.30898>:
  D.30896 = this->bounds;
  D.30900 = (long unsigned int) dimension;
  D.30901 = D.30900 * 8;
  D.30902 = D.30896 + D.30901;
  D.30899 = D.30902->lower_bound;
  return D.30899;
}


ves_icall_System_Array_GetLongLength (struct MonoArray * this, gint32 dimension)
{
  struct MonoVTable * D.30904;
  struct MonoClass * D.30905;
  unsigned char D.30906;
  struct MonoException * D.30910;
  struct MonoArrayBounds * D.30911;
  gint64 D.30914;
  unsigned int D.30915;
  long unsigned int D.30916;
  long unsigned int D.30917;
  struct MonoArrayBounds * D.30918;
  unsigned int D.30919;
  gint32 rank;

  D.30904 = MEM[(struct MonoObject *)this].vtable;
  D.30905 = D.30904->klass;
  D.30906 = D.30905->rank;
  rank = (gint32) D.30906;
  if (dimension < 0) goto <D.30907>; else goto <D.30909>;
  <D.30909>:
  if (dimension >= rank) goto <D.30907>; else goto <D.30908>;
  <D.30907>:
  D.30910 = mono_get_exception_index_out_of_range ();
  mono_raise_exception (D.30910);
  <D.30908>:
  D.30911 = this->bounds;
  if (D.30911 == 0B) goto <D.30912>; else goto <D.30913>;
  <D.30912>:
  D.30915 = this->max_length;
  D.30914 = (gint64) D.30915;
  return D.30914;
  <D.30913>:
  D.30911 = this->bounds;
  D.30916 = (long unsigned int) dimension;
  D.30917 = D.30916 * 8;
  D.30918 = D.30911 + D.30917;
  D.30919 = D.30918->length;
  D.30914 = (gint64) D.30919;
  return D.30914;
}


ves_icall_System_Array_GetLength (struct MonoArray * this, gint32 dimension)
{
  struct MonoVTable * D.30921;
  struct MonoClass * D.30922;
  unsigned char D.30923;
  struct MonoException * D.30927;
  struct MonoArrayBounds * D.30928;
  unsigned int D.30931;
  long unsigned int D.30933;
  long unsigned int D.30934;
  struct MonoArrayBounds * D.30935;
  unsigned int D.30936;
  gint32 D.30937;
  gint32 rank;
  uintptr_t length;

  D.30921 = MEM[(struct MonoObject *)this].vtable;
  D.30922 = D.30921->klass;
  D.30923 = D.30922->rank;
  rank = (gint32) D.30923;
  if (dimension < 0) goto <D.30924>; else goto <D.30926>;
  <D.30926>:
  if (dimension >= rank) goto <D.30924>; else goto <D.30925>;
  <D.30924>:
  D.30927 = mono_get_exception_index_out_of_range ();
  mono_raise_exception (D.30927);
  <D.30925>:
  D.30928 = this->bounds;
  if (D.30928 == 0B) goto <D.30929>; else goto <D.30930>;
  <D.30929>:
  D.30931 = this->max_length;
  length = (uintptr_t) D.30931;
  goto <D.30932>;
  <D.30930>:
  D.30928 = this->bounds;
  D.30933 = (long unsigned int) dimension;
  D.30934 = D.30933 * 8;
  D.30935 = D.30928 + D.30934;
  D.30936 = D.30935->length;
  length = (uintptr_t) D.30936;
  <D.30932>:
  D.30937 = (gint32) length;
  return D.30937;
}


ves_icall_System_Array_GetGenericValueImpl (struct MonoObject * this, guint32 pos, void * value)
{
  struct MonoVTable * D.30939;
  double[0:] * D.30940;
  unsigned int esize.196;
  unsigned int D.30942;
  sizetype D.30943;
  long unsigned int D.30944;
  struct MonoClass * ac;
  struct MonoArray * ao;
  gint32 esize;
  void * * ea;

  ao = this;
  D.30939 = ao->obj.vtable;
  ac = D.30939->klass;
  esize = mono_array_element_size (ac);
  D.30940 = &ao->vector;
  esize.196 = (unsigned int) esize;
  D.30942 = pos * esize.196;
  D.30943 = (sizetype) D.30942;
  ea = D.30940 + D.30943;
  D.30944 = (long unsigned int) esize;
  mono_gc_memmove_atomic (value, ea, D.30944);
}


ves_icall_System_Array_FastCopy (struct MonoArray * source, int source_idx, struct MonoArray * dest, int dest_idx, int length)
{
  unsigned char D.30945;
  unsigned char D.30946;
  gboolean D.30949;
  struct MonoArrayBounds * D.30952;
  struct MonoArrayBounds * D.30954;
  int D.30957;
  unsigned int D.30958;
  unsigned int D.30959;
  int D.30961;
  unsigned int D.30962;
  unsigned int D.30963;
  struct MonoClass * D.30964;
  struct MonoClass * D.30965;
  struct MonoClass * D.30966;
  long unsigned int D.30969;
  long unsigned int D.30970;
  long unsigned int D.30977;
  long unsigned int D.30979;
  long unsigned int D.30980;
  int D.30981;
  struct MonoVTable * D.30986;
  struct MonoClass * D.30987;
  double[0:] * D.30988;
  int D.30989;
  sizetype D.30990;
  long unsigned int D.30991;
  double[0:] * D.30995;
  int D.30996;
  sizetype D.30997;
  int D.30998;
  long unsigned int D.30999;
  long unsigned int D.31001;
  long unsigned int D.31002;
  long unsigned int D.31003;
  long unsigned int D.31004;
  int element_size;
  void * dest_addr;
  void * source_addr;
  struct MonoVTable * src_vtable;
  struct MonoVTable * dest_vtable;
  struct MonoClass * src_class;
  struct MonoClass * dest_class;

  src_vtable = source->obj.vtable;
  dest_vtable = dest->obj.vtable;
  D.30945 = src_vtable->rank;
  D.30946 = dest_vtable->rank;
  if (D.30945 != D.30946) goto <D.30947>; else goto <D.30948>;
  <D.30947>:
  D.30949 = 0;
  return D.30949;
  <D.30948>:
  D.30952 = source->bounds;
  if (D.30952 != 0B) goto <D.30950>; else goto <D.30953>;
  <D.30953>:
  D.30954 = dest->bounds;
  if (D.30954 != 0B) goto <D.30950>; else goto <D.30951>;
  <D.30950>:
  D.30949 = 0;
  return D.30949;
  <D.30951>:
  D.30957 = dest_idx + length;
  D.30958 = (unsigned int) D.30957;
  D.30959 = dest->max_length;
  if (D.30958 > D.30959) goto <D.30955>; else goto <D.30960>;
  <D.30960>:
  D.30961 = source_idx + length;
  D.30962 = (unsigned int) D.30961;
  D.30963 = source->max_length;
  if (D.30962 > D.30963) goto <D.30955>; else goto <D.30956>;
  <D.30955>:
  D.30949 = 0;
  return D.30949;
  <D.30956>:
  D.30964 = src_vtable->klass;
  src_class = D.30964->element_class;
  D.30965 = dest_vtable->klass;
  dest_class = D.30965->element_class;
  D.30966 = mono_defaults.object_class;
  if (D.30966 == src_class) goto <D.30967>; else goto <D.30968>;
  <D.30967>:
  D.30969 = BIT_FIELD_REF <*dest_class, 64, 256>;
  D.30970 = D.30969 & 1152921504606846976;
  if (D.30970 != 0) goto <D.30971>; else goto <D.30972>;
  <D.30971>:
  D.30949 = 0;
  return D.30949;
  <D.30972>:
  <D.30968>:
  if (src_class != dest_class) goto <D.30973>; else goto <D.30974>;
  <D.30973>:
  D.30969 = BIT_FIELD_REF <*dest_class, 64, 256>;
  D.30977 = D.30969 & 1729382256910270464;
  if (D.30977 != 0) goto <D.30975>; else goto <D.30978>;
  <D.30978>:
  D.30979 = BIT_FIELD_REF <*src_class, 64, 256>;
  D.30980 = D.30979 & 1729382256910270464;
  if (D.30980 != 0) goto <D.30975>; else goto <D.30976>;
  <D.30975>:
  D.30949 = 0;
  return D.30949;
  <D.30976>:
  D.30981 = mono_class_is_subclass_of (src_class, dest_class, 0);
  if (D.30981 == 0) goto <D.30982>; else goto <D.30983>;
  <D.30982>:
  D.30949 = 0;
  return D.30949;
  <D.30983>:
  <D.30974>:
  D.30969 = BIT_FIELD_REF <*dest_class, 64, 256>;
  D.30970 = D.30969 & 1152921504606846976;
  if (D.30970 != 0) goto <D.30984>; else goto <D.30985>;
  <D.30984>:
  D.30986 = source->obj.vtable;
  D.30987 = D.30986->klass;
  element_size = mono_array_element_size (D.30987);
  D.30988 = &source->vector;
  D.30989 = element_size * source_idx;
  D.30990 = (sizetype) D.30989;
  source_addr = D.30988 + D.30990;
  D.30969 = BIT_FIELD_REF <*dest_class, 64, 256>;
  D.30991 = D.30969 & 68719476736;
  if (D.30991 != 0) goto <D.30992>; else goto <D.30993>;
  <D.30992>:
  mono_value_copy_array (dest, dest_idx, source_addr, length);
  goto <D.30994>;
  <D.30993>:
  D.30995 = &dest->vector;
  D.30996 = element_size * dest_idx;
  D.30997 = (sizetype) D.30996;
  dest_addr = D.30995 + D.30997;
  D.30998 = element_size * length;
  D.30999 = (long unsigned int) D.30998;
  mono_gc_memmove_atomic (dest_addr, source_addr, D.30999);
  <D.30994>:
  goto <D.31000>;
  <D.30985>:
  {
    void * * __p;
    void * * __s;

    D.30995 = &dest->vector;
    D.31001 = (long unsigned int) dest_idx;
    D.31002 = D.31001 * 8;
    __p = D.30995 + D.31002;
    D.30988 = &source->vector;
    D.31003 = (long unsigned int) source_idx;
    D.31004 = D.31003 * 8;
    __s = D.30988 + D.31004;
    mono_gc_wbarrier_arrayref_copy (__p, __s, length);
  }
  <D.31000>:
  D.30949 = 1;
  return D.30949;
}


ves_icall_System_Array_CreateInstanceImpl64 (struct MonoReflectionType * type, struct MonoArray * lengths, struct MonoArray * bounds)
{
  _Bool D.31006;
  long int D.31007;
  long int D.31008;
  _Bool D.31013;
  long int D.31014;
  long int D.31015;
  long unsigned int D.31020;
  _Bool D.31021;
  long int D.31022;
  long int D.31023;
  long unsigned int D.31030;
  long unsigned int D.31031;
  _Bool D.31032;
  long int D.31033;
  long int D.31034;
  char * D.31041;
  long int D.31042;
  char * D.31044;
  long int D.31045;
  struct MonoException * D.31046;
  long unsigned int D.31047;
  struct MonoType * D.31048;
  long unsigned int D.31052;
  char * D.31054;
  long int D.31055;
  long unsigned int D.31057;
  unsigned int D.31058;
  unsigned char D.31059;
  long unsigned int D.31060;
  long unsigned int D.31061;
  long unsigned int D.31062;
  uintptr_t * D.31063;
  char * D.31064;
  long unsigned int D.31065;
  long unsigned int D.31068;
  long unsigned int D.31069;
  long unsigned int D.31070;
  uintptr_t * D.31071;
  char * D.31072;
  long unsigned int D.31073;
  unsigned int D.31074;
  long unsigned int D.31075;
  struct MonoVTable * D.31077;
  struct MonoDomain * D.31078;
  long unsigned int D.31079;
  intptr_t * D.31080;
  struct MonoArray * D.31081;
  struct MonoClass * aklass;
  struct MonoClass * klass;
  struct MonoArray * array;
  uintptr_t * sizes;
  uintptr_t i;
  gboolean bounded;

  bounded = 0;
  D.31006 = type == 0B;
  D.31007 = (long int) D.31006;
  D.31008 = __builtin_expect (D.31007, 0);
  if (D.31008 != 0) goto <D.31009>; else goto <D.31010>;
  <D.31009>:
  {
    struct MonoException * ex;

    if (type != 0B) goto <D.31011>; else goto <D.31012>;
    <D.31011>:
    <D.31012>:
    ex = mono_get_exception_argument_null ("type");
    mono_raise_exception (ex);
  }
  <D.31010>:
  D.31013 = lengths == 0B;
  D.31014 = (long int) D.31013;
  D.31015 = __builtin_expect (D.31014, 0);
  if (D.31015 != 0) goto <D.31016>; else goto <D.31017>;
  <D.31016>:
  {
    struct MonoException * ex;

    if (lengths != 0B) goto <D.31018>; else goto <D.31019>;
    <D.31018>:
    <D.31019>:
    ex = mono_get_exception_argument_null ("lengths");
    mono_raise_exception (ex);
  }
  <D.31017>:
  D.31020 = mono_array_length (lengths);
  D.31021 = D.31020 == 0;
  D.31022 = (long int) D.31021;
  D.31023 = __builtin_expect (D.31022, 0);
  if (D.31023 != 0) goto <D.31024>; else goto <D.31025>;
  <D.31024>:
  {
    struct MonoException * ex;
    char * msg;

    msg = monoeg_g_strdup_printf ("assertion `%s\' failed", "mono_array_length (lengths) > 0");
    if (lengths != 0B) goto <D.31026>; else goto <D.31027>;
    <D.31026>:
    <D.31027>:
    ex = mono_get_exception_argument ("lengths", msg);
    monoeg_g_free (msg);
    mono_raise_exception (ex);
  }
  <D.31025>:
  if (bounds != 0B) goto <D.31028>; else goto <D.31029>;
  <D.31028>:
  D.31030 = mono_array_length (lengths);
  D.31031 = mono_array_length (bounds);
  D.31032 = D.31030 != D.31031;
  D.31033 = (long int) D.31032;
  D.31034 = __builtin_expect (D.31033, 0);
  if (D.31034 != 0) goto <D.31035>; else goto <D.31036>;
  <D.31035>:
  {
    struct MonoException * ex;
    char * msg;

    msg = monoeg_g_strdup_printf ("assertion `%s\' failed", "mono_array_length (lengths) == mono_array_length (bounds)");
    if (bounds != 0B) goto <D.31037>; else goto <D.31038>;
    <D.31037>:
    <D.31038>:
    ex = mono_get_exception_argument ("bounds", msg);
    monoeg_g_free (msg);
    mono_raise_exception (ex);
  }
  <D.31036>:
  <D.31029>:
  i = 0;
  goto <D.21115>;
  <D.21114>:
  D.31041 = mono_array_addr_with_size (lengths, 8, i);
  D.31042 = MEM[(gint64 *)D.31041];
  if (D.31042 < 0) goto <D.31039>; else goto <D.31043>;
  <D.31043>:
  D.31044 = mono_array_addr_with_size (lengths, 8, i);
  D.31045 = MEM[(gint64 *)D.31044];
  if (D.31045 > 2147483647) goto <D.31039>; else goto <D.31040>;
  <D.31039>:
  D.31046 = mono_get_exception_argument_out_of_range (0B);
  mono_raise_exception (D.31046);
  <D.31040>:
  i = i + 1;
  <D.21115>:
  D.31047 = mono_array_length (lengths);
  if (D.31047 > i) goto <D.21114>; else goto <D.21116>;
  <D.21116>:
  D.31048 = type->type;
  klass = mono_class_from_mono_type (D.31048);
  mono_class_init_or_throw (klass);
  if (bounds != 0B) goto <D.31051>; else goto <D.31049>;
  <D.31051>:
  D.31052 = mono_array_length (bounds);
  if (D.31052 == 1) goto <D.31053>; else goto <D.31049>;
  <D.31053>:
  D.31054 = mono_array_addr_with_size (bounds, 8, 0);
  D.31055 = MEM[(gint64 *)D.31054];
  if (D.31055 != 0) goto <D.31056>; else goto <D.31049>;
  <D.31056>:
  bounded = 1;
  goto <D.31050>;
  <D.31049>:
  bounded = 0;
  <D.31050>:
  D.31057 = mono_array_length (lengths);
  D.31058 = (unsigned int) D.31057;
  aklass = mono_bounded_array_class_get (klass, D.31058, bounded);
  D.31059 = aklass->rank;
  D.31060 = (long unsigned int) D.31059;
  D.31061 = D.31060 * 16;
  sizes = __builtin_alloca (D.31061);
  i = 0;
  goto <D.21118>;
  <D.21117>:
  D.31062 = i * 8;
  D.31063 = sizes + D.31062;
  D.31064 = mono_array_addr_with_size (lengths, 8, i);
  D.31065 = MEM[(guint64 *)D.31064];
  *D.31063 = D.31065;
  if (bounds != 0B) goto <D.31066>; else goto <D.31067>;
  <D.31066>:
  D.31059 = aklass->rank;
  D.31068 = (long unsigned int) D.31059;
  D.31069 = D.31068 + i;
  D.31070 = D.31069 * 8;
  D.31071 = sizes + D.31070;
  D.31072 = mono_array_addr_with_size (bounds, 8, i);
  D.31073 = MEM[(guint64 *)D.31072];
  D.31074 = (unsigned int) D.31073;
  D.31075 = (long unsigned int) D.31074;
  *D.31071 = D.31075;
  goto <D.31076>;
  <D.31067>:
  D.31059 = aklass->rank;
  D.31068 = (long unsigned int) D.31059;
  D.31069 = D.31068 + i;
  D.31070 = D.31069 * 8;
  D.31071 = sizes + D.31070;
  *D.31071 = 0;
  <D.31076>:
  i = i + 1;
  <D.21118>:
  D.31059 = aklass->rank;
  D.31068 = (long unsigned int) D.31059;
  if (D.31068 > i) goto <D.21117>; else goto <D.21119>;
  <D.21119>:
  D.31077 = MEM[(struct MonoObject *)type].vtable;
  D.31078 = D.31077->domain;
  D.31059 = aklass->rank;
  D.31060 = (long unsigned int) D.31059;
  D.31079 = D.31060 * 8;
  D.31080 = sizes + D.31079;
  array = mono_array_new_full (D.31078, aklass, sizes, D.31080);
  D.31081 = array;
  return D.31081;
}


ves_icall_System_Array_CreateInstanceImpl (struct MonoReflectionType * type, struct MonoArray * lengths, struct MonoArray * bounds)
{
  _Bool D.31083;
  long int D.31084;
  long int D.31085;
  _Bool D.31090;
  long int D.31091;
  long int D.31092;
  long unsigned int D.31097;
  _Bool D.31098;
  long int D.31099;
  long int D.31100;
  long unsigned int D.31107;
  long unsigned int D.31108;
  _Bool D.31109;
  long int D.31110;
  long int D.31111;
  char * D.31116;
  int D.31117;
  struct MonoException * D.31120;
  long unsigned int D.31121;
  struct MonoType * D.31122;
  long unsigned int D.31126;
  char * D.31128;
  int D.31129;
  long unsigned int D.31131;
  unsigned int D.31132;
  unsigned char D.31133;
  long unsigned int D.31134;
  long unsigned int D.31135;
  long unsigned int D.31136;
  uintptr_t * D.31137;
  char * D.31138;
  unsigned int D.31139;
  long unsigned int D.31140;
  long unsigned int D.31143;
  long unsigned int D.31144;
  long unsigned int D.31145;
  uintptr_t * D.31146;
  char * D.31147;
  int D.31148;
  long unsigned int D.31149;
  struct MonoVTable * D.31151;
  struct MonoDomain * D.31152;
  long unsigned int D.31153;
  intptr_t * D.31154;
  struct MonoArray * D.31155;
  struct MonoClass * aklass;
  struct MonoClass * klass;
  struct MonoArray * array;
  uintptr_t * sizes;
  uintptr_t i;
  gboolean bounded;

  bounded = 0;
  D.31083 = type == 0B;
  D.31084 = (long int) D.31083;
  D.31085 = __builtin_expect (D.31084, 0);
  if (D.31085 != 0) goto <D.31086>; else goto <D.31087>;
  <D.31086>:
  {
    struct MonoException * ex;

    if (type != 0B) goto <D.31088>; else goto <D.31089>;
    <D.31088>:
    <D.31089>:
    ex = mono_get_exception_argument_null ("type");
    mono_raise_exception (ex);
  }
  <D.31087>:
  D.31090 = lengths == 0B;
  D.31091 = (long int) D.31090;
  D.31092 = __builtin_expect (D.31091, 0);
  if (D.31092 != 0) goto <D.31093>; else goto <D.31094>;
  <D.31093>:
  {
    struct MonoException * ex;

    if (lengths != 0B) goto <D.31095>; else goto <D.31096>;
    <D.31095>:
    <D.31096>:
    ex = mono_get_exception_argument_null ("lengths");
    mono_raise_exception (ex);
  }
  <D.31094>:
  D.31097 = mono_array_length (lengths);
  D.31098 = D.31097 == 0;
  D.31099 = (long int) D.31098;
  D.31100 = __builtin_expect (D.31099, 0);
  if (D.31100 != 0) goto <D.31101>; else goto <D.31102>;
  <D.31101>:
  {
    struct MonoException * ex;
    char * msg;

    msg = monoeg_g_strdup_printf ("assertion `%s\' failed", "mono_array_length (lengths) > 0");
    if (lengths != 0B) goto <D.31103>; else goto <D.31104>;
    <D.31103>:
    <D.31104>:
    ex = mono_get_exception_argument ("lengths", msg);
    monoeg_g_free (msg);
    mono_raise_exception (ex);
  }
  <D.31102>:
  if (bounds != 0B) goto <D.31105>; else goto <D.31106>;
  <D.31105>:
  D.31107 = mono_array_length (lengths);
  D.31108 = mono_array_length (bounds);
  D.31109 = D.31107 != D.31108;
  D.31110 = (long int) D.31109;
  D.31111 = __builtin_expect (D.31110, 0);
  if (D.31111 != 0) goto <D.31112>; else goto <D.31113>;
  <D.31112>:
  {
    struct MonoException * ex;
    char * msg;

    msg = monoeg_g_strdup_printf ("assertion `%s\' failed", "mono_array_length (lengths) == mono_array_length (bounds)");
    if (bounds != 0B) goto <D.31114>; else goto <D.31115>;
    <D.31114>:
    <D.31115>:
    ex = mono_get_exception_argument ("bounds", msg);
    monoeg_g_free (msg);
    mono_raise_exception (ex);
  }
  <D.31113>:
  <D.31106>:
  i = 0;
  goto <D.21092>;
  <D.21091>:
  D.31116 = mono_array_addr_with_size (lengths, 4, i);
  D.31117 = MEM[(gint32 *)D.31116];
  if (D.31117 < 0) goto <D.31118>; else goto <D.31119>;
  <D.31118>:
  D.31120 = mono_get_exception_argument_out_of_range (0B);
  mono_raise_exception (D.31120);
  <D.31119>:
  i = i + 1;
  <D.21092>:
  D.31121 = mono_array_length (lengths);
  if (D.31121 > i) goto <D.21091>; else goto <D.21093>;
  <D.21093>:
  D.31122 = type->type;
  klass = mono_class_from_mono_type (D.31122);
  mono_class_init_or_throw (klass);
  if (bounds != 0B) goto <D.31125>; else goto <D.31123>;
  <D.31125>:
  D.31126 = mono_array_length (bounds);
  if (D.31126 == 1) goto <D.31127>; else goto <D.31123>;
  <D.31127>:
  D.31128 = mono_array_addr_with_size (bounds, 4, 0);
  D.31129 = MEM[(gint32 *)D.31128];
  if (D.31129 != 0) goto <D.31130>; else goto <D.31123>;
  <D.31130>:
  bounded = 1;
  goto <D.31124>;
  <D.31123>:
  bounded = 0;
  <D.31124>:
  D.31131 = mono_array_length (lengths);
  D.31132 = (unsigned int) D.31131;
  aklass = mono_bounded_array_class_get (klass, D.31132, bounded);
  D.31133 = aklass->rank;
  D.31134 = (long unsigned int) D.31133;
  D.31135 = D.31134 * 16;
  sizes = __builtin_alloca (D.31135);
  i = 0;
  goto <D.21095>;
  <D.21094>:
  D.31136 = i * 8;
  D.31137 = sizes + D.31136;
  D.31138 = mono_array_addr_with_size (lengths, 4, i);
  D.31139 = MEM[(guint32 *)D.31138];
  D.31140 = (long unsigned int) D.31139;
  *D.31137 = D.31140;
  if (bounds != 0B) goto <D.31141>; else goto <D.31142>;
  <D.31141>:
  D.31133 = aklass->rank;
  D.31143 = (long unsigned int) D.31133;
  D.31144 = D.31143 + i;
  D.31145 = D.31144 * 8;
  D.31146 = sizes + D.31145;
  D.31147 = mono_array_addr_with_size (bounds, 4, i);
  D.31148 = MEM[(gint32 *)D.31147];
  D.31149 = (long unsigned int) D.31148;
  *D.31146 = D.31149;
  goto <D.31150>;
  <D.31142>:
  D.31133 = aklass->rank;
  D.31143 = (long unsigned int) D.31133;
  D.31144 = D.31143 + i;
  D.31145 = D.31144 * 8;
  D.31146 = sizes + D.31145;
  *D.31146 = 0;
  <D.31150>:
  i = i + 1;
  <D.21095>:
  D.31133 = aklass->rank;
  D.31143 = (long unsigned int) D.31133;
  if (D.31143 > i) goto <D.21094>; else goto <D.21096>;
  <D.21096>:
  D.31151 = MEM[(struct MonoObject *)type].vtable;
  D.31152 = D.31151->domain;
  D.31133 = aklass->rank;
  D.31134 = (long unsigned int) D.31133;
  D.31153 = D.31134 * 8;
  D.31154 = sizes + D.31153;
  array = mono_array_new_full (D.31152, aklass, sizes, D.31154);
  D.31155 = array;
  return D.31155;
}


ves_icall_System_Array_ClearInternal (struct MonoArray * arr, int idx, int length)
{
  struct MonoVTable * D.31157;
  struct MonoClass * D.31158;
  double[0:] * D.31159;
  int D.31160;
  sizetype D.31161;
  void * D.31162;
  int D.31163;
  long unsigned int D.31164;
  int sz;

  D.31157 = MEM[(struct MonoObject *)arr].vtable;
  D.31158 = D.31157->klass;
  sz = mono_array_element_size (D.31158);
  D.31159 = &arr->vector;
  D.31160 = sz * idx;
  D.31161 = (sizetype) D.31160;
  D.31162 = D.31159 + D.31161;
  D.31163 = length * sz;
  D.31164 = (long unsigned int) D.31163;
  mono_gc_bzero_atomic (D.31162, D.31164);
}


mono_ArgIterator_Setup (struct MonoArgIterator * iter, char * argsp, char * start)
{
  struct MonoMethodSignature * D.31165;
  struct MonoMethodSignature * D.31166;
  short int D.31167;
  int D.31168;
  short unsigned int D.31169;
  int D.31170;
  _Bool D.31171;
  long int D.31172;
  long int D.31173;
  long unsigned int D.31176;
  long unsigned int D.31177;
  _Bool D.31178;
  long int D.31179;
  long int D.31180;
  char * D.31186;
  int D.31187;

  D.31165 = MEM[(struct MonoMethodSignature * *)argsp];
  iter->sig = D.31165;
  D.31166 = iter->sig;
  D.31167 = D.31166->sentinelpos;
  D.31168 = (int) D.31167;
  D.31166 = iter->sig;
  D.31169 = D.31166->param_count;
  D.31170 = (int) D.31169;
  D.31171 = D.31168 > D.31170;
  D.31172 = (long int) D.31171;
  D.31173 = __builtin_expect (D.31172, 0);
  if (D.31173 != 0) goto <D.31174>; else goto <D.31175>;
  <D.31174>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 7168, "iter->sig->sentinelpos <= iter->sig->param_count");
  <D.31175>:
  D.31166 = iter->sig;
  D.31176 = BIT_FIELD_REF <*D.31166, 64, 64>;
  D.31177 = D.31176 & 64512;
  D.31178 = D.31177 != 5120;
  D.31179 = (long int) D.31178;
  D.31180 = __builtin_expect (D.31179, 0);
  if (D.31180 != 0) goto <D.31181>; else goto <D.31182>;
  <D.31181>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 7169, "iter->sig->call_convention == MONO_CALL_VARARG");
  <D.31182>:
  iter->next_arg = 0;
  if (start != 0B) goto <D.31183>; else goto <D.31184>;
  <D.31183>:
  iter->args = start;
  goto <D.31185>;
  <D.31184>:
  D.31186 = argsp + 8;
  iter->args = D.31186;
  <D.31185>:
  D.31166 = iter->sig;
  D.31169 = D.31166->param_count;
  D.31170 = (int) D.31169;
  D.31166 = iter->sig;
  D.31167 = D.31166->sentinelpos;
  D.31168 = (int) D.31167;
  D.31187 = D.31170 - D.31168;
  iter->num_args = D.31187;
}


mono_ArgIterator_IntGetNextArgType (struct MonoArgIterator * iter)
{
  struct MonoMethodSignature * D.31188;
  short int D.31189;
  int D.31190;
  int D.31191;
  short unsigned int D.31192;
  int D.31193;
  _Bool D.31194;
  long int D.31195;
  long int D.31196;
  struct MonoType * D.31199;
  gint i;

  D.31188 = iter->sig;
  D.31189 = D.31188->sentinelpos;
  D.31190 = (int) D.31189;
  D.31191 = iter->next_arg;
  i = D.31190 + D.31191;
  D.31188 = iter->sig;
  D.31192 = D.31188->param_count;
  D.31193 = (int) D.31192;
  D.31194 = D.31193 <= i;
  D.31195 = (long int) D.31194;
  D.31196 = __builtin_expect (D.31195, 0);
  if (D.31196 != 0) goto <D.31197>; else goto <D.31198>;
  <D.31197>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 7267, "i < iter->sig->param_count");
  <D.31198>:
  D.31188 = iter->sig;
  D.31199 = D.31188->params[i];
  return D.31199;
}


mono_ArgIterator_IntGetNextArgT (struct MonoArgIterator * iter, struct MonoType * type)
{
  struct MonoMethodSignature * D.31202;
  short int D.31203;
  int D.31204;
  int D.31205;
  int D.31206;
  short unsigned int D.31207;
  unsigned int D.31208;
  _Bool D.31209;
  long int D.31210;
  long int D.31211;
  struct MonoType * D.31214;
  int D.31215;
  struct MonoType * D.31218;
  struct MonoClass * D.31219;
  int D.31220;
  void * D.31221;
  sizetype D.31222;
  void * D.31223;
  int D.31224;
  guint32 i;
  guint32 arg_size;
  gint32 align;
  struct MonoTypedRef res;

  try
    {
      D.31202 = iter->sig;
      D.31203 = D.31202->sentinelpos;
      D.31204 = (int) D.31203;
      D.31205 = iter->next_arg;
      D.31206 = D.31204 + D.31205;
      i = (guint32) D.31206;
      D.31202 = iter->sig;
      D.31207 = D.31202->param_count;
      D.31208 = (unsigned int) D.31207;
      D.31209 = D.31208 <= i;
      D.31210 = (long int) D.31209;
      D.31211 = __builtin_expect (D.31210, 0);
      if (D.31211 != 0) goto <D.31212>; else goto <D.31213>;
      <D.31212>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 7233, "i < iter->sig->param_count");
      <D.31213>:
      goto <D.23384>;
      <D.23385>:
      D.31202 = iter->sig;
      D.31214 = D.31202->params[i];
      D.31215 = mono_metadata_type_equal (type, D.31214);
      if (D.31215 == 0) goto <D.31216>; else goto <D.31217>;
      <D.31216>:
      // predicted unlikely by continue predictor.
      goto <D.23384>;
      <D.31217>:
      D.31202 = iter->sig;
      D.31214 = D.31202->params[i];
      res.type = D.31214;
      D.31218 = res.type;
      D.31219 = mono_class_from_mono_type (D.31218);
      res.klass = D.31219;
      D.31218 = res.type;
      D.31220 = mono_type_stack_size (D.31218, &align);
      arg_size = (guint32) D.31220;
      D.31221 = iter->args;
      res.value = D.31221;
      D.31221 = iter->args;
      D.31222 = (sizetype) arg_size;
      D.31223 = D.31221 + D.31222;
      iter->args = D.31223;
      D.31205 = iter->next_arg;
      D.31224 = D.31205 + 1;
      iter->next_arg = D.31224;
      <retval> = res;
      return <retval>;
      <D.23384>:
      D.31202 = iter->sig;
      D.31207 = D.31202->param_count;
      D.31208 = (unsigned int) D.31207;
      if (D.31208 > i) goto <D.23385>; else goto <D.23386>;
      <D.23386>:
      res.type = 0B;
      res.value = 0B;
      res.klass = 0B;
      <retval> = res;
      return <retval>;
    }
  finally
    {
      align = {CLOBBER};
      res = {CLOBBER};
    }
}


mono_ArgIterator_IntGetNextArg (struct MonoArgIterator * iter)
{
  struct MonoMethodSignature * D.31228;
  short int D.31229;
  int D.31230;
  int D.31231;
  int D.31232;
  short unsigned int D.31233;
  unsigned int D.31234;
  _Bool D.31235;
  long int D.31236;
  long int D.31237;
  struct MonoType * D.31240;
  struct MonoType * D.31241;
  struct MonoClass * D.31242;
  int D.31243;
  void * D.31244;
  int D.31247;
  unsigned int D.31248;
  unsigned int D.31249;
  void * D.31250;
  sizetype D.31251;
  void * D.31252;
  sizetype D.31253;
  void * D.31254;
  int D.31255;
  guint32 i;
  guint32 arg_size;
  gint32 align;
  struct MonoTypedRef res;

  try
    {
      D.31228 = iter->sig;
      D.31229 = D.31228->sentinelpos;
      D.31230 = (int) D.31229;
      D.31231 = iter->next_arg;
      D.31232 = D.31230 + D.31231;
      i = (guint32) D.31232;
      D.31228 = iter->sig;
      D.31233 = D.31228->param_count;
      D.31234 = (unsigned int) D.31233;
      D.31235 = D.31234 <= i;
      D.31236 = (long int) D.31235;
      D.31237 = __builtin_expect (D.31236, 0);
      if (D.31237 != 0) goto <D.31238>; else goto <D.31239>;
      <D.31238>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 7193, "i < iter->sig->param_count");
      <D.31239>:
      D.31228 = iter->sig;
      D.31240 = D.31228->params[i];
      res.type = D.31240;
      D.31241 = res.type;
      D.31242 = mono_class_from_mono_type (D.31241);
      res.klass = D.31242;
      D.31241 = res.type;
      D.31243 = mono_type_stack_size (D.31241, &align);
      arg_size = (guint32) D.31243;
      D.31244 = iter->args;
      res.value = D.31244;
      if (arg_size <= 8) goto <D.31245>; else goto <D.31246>;
      <D.31245>:
      {
        int dummy;
        int padding;

        try
          {
            D.31241 = res.type;
            D.31247 = mono_type_size (D.31241, &dummy);
            D.31248 = (unsigned int) D.31247;
            D.31249 = arg_size - D.31248;
            padding = (int) D.31249;
            D.31250 = res.value;
            D.31251 = (sizetype) padding;
            D.31252 = D.31250 + D.31251;
            res.value = D.31252;
          }
        finally
          {
            dummy = {CLOBBER};
          }
      }
      <D.31246>:
      D.31244 = iter->args;
      D.31253 = (sizetype) arg_size;
      D.31254 = D.31244 + D.31253;
      iter->args = D.31254;
      D.31231 = iter->next_arg;
      D.31255 = D.31231 + 1;
      iter->next_arg = D.31255;
      <retval> = res;
      return <retval>;
    }
  finally
    {
      align = {CLOBBER};
      res = {CLOBBER};
    }
}


ves_icall_System_Activator_CreateInstanceInternal (struct MonoReflectionType * type)
{
  struct MonoVTable * D.31258;
  struct MonoType * D.31259;
  int D.31260;
  struct MonoObject * D.31263;
  struct MonoClass * klass;
  struct MonoDomain * domain;

  D.31258 = MEM[(struct MonoObject *)type].vtable;
  domain = D.31258->domain;
  D.31259 = type->type;
  klass = mono_class_from_mono_type (D.31259);
  mono_class_init_or_throw (klass);
  D.31260 = mono_class_is_nullable (klass);
  if (D.31260 != 0) goto <D.31261>; else goto <D.31262>;
  <D.31261>:
  D.31263 = 0B;
  return D.31263;
  <D.31262>:
  D.31263 = mono_object_new (domain, klass);
  return D.31263;
}


ves_icall_Mono_Runtime_GetDisplayName ()
{
  struct MonoRuntimeCallbacks * D.31265;
  char * (*<T28fb>) (void) D.31266;
  struct MonoDomain * D.31267;
  struct MonoString * D.31268;
  char * info;
  struct MonoString * display_name;

  D.31265 = mono_get_runtime_callbacks ();
  D.31266 = D.31265->get_runtime_build_info;
  info = D.31266 ();
  D.31267 = mono_domain_get ();
  display_name = mono_string_new (D.31267, info);
  monoeg_g_free (info);
  D.31268 = display_name;
  return D.31268;
}


compare_method_imap (const void * key, const void * elem)
{
  short unsigned int D.31270;
  sizetype D.31271;
  int D.31272;
  const char * method_name;

  D.31270 = MEM[(guint16 *)elem];
  D.31271 = (sizetype) D.31270;
  method_name = &icall_names_str + D.31271;
  D.31272 = strcmp (key, method_name);
  return D.31272;
}


mono_lookup_icall_symbol (struct MonoMethod * m)
{
  struct _IO_FILE * stderr.197;
  const char * D.31275;

  stderr.197 = stderr;
  fprintf (stderr.197, "icall symbol maps not enabled, pass --enable-icall-symbol-map to configure.\n");
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "icall.c", 8216);
  D.31275 = 0B;
  return D.31275;
}


__attribute__((__artificial__, __gnu_inline__, __always_inline__))
fprintf (struct FILE * restrict __stream, const char * restrict __fmt)
{
  int D.31277;

  D.31277 = __fprintf_chk (__stream, 1, __fmt, __builtin_va_arg_pack ());
  return D.31277;
}


__attribute__((visibility ("hidden")))
mono_create_icall_signature (const char * sigstr)
{
  struct GHashTable * D.31279;
  struct MonoMethodSignature * D.31282;
  gchar * D.31283;
  int D.31284;
  unsigned int D.31285;
  gchar * D.31286;
  struct MonoType * D.31287;
  int D.31288;
  long unsigned int D.31289;
  long unsigned int D.31290;
  gchar * * D.31291;
  gchar * D.31292;
  struct MonoType * D.31293;
  gchar * * parts;
  int i;
  int len;
  gchar * * tmp;
  struct MonoMethodSignature * res;
  struct MonoMethodSignature * res2;
  struct MonoImage * corlib;

  corlib = mono_defaults.corlib;
  mono_image_lock (corlib);
  D.31279 = corlib->helper_signatures;
  res = monoeg_g_hash_table_lookup (D.31279, sigstr);
  mono_image_unlock (corlib);
  if (res != 0B) goto <D.31280>; else goto <D.31281>;
  <D.31280>:
  D.31282 = res;
  return D.31282;
  <D.31281>:
  parts = monoeg_g_strsplit (sigstr, " ", 256);
  tmp = parts;
  len = 0;
  goto <D.25260>;
  <D.25259>:
  len = len + 1;
  tmp = tmp + 8;
  <D.25260>:
  D.31283 = *tmp;
  if (D.31283 != 0B) goto <D.25259>; else goto <D.25261>;
  <D.25261>:
  D.31284 = len + -1;
  D.31285 = (unsigned int) D.31284;
  res = mono_metadata_signature_alloc (corlib, D.31285);
  res->pinvoke = 1;
  D.31286 = *parts;
  D.31287 = type_from_typename (D.31286);
  res->ret = D.31287;
  i = 1;
  goto <D.25263>;
  <D.25262>:
  D.31288 = i + -1;
  D.31289 = (long unsigned int) i;
  D.31290 = D.31289 * 8;
  D.31291 = parts + D.31290;
  D.31292 = *D.31291;
  D.31293 = type_from_typename (D.31292);
  res->params[D.31288] = D.31293;
  i = i + 1;
  <D.25263>:
  if (i < len) goto <D.25262>; else goto <D.25264>;
  <D.25264>:
  monoeg_g_strfreev (parts);
  mono_image_lock (corlib);
  D.31279 = corlib->helper_signatures;
  res2 = monoeg_g_hash_table_lookup (D.31279, sigstr);
  if (res2 != 0B) goto <D.31294>; else goto <D.31295>;
  <D.31294>:
  res = res2;
  goto <D.31296>;
  <D.31295>:
  D.31279 = corlib->helper_signatures;
  monoeg_g_hash_table_insert_replace (D.31279, sigstr, res, 0);
  <D.31296>:
  mono_image_unlock (corlib);
  D.31282 = res;
  return D.31282;
}


type_from_typename (char * typename)
{
  int D.31298;
  int D.31302;
  int D.31306;
  int D.31310;
  int D.31314;
  int D.31318;
  int D.31322;
  int D.31326;
  int D.31330;
  int D.31334;
  int D.31338;
  int D.31342;
  int D.31346;
  int D.31350;
  int D.31354;
  int D.31358;
  int D.31362;
  int D.31366;
  struct MonoType * D.31370;
  struct MonoClass * klass;

  klass = 0B;
  D.31298 = strcmp (typename, "int");
  if (D.31298 == 0) goto <D.31299>; else goto <D.31300>;
  <D.31299>:
  klass = mono_defaults.int_class;
  goto <D.31301>;
  <D.31300>:
  D.31302 = strcmp (typename, "ptr");
  if (D.31302 == 0) goto <D.31303>; else goto <D.31304>;
  <D.31303>:
  klass = mono_defaults.int_class;
  goto <D.31305>;
  <D.31304>:
  D.31306 = strcmp (typename, "void");
  if (D.31306 == 0) goto <D.31307>; else goto <D.31308>;
  <D.31307>:
  klass = mono_defaults.void_class;
  goto <D.31309>;
  <D.31308>:
  D.31310 = strcmp (typename, "int32");
  if (D.31310 == 0) goto <D.31311>; else goto <D.31312>;
  <D.31311>:
  klass = mono_defaults.int32_class;
  goto <D.31313>;
  <D.31312>:
  D.31314 = strcmp (typename, "uint32");
  if (D.31314 == 0) goto <D.31315>; else goto <D.31316>;
  <D.31315>:
  klass = mono_defaults.uint32_class;
  goto <D.31317>;
  <D.31316>:
  D.31318 = strcmp (typename, "int8");
  if (D.31318 == 0) goto <D.31319>; else goto <D.31320>;
  <D.31319>:
  klass = mono_defaults.sbyte_class;
  goto <D.31321>;
  <D.31320>:
  D.31322 = strcmp (typename, "uint8");
  if (D.31322 == 0) goto <D.31323>; else goto <D.31324>;
  <D.31323>:
  klass = mono_defaults.byte_class;
  goto <D.31325>;
  <D.31324>:
  D.31326 = strcmp (typename, "int16");
  if (D.31326 == 0) goto <D.31327>; else goto <D.31328>;
  <D.31327>:
  klass = mono_defaults.int16_class;
  goto <D.31329>;
  <D.31328>:
  D.31330 = strcmp (typename, "uint16");
  if (D.31330 == 0) goto <D.31331>; else goto <D.31332>;
  <D.31331>:
  klass = mono_defaults.uint16_class;
  goto <D.31333>;
  <D.31332>:
  D.31334 = strcmp (typename, "long");
  if (D.31334 == 0) goto <D.31335>; else goto <D.31336>;
  <D.31335>:
  klass = mono_defaults.int64_class;
  goto <D.31337>;
  <D.31336>:
  D.31338 = strcmp (typename, "ulong");
  if (D.31338 == 0) goto <D.31339>; else goto <D.31340>;
  <D.31339>:
  klass = mono_defaults.uint64_class;
  goto <D.31341>;
  <D.31340>:
  D.31342 = strcmp (typename, "float");
  if (D.31342 == 0) goto <D.31343>; else goto <D.31344>;
  <D.31343>:
  klass = mono_defaults.single_class;
  goto <D.31345>;
  <D.31344>:
  D.31346 = strcmp (typename, "double");
  if (D.31346 == 0) goto <D.31347>; else goto <D.31348>;
  <D.31347>:
  klass = mono_defaults.double_class;
  goto <D.31349>;
  <D.31348>:
  D.31350 = strcmp (typename, "object");
  if (D.31350 == 0) goto <D.31351>; else goto <D.31352>;
  <D.31351>:
  klass = mono_defaults.object_class;
  goto <D.31353>;
  <D.31352>:
  D.31354 = strcmp (typename, "obj");
  if (D.31354 == 0) goto <D.31355>; else goto <D.31356>;
  <D.31355>:
  klass = mono_defaults.object_class;
  goto <D.31357>;
  <D.31356>:
  D.31358 = strcmp (typename, "string");
  if (D.31358 == 0) goto <D.31359>; else goto <D.31360>;
  <D.31359>:
  klass = mono_defaults.string_class;
  goto <D.31361>;
  <D.31360>:
  D.31362 = strcmp (typename, "bool");
  if (D.31362 == 0) goto <D.31363>; else goto <D.31364>;
  <D.31363>:
  klass = mono_defaults.boolean_class;
  goto <D.31365>;
  <D.31364>:
  D.31366 = strcmp (typename, "boolean");
  if (D.31366 == 0) goto <D.31367>; else goto <D.31368>;
  <D.31367>:
  klass = mono_defaults.boolean_class;
  goto <D.31369>;
  <D.31368>:
  monoeg_g_log (0B, 4, "%s", typename);
  <D.25248>:
  goto <D.25248>;
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "icall.c", 8265);
  <D.31369>:
  <D.31365>:
  <D.31361>:
  <D.31357>:
  <D.31353>:
  <D.31349>:
  <D.31345>:
  <D.31341>:
  <D.31337>:
  <D.31333>:
  <D.31329>:
  <D.31325>:
  <D.31321>:
  <D.31317>:
  <D.31313>:
  <D.31309>:
  <D.31305>:
  <D.31301>:
  D.31370 = &klass->byval_arg;
  return D.31370;
}


__attribute__((visibility ("hidden")))
mono_find_jit_icall_by_name (const char * name)
{
  struct GHashTable * jit_icall_hash_name.198;
  _Bool D.31373;
  long int D.31374;
  long int D.31375;
  struct MonoJitICallInfo * D.31378;
  struct MonoJitICallInfo * info;

  jit_icall_hash_name.198 = jit_icall_hash_name;
  D.31373 = jit_icall_hash_name.198 == 0B;
  D.31374 = (long int) D.31373;
  D.31375 = __builtin_expect (D.31374, 0);
  if (D.31375 != 0) goto <D.31376>; else goto <D.31377>;
  <D.31376>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 8331, "jit_icall_hash_name");
  <D.31377>:
  mono_icall_lock ();
  jit_icall_hash_name.198 = jit_icall_hash_name;
  info = monoeg_g_hash_table_lookup (jit_icall_hash_name.198, name);
  mono_icall_unlock ();
  D.31378 = info;
  return D.31378;
}


__attribute__((visibility ("hidden")))
mono_find_jit_icall_by_addr (const void * addr)
{
  struct GHashTable * jit_icall_hash_addr.199;
  _Bool D.31381;
  long int D.31382;
  long int D.31383;
  struct MonoJitICallInfo * D.31386;
  struct MonoJitICallInfo * info;

  jit_icall_hash_addr.199 = jit_icall_hash_addr;
  D.31381 = jit_icall_hash_addr.199 == 0B;
  D.31382 = (long int) D.31381;
  D.31383 = __builtin_expect (D.31382, 0);
  if (D.31383 != 0) goto <D.31384>; else goto <D.31385>;
  <D.31384>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 8343, "jit_icall_hash_addr");
  <D.31385>:
  mono_icall_lock ();
  jit_icall_hash_addr.199 = jit_icall_hash_addr;
  info = monoeg_g_hash_table_lookup (jit_icall_hash_addr.199, addr);
  mono_icall_unlock ();
  D.31386 = info;
  return D.31386;
}


__attribute__((visibility ("hidden")))
mono_get_jit_icall_info ()
{
  struct GHashTable * D.31388;

  D.31388 = jit_icall_hash_name;
  return D.31388;
}


__attribute__((visibility ("hidden")))
mono_lookup_jit_icall_symbol (const char * name)
{
  struct GHashTable * jit_icall_hash_name.200;
  const char * D.31393;
  struct MonoJitICallInfo * info;
  const char * res;

  res = 0B;
  mono_icall_lock ();
  jit_icall_hash_name.200 = jit_icall_hash_name;
  info = monoeg_g_hash_table_lookup (jit_icall_hash_name.200, name);
  if (info != 0B) goto <D.31391>; else goto <D.31392>;
  <D.31391>:
  res = info->c_symbol;
  <D.31392>:
  mono_icall_unlock ();
  D.31393 = res;
  return D.31393;
}


__attribute__((visibility ("hidden")))
mono_register_jit_icall_wrapper (struct MonoJitICallInfo * info, const void * wrapper)
{
  struct GHashTable * jit_icall_hash_addr.201;

  mono_icall_lock ();
  jit_icall_hash_addr.201 = jit_icall_hash_addr;
  monoeg_g_hash_table_insert_replace (jit_icall_hash_addr.201, wrapper, info, 0);
  mono_icall_unlock ();
}


__attribute__((visibility ("hidden")))
mono_register_jit_icall_full (const void * func, const char * name, struct MonoMethodSignature * sig, gboolean is_save, const char * c_symbol)
{
  _Bool D.31396;
  long int D.31397;
  long int D.31398;
  _Bool D.31401;
  long int D.31402;
  long int D.31403;
  struct GHashTable * jit_icall_hash_name.202;
  struct GHashTable * D.31409;
  struct GHashTable * D.31410;
  void * D.31411;
  const char * D.31417;
  struct GHashTable * jit_icall_hash_addr.203;
  struct MonoJitICallInfo * D.31419;
  struct MonoJitICallInfo * info;

  D.31396 = func == 0B;
  D.31397 = (long int) D.31396;
  D.31398 = __builtin_expect (D.31397, 0);
  if (D.31398 != 0) goto <D.31399>; else goto <D.31400>;
  <D.31399>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 8396, "func");
  <D.31400>:
  D.31401 = name == 0B;
  D.31402 = (long int) D.31401;
  D.31403 = __builtin_expect (D.31402, 0);
  if (D.31403 != 0) goto <D.31404>; else goto <D.31405>;
  <D.31404>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 8397, "name");
  <D.31405>:
  mono_icall_lock ();
  jit_icall_hash_name.202 = jit_icall_hash_name;
  if (jit_icall_hash_name.202 == 0B) goto <D.31407>; else goto <D.31408>;
  <D.31407>:
  D.31409 = monoeg_g_hash_table_new_full (monoeg_g_str_hash, monoeg_g_str_equal, 0B, monoeg_g_free);
  jit_icall_hash_name = D.31409;
  D.31410 = monoeg_g_hash_table_new (0B, 0B);
  jit_icall_hash_addr = D.31410;
  <D.31408>:
  jit_icall_hash_name.202 = jit_icall_hash_name;
  D.31411 = monoeg_g_hash_table_lookup (jit_icall_hash_name.202, name);
  if (D.31411 != 0B) goto <D.31412>; else goto <D.31413>;
  <D.31412>:
  monoeg_g_log (0B, 16, "jit icall already defined \"%s\"\n", name);
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "icall.c", 8408);
  <D.31413>:
  info = monoeg_malloc0 (48);
  info->name = name;
  info->func = func;
  info->sig = sig;
  info->c_symbol = c_symbol;
  if (is_save != 0) goto <D.31414>; else goto <D.31415>;
  <D.31414>:
  info->wrapper = func;
  goto <D.31416>;
  <D.31415>:
  info->wrapper = 0B;
  <D.31416>:
  jit_icall_hash_name.202 = jit_icall_hash_name;
  D.31417 = info->name;
  monoeg_g_hash_table_insert_replace (jit_icall_hash_name.202, D.31417, info, 0);
  jit_icall_hash_addr.203 = jit_icall_hash_addr;
  monoeg_g_hash_table_insert_replace (jit_icall_hash_addr.203, func, info, 0);
  mono_icall_unlock ();
  D.31419 = info;
  return D.31419;
}


__attribute__((visibility ("hidden")))
mono_register_jit_icall (const void * func, const char * name, struct MonoMethodSignature * sig, gboolean is_save)
{
  struct MonoJitICallInfo * D.31421;

  D.31421 = mono_register_jit_icall_full (func, name, sig, is_save, 0B);
  return D.31421;
}