mono_runtime_object_init (struct MonoObject * this)
{
  struct MonoVTable * D.20405;
  char * D.20408;
  struct MonoClass * D.20409;
  unsigned char D.20410;
  unsigned char D.20411;
  struct MonoMethod * method;
  struct MonoClass * klass;

  method = 0B;
  D.20405 = this->vtable;
  klass = D.20405->klass;
  method = mono_class_get_method_from_name (klass, ".ctor", 0);
  if (method == 0B) goto <D.20406>; else goto <D.20407>;
  <D.20406>:
  D.20408 = mono_type_get_full_name (klass);
  monoeg_g_log (0B, 4, "Could not lookup zero argument constructor for class %s", D.20408);
  <D.18587>:
  goto <D.18587>;
  <D.20407>:
  D.20409 = method->klass;
  D.20410 = BIT_FIELD_REF <*D.20409, 8, 160>;
  D.20411 = D.20410 & 8;
  if (D.20411 != 0) goto <D.20412>; else goto <D.20413>;
  <D.20412>:
  this = mono_object_unbox (this);
  <D.20413>:
  mono_runtime_invoke (method, this, 0B, 0B);
}


mono_thread_set_main (struct MonoThread * thread)
{
  int registered.0;
  void * D.20419;
  static gboolean registered = 0;

  registered.0 = registered;
  if (registered.0 == 0) goto <D.20415>; else goto <D.20416>;
  <D.20415>:
  if (0 != 0) goto <D.20417>; else goto <D.20418>;
  <D.20417>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 175, "sizeof (main_thread) == sizeof (MonoObject*)");
  <D.20418>:
  D.20419 = mono_gc_make_root_descr_all_refs (1);
  mono_gc_register_root (&main_thread, 4, D.20419);
  registered = 1;
  <D.20416>:
  main_thread = thread;
}


mono_thread_get_main ()
{
  struct MonoThread * D.20420;

  D.20420 = main_thread;
  return D.20420;
}


mono_type_initialization_init ()
{
  struct GHashTable * type_initialization_hash.1;
  struct GHashTable * blocked_thread_hash.2;

  InitializeCriticalSection (&type_initialization_section);
  type_initialization_hash.1 = monoeg_g_hash_table_new (0B, 0B);
  type_initialization_hash = type_initialization_hash.1;
  blocked_thread_hash.2 = monoeg_g_hash_table_new (0B, 0B);
  blocked_thread_hash = blocked_thread_hash.2;
  InitializeCriticalSection (&ldstr_section);
}


mono_type_initialization_cleanup ()
{
  struct GHashTable * blocked_thread_hash.3;

  DeleteCriticalSection (&ldstr_section);
  blocked_thread_hash.3 = blocked_thread_hash;
  monoeg_g_hash_table_destroy (blocked_thread_hash.3);
  blocked_thread_hash = 0B;
  free_main_args ();
}


free_main_args ()
{
  char * * main_args.4;
  unsigned int i.5;
  unsigned int D.20427;
  char * * D.20428;
  char * D.20429;
  int num_main_args.6;
  int i;

  i = 0;
  goto <D.19620>;
  <D.19619>:
  main_args.4 = main_args;
  i.5 = (unsigned int) i;
  D.20427 = i.5 * 4;
  D.20428 = main_args.4 + D.20427;
  D.20429 = *D.20428;
  monoeg_g_free (D.20429);
  i = i + 1;
  <D.19620>:
  num_main_args.6 = num_main_args;
  if (i < num_main_args.6) goto <D.19619>; else goto <D.19621>;
  <D.19621>:
  main_args.4 = main_args;
  monoeg_g_free (main_args.4);
}


mono_runtime_class_init (struct MonoVTable * vtable)
{
  mono_runtime_class_init_full (vtable, 1);
}


mono_runtime_class_init_full (struct MonoVTable * vtable, gboolean raise_exception)
{
  unsigned char D.20431;
  unsigned char D.20432;
  struct MonoException * D.20435;
  struct MonoImage * D.20436;
  unsigned char D.20437;
  unsigned char D.20438;
  unsigned char D.20441;
  struct MonoDomain * D.20444;
  struct MonoException * exc.7;
  struct MonoException * exc.8;
  _Bool D.20455;
  long int D.20456;
  long int D.20457;
  _Bool D.20464;
  long int D.20465;
  long int D.20466;
  unsigned char D.20469;
  _Bool D.20474;
  long int D.20475;
  long int D.20476;
  struct MonoException * D.20481;
  struct GHashTable * type_initialization_hash.9;
  struct MonoDomain * D.20485;
  int D.20488;
  _Bool D.20493;
  long int D.20494;
  long int D.20495;
  struct MonoException * D.20500;
  struct CRITICAL_SECTION * D.20501;
  union mono_mutex_t * D.20502;
  _Bool D.20505;
  long int D.20506;
  long int D.20507;
  unsigned int D.20513;
  int D.20515;
  _Bool D.20518;
  long int D.20519;
  long int D.20520;
  unsigned int D.20523;
  int D.20526;
  _Bool D.20530;
  long int D.20531;
  long int D.20532;
  struct GHashTable * blocked_thread_hash.10;
  unsigned int D.20536;
  unsigned int D.20537;
  void * tid.11;
  _Bool D.20541;
  long int D.20542;
  long int D.20543;
  struct MonoImage * D.20552;
  int D.18662;
  int iftmp.12;
  int D.18661;
  const char[7] * D.20557;
  unsigned char D.20558;
  int D.20559;
  unsigned char D.20560;
  int D.20561;
  _Bool D.20562;
  _Bool D.20563;
  _Bool D.20564;
  const unsigned char * D.20567;
  unsigned char D.20568;
  int D.20569;
  const unsigned char * D.20570;
  unsigned char D.20571;
  int D.20572;
  _Bool D.20573;
  _Bool D.20574;
  const unsigned char * D.20577;
  unsigned char D.20578;
  int D.20579;
  const unsigned char * D.20580;
  unsigned char D.20581;
  int D.20582;
  _Bool D.20583;
  _Bool D.20584;
  const unsigned char * D.20587;
  unsigned char D.20588;
  int D.20589;
  const unsigned char * D.20590;
  unsigned char D.20591;
  int D.20592;
  const char * D.20594;
  int D.18671;
  int iftmp.13;
  int D.18670;
  const char[28] * D.20599;
  unsigned char D.20600;
  int D.20601;
  unsigned char D.20602;
  int D.20603;
  _Bool D.20604;
  _Bool D.20605;
  _Bool D.20606;
  const unsigned char * D.20609;
  unsigned char D.20610;
  int D.20611;
  const unsigned char * D.20612;
  unsigned char D.20613;
  int D.20614;
  _Bool D.20615;
  _Bool D.20616;
  const unsigned char * D.20619;
  unsigned char D.20620;
  int D.20621;
  const unsigned char * D.20622;
  unsigned char D.20623;
  int D.20624;
  _Bool D.20625;
  _Bool D.20626;
  const unsigned char * D.20629;
  unsigned char D.20630;
  int D.20631;
  const unsigned char * D.20632;
  unsigned char D.20633;
  int D.20634;
  const char * D.20636;
  char D.20640;
  union mono_mutex_t * D.20642;
  _Bool D.20645;
  long int D.20646;
  long int D.20647;
  struct MonoGHashTable * D.20650;
  struct MonoGHashTable * D.20653;
  _Bool D.20656;
  long int D.20657;
  long int D.20658;
  _Bool D.20665;
  long int D.20666;
  long int D.20667;
  _Bool D.20673;
  long int D.20674;
  long int D.20675;
  _Bool D.20680;
  long int D.20681;
  long int D.20682;
  _Bool D.20687;
  long int D.20688;
  long int D.20689;
  const void * tid.14;
  unsigned int D.20695;
  _Bool D.20702;
  long int D.20703;
  long int D.20704;
  struct MonoException * D.20711;
  struct MonoException * exc;
  struct MonoException * exc_to_throw;
  struct MonoMethod * method;
  struct MonoClass * klass;
  gchar * full_name;

  try
    {
      method = 0B;
      D.20431 = BIT_FIELD_REF <*vtable, 8, 184>;
      D.20432 = D.20431 & 2;
      if (D.20432 != 0) goto <D.20433>; else goto <D.20434>;
      <D.20433>:
      D.20435 = 0B;
      return D.20435;
      <D.20434>:
      exc = 0B;
      klass = vtable->klass;
      D.20436 = klass->image;
      D.20437 = BIT_FIELD_REF <*D.20436, 8, 128>;
      D.20438 = D.20437 & 64;
      if (D.20438 == 0) goto <D.20439>; else goto <D.20440>;
      <D.20439>:
      D.20436 = klass->image;
      mono_image_check_for_module_cctor (D.20436);
      D.20436 = klass->image;
      D.20437 = BIT_FIELD_REF <*D.20436, 8, 128>;
      D.20441 = D.20437 & 128;
      if (D.20441 != 0) goto <D.20442>; else goto <D.20443>;
      <D.20442>:
      {
        struct MonoClass * module_klass;
        struct MonoVTable * module_vtable;

        D.20436 = klass->image;
        module_klass = mono_class_get (D.20436, 33554433);
        D.20444 = vtable->domain;
        module_vtable = mono_class_vtable_full (D.20444, module_klass, raise_exception);
        if (module_vtable == 0B) goto <D.20445>; else goto <D.20446>;
        <D.20445>:
        D.20435 = 0B;
        return D.20435;
        <D.20446>:
        exc.7 = mono_runtime_class_init_full (module_vtable, raise_exception);
        exc = exc.7;
        exc.8 = exc;
        if (exc.8 != 0B) goto <D.20449>; else goto <D.20450>;
        <D.20449>:
        D.20435 = exc;
        return D.20435;
        <D.20450>:
      }
      <D.20443>:
      <D.20440>:
      method = mono_class_get_cctor (klass);
      if (method != 0B) goto <D.20451>; else goto <D.20452>;
      <D.20451>:
      {
        struct MonoDomain * domain;
        struct TypeInitializationLock * lock;
        guint32 tid;
        int do_initialization;
        struct MonoDomain * last_domain;

        domain = vtable->domain;
        tid = GetCurrentThreadId ();
        do_initialization = 0;
        last_domain = 0B;
        {
          int ret;

          ret = pthread_mutex_lock (&type_initialization_section.mutex);
          if (ret != 0) goto <D.20453>; else goto <D.20454>;
          <D.20453>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
          <D.20454>:
          D.20455 = ret != 0;
          D.20456 = (long int) D.20455;
          D.20457 = __builtin_expect (D.20456, 0);
          if (D.20457 != 0) goto <D.20458>; else goto <D.20459>;
          <D.20458>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 308, "ret == 0");
          <D.20459>:
        }
        D.20431 = BIT_FIELD_REF <*vtable, 8, 184>;
        D.20432 = D.20431 & 2;
        if (D.20432 != 0) goto <D.20460>; else goto <D.20461>;
        <D.20460>:
        {
          int ret;

          ret = pthread_mutex_unlock (&type_initialization_section.mutex);
          if (ret != 0) goto <D.20462>; else goto <D.20463>;
          <D.20462>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
          <D.20463>:
          D.20464 = ret != 0;
          D.20465 = (long int) D.20464;
          D.20466 = __builtin_expect (D.20465, 0);
          if (D.20466 != 0) goto <D.20467>; else goto <D.20468>;
          <D.20467>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 311, "ret == 0");
          <D.20468>:
        }
        D.20435 = 0B;
        return D.20435;
        <D.20461>:
        D.20431 = BIT_FIELD_REF <*vtable, 8, 184>;
        D.20469 = D.20431 & 4;
        if (D.20469 != 0) goto <D.20470>; else goto <D.20471>;
        <D.20470>:
        {
          int ret;

          ret = pthread_mutex_unlock (&type_initialization_section.mutex);
          if (ret != 0) goto <D.20472>; else goto <D.20473>;
          <D.20472>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
          <D.20473>:
          D.20474 = ret != 0;
          D.20475 = (long int) D.20474;
          D.20476 = __builtin_expect (D.20475, 0);
          if (D.20476 != 0) goto <D.20477>; else goto <D.20478>;
          <D.20477>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 315, "ret == 0");
          <D.20478>:
        }
        if (raise_exception != 0) goto <D.20479>; else goto <D.20480>;
        <D.20479>:
        D.20481 = get_type_init_exception_for_vtable (vtable);
        mono_raise_exception (D.20481);
        <D.20480>:
        D.20435 = get_type_init_exception_for_vtable (vtable);
        return D.20435;
        <D.20471>:
        type_initialization_hash.9 = type_initialization_hash;
        lock = monoeg_g_hash_table_lookup (type_initialization_hash.9, vtable);
        if (lock == 0B) goto <D.20483>; else goto <D.20484>;
        <D.20483>:
        D.20485 = mono_domain_get ();
        if (D.20485 != domain) goto <D.20486>; else goto <D.20487>;
        <D.20486>:
        last_domain = mono_domain_get ();
        D.20488 = mono_domain_set (domain, 0);
        if (D.20488 == 0) goto <D.20489>; else goto <D.20490>;
        <D.20489>:
        vtable->initialized = 1;
        {
          int ret;

          ret = pthread_mutex_unlock (&type_initialization_section.mutex);
          if (ret != 0) goto <D.20491>; else goto <D.20492>;
          <D.20491>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
          <D.20492>:
          D.20493 = ret != 0;
          D.20494 = (long int) D.20493;
          D.20495 = __builtin_expect (D.20494, 0);
          if (D.20495 != 0) goto <D.20496>; else goto <D.20497>;
          <D.20496>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 330, "ret == 0");
          <D.20497>:
        }
        if (raise_exception != 0) goto <D.20498>; else goto <D.20499>;
        <D.20498>:
        D.20500 = mono_get_exception_appdomain_unloaded ();
        mono_raise_exception (D.20500);
        <D.20499>:
        D.20435 = mono_get_exception_appdomain_unloaded ();
        return D.20435;
        <D.20490>:
        <D.20487>:
        lock = monoeg_malloc (40);
        D.20501 = &lock->initialization_section;
        InitializeCriticalSection (D.20501);
        lock->initializing_tid = tid;
        lock->waiting_count = 1;
        lock->done = 0;
        {
          int ret;

          D.20502 = &lock->initialization_section.mutex;
          ret = pthread_mutex_lock (D.20502);
          if (ret != 0) goto <D.20503>; else goto <D.20504>;
          <D.20503>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
          <D.20504>:
          D.20505 = ret != 0;
          D.20506 = (long int) D.20505;
          D.20507 = __builtin_expect (D.20506, 0);
          if (D.20507 != 0) goto <D.20508>; else goto <D.20509>;
          <D.20508>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 342, "ret == 0");
          <D.20509>:
        }
        type_initialization_hash.9 = type_initialization_hash;
        monoeg_g_hash_table_insert_replace (type_initialization_hash.9, vtable, lock, 0);
        do_initialization = 1;
        goto <D.20510>;
        <D.20484>:
        {
          void * blocked;
          struct TypeInitializationLock * pending_lock;

          D.20513 = lock->initializing_tid;
          if (D.20513 == tid) goto <D.20511>; else goto <D.20514>;
          <D.20514>:
          D.20515 = lock->done;
          if (D.20515 != 0) goto <D.20511>; else goto <D.20512>;
          <D.20511>:
          {
            int ret;

            ret = pthread_mutex_unlock (&type_initialization_section.mutex);
            if (ret != 0) goto <D.20516>; else goto <D.20517>;
            <D.20516>:
            monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
            <D.20517>:
            D.20518 = ret != 0;
            D.20519 = (long int) D.20518;
            D.20520 = __builtin_expect (D.20519, 0);
            if (D.20520 != 0) goto <D.20521>; else goto <D.20522>;
            <D.20521>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 350, "ret == 0");
            <D.20522>:
          }
          D.20435 = 0B;
          return D.20435;
          <D.20512>:
          D.20513 = lock->initializing_tid;
          blocked = (void *) D.20513;
          goto <D.18652>;
          <D.18651>:
          D.20523 = pending_lock->initializing_tid;
          if (D.20523 == tid) goto <D.20524>; else goto <D.20525>;
          <D.20524>:
          D.20526 = pending_lock->done;
          if (D.20526 == 0) goto <D.20527>; else goto <D.18650>;
          <D.20527>:
          {
            int ret;

            ret = pthread_mutex_unlock (&type_initialization_section.mutex);
            if (ret != 0) goto <D.20528>; else goto <D.20529>;
            <D.20528>:
            monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
            <D.20529>:
            D.20530 = ret != 0;
            D.20531 = (long int) D.20530;
            D.20532 = __builtin_expect (D.20531, 0);
            if (D.20532 != 0) goto <D.20533>; else goto <D.20534>;
            <D.20533>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 358, "ret == 0");
            <D.20534>:
          }
          D.20435 = 0B;
          return D.20435;
          <D.20525>:
          D.20523 = pending_lock->initializing_tid;
          blocked = (void *) D.20523;
          <D.18652>:
          blocked_thread_hash.10 = blocked_thread_hash;
          pending_lock = monoeg_g_hash_table_lookup (blocked_thread_hash.10, blocked);
          if (pending_lock != 0B) goto <D.18651>; else goto <D.18650>;
          <D.18650>:
          D.20536 = lock->waiting_count;
          D.20537 = D.20536 + 1;
          lock->waiting_count = D.20537;
          tid.11 = (void *) tid;
          blocked_thread_hash.10 = blocked_thread_hash;
          monoeg_g_hash_table_insert_replace (blocked_thread_hash.10, tid.11, lock, 0);
        }
        <D.20510>:
        {
          int ret;

          ret = pthread_mutex_unlock (&type_initialization_section.mutex);
          if (ret != 0) goto <D.20539>; else goto <D.20540>;
          <D.20539>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
          <D.20540>:
          D.20541 = ret != 0;
          D.20542 = (long int) D.20541;
          D.20543 = __builtin_expect (D.20542, 0);
          if (D.20543 != 0) goto <D.20544>; else goto <D.20545>;
          <D.20544>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 373, "ret == 0");
          <D.20545>:
        }
        if (do_initialization != 0) goto <D.20546>; else goto <D.20547>;
        <D.20546>:
        mono_runtime_invoke (method, 0B, 0B, &exc);
        exc.8 = exc;
        if (exc.8 != 0B) goto <D.20550>; else goto <D.20551>;
        <D.20550>:
        D.20436 = klass->image;
        D.20552 = mono_defaults.corlib;
        if (D.20436 != D.20552) goto <D.20548>; else goto <D.20553>;
        <D.20553>:
        {
          size_t __s1_len;
          size_t __s2_len;

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

            __s2 = klass->name_space;
            D.20557 = "System";
            D.20558 = MEM[(const unsigned char *)D.20557];
            D.20559 = (int) D.20558;
            D.20560 = *__s2;
            D.20561 = (int) D.20560;
            __result = D.20559 - D.20561;
            {
              D.20562 = __s2_len != 0;
              D.20563 = __result == 0;
              D.20564 = D.20562 & D.20563;
              if (D.20564 != 0) goto <D.20565>; else goto <D.20566>;
              <D.20565>:
              D.20567 = &MEM[(void *)"System" + 1B];
              D.20568 = *D.20567;
              D.20569 = (int) D.20568;
              D.20570 = __s2 + 1;
              D.20571 = *D.20570;
              D.20572 = (int) D.20571;
              __result = D.20569 - D.20572;
              D.20573 = __s2_len > 1;
              D.20563 = __result == 0;
              D.20574 = D.20573 & D.20563;
              if (D.20574 != 0) goto <D.20575>; else goto <D.20576>;
              <D.20575>:
              D.20577 = &MEM[(void *)"System" + 2B];
              D.20578 = *D.20577;
              D.20579 = (int) D.20578;
              D.20580 = __s2 + 2;
              D.20581 = *D.20580;
              D.20582 = (int) D.20581;
              __result = D.20579 - D.20582;
              D.20583 = __s2_len > 2;
              D.20563 = __result == 0;
              D.20584 = D.20583 & D.20563;
              if (D.20584 != 0) goto <D.20585>; else goto <D.20586>;
              <D.20585>:
              D.20587 = &MEM[(void *)"System" + 3B];
              D.20588 = *D.20587;
              D.20589 = (int) D.20588;
              D.20590 = __s2 + 3;
              D.20591 = *D.20590;
              D.20592 = (int) D.20591;
              __result = D.20589 - D.20592;
              <D.20586>:
              <D.20576>:
              <D.20566>:
            }
            D.18661 = __result;
          }
          iftmp.12 = -D.18661;
          goto <D.20593>;
          <D.20556>:
          D.20594 = klass->name_space;
          iftmp.12 = __builtin_strcmp (D.20594, "System");
          <D.20593>:
          D.18662 = iftmp.12;
        }
        if (D.18662 != 0) goto <D.20548>; else goto <D.20595>;
        <D.20595>:
        {
          size_t __s1_len;
          size_t __s2_len;

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

            __s2 = klass->name;
            D.20599 = "TypeInitializationException";
            D.20600 = MEM[(const unsigned char *)D.20599];
            D.20601 = (int) D.20600;
            D.20602 = *__s2;
            D.20603 = (int) D.20602;
            __result = D.20601 - D.20603;
            {
              D.20604 = __s2_len != 0;
              D.20605 = __result == 0;
              D.20606 = D.20604 & D.20605;
              if (D.20606 != 0) goto <D.20607>; else goto <D.20608>;
              <D.20607>:
              D.20609 = &MEM[(void *)"TypeInitializationException" + 1B];
              D.20610 = *D.20609;
              D.20611 = (int) D.20610;
              D.20612 = __s2 + 1;
              D.20613 = *D.20612;
              D.20614 = (int) D.20613;
              __result = D.20611 - D.20614;
              D.20615 = __s2_len > 1;
              D.20605 = __result == 0;
              D.20616 = D.20615 & D.20605;
              if (D.20616 != 0) goto <D.20617>; else goto <D.20618>;
              <D.20617>:
              D.20619 = &MEM[(void *)"TypeInitializationException" + 2B];
              D.20620 = *D.20619;
              D.20621 = (int) D.20620;
              D.20622 = __s2 + 2;
              D.20623 = *D.20622;
              D.20624 = (int) D.20623;
              __result = D.20621 - D.20624;
              D.20625 = __s2_len > 2;
              D.20605 = __result == 0;
              D.20626 = D.20625 & D.20605;
              if (D.20626 != 0) goto <D.20627>; else goto <D.20628>;
              <D.20627>:
              D.20629 = &MEM[(void *)"TypeInitializationException" + 3B];
              D.20630 = *D.20629;
              D.20631 = (int) D.20630;
              D.20632 = __s2 + 3;
              D.20633 = *D.20632;
              D.20634 = (int) D.20633;
              __result = D.20631 - D.20634;
              <D.20628>:
              <D.20618>:
              <D.20608>:
            }
            D.18670 = __result;
          }
          iftmp.13 = -D.18670;
          goto <D.20635>;
          <D.20598>:
          D.20636 = klass->name;
          iftmp.13 = __builtin_strcmp (D.20636, "TypeInitializationException");
          <D.20635>:
          D.18671 = iftmp.13;
        }
        if (D.18671 != 0) goto <D.20548>; else goto <D.20549>;
        <D.20548>:
        vtable->init_failed = 1;
        D.20594 = klass->name_space;
        if (D.20594 != 0B) goto <D.20639>; else goto <D.20637>;
        <D.20639>:
        D.20594 = klass->name_space;
        D.20640 = *D.20594;
        if (D.20640 != 0) goto <D.20641>; else goto <D.20637>;
        <D.20641>:
        D.20636 = klass->name;
        D.20594 = klass->name_space;
        full_name = monoeg_g_strdup_printf ("%s.%s", D.20594, D.20636);
        goto <D.20638>;
        <D.20637>:
        D.20636 = klass->name;
        full_name = monoeg_strdup (D.20636);
        <D.20638>:
        exc.8 = exc;
        exc_to_throw = mono_get_exception_type_initialization (full_name, exc.8);
        monoeg_g_free (full_name);
        {
          int ret;

          D.20642 = &domain->lock.mutex;
          ret = pthread_mutex_lock (D.20642);
          if (ret != 0) goto <D.20643>; else goto <D.20644>;
          <D.20643>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
          <D.20644>:
          D.20645 = ret != 0;
          D.20646 = (long int) D.20645;
          D.20647 = __builtin_expect (D.20646, 0);
          if (D.20647 != 0) goto <D.20648>; else goto <D.20649>;
          <D.20648>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 397, "ret == 0");
          <D.20649>:
        }
        D.20650 = domain->type_init_exception_hash;
        if (D.20650 == 0B) goto <D.20651>; else goto <D.20652>;
        <D.20651>:
        D.20653 = mono_g_hash_table_new_type (mono_aligned_addr_hash, 0B, 2);
        domain->type_init_exception_hash = D.20653;
        <D.20652>:
        D.20650 = domain->type_init_exception_hash;
        mono_g_hash_table_insert (D.20650, klass, exc_to_throw);
        {
          int ret;

          D.20642 = &domain->lock.mutex;
          ret = pthread_mutex_unlock (D.20642);
          if (ret != 0) goto <D.20654>; else goto <D.20655>;
          <D.20654>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
          <D.20655>:
          D.20656 = ret != 0;
          D.20657 = (long int) D.20656;
          D.20658 = __builtin_expect (D.20657, 0);
          if (D.20658 != 0) goto <D.20659>; else goto <D.20660>;
          <D.20659>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 401, "ret == 0");
          <D.20660>:
        }
        <D.20549>:
        <D.20551>:
        if (last_domain != 0B) goto <D.20661>; else goto <D.20662>;
        <D.20661>:
        mono_domain_set (last_domain, 1);
        <D.20662>:
        lock->done = 1;
        {
          int ret;

          D.20502 = &lock->initialization_section.mutex;
          ret = pthread_mutex_unlock (D.20502);
          if (ret != 0) goto <D.20663>; else goto <D.20664>;
          <D.20663>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
          <D.20664>:
          D.20665 = ret != 0;
          D.20666 = (long int) D.20665;
          D.20667 = __builtin_expect (D.20666, 0);
          if (D.20667 != 0) goto <D.20668>; else goto <D.20669>;
          <D.20668>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 407, "ret == 0");
          <D.20669>:
        }
        goto <D.20670>;
        <D.20547>:
        {
          int ret;

          D.20502 = &lock->initialization_section.mutex;
          ret = pthread_mutex_lock (D.20502);
          if (ret != 0) goto <D.20671>; else goto <D.20672>;
          <D.20671>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
          <D.20672>:
          D.20673 = ret != 0;
          D.20674 = (long int) D.20673;
          D.20675 = __builtin_expect (D.20674, 0);
          if (D.20675 != 0) goto <D.20676>; else goto <D.20677>;
          <D.20676>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 410, "ret == 0");
          <D.20677>:
        }
        {
          int ret;

          D.20502 = &lock->initialization_section.mutex;
          ret = pthread_mutex_unlock (D.20502);
          if (ret != 0) goto <D.20678>; else goto <D.20679>;
          <D.20678>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
          <D.20679>:
          D.20680 = ret != 0;
          D.20681 = (long int) D.20680;
          D.20682 = __builtin_expect (D.20681, 0);
          if (D.20682 != 0) goto <D.20683>; else goto <D.20684>;
          <D.20683>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 411, "ret == 0");
          <D.20684>:
        }
        <D.20670>:
        {
          int ret;

          ret = pthread_mutex_lock (&type_initialization_section.mutex);
          if (ret != 0) goto <D.20685>; else goto <D.20686>;
          <D.20685>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
          <D.20686>:
          D.20687 = ret != 0;
          D.20688 = (long int) D.20687;
          D.20689 = __builtin_expect (D.20688, 0);
          if (D.20689 != 0) goto <D.20690>; else goto <D.20691>;
          <D.20690>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 414, "ret == 0");
          <D.20691>:
        }
        D.20513 = lock->initializing_tid;
        if (D.20513 != tid) goto <D.20692>; else goto <D.20693>;
        <D.20692>:
        tid.14 = (const void *) tid;
        blocked_thread_hash.10 = blocked_thread_hash;
        monoeg_g_hash_table_remove (blocked_thread_hash.10, tid.14);
        <D.20693>:
        D.20536 = lock->waiting_count;
        D.20695 = D.20536 + 4294967295;
        lock->waiting_count = D.20695;
        D.20536 = lock->waiting_count;
        if (D.20536 == 0) goto <D.20696>; else goto <D.20697>;
        <D.20696>:
        D.20501 = &lock->initialization_section;
        DeleteCriticalSection (D.20501);
        type_initialization_hash.9 = type_initialization_hash;
        monoeg_g_hash_table_remove (type_initialization_hash.9, vtable);
        monoeg_g_free (lock);
        <D.20697>:
        mono_memory_barrier ();
        D.20431 = BIT_FIELD_REF <*vtable, 8, 184>;
        D.20469 = D.20431 & 4;
        if (D.20469 == 0) goto <D.20698>; else goto <D.20699>;
        <D.20698>:
        vtable->initialized = 1;
        <D.20699>:
        {
          int ret;

          ret = pthread_mutex_unlock (&type_initialization_section.mutex);
          if (ret != 0) goto <D.20700>; else goto <D.20701>;
          <D.20700>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
          <D.20701>:
          D.20702 = ret != 0;
          D.20703 = (long int) D.20702;
          D.20704 = __builtin_expect (D.20703, 0);
          if (D.20704 != 0) goto <D.20705>; else goto <D.20706>;
          <D.20705>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 426, "ret == 0");
          <D.20706>:
        }
        D.20431 = BIT_FIELD_REF <*vtable, 8, 184>;
        D.20469 = D.20431 & 4;
        if (D.20469 != 0) goto <D.20707>; else goto <D.20708>;
        <D.20707>:
        if (raise_exception != 0) goto <D.20709>; else goto <D.20710>;
        <D.20709>:
        D.20711 = get_type_init_exception_for_vtable (vtable);
        mono_raise_exception (D.20711);
        <D.20710>:
        D.20435 = get_type_init_exception_for_vtable (vtable);
        return D.20435;
        <D.20708>:
      }
      goto <D.20712>;
      <D.20452>:
      vtable->initialized = 1;
      D.20435 = 0B;
      return D.20435;
      <D.20712>:
      D.20435 = 0B;
      return D.20435;
    }
  finally
    {
      exc = {CLOBBER};
    }
}


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

  if (str != 0B) goto <D.20715>; else goto <D.20716>;
  <D.20715>:
  D.20717 = __strdup (str);
  return D.20717;
  <D.20716>:
  D.20717 = 0B;
  return D.20717;
}


mono_memory_barrier ()
{
  __sync_synchronize ();
}


get_type_init_exception_for_vtable (struct MonoVTable * vtable)
{
  unsigned char D.20719;
  unsigned char D.20720;
  char * D.20723;
  union mono_mutex_t * D.20724;
  _Bool D.20727;
  long int D.20728;
  long int D.20729;
  struct MonoGHashTable * D.20732;
  _Bool D.20737;
  long int D.20738;
  long int D.20739;
  const char * D.20746;
  char D.20748;
  const char * D.20750;
  struct MonoException * D.20751;
  struct MonoDomain * domain;
  struct MonoClass * klass;
  struct MonoException * ex;
  gchar * full_name;

  domain = vtable->domain;
  klass = vtable->klass;
  D.20719 = BIT_FIELD_REF <*vtable, 8, 184>;
  D.20720 = D.20719 & 4;
  if (D.20720 == 0) goto <D.20721>; else goto <D.20722>;
  <D.20721>:
  D.20723 = mono_type_get_full_name (klass);
  monoeg_g_log (0B, 4, "Trying to get the init exception for a non-failed vtable of class %s", D.20723);
  <D.18619>:
  goto <D.18619>;
  <D.20722>:
  ex = 0B;
  {
    int ret;

    D.20724 = &domain->lock.mutex;
    ret = pthread_mutex_lock (D.20724);
    if (ret != 0) goto <D.20725>; else goto <D.20726>;
    <D.20725>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.20726>:
    D.20727 = ret != 0;
    D.20728 = (long int) D.20727;
    D.20729 = __builtin_expect (D.20728, 0);
    if (D.20729 != 0) goto <D.20730>; else goto <D.20731>;
    <D.20730>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 236, "ret == 0");
    <D.20731>:
  }
  D.20732 = domain->type_init_exception_hash;
  if (D.20732 != 0B) goto <D.20733>; else goto <D.20734>;
  <D.20733>:
  D.20732 = domain->type_init_exception_hash;
  ex = mono_g_hash_table_lookup (D.20732, klass);
  <D.20734>:
  {
    int ret;

    D.20724 = &domain->lock.mutex;
    ret = pthread_mutex_unlock (D.20724);
    if (ret != 0) goto <D.20735>; else goto <D.20736>;
    <D.20735>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.20736>:
    D.20737 = ret != 0;
    D.20738 = (long int) D.20737;
    D.20739 = __builtin_expect (D.20738, 0);
    if (D.20739 != 0) goto <D.20740>; else goto <D.20741>;
    <D.20740>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 239, "ret == 0");
    <D.20741>:
  }
  if (ex == 0B) goto <D.20742>; else goto <D.20743>;
  <D.20742>:
  D.20746 = klass->name_space;
  if (D.20746 != 0B) goto <D.20747>; else goto <D.20744>;
  <D.20747>:
  D.20746 = klass->name_space;
  D.20748 = *D.20746;
  if (D.20748 != 0) goto <D.20749>; else goto <D.20744>;
  <D.20749>:
  D.20750 = klass->name;
  D.20746 = klass->name_space;
  full_name = monoeg_g_strdup_printf ("%s.%s", D.20746, D.20750);
  goto <D.20745>;
  <D.20744>:
  D.20750 = klass->name;
  full_name = monoeg_strdup (D.20750);
  <D.20745>:
  ex = mono_get_exception_type_initialization (full_name, 0B);
  monoeg_g_free (full_name);
  <D.20743>:
  D.20751 = ex;
  return D.20751;
}


mono_release_type_locks (struct MonoInternalThread * thread)
{
  _Bool D.20755;
  long int D.20756;
  long int D.20757;
  long long unsigned int D.20760;
  unsigned int D.20761;
  void * D.20762;
  struct GHashTable * type_initialization_hash.15;
  _Bool D.20766;
  long int D.20767;
  long int D.20768;

  {
    int ret;

    ret = pthread_mutex_lock (&type_initialization_section.mutex);
    if (ret != 0) goto <D.20753>; else goto <D.20754>;
    <D.20753>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.20754>:
    D.20755 = ret != 0;
    D.20756 = (long int) D.20755;
    D.20757 = __builtin_expect (D.20756, 0);
    if (D.20757 != 0) goto <D.20758>; else goto <D.20759>;
    <D.20758>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 469, "ret == 0");
    <D.20759>:
  }
  D.20760 = thread->tid;
  D.20761 = (unsigned int) D.20760;
  D.20762 = (void *) D.20761;
  type_initialization_hash.15 = type_initialization_hash;
  monoeg_g_hash_table_foreach_remove (type_initialization_hash.15, release_type_locks, D.20762);
  {
    int ret;

    ret = pthread_mutex_unlock (&type_initialization_section.mutex);
    if (ret != 0) goto <D.20764>; else goto <D.20765>;
    <D.20764>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.20765>:
    D.20766 = ret != 0;
    D.20767 = (long int) D.20766;
    D.20768 = __builtin_expect (D.20767, 0);
    if (D.20768 != 0) goto <D.20769>; else goto <D.20770>;
    <D.20769>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 471, "ret == 0");
    <D.20770>:
  }
}


release_type_locks (void * key, void * value, void * user)
{
  unsigned int D.20771;
  unsigned int user.16;
  int D.20775;
  union mono_mutex_t * D.20778;
  _Bool D.20781;
  long int D.20782;
  long int D.20783;
  unsigned int D.20786;
  unsigned int D.20787;
  struct CRITICAL_SECTION * D.20790;
  gboolean D.20791;
  struct MonoVTable * vtable;
  struct TypeInitializationLock * lock;

  vtable = key;
  lock = value;
  D.20771 = lock->initializing_tid;
  user.16 = (unsigned int) user;
  if (D.20771 == user.16) goto <D.20773>; else goto <D.20774>;
  <D.20773>:
  D.20775 = lock->done;
  if (D.20775 == 0) goto <D.20776>; else goto <D.20777>;
  <D.20776>:
  lock->done = 1;
  vtable->init_failed = 1;
  {
    int ret;

    D.20778 = &lock->initialization_section.mutex;
    ret = pthread_mutex_unlock (D.20778);
    if (ret != 0) goto <D.20779>; else goto <D.20780>;
    <D.20779>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.20780>:
    D.20781 = ret != 0;
    D.20782 = (long int) D.20781;
    D.20783 = __builtin_expect (D.20782, 0);
    if (D.20783 != 0) goto <D.20784>; else goto <D.20785>;
    <D.20784>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 455, "ret == 0");
    <D.20785>:
  }
  D.20786 = lock->waiting_count;
  D.20787 = D.20786 + 4294967295;
  lock->waiting_count = D.20787;
  D.20786 = lock->waiting_count;
  if (D.20786 == 0) goto <D.20788>; else goto <D.20789>;
  <D.20788>:
  D.20790 = &lock->initialization_section;
  DeleteCriticalSection (D.20790);
  monoeg_g_free (lock);
  D.20791 = 1;
  return D.20791;
  <D.20789>:
  <D.20777>:
  <D.20774>:
  D.20791 = 0;
  return D.20791;
}


mono_install_callbacks (struct MonoRuntimeCallbacks * cbs)
{
  memcpy (&callbacks, cbs, 32);
}


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

  D.20794 = __builtin_object_size (__dest, 0);
  D.20793 = __builtin___memcpy_chk (__dest, __src, __len, D.20794);
  return D.20793;
}


mono_get_runtime_callbacks ()
{
  struct MonoRuntimeCallbacks * D.20796;

  D.20796 = &callbacks;
  return D.20796;
}


mono_install_trampoline (void * (*MonoTrampoline) (struct MonoMethod *) func)
{
  void * (*<T1d2d>) (struct MonoMethod *) iftmp.17;

  if (func != 0B) goto <D.20799>; else goto <D.20800>;
  <D.20799>:
  iftmp.17 = func;
  goto <D.20801>;
  <D.20800>:
  iftmp.17 = default_trampoline;
  <D.20801>:
  arch_create_jit_trampoline = iftmp.17;
}


default_trampoline (struct MonoMethod * method)
{
  void * D.20802;

  D.20802 = method;
  return D.20802;
}


mono_install_jump_trampoline (void * (*MonoJumpTrampoline) (struct MonoDomain *, struct MonoMethod *, gboolean) func)
{
  void * (*<T1d31>) (struct MonoDomain *, struct MonoMethod *, gboolean) iftmp.18;

  if (func != 0B) goto <D.20805>; else goto <D.20806>;
  <D.20805>:
  iftmp.18 = func;
  goto <D.20807>;
  <D.20806>:
  iftmp.18 = default_jump_trampoline;
  <D.20807>:
  arch_create_jump_trampoline = iftmp.18;
}


default_jump_trampoline (struct MonoDomain * domain, struct MonoMethod * method, gboolean add_sync_wrapper)
{
  void * D.20808;

  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "object.c", 483);
  D.20808 = 0B;
  return D.20808;
}


mono_install_remoting_trampoline (void * (*MonoRemotingTrampoline) (struct MonoDomain *, struct MonoMethod *, MonoRemotingTarget) func)
{
  void * (*<T1d36>) (struct MonoDomain *, struct MonoMethod *, MonoRemotingTarget) iftmp.19;

  if (func != 0B) goto <D.20811>; else goto <D.20812>;
  <D.20811>:
  iftmp.19 = func;
  goto <D.20813>;
  <D.20812>:
  iftmp.19 = default_remoting_trampoline;
  <D.20813>:
  arch_create_remoting_trampoline = iftmp.19;
}


default_remoting_trampoline (struct MonoDomain * domain, struct MonoMethod * method, MonoRemotingTarget target)
{
  void * D.20814;

  monoeg_g_log (0B, 4, "remoting not installed");
  <D.18705>:
  goto <D.18705>;
  D.20814 = 0B;
  return D.20814;
}


mono_install_delegate_trampoline (void * (*MonoDelegateTrampoline) (struct MonoDomain *, struct MonoClass *) func)
{
  void * (*<T1d3b>) (struct MonoDomain *, struct MonoClass *) iftmp.20;

  if (func != 0B) goto <D.20817>; else goto <D.20818>;
  <D.20817>:
  iftmp.20 = func;
  goto <D.20819>;
  <D.20818>:
  iftmp.20 = default_delegate_trampoline;
  <D.20819>:
  arch_create_delegate_trampoline = iftmp.20;
}


default_delegate_trampoline (struct MonoDomain * domain, struct MonoClass * klass)
{
  void * D.20820;

  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "object.c", 503);
  D.20820 = 0B;
  return D.20820;
}


mono_install_imt_thunk_builder (void * (*MonoImtThunkBuilder) (struct MonoVTable *, struct MonoDomain *, struct MonoIMTCheckItem * *, int, void *) func)
{
  imt_thunk_builder = func;
}


mono_install_compile_method (void * (*MonoCompileFunc) (struct MonoMethod *) func)
{
  default_mono_compile_method = func;
}


mono_compile_method (struct MonoMethod * method)
{
  void * (*<T11cc>) (struct MonoMethod *) default_mono_compile_method.21;
  void * D.20825;

  default_mono_compile_method.21 = default_mono_compile_method;
  if (default_mono_compile_method.21 == 0B) goto <D.20823>; else goto <D.20824>;
  <D.20823>:
  monoeg_g_log (0B, 4, "compile method called on uninitialized runtime");
  <D.18743>:
  goto <D.18743>;
  D.20825 = 0B;
  return D.20825;
  <D.20824>:
  default_mono_compile_method.21 = default_mono_compile_method;
  D.20825 = default_mono_compile_method.21 (method);
  return D.20825;
}


mono_runtime_create_jump_trampoline (struct MonoDomain * domain, struct MonoMethod * method, gboolean add_sync_wrapper)
{
  void * D.20827;
  void * (*<T1d31>) (struct MonoDomain *, struct MonoMethod *, gboolean) arch_create_jump_trampoline.22;

  arch_create_jump_trampoline.22 = arch_create_jump_trampoline;
  D.20827 = arch_create_jump_trampoline.22 (domain, method, add_sync_wrapper);
  return D.20827;
}


mono_runtime_create_delegate_trampoline (struct MonoClass * klass)
{
  void * D.20830;
  void * (*<T1d3b>) (struct MonoDomain *, struct MonoClass *) arch_create_delegate_trampoline.23;
  struct MonoDomain * D.20832;

  arch_create_delegate_trampoline.23 = arch_create_delegate_trampoline;
  D.20832 = mono_domain_get ();
  D.20830 = arch_create_delegate_trampoline.23 (D.20832, klass);
  return D.20830;
}


mono_install_free_method (void (*MonoFreeMethodFunc) (struct MonoDomain *, struct MonoMethod *) func)
{
  default_mono_free_method = func;
}


mono_runtime_free_method (struct MonoDomain * domain, struct MonoMethod * method)
{
  void (*<T24de>) (struct MonoDomain *, struct MonoMethod *) default_mono_free_method.24;

  default_mono_free_method.24 = default_mono_free_method;
  if (default_mono_free_method.24 != 0B) goto <D.20835>; else goto <D.20836>;
  <D.20835>:
  default_mono_free_method.24 = default_mono_free_method;
  default_mono_free_method.24 (domain, method);
  <D.20836>:
  mono_method_clear_object (domain, method);
  mono_free_method (method);
}


mono_class_compute_bitmap (struct MonoClass * class, gsize * bitmap, int size, int offset, int * max_set, gboolean static_fields)
{
  gsize * D.20837;

  D.20837 = compute_class_bitmap (class, bitmap, size, offset, max_set, static_fields);
  return D.20837;
}


compute_class_bitmap (struct MonoClass * class, gsize * bitmap, int size, int offset, int * max_set, gboolean static_fields)
{
  int D.20841;
  unsigned int D.20842;
  unsigned int D.20843;
  int D.20845;
  unsigned int D.20846;
  unsigned int D.20847;
  _Bool D.20850;
  long int D.20851;
  long int D.20852;
  unsigned int max_size.25;
  unsigned int D.20856;
  unsigned int D.20857;
  unsigned int D.20858;
  struct MonoImage * D.20861;
  struct MonoImage * D.20862;
  int D.18780;
  int iftmp.26;
  int D.18776;
  const char[10] * D.20868;
  unsigned char D.20869;
  int D.20870;
  unsigned char D.20871;
  int D.20872;
  _Bool D.20873;
  _Bool D.20874;
  _Bool D.20875;
  const unsigned char * D.20878;
  unsigned char D.20879;
  int D.20880;
  const unsigned char * D.20881;
  unsigned char D.20882;
  int D.20883;
  _Bool D.20884;
  _Bool D.20885;
  const unsigned char * D.20888;
  unsigned char D.20889;
  int D.20890;
  const unsigned char * D.20891;
  unsigned char D.20892;
  int D.20893;
  _Bool D.20894;
  _Bool D.20895;
  const unsigned char * D.20898;
  unsigned char D.20899;
  int D.20900;
  const unsigned char * D.20901;
  unsigned char D.20902;
  int D.20903;
  const char * D.20905;
  int D.20908;
  unsigned int D.20909;
  gsize * D.20910;
  struct MonoType * D.20913;
  short unsigned int D.20914;
  int D.20915;
  int D.20916;
  int D.20919;
  unsigned char D.20925;
  unsigned char D.20926;
  int D.20930;
  unsigned int D.20933;
  unsigned int offset.27;
  unsigned char D.20935;
  int D.20936;
  unsigned int D.20937;
  _Bool D.20938;
  long int D.20939;
  long int D.20940;
  unsigned int size.28;
  _Bool D.20944;
  unsigned int max_size.29;
  _Bool D.20946;
  _Bool D.20947;
  int D.20948;
  _Bool D.20949;
  long int D.20950;
  long int D.20951;
  unsigned int D.20954;
  unsigned int D.20955;
  gsize * D.20956;
  unsigned int D.20957;
  int pos.30;
  int D.20959;
  unsigned int D.20960;
  unsigned int D.20961;
  int D.20962;
  unsigned int D.20963;
  unsigned int D.20964;
  int D.20965;
  int D.20966;
  unsigned int D.20971;
  unsigned int D.20972;
  gsize * D.20973;
  unsigned int D.20974;
  unsigned int D.20975;
  unsigned char D.20976;
  unsigned char D.20977;
  unsigned int D.20980;
  int D.20981;
  const char * D.20982;
  struct MonoClass * D.20983;
  char * D.20984;
  struct MonoClassField * field;
  struct MonoClass * p;
  guint32 pos;
  int max_size;

  if (static_fields != 0) goto <D.20839>; else goto <D.20840>;
  <D.20839>:
  D.20841 = mono_class_data_size (class);
  D.20842 = (unsigned int) D.20841;
  D.20843 = D.20842 / 4;
  max_size = (int) D.20843;
  goto <D.20844>;
  <D.20840>:
  D.20845 = class->instance_size;
  D.20846 = (unsigned int) D.20845;
  D.20847 = D.20846 / 4;
  max_size = (int) D.20847;
  <D.20844>:
  if (max_size > size) goto <D.20848>; else goto <D.20849>;
  <D.20848>:
  D.20850 = offset > 0;
  D.20851 = (long int) D.20850;
  D.20852 = __builtin_expect (D.20851, 0);
  if (D.20852 != 0) goto <D.20853>; else goto <D.20854>;
  <D.20853>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 664, "offset <= 0");
  <D.20854>:
  max_size.25 = (unsigned int) max_size;
  D.20856 = max_size.25 + 31;
  D.20857 = D.20856 / 32;
  D.20858 = D.20857 * 4;
  bitmap = monoeg_malloc0 (D.20858);
  size = max_size;
  <D.20849>:
  if (static_fields == 0) goto <D.20859>; else goto <D.20860>;
  <D.20859>:
  D.20861 = class->image;
  D.20862 = mono_defaults.corlib;
  if (D.20861 == D.20862) goto <D.20863>; else goto <D.20864>;
  <D.20863>:
  {
    size_t __s1_len;
    size_t __s2_len;

    __s1_len = 9;
    if (__s1_len <= 3) goto <D.20866>; else goto <D.20867>;
    <D.20866>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = class->name;
      D.20868 = "Ephemeron";
      D.20869 = MEM[(const unsigned char *)D.20868];
      D.20870 = (int) D.20869;
      D.20871 = *__s2;
      D.20872 = (int) D.20871;
      __result = D.20870 - D.20872;
      {
        D.20873 = __s1_len != 0;
        D.20874 = __result == 0;
        D.20875 = D.20873 & D.20874;
        if (D.20875 != 0) goto <D.20876>; else goto <D.20877>;
        <D.20876>:
        D.20878 = &MEM[(void *)"Ephemeron" + 1B];
        D.20879 = *D.20878;
        D.20880 = (int) D.20879;
        D.20881 = __s2 + 1;
        D.20882 = *D.20881;
        D.20883 = (int) D.20882;
        __result = D.20880 - D.20883;
        D.20884 = __s1_len > 1;
        D.20874 = __result == 0;
        D.20885 = D.20884 & D.20874;
        if (D.20885 != 0) goto <D.20886>; else goto <D.20887>;
        <D.20886>:
        D.20888 = &MEM[(void *)"Ephemeron" + 2B];
        D.20889 = *D.20888;
        D.20890 = (int) D.20889;
        D.20891 = __s2 + 2;
        D.20892 = *D.20891;
        D.20893 = (int) D.20892;
        __result = D.20890 - D.20893;
        D.20894 = __s1_len > 2;
        D.20874 = __result == 0;
        D.20895 = D.20894 & D.20874;
        if (D.20895 != 0) goto <D.20896>; else goto <D.20897>;
        <D.20896>:
        D.20898 = &MEM[(void *)"Ephemeron" + 3B];
        D.20899 = *D.20898;
        D.20900 = (int) D.20899;
        D.20901 = __s2 + 3;
        D.20902 = *D.20901;
        D.20903 = (int) D.20902;
        __result = D.20900 - D.20903;
        <D.20897>:
        <D.20887>:
        <D.20877>:
      }
      D.18776 = __result;
    }
    iftmp.26 = D.18776;
    goto <D.20904>;
    <D.20867>:
    D.20905 = class->name;
    iftmp.26 = __builtin_strcmp ("Ephemeron", D.20905);
    <D.20904>:
    D.18780 = iftmp.26;
  }
  if (D.18780 == 0) goto <D.20906>; else goto <D.20907>;
  <D.20906>:
  *max_set = 0;
  D.20908 = size / 8;
  D.20909 = (unsigned int) D.20908;
  memset (bitmap, 0, D.20909);
  D.20910 = bitmap;
  return D.20910;
  <D.20907>:
  <D.20864>:
  <D.20860>:
  p = class;
  goto <D.18815>;
  <D.18814>:
  {
    void * iter;

    try
      {
        iter = 0B;
        goto <D.18783>;
        <D.18812>:
        {
          struct MonoType * type;

          if (static_fields != 0) goto <D.20911>; else goto <D.20912>;
          <D.20911>:
          D.20913 = field->type;
          D.20914 = D.20913->attrs;
          D.20915 = (int) D.20914;
          D.20916 = D.20915 & 272;
          if (D.20916 == 0) goto <D.20917>; else goto <D.20918>;
          <D.20917>:
          // predicted unlikely by continue predictor.
          goto <D.18783>;
          <D.20918>:
          D.20913 = field->type;
          D.20914 = D.20913->attrs;
          D.20915 = (int) D.20914;
          D.20919 = D.20915 & 64;
          if (D.20919 != 0) goto <D.20920>; else goto <D.20921>;
          <D.20920>:
          // predicted unlikely by continue predictor.
          goto <D.18783>;
          <D.20921>:
          goto <D.20922>;
          <D.20912>:
          D.20913 = field->type;
          D.20914 = D.20913->attrs;
          D.20915 = (int) D.20914;
          D.20916 = D.20915 & 272;
          if (D.20916 != 0) goto <D.20923>; else goto <D.20924>;
          <D.20923>:
          // predicted unlikely by continue predictor.
          goto <D.18783>;
          <D.20924>:
          <D.20922>:
          D.20913 = field->type;
          D.20925 = BIT_FIELD_REF <*D.20913, 8, 56>;
          D.20926 = D.20925 & 64;
          if (D.20926 != 0) goto <D.18784>; else goto <D.20927>;
          <D.20927>:
          if (static_fields != 0) goto <D.20928>; else goto <D.20929>;
          <D.20928>:
          D.20930 = field->offset;
          if (D.20930 == -1) goto <D.20931>; else goto <D.20932>;
          <D.20931>:
          // predicted unlikely by continue predictor.
          goto <D.18783>;
          <D.20932>:
          <D.20929>:
          D.20930 = field->offset;
          D.20933 = (unsigned int) D.20930;
          pos = D.20933 / 4;
          offset.27 = (unsigned int) offset;
          pos = pos + offset.27;
          D.20913 = field->type;
          type = mono_type_get_underlying_type (D.20913);
          D.20935 = type->type;
          D.20936 = (int) D.20935;
          switch (D.20936) <default: <D.18810>, case 2: <D.18808>, case 3: <D.18809>, case 4: <D.18798>, case 5: <D.18799>, case 6: <D.18800>, case 7: <D.18801>, case 8: <D.18802>, case 9: <D.18803>, case 10: <D.18804>, case 11: <D.18805>, case 12: <D.18806>, case 13: <D.18807>, case 14: <D.18790>, case 15: <D.18786>, case 17: <D.18796>, case 18: <D.18792>, case 20: <D.18794>, case 21: <D.18795>, case 24: <D.18785>, case 25: <D.18789>, case 27: <D.18787>, case 28: <D.18793>, case 29: <D.18791>>
          <D.18785>:
          <D.18786>:
          <D.18787>:
          goto <D.18788>;
          <D.18789>:
          goto <D.18788>;
          <D.18790>:
          <D.18791>:
          <D.18792>:
          <D.18793>:
          <D.18794>:
          D.20930 = field->offset;
          D.20933 = (unsigned int) D.20930;
          D.20937 = D.20933 & 3;
          D.20938 = D.20937 != 0;
          D.20939 = (long int) D.20938;
          D.20940 = __builtin_expect (D.20939, 0);
          if (D.20940 != 0) goto <D.20941>; else goto <D.20942>;
          <D.20941>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 722, "(field->offset % sizeof(gpointer)) == 0");
          <D.20942>:
          size.28 = (unsigned int) size;
          D.20944 = size.28 <= pos;
          max_size.29 = (unsigned int) max_size;
          D.20946 = max_size.29 < pos;
          D.20947 = D.20944 & D.20946;
          D.20948 = (int) D.20947;
          D.20949 = D.20948 != 0;
          D.20950 = (long int) D.20949;
          D.20951 = __builtin_expect (D.20950, 0);
          if (D.20951 != 0) goto <D.20952>; else goto <D.20953>;
          <D.20952>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 724, "pos < size || pos <= max_size");
          <D.20953>:
          D.20954 = pos / 32;
          D.20955 = D.20954 * 4;
          D.20956 = bitmap + D.20955;
          D.20955 = D.20954 * 4;
          D.20956 = bitmap + D.20955;
          D.20957 = *D.20956;
          pos.30 = (int) pos;
          D.20959 = pos.30 & 31;
          D.20960 = 1 << D.20959;
          D.20961 = D.20957 | D.20960;
          *D.20956 = D.20961;
          D.20962 = *max_set;
          D.20963 = (unsigned int) D.20962;
          D.20964 = MAX_EXPR <D.20963, pos>;
          D.20965 = (int) D.20964;
          *max_set = D.20965;
          goto <D.18788>;
          <D.18795>:
          D.20966 = mono_type_generic_inst_is_valuetype (type);
          if (D.20966 == 0) goto <D.20967>; else goto <D.20968>;
          <D.20967>:
          D.20930 = field->offset;
          D.20933 = (unsigned int) D.20930;
          D.20937 = D.20933 & 3;
          D.20938 = D.20937 != 0;
          D.20939 = (long int) D.20938;
          D.20940 = __builtin_expect (D.20939, 0);
          if (D.20940 != 0) goto <D.20969>; else goto <D.20970>;
          <D.20969>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 730, "(field->offset % sizeof(gpointer)) == 0");
          <D.20970>:
          D.20971 = pos / 32;
          D.20972 = D.20971 * 4;
          D.20973 = bitmap + D.20972;
          D.20972 = D.20971 * 4;
          D.20973 = bitmap + D.20972;
          D.20974 = *D.20973;
          pos.30 = (int) pos;
          D.20959 = pos.30 & 31;
          D.20960 = 1 << D.20959;
          D.20975 = D.20974 | D.20960;
          *D.20973 = D.20975;
          D.20962 = *max_set;
          D.20963 = (unsigned int) D.20962;
          D.20964 = MAX_EXPR <D.20963, pos>;
          D.20965 = (int) D.20964;
          *max_set = D.20965;
          goto <D.18788>;
          <D.20968>:
          <D.18796>:
          {
            struct MonoClass * fclass;

            D.20913 = field->type;
            fclass = mono_class_from_mono_type (D.20913);
            D.20976 = BIT_FIELD_REF <*fclass, 8, 184>;
            D.20977 = D.20976 & 8;
            if (D.20977 != 0) goto <D.20978>; else goto <D.20979>;
            <D.20978>:
            D.20980 = pos + 4294967294;
            D.20981 = (int) D.20980;
            compute_class_bitmap (fclass, bitmap, size, D.20981, max_set, 0);
            <D.20979>:
            goto <D.18788>;
          }
          <D.18798>:
          <D.18799>:
          <D.18800>:
          <D.18801>:
          <D.18802>:
          <D.18803>:
          <D.18804>:
          <D.18805>:
          <D.18806>:
          <D.18807>:
          <D.18808>:
          <D.18809>:
          goto <D.18788>;
          <D.18810>:
          D.20982 = field->name;
          D.20983 = field->parent;
          D.20984 = mono_type_get_full_name (D.20983);
          D.20935 = type->type;
          D.20936 = (int) D.20935;
          monoeg_g_log (0B, 4, "compute_class_bitmap: Invalid type %x for field %s:%s\n", D.20936, D.20984, D.20982);
          <D.18811>:
          goto <D.18811>;
          <D.18788>:
        }
        <D.18783>:
        field = mono_class_get_fields (p, &iter);
        if (field != 0B) goto <D.18812>; else goto <D.18784>;
        <D.18784>:
        if (static_fields != 0) goto <D.18813>; else goto <D.20985>;
        <D.20985>:
      }
    finally
      {
        iter = {CLOBBER};
      }
  }
  p = p->parent;
  <D.18815>:
  if (p != 0B) goto <D.18814>; else goto <D.18813>;
  <D.18813>:
  D.20910 = bitmap;
  return D.20910;
}


memset (void * __dest, int __ch, size_t __len)
{
  int D.20992;
  int D.20997;
  void * D.20999;
  unsigned int D.21000;

  D.20992 = __builtin_constant_p (__len);
  if (D.20992 != 0) goto <D.20993>; else goto <D.20994>;
  <D.20993>:
  if (__len == 0) goto <D.20995>; else goto <D.20996>;
  <D.20995>:
  D.20997 = __builtin_constant_p (__ch);
  if (D.20997 == 0) goto <D.20990>; else goto <D.20998>;
  <D.20998>:
  if (__ch != 0) goto <D.20990>; else goto <D.20991>;
  <D.20990>:
  __warn_memset_zero_len ();
  D.20999 = __dest;
  return D.20999;
  <D.20991>:
  <D.20996>:
  <D.20994>:
  D.21000 = __builtin_object_size (__dest, 0);
  D.20999 = __builtin___memset_chk (__dest, __ch, __len, D.21000);
  return D.20999;
}


mono_string_alloc (int length)
{
  struct MonoString * D.21002;
  struct MonoDomain * D.21003;

  D.21003 = mono_domain_get ();
  D.21002 = mono_string_new_size (D.21003, length);
  return D.21002;
}


mono_class_compute_gc_descriptor (struct MonoClass * class)
{
  int gcj_inited.31;
  struct MonoMethodSignature * D.21008;
  struct MonoMethodSignature * D.21009;
  struct MonoMethodSignature * D.21010;
  struct MonoMethodSignature * D.21011;
  unsigned char D.21012;
  unsigned char D.21013;
  unsigned char D.21016;
  unsigned char D.21017;
  struct MonoClass * D.21020;
  void * D.21023;
  unsigned char D.21025;
  struct MonoClass * D.21028;
  unsigned char D.21029;
  unsigned char D.21030;
  unsigned char D.21033;
  _Bool D.21034;
  int D.21035;
  void * D.21036;
  int D.21038;
  unsigned int D.21039;
  int D.21040;
  unsigned int D.21041;
  unsigned int D.21042;
  int D.21043;
  void * D.21044;
  int D.21048;
  unsigned int D.21049;
  int max_set.32;
  int D.21051;
  void * D.21052;
  int max_set;
  gsize * bitmap;
  gsize default_bitmap[4];
  static gboolean gcj_inited = 0;

  try
    {
      max_set = 0;
      default_bitmap = {};
      gcj_inited.31 = gcj_inited;
      if (gcj_inited.31 == 0) goto <D.21006>; else goto <D.21007>;
      <D.21006>:
      mono_loader_lock ();
      D.21008 = mono_create_icall_signature ("object ptr");
      mono_register_jit_icall (mono_object_new_ptrfree, "mono_object_new_ptrfree", D.21008, 0);
      D.21009 = mono_create_icall_signature ("object ptr");
      mono_register_jit_icall (mono_object_new_ptrfree_box, "mono_object_new_ptrfree_box", D.21009, 0);
      D.21010 = mono_create_icall_signature ("object ptr");
      mono_register_jit_icall (mono_object_new_fast, "mono_object_new_fast", D.21010, 0);
      D.21011 = mono_create_icall_signature ("object int");
      mono_register_jit_icall (mono_string_alloc, "mono_string_alloc", D.21011, 0);
      gcj_inited = 1;
      mono_loader_unlock ();
      <D.21007>:
      D.21012 = BIT_FIELD_REF <*class, 8, 160>;
      D.21013 = D.21012 & 1;
      if (D.21013 == 0) goto <D.21014>; else goto <D.21015>;
      <D.21014>:
      mono_class_init (class);
      <D.21015>:
      D.21016 = BIT_FIELD_REF <*class, 8, 184>;
      D.21017 = D.21016 & 2;
      if (D.21017 != 0) goto <D.21018>; else goto <D.21019>;
      <D.21018>:
      return;
      <D.21019>:
      class->gc_descr_inited = 1;
      class->gc_descr = 0B;
      bitmap = &default_bitmap;
      D.21020 = mono_defaults.string_class;
      if (D.21020 == class) goto <D.21021>; else goto <D.21022>;
      <D.21021>:
      D.21023 = mono_gc_make_descr_for_string (bitmap, 2);
      class->gc_descr = D.21023;
      goto <D.21024>;
      <D.21022>:
      D.21025 = class->rank;
      if (D.21025 != 0) goto <D.21026>; else goto <D.21027>;
      <D.21026>:
      D.21028 = class->element_class;
      mono_class_compute_gc_descriptor (D.21028);
      D.21028 = class->element_class;
      D.21029 = BIT_FIELD_REF <*D.21028, 8, 160>;
      D.21030 = D.21029 & 8;
      if (D.21030 == 0) goto <D.21031>; else goto <D.21032>;
      <D.21031>:
      {
        gsize abm;

        try
          {
            abm = 1;
            D.21033 = class->byval_arg.type;
            D.21034 = D.21033 == 29;
            D.21035 = (int) D.21034;
            D.21036 = mono_gc_make_descr_for_array (D.21035, &abm, 1, 4);
            class->gc_descr = D.21036;
          }
        finally
          {
            abm = {CLOBBER};
          }
      }
      goto <D.21037>;
      <D.21032>:
      D.21028 = class->element_class;
      bitmap = compute_class_bitmap (D.21028, &default_bitmap, 128, -2, &max_set, 0);
      D.21038 = mono_array_element_size (class);
      D.21039 = (unsigned int) D.21038;
      D.21040 = mono_array_element_size (class);
      D.21041 = (unsigned int) D.21040;
      D.21042 = D.21041 / 4;
      D.21043 = (int) D.21042;
      D.21033 = class->byval_arg.type;
      D.21034 = D.21033 == 29;
      D.21035 = (int) D.21034;
      D.21044 = mono_gc_make_descr_for_array (D.21035, bitmap, D.21043, D.21039);
      class->gc_descr = D.21044;
      if (&default_bitmap != bitmap) goto <D.21045>; else goto <D.21046>;
      <D.21045>:
      monoeg_g_free (bitmap);
      <D.21046>:
      <D.21037>:
      goto <D.21047>;
      <D.21027>:
      bitmap = compute_class_bitmap (class, &default_bitmap, 128, 0, &max_set, 0);
      D.21048 = class->instance_size;
      D.21049 = (unsigned int) D.21048;
      max_set.32 = max_set;
      D.21051 = max_set.32 + 1;
      D.21052 = mono_gc_make_descr_for_object (bitmap, D.21051, D.21049);
      class->gc_descr = D.21052;
      if (&default_bitmap != bitmap) goto <D.21053>; else goto <D.21054>;
      <D.21053>:
      monoeg_g_free (bitmap);
      <D.21054>:
      <D.21047>:
      <D.21024>:
    }
  finally
    {
      max_set = {CLOBBER};
      default_bitmap = {CLOBBER};
    }
}


mono_object_new_ptrfree_box (struct MonoVTable * vtable)
{
  struct MonoClass * D.21058;
  int D.21059;
  unsigned int D.21060;
  struct MonoObject * D.21061;
  struct MonoObject * obj;

  D.21058 = vtable->klass;
  D.21059 = D.21058->instance_size;
  D.21060 = (unsigned int) D.21059;
  obj = mono_gc_alloc_obj (vtable, D.21060);
  D.21061 = obj;
  return D.21061;
}


mono_object_new_ptrfree (struct MonoVTable * vtable)
{
  struct MonoClass * D.21063;
  int D.21064;
  unsigned int D.21065;
  struct MonoObject * D.21066;
  struct MonoObject * obj;

  D.21063 = vtable->klass;
  D.21064 = D.21063->instance_size;
  D.21065 = (unsigned int) D.21064;
  obj = mono_gc_alloc_obj (vtable, D.21065);
  D.21066 = obj;
  return D.21066;
}


mono_method_get_imt_slot (struct MonoMethod * method)
{
  unsigned char D.21068;
  unsigned char D.21069;
  short unsigned int D.21072;
  int D.21073;
  unsigned int hashes_count.33;
  unsigned int D.21075;
  struct MonoClass * D.21076;
  unsigned int D.21077;
  unsigned int D.21078;
  unsigned char D.21081;
  const char * D.21086;
  const char * D.21087;
  const char * D.21088;
  unsigned int D.21089;
  guint32 * D.21090;
  unsigned int D.21091;
  guint32 * D.21092;
  unsigned int D.21093;
  guint32 * D.21094;
  struct MonoType * D.21095;
  unsigned int D.21096;
  int D.21097;
  unsigned int D.21098;
  unsigned int D.21099;
  guint32 * D.21100;
  struct MonoType * D.21101;
  unsigned int D.21102;
  unsigned int D.21103;
  unsigned int D.21104;
  unsigned int D.21105;
  unsigned int D.21106;
  unsigned int D.21107;
  unsigned int D.21108;
  unsigned int D.21109;
  unsigned int D.21110;
  unsigned int D.21111;
  unsigned int D.21112;
  unsigned int D.21113;
  unsigned int D.21114;
  unsigned int D.21115;
  unsigned int D.21116;
  unsigned int D.21117;
  unsigned int D.21118;
  guint32 D.21120;
  struct MonoMethodSignature * sig;
  int hashes_count;
  guint32 * hashes_start;
  guint32 * hashes;
  guint32 a;
  guint32 b;
  guint32 c;
  int i;

  D.21068 = BIT_FIELD_REF <*method, 8, 168>;
  D.21069 = D.21068 & 16;
  if (D.21069 != 0) goto <D.21070>; else goto <D.21071>;
  <D.21070>:
  method = MEM[(struct MonoMethodInflated *)method].declaring;
  <D.21071>:
  sig = mono_method_signature (method);
  D.21072 = sig->param_count;
  D.21073 = (int) D.21072;
  hashes_count = D.21073 + 4;
  hashes_count.33 = (unsigned int) hashes_count;
  D.21075 = hashes_count.33 * 4;
  hashes_start = malloc (D.21075);
  hashes = hashes_start;
  D.21076 = method->klass;
  D.21077 = D.21076->flags;
  D.21078 = D.21077 & 32;
  if (D.21078 == 0) goto <D.21079>; else goto <D.21080>;
  <D.21079>:
  D.21076 = method->klass;
  D.21081 = D.21076->byval_arg.type;
  if (D.21081 != 19) goto <D.21082>; else goto <D.21083>;
  <D.21082>:
  D.21076 = method->klass;
  D.21081 = D.21076->byval_arg.type;
  if (D.21081 != 30) goto <D.21084>; else goto <D.21085>;
  <D.21084>:
  D.21086 = method->name;
  D.21076 = method->klass;
  D.21087 = D.21076->name;
  D.21076 = method->klass;
  D.21088 = D.21076->name_space;
  monoeg_g_log (0B, 4, "mono_method_get_imt_slot: %s.%s.%s is not an interface MonoMethod", D.21088, D.21087, D.21086);
  <D.18874>:
  goto <D.18874>;
  <D.21085>:
  <D.21083>:
  <D.21080>:
  D.21076 = method->klass;
  D.21087 = D.21076->name;
  D.21089 = mono_metadata_str_hash (D.21087);
  *hashes = D.21089;
  D.21090 = hashes + 4;
  D.21076 = method->klass;
  D.21088 = D.21076->name_space;
  D.21091 = mono_metadata_str_hash (D.21088);
  *D.21090 = D.21091;
  D.21092 = hashes + 8;
  D.21086 = method->name;
  D.21093 = mono_metadata_str_hash (D.21086);
  *D.21092 = D.21093;
  D.21094 = hashes + 12;
  D.21095 = sig->ret;
  D.21096 = mono_metadata_type_hash (D.21095);
  *D.21094 = D.21096;
  i = 0;
  goto <D.18876>;
  <D.18875>:
  D.21097 = i + 4;
  D.21098 = (unsigned int) D.21097;
  D.21099 = D.21098 * 4;
  D.21100 = hashes + D.21099;
  D.21101 = sig->params[i];
  D.21102 = mono_metadata_type_hash (D.21101);
  *D.21100 = D.21102;
  i = i + 1;
  <D.18876>:
  D.21072 = sig->param_count;
  D.21073 = (int) D.21072;
  if (D.21073 > i) goto <D.18875>; else goto <D.18877>;
  <D.18877>:
  hashes_count.33 = (unsigned int) hashes_count;
  D.21103 = hashes_count.33 << 2;
  c = D.21103 + 3735928559;
  b = c;
  a = b;
  goto <D.18879>;
  <D.18878>:
  D.21104 = *hashes;
  a = D.21104 + a;
  D.21090 = hashes + 4;
  D.21105 = *D.21090;
  b = D.21105 + b;
  D.21092 = hashes + 8;
  D.21106 = *D.21092;
  c = D.21106 + c;
  a = a - c;
  D.21107 = c r>> 28;
  a = D.21107 ^ a;
  c = c + b;
  b = b - a;
  D.21108 = a r>> 26;
  b = D.21108 ^ b;
  a = a + c;
  c = c - b;
  D.21109 = b r>> 24;
  c = D.21109 ^ c;
  b = b + a;
  a = a - c;
  D.21110 = c r>> 16;
  a = D.21110 ^ a;
  c = c + b;
  b = b - a;
  D.21111 = a r>> 13;
  b = D.21111 ^ b;
  a = a + c;
  c = c - b;
  D.21112 = b r>> 28;
  c = D.21112 ^ c;
  b = b + a;
  hashes_count = hashes_count + -3;
  hashes = hashes + 12;
  <D.18879>:
  if (hashes_count > 3) goto <D.18878>; else goto <D.18880>;
  <D.18880>:
  switch (hashes_count) <default: <D.21119>, case 0: <D.18884>, case 1: <D.18883>, case 2: <D.18882>, case 3: <D.18881>>
  <D.18881>:
  D.21092 = hashes + 8;
  D.21106 = *D.21092;
  c = D.21106 + c;
  <D.18882>:
  D.21090 = hashes + 4;
  D.21105 = *D.21090;
  b = D.21105 + b;
  <D.18883>:
  D.21104 = *hashes;
  a = D.21104 + a;
  c = c ^ b;
  D.21113 = b r>> 18;
  c = c - D.21113;
  a = a ^ c;
  D.21114 = c r>> 21;
  a = a - D.21114;
  b = b ^ a;
  D.21115 = a r>> 7;
  b = b - D.21115;
  c = c ^ b;
  D.21116 = b r>> 16;
  c = c - D.21116;
  a = a ^ c;
  D.21107 = c r>> 28;
  a = a - D.21107;
  b = b ^ a;
  D.21117 = a r>> 18;
  b = b - D.21117;
  c = c ^ b;
  D.21118 = b r>> 8;
  c = c - D.21118;
  <D.18884>:
  goto <D.18885>;
  <D.21119>:
  <D.18885>:
  free (hashes_start);
  D.21120 = c % 19;
  return D.21120;
}


mono_vtable_build_imt_slot (struct MonoVTable * vtable, int imt_slot)
{
  unsigned int imt_slot.34;
  _Bool D.21123;
  long int D.21124;
  long int D.21125;
  struct MonoDomain * D.21128;
  union mono_mutex_t * D.21129;
  _Bool D.21132;
  long int D.21133;
  long int D.21134;
  unsigned int imt_slot.35;
  unsigned int D.21138;
  void * * D.21139;
  void * D.21140;
  void * (*<T24a4>) (int) D.21141;
  void * D.21142;
  struct MonoClass * D.21145;
  _Bool D.21148;
  long int D.21149;
  long int D.21150;
  void * * imt;

  imt = vtable;
  imt = imt + 4294967220;
  imt_slot.34 = (unsigned int) imt_slot;
  D.21123 = imt_slot.34 > 18;
  D.21124 = (long int) D.21123;
  D.21125 = __builtin_expect (D.21124, 0);
  if (D.21125 != 0) goto <D.21126>; else goto <D.21127>;
  <D.21126>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 1452, "imt_slot >= 0 && imt_slot < MONO_IMT_SIZE");
  <D.21127>:
  mono_loader_lock ();
  {
    int ret;

    D.21128 = vtable->domain;
    D.21129 = &D.21128->lock.mutex;
    ret = pthread_mutex_lock (D.21129);
    if (ret != 0) goto <D.21130>; else goto <D.21131>;
    <D.21130>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.21131>:
    D.21132 = ret != 0;
    D.21133 = (long int) D.21132;
    D.21134 = __builtin_expect (D.21133, 0);
    if (D.21134 != 0) goto <D.21135>; else goto <D.21136>;
    <D.21135>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 1460, "ret == 0");
    <D.21136>:
  }
  imt_slot.35 = (unsigned int) imt_slot;
  D.21138 = imt_slot.35 * 4;
  D.21139 = imt + D.21138;
  D.21140 = *D.21139;
  D.21141 = callbacks.get_imt_trampoline;
  D.21142 = D.21141 (imt_slot);
  if (D.21140 == D.21142) goto <D.21143>; else goto <D.21144>;
  <D.21143>:
  D.21128 = vtable->domain;
  D.21145 = vtable->klass;
  build_imt_slots (D.21145, vtable, D.21128, imt, 0B, imt_slot);
  <D.21144>:
  {
    int ret;

    D.21128 = vtable->domain;
    D.21129 = &D.21128->lock.mutex;
    ret = pthread_mutex_unlock (D.21129);
    if (ret != 0) goto <D.21146>; else goto <D.21147>;
    <D.21146>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.21147>:
    D.21148 = ret != 0;
    D.21149 = (long int) D.21148;
    D.21150 = __builtin_expect (D.21149, 0);
    if (D.21150 != 0) goto <D.21151>; else goto <D.21152>;
    <D.21151>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 1464, "ret == 0");
    <D.21152>:
  }
  mono_loader_unlock ();
}


build_imt_slots (struct MonoClass * klass, struct MonoVTable * vt, struct MonoDomain * domain, void * * imt, struct GSList * extra_interfaces, int slot_num)
{
  struct MonoClass * * D.21153;
  unsigned int i.36;
  unsigned int D.21155;
  struct MonoClass * * D.21156;
  guint16 * D.21157;
  unsigned int D.21158;
  guint16 * D.21159;
  short unsigned int D.21160;
  int D.21161;
  unsigned char D.21166;
  unsigned char D.21167;
  struct MonoGenericClass * D.21170;
  struct MonoClass * D.21171;
  unsigned int D.21172;
  unsigned int slot_num.37;
  unsigned char D.21176;
  unsigned char D.21177;
  short unsigned int D.21180;
  int D.21181;
  int D.21182;
  unsigned int method_slot_in_interface.38;
  unsigned int D.21186;
  short unsigned int D.21187;
  int D.21188;
  int D.21191;
  unsigned int method_slot_in_interface.39;
  unsigned int D.21193;
  unsigned int interface_offset.40;
  unsigned int D.21195;
  _Bool D.21196;
  _Bool D.21197;
  _Bool D.21198;
  void * * D.21201;
  struct MonoImtBuilderEntry * * D.21204;
  struct MonoImtBuilderEntry * D.21205;
  struct _MonoImtBuilderEntry * D.21208;
  int D.21209;
  int D.21210;
  int D.21211;
  int D.21212;
  int D.21213;
  int D.21216;
  unsigned int D.21217;
  unsigned int imt_collisions_bitmap.41;
  unsigned int imt_collisions_bitmap.42;
  void * iftmp.43;
  void * (*<T24a4>) (int) D.21221;
  void * D.21225;
  void * D.21227;
  long unsigned int methods_in_slot.44;
  long unsigned int D.21231;
  long unsigned int methods_in_slot.45;
  long unsigned int D.21235;
  long unsigned int method_count.46;
  long unsigned int D.21237;
  long unsigned int method_count.47;
  unsigned int D.21241;
  unsigned int D.21242;
  int i;
  struct GSList * list_item;
  guint32 imt_collisions_bitmap;
  struct MonoImtBuilderEntry * * imt_builder;
  int method_count;
  gboolean record_method_count_for_max_collisions;
  gboolean has_generic_virtual;
  gboolean has_variant_iface;

  try
    {
      imt_collisions_bitmap = 0;
      imt_builder = calloc (19, 4);
      method_count = 0;
      record_method_count_for_max_collisions = 0;
      has_generic_virtual = 0;
      has_variant_iface = 0;
      i = 0;
      goto <D.18968>;
      <D.18967>:
      {
        struct MonoClass * iface;
        int interface_offset;
        int method_slot_in_interface;
        int vt_slot;

        D.21153 = klass->interfaces_packed;
        i.36 = (unsigned int) i;
        D.21155 = i.36 * 4;
        D.21156 = D.21153 + D.21155;
        iface = *D.21156;
        D.21157 = klass->interface_offsets_packed;
        i.36 = (unsigned int) i;
        D.21158 = i.36 * 2;
        D.21159 = D.21157 + D.21158;
        D.21160 = *D.21159;
        interface_offset = (int) D.21160;
        D.21161 = mono_class_has_variant_generic_params (iface);
        if (D.21161 != 0) goto <D.21162>; else goto <D.21163>;
        <D.21162>:
        has_variant_iface = 1;
        <D.21163>:
        mono_class_setup_methods (iface);
        vt_slot = interface_offset;
        method_slot_in_interface = 0;
        goto <D.18965>;
        <D.18964>:
        {
          struct MonoMethod * method;

          if (slot_num >= 0) goto <D.21164>; else goto <D.21165>;
          <D.21164>:
          D.21166 = BIT_FIELD_REF <*iface, 8, 192>;
          D.21167 = D.21166 & 8;
          if (D.21167 != 0) goto <D.21168>; else goto <D.21169>;
          <D.21168>:
          D.21170 = iface->generic_class;
          D.21171 = D.21170->container_class;
          method = mono_class_get_method_by_index (D.21171, method_slot_in_interface);
          D.21172 = mono_method_get_imt_slot (method);
          slot_num.37 = (unsigned int) slot_num;
          if (D.21172 != slot_num.37) goto <D.21174>; else goto <D.21175>;
          <D.21174>:
          vt_slot = vt_slot + 1;
          // predicted unlikely by continue predictor.
          goto <D.18963>;
          <D.21175>:
          <D.21169>:
          <D.21165>:
          method = mono_class_get_method_by_index (iface, method_slot_in_interface);
          D.21176 = BIT_FIELD_REF <*method, 8, 168>;
          D.21177 = D.21176 & 8;
          if (D.21177 != 0) goto <D.21178>; else goto <D.21179>;
          <D.21178>:
          has_generic_virtual = 1;
          vt_slot = vt_slot + 1;
          // predicted unlikely by continue predictor.
          goto <D.18963>;
          <D.21179>:
          D.21180 = method->flags;
          D.21181 = (int) D.21180;
          D.21182 = D.21181 & 16;
          if (D.21182 == 0) goto <D.21183>; else goto <D.21184>;
          <D.21183>:
          add_imt_builder_entry (imt_builder, method, &imt_collisions_bitmap, vt_slot, slot_num);
          vt_slot = vt_slot + 1;
          <D.21184>:
        }
        <D.18963>:
        method_slot_in_interface = method_slot_in_interface + 1;
        <D.18965>:
        method_slot_in_interface.38 = (unsigned int) method_slot_in_interface;
        D.21186 = iface->method.count;
        if (method_slot_in_interface.38 < D.21186) goto <D.18964>; else goto <D.18966>;
        <D.18966>:
      }
      i = i + 1;
      <D.18968>:
      D.21187 = klass->interface_offsets_count;
      D.21188 = (int) D.21187;
      if (D.21188 > i) goto <D.18967>; else goto <D.18969>;
      <D.18969>:
      if (extra_interfaces != 0B) goto <D.21189>; else goto <D.21190>;
      <D.21189>:
      {
        int interface_offset;

        interface_offset = klass->vtable_size;
        list_item = extra_interfaces;
        goto <D.18978>;
        <D.18977>:
        {
          struct MonoClass * iface;
          int method_slot_in_interface;

          iface = list_item->data;
          method_slot_in_interface = 0;
          goto <D.18975>;
          <D.18974>:
          {
            struct MonoMethod * method;

            method = mono_class_get_method_by_index (iface, method_slot_in_interface);
            D.21191 = interface_offset + method_slot_in_interface;
            add_imt_builder_entry (imt_builder, method, &imt_collisions_bitmap, D.21191, slot_num);
          }
          method_slot_in_interface = method_slot_in_interface + 1;
          <D.18975>:
          method_slot_in_interface.39 = (unsigned int) method_slot_in_interface;
          D.21193 = iface->method.count;
          if (method_slot_in_interface.39 < D.21193) goto <D.18974>; else goto <D.18976>;
          <D.18976>:
          D.21193 = iface->method.count;
          interface_offset.40 = (unsigned int) interface_offset;
          D.21195 = D.21193 + interface_offset.40;
          interface_offset = (int) D.21195;
        }
        list_item = list_item->next;
        <D.18978>:
        if (list_item != 0B) goto <D.18977>; else goto <D.18979>;
        <D.18979>:
      }
      <D.21190>:
      i = 0;
      goto <D.18987>;
      <D.18986>:
      D.21196 = slot_num < 0;
      D.21197 = i == slot_num;
      D.21198 = D.21196 | D.21197;
      if (D.21198 != 0) goto <D.21199>; else goto <D.21200>;
      <D.21199>:
      {
        struct MonoImtBuilderEntry * entries;

        i.36 = (unsigned int) i;
        D.21155 = i.36 * 4;
        D.21201 = imt + D.21155;
        entries = get_generic_virtual_entries (domain, D.21201);
        if (entries != 0B) goto <D.21202>; else goto <D.21203>;
        <D.21202>:
        i.36 = (unsigned int) i;
        D.21155 = i.36 * 4;
        D.21204 = imt_builder + D.21155;
        D.21205 = *D.21204;
        if (D.21205 != 0B) goto <D.21206>; else goto <D.21207>;
        <D.21206>:
        {
          struct MonoImtBuilderEntry * entry;

          entry = entries;
          goto <D.18983>;
          <D.18982>:
          entry = entry->next;
          <D.18983>:
          D.21208 = entry->next;
          if (D.21208 != 0B) goto <D.18982>; else goto <D.18984>;
          <D.18984>:
          i.36 = (unsigned int) i;
          D.21155 = i.36 * 4;
          D.21204 = imt_builder + D.21155;
          D.21205 = *D.21204;
          entry->next = D.21205;
          D.21209 = entries->children;
          i.36 = (unsigned int) i;
          D.21155 = i.36 * 4;
          D.21204 = imt_builder + D.21155;
          D.21205 = *D.21204;
          D.21210 = D.21205->children;
          D.21211 = D.21210 + 1;
          D.21212 = D.21209 + D.21211;
          entries->children = D.21212;
        }
        <D.21207>:
        i.36 = (unsigned int) i;
        D.21155 = i.36 * 4;
        D.21204 = imt_builder + D.21155;
        *D.21204 = entries;
        <D.21203>:
        D.21213 = has_generic_virtual | has_variant_iface;
        if (D.21213 != 0) goto <D.21214>; else goto <D.21215>;
        <D.21214>:
        D.21216 = 1 << i;
        D.21217 = (unsigned int) D.21216;
        imt_collisions_bitmap.41 = imt_collisions_bitmap;
        imt_collisions_bitmap.42 = D.21217 | imt_collisions_bitmap.41;
        imt_collisions_bitmap = imt_collisions_bitmap.42;
        i.36 = (unsigned int) i;
        D.21155 = i.36 * 4;
        D.21201 = imt + D.21155;
        D.21221 = callbacks.get_imt_trampoline;
        if (D.21221 != 0B) goto <D.21222>; else goto <D.21223>;
        <D.21222>:
        D.21221 = callbacks.get_imt_trampoline;
        iftmp.43 = D.21221 (i);
        goto <D.21224>;
        <D.21223>:
        iftmp.43 = 0B;
        <D.21224>:
        i.36 = (unsigned int) i;
        D.21155 = i.36 * 4;
        D.21204 = imt_builder + D.21155;
        D.21205 = *D.21204;
        D.21225 = initialize_imt_slot (vt, domain, D.21205, iftmp.43);
        *D.21201 = D.21225;
        goto <D.21226>;
        <D.21215>:
        i.36 = (unsigned int) i;
        D.21155 = i.36 * 4;
        D.21201 = imt + D.21155;
        i.36 = (unsigned int) i;
        D.21155 = i.36 * 4;
        D.21204 = imt_builder + D.21155;
        D.21205 = *D.21204;
        D.21227 = initialize_imt_slot (vt, domain, D.21205, 0B);
        *D.21201 = D.21227;
        <D.21226>:
      }
      <D.21200>:
      i.36 = (unsigned int) i;
      D.21155 = i.36 * 4;
      D.21204 = imt_builder + D.21155;
      D.21205 = *D.21204;
      if (D.21205 != 0B) goto <D.21228>; else goto <D.21229>;
      <D.21228>:
      {
        int methods_in_slot;

        i.36 = (unsigned int) i;
        D.21155 = i.36 * 4;
        D.21204 = imt_builder + D.21155;
        D.21205 = *D.21204;
        D.21210 = D.21205->children;
        methods_in_slot = D.21210 + 1;
        methods_in_slot.44 = (long unsigned int) methods_in_slot;
        D.21231 = mono_stats.imt_max_collisions_in_slot;
        if (methods_in_slot.44 > D.21231) goto <D.21232>; else goto <D.21233>;
        <D.21232>:
        methods_in_slot.45 = (long unsigned int) methods_in_slot;
        mono_stats.imt_max_collisions_in_slot = methods_in_slot.45;
        record_method_count_for_max_collisions = 1;
        <D.21233>:
        method_count = method_count + methods_in_slot;
      }
      <D.21229>:
      i = i + 1;
      <D.18987>:
      if (i <= 18) goto <D.18986>; else goto <D.18988>;
      <D.18988>:
      D.21235 = mono_stats.imt_number_of_methods;
      method_count.46 = (long unsigned int) method_count;
      D.21237 = D.21235 + method_count.46;
      mono_stats.imt_number_of_methods = D.21237;
      if (record_method_count_for_max_collisions != 0) goto <D.21238>; else goto <D.21239>;
      <D.21238>:
      method_count.47 = (long unsigned int) method_count;
      mono_stats.imt_method_count_when_max_collisions = method_count.47;
      <D.21239>:
      i = 0;
      goto <D.18995>;
      <D.18994>:
      {
        struct MonoImtBuilderEntry * entry;

        i.36 = (unsigned int) i;
        D.21155 = i.36 * 4;
        D.21204 = imt_builder + D.21155;
        entry = *D.21204;
        goto <D.18992>;
        <D.18991>:
        {
          struct MonoImtBuilderEntry * next;

          next = entry->next;
          monoeg_g_free (entry);
          entry = next;
        }
        <D.18992>:
        if (entry != 0B) goto <D.18991>; else goto <D.18993>;
        <D.18993>:
      }
      i = i + 1;
      <D.18995>:
      if (i <= 18) goto <D.18994>; else goto <D.18996>;
      <D.18996>:
      free (imt_builder);
      D.21241 = vt->imt_collisions_bitmap;
      imt_collisions_bitmap.41 = imt_collisions_bitmap;
      D.21242 = D.21241 | imt_collisions_bitmap.41;
      vt->imt_collisions_bitmap = D.21242;
    }
  finally
    {
      imt_collisions_bitmap = {CLOBBER};
    }
}


add_imt_builder_entry (struct MonoImtBuilderEntry * * imt_builder, struct MonoMethod * method, guint32 * imt_collisions_bitmap, int vtable_slot, int slot_num)
{
  _Bool D.21243;
  unsigned int slot_num.48;
  _Bool D.21245;
  _Bool D.21246;
  unsigned int D.21249;
  struct MonoImtBuilderEntry * * D.21250;
  struct MonoImtBuilderEntry * D.21251;
  int D.21254;
  int D.21255;
  int D.21256;
  long unsigned int D.21259;
  long unsigned int D.21260;
  unsigned int D.21261;
  int imt_slot.49;
  int D.21263;
  unsigned int D.21264;
  unsigned int D.21265;
  long unsigned int D.21267;
  long unsigned int D.21268;
  guint32 imt_slot;
  struct MonoImtBuilderEntry * entry;

  imt_slot = mono_method_get_imt_slot (method);
  D.21243 = slot_num >= 0;
  slot_num.48 = (unsigned int) slot_num;
  D.21245 = slot_num.48 != imt_slot;
  D.21246 = D.21243 & D.21245;
  if (D.21246 != 0) goto <D.21247>; else goto <D.21248>;
  <D.21247>:
  return;
  <D.21248>:
  entry = monoeg_malloc0 (20);
  entry->key = method;
  entry->value.vtable_slot = vtable_slot;
  D.21249 = imt_slot * 4;
  D.21250 = imt_builder + D.21249;
  D.21251 = *D.21250;
  entry->next = D.21251;
  D.21249 = imt_slot * 4;
  D.21250 = imt_builder + D.21249;
  D.21251 = *D.21250;
  if (D.21251 != 0B) goto <D.21252>; else goto <D.21253>;
  <D.21252>:
  D.21249 = imt_slot * 4;
  D.21250 = imt_builder + D.21249;
  D.21251 = *D.21250;
  D.21254 = D.21251->children;
  D.21255 = D.21254 + 1;
  entry->children = D.21255;
  D.21256 = entry->children;
  if (D.21256 == 1) goto <D.21257>; else goto <D.21258>;
  <D.21257>:
  D.21259 = mono_stats.imt_slots_with_collisions;
  D.21260 = D.21259 + 1;
  mono_stats.imt_slots_with_collisions = D.21260;
  D.21261 = *imt_collisions_bitmap;
  imt_slot.49 = (int) imt_slot;
  D.21263 = 1 << imt_slot.49;
  D.21264 = (unsigned int) D.21263;
  D.21265 = D.21261 | D.21264;
  *imt_collisions_bitmap = D.21265;
  <D.21258>:
  goto <D.21266>;
  <D.21253>:
  entry->children = 0;
  D.21267 = mono_stats.imt_used_slots;
  D.21268 = D.21267 + 1;
  mono_stats.imt_used_slots = D.21268;
  <D.21266>:
  D.21249 = imt_slot * 4;
  D.21250 = imt_builder + D.21249;
  *D.21250 = entry;
}


get_generic_virtual_entries (struct MonoDomain * domain, void * * vtable_slot)
{
  union mono_mutex_t * D.21270;
  _Bool D.21273;
  long int D.21274;
  long int D.21275;
  struct GHashTable * D.21278;
  struct GHashTable * D.21281;
  int D.21282;
  struct MonoMethod * D.21285;
  void * D.21286;
  void * D.21287;
  int D.21290;
  int D.21291;
  _Bool D.21294;
  long int D.21295;
  long int D.21296;
  struct MonoImtBuilderEntry * D.21299;
  struct GenericVirtualCase * list;
  struct MonoImtBuilderEntry * entries;

  {
    int ret;

    D.21270 = &domain->lock.mutex;
    ret = pthread_mutex_lock (D.21270);
    if (ret != 0) goto <D.21271>; else goto <D.21272>;
    <D.21271>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.21272>:
    D.21273 = ret != 0;
    D.21274 = (long int) D.21273;
    D.21275 = __builtin_expect (D.21274, 0);
    if (D.21275 != 0) goto <D.21276>; else goto <D.21277>;
    <D.21276>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 1645, "ret == 0");
    <D.21277>:
  }
  D.21278 = domain->generic_virtual_cases;
  if (D.21278 == 0B) goto <D.21279>; else goto <D.21280>;
  <D.21279>:
  D.21281 = monoeg_g_hash_table_new (mono_aligned_addr_hash, 0B);
  domain->generic_virtual_cases = D.21281;
  <D.21280>:
  D.21278 = domain->generic_virtual_cases;
  list = monoeg_g_hash_table_lookup (D.21278, vtable_slot);
  entries = 0B;
  goto <D.19072>;
  <D.19071>:
  {
    struct MonoImtBuilderEntry * entry;

    D.21282 = list->count;
    if (D.21282 <= 9) goto <D.21283>; else goto <D.21284>;
    <D.21283>:
    // predicted unlikely by continue predictor.
    goto <D.19070>;
    <D.21284>:
    entry = monoeg_malloc0 (20);
    D.21285 = list->method;
    entry->key = D.21285;
    D.21286 = list->code;
    D.21287 = mono_get_addr_from_ftnptr (D.21286);
    entry->value.target_code = D.21287;
    entry->has_target_code = 1;
    if (entries != 0B) goto <D.21288>; else goto <D.21289>;
    <D.21288>:
    D.21290 = entries->children;
    D.21291 = D.21290 + 1;
    entry->children = D.21291;
    <D.21289>:
    entry->next = entries;
    entries = entry;
  }
  <D.19070>:
  list = list->next;
  <D.19072>:
  if (list != 0B) goto <D.19071>; else goto <D.19073>;
  <D.19073>:
  {
    int ret;

    D.21270 = &domain->lock.mutex;
    ret = pthread_mutex_unlock (D.21270);
    if (ret != 0) goto <D.21292>; else goto <D.21293>;
    <D.21292>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.21293>:
    D.21294 = ret != 0;
    D.21295 = (long int) D.21294;
    D.21296 = __builtin_expect (D.21295, 0);
    if (D.21296 != 0) goto <D.21297>; else goto <D.21298>;
    <D.21297>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 1668, "ret == 0");
    <D.21298>:
  }
  D.21299 = entries;
  return D.21299;
}


initialize_imt_slot (struct MonoVTable * vtable, struct MonoDomain * domain, struct MonoImtBuilderEntry * imt_builder_entry, void * fail_tramp)
{
  int D.21304;
  void * D.21307;
  int D.21308;
  void * (*<T26dc>) (struct MonoVTable *, struct MonoDomain *, struct MonoIMTCheckItem * *, int, void *) imt_thunk_builder.50;
  unsigned int D.21310;
  int D.21311;
  void * * D.21312;
  unsigned int i.51;
  unsigned int D.21314;
  void * * D.21315;
  void * D.21316;
  unsigned int i.52;

  if (imt_builder_entry != 0B) goto <D.21301>; else goto <D.21302>;
  <D.21301>:
  D.21304 = imt_builder_entry->children;
  if (D.21304 == 0) goto <D.21305>; else goto <D.21303>;
  <D.21305>:
  if (fail_tramp == 0B) goto <D.21306>; else goto <D.21303>;
  <D.21306>:
  D.21308 = imt_builder_entry->value.vtable_slot;
  D.21307 = vtable->vtable[D.21308];
  return D.21307;
  <D.21303>:
  {
    struct GPtrArray * imt_ir;
    void * result;
    int i;

    imt_ir = imt_sort_slot_entries (imt_builder_entry);
    imt_thunk_builder.50 = imt_thunk_builder;
    D.21310 = imt_ir->len;
    D.21311 = (int) D.21310;
    D.21312 = imt_ir->pdata;
    result = imt_thunk_builder.50 (vtable, domain, D.21312, D.21311, fail_tramp);
    i = 0;
    goto <D.18937>;
    <D.18936>:
    D.21312 = imt_ir->pdata;
    i.51 = (unsigned int) i;
    D.21314 = i.51 * 4;
    D.21315 = D.21312 + D.21314;
    D.21316 = *D.21315;
    monoeg_g_free (D.21316);
    i = i + 1;
    <D.18937>:
    i.52 = (unsigned int) i;
    D.21310 = imt_ir->len;
    if (i.52 < D.21310) goto <D.18936>; else goto <D.18938>;
    <D.18938>:
    monoeg_g_ptr_array_free (imt_ir, 1);
    D.21307 = result;
    return D.21307;
  }
  <D.21302>:
  if (fail_tramp != 0B) goto <D.21318>; else goto <D.21319>;
  <D.21318>:
  D.21307 = fail_tramp;
  return D.21307;
  <D.21319>:
  D.21307 = 0B;
  return D.21307;
}


imt_sort_slot_entries (struct MonoImtBuilderEntry * entries)
{
  int D.21321;
  unsigned int number_of_entries.53;
  unsigned int D.21323;
  unsigned int i.54;
  unsigned int D.21325;
  struct MonoImtBuilderEntry * * D.21326;
  unsigned int number_of_entries.55;
  struct GPtrArray * D.21328;
  int number_of_entries;
  struct MonoImtBuilderEntry * * sorted_array;
  struct GPtrArray * result;
  struct MonoImtBuilderEntry * current_entry;
  int i;

  D.21321 = entries->children;
  number_of_entries = D.21321 + 1;
  number_of_entries.53 = (unsigned int) number_of_entries;
  D.21323 = number_of_entries.53 * 4;
  sorted_array = malloc (D.21323);
  result = monoeg_g_ptr_array_new ();
  current_entry = entries;
  i = 0;
  goto <D.18925>;
  <D.18924>:
  i.54 = (unsigned int) i;
  D.21325 = i.54 * 4;
  D.21326 = sorted_array + D.21325;
  *D.21326 = current_entry;
  current_entry = current_entry->next;
  i = i + 1;
  <D.18925>:
  if (current_entry != 0B) goto <D.18924>; else goto <D.18926>;
  <D.18926>:
  number_of_entries.55 = (unsigned int) number_of_entries;
  qsort (sorted_array, number_of_entries.55, 4, compare_imt_builder_entries);
  imt_emit_ir (sorted_array, 0, number_of_entries, result);
  free (sorted_array);
  D.21328 = result;
  return D.21328;
}


compare_imt_builder_entries (const void * p1, const void * p2)
{
  int D.21330;
  int iftmp.56;
  void * D.21332;
  void * D.21333;
  _Bool D.21336;
  struct MonoImtBuilderEntry * e1;
  struct MonoImtBuilderEntry * e2;

  e1 = MEM[(struct MonoImtBuilderEntry * *)p1];
  e2 = MEM[(struct MonoImtBuilderEntry * *)p2];
  D.21332 = e1->key;
  D.21333 = e2->key;
  if (D.21332 >= D.21333) goto <D.21334>; else goto <D.21335>;
  <D.21334>:
  D.21332 = e1->key;
  D.21333 = e2->key;
  D.21336 = D.21332 > D.21333;
  iftmp.56 = (int) D.21336;
  goto <D.21337>;
  <D.21335>:
  iftmp.56 = -1;
  <D.21337>:
  D.21330 = iftmp.56;
  return D.21330;
}


imt_emit_ir (struct MonoImtBuilderEntry * * sorted_array, int start, int end, struct GPtrArray * out_array)
{
  unsigned int D.21339;
  unsigned int i.57;
  unsigned int D.21343;
  struct MonoImtBuilderEntry * * D.21344;
  struct MonoImtBuilderEntry * D.21345;
  void * D.21346;
  <unnamed-unsigned:1> D.21347;
  unsigned char D.21348;
  int D.21349;
  unsigned int D.21352;
  int D.21353;
  int D.21356;
  unsigned int middle.58;
  unsigned int D.21358;
  struct MonoImtBuilderEntry * * D.21359;
  struct MonoImtBuilderEntry * D.21360;
  void * D.21361;
  int D.21362;
  int D.21363;
  int count;
  int chunk_start;

  count = end - start;
  D.21339 = out_array->len;
  chunk_start = (int) D.21339;
  if (count <= 3) goto <D.21340>; else goto <D.21341>;
  <D.21340>:
  {
    int i;

    i = start;
    goto <D.18912>;
    <D.18911>:
    {
      struct MonoIMTCheckItem * item;

      item = monoeg_malloc0 (28);
      i.57 = (unsigned int) i;
      D.21343 = i.57 * 4;
      D.21344 = sorted_array + D.21343;
      D.21345 = *D.21344;
      D.21346 = D.21345->key;
      item->key = D.21346;
      i.57 = (unsigned int) i;
      D.21343 = i.57 * 4;
      D.21344 = sorted_array + D.21343;
      D.21345 = *D.21344;
      item->value = D.21345->value;
      i.57 = (unsigned int) i;
      D.21343 = i.57 * 4;
      D.21344 = sorted_array + D.21343;
      D.21345 = *D.21344;
      D.21347 = D.21345->has_target_code;
      D.21348 = (unsigned char) D.21347;
      item->has_target_code = D.21348;
      item->is_equals = 1;
      D.21349 = end + -1;
      if (D.21349 > i) goto <D.21350>; else goto <D.21351>;
      <D.21350>:
      D.21339 = out_array->len;
      D.21352 = D.21339 + 1;
      D.21353 = (int) D.21352;
      item->check_target_idx = D.21353;
      goto <D.21354>;
      <D.21351>:
      item->check_target_idx = 0;
      <D.21354>:
      monoeg_g_ptr_array_add (out_array, item);
    }
    i = i + 1;
    <D.18912>:
    if (i < end) goto <D.18911>; else goto <D.18913>;
    <D.18913>:
  }
  goto <D.21355>;
  <D.21341>:
  {
    int middle;
    struct MonoIMTCheckItem * item;

    D.21356 = count / 2;
    middle = D.21356 + start;
    item = monoeg_malloc0 (28);
    middle.58 = (unsigned int) middle;
    D.21358 = middle.58 * 4;
    D.21359 = sorted_array + D.21358;
    D.21360 = *D.21359;
    D.21361 = D.21360->key;
    item->key = D.21361;
    item->is_equals = 0;
    monoeg_g_ptr_array_add (out_array, item);
    imt_emit_ir (sorted_array, start, middle, out_array);
    D.21362 = imt_emit_ir (sorted_array, middle, end, out_array);
    item->check_target_idx = D.21362;
  }
  <D.21355>:
  D.21363 = chunk_start;
  return D.21363;
}


mono_method_alloc_generic_virtual_thunk (struct MonoDomain * domain, int size)
{
  unsigned int size.59;
  unsigned int D.21366;
  struct MonoThunkFreeList * * D.21369;
  unsigned int i.60;
  unsigned int D.21371;
  struct MonoThunkFreeList * D.21372;
  unsigned int D.21373;
  unsigned int size.61;
  struct _MonoThunkFreeList * D.21377;
  void * D.21378;
  struct MonoThunkFreeList * * D.21379;
  unsigned int D.21382;
  _Bool D.21383;
  long int D.21384;
  long int D.21385;
  struct _MonoThunkFreeList * D.21388;
  int inited.62;
  int generic_virtual_thunks_size.63;
  int generic_virtual_thunks_size.64;
  union mono_mutex_t * D.21394;
  _Bool D.21397;
  long int D.21398;
  long int D.21399;
  struct GHashTable * D.21402;
  struct GHashTable * D.21405;
  _Bool D.21408;
  long int D.21409;
  long int D.21410;
  static gboolean inited = 0;
  static int generic_virtual_thunks_size = 0;
  guint32 * p;
  int i;
  struct MonoThunkFreeList * * l;

  init_thunk_free_lists (domain);
  size.59 = (unsigned int) size;
  D.21366 = size.59 + 4;
  size = (int) D.21366;
  size.59 = (unsigned int) size;
  if (size.59 <= 11) goto <D.21367>; else goto <D.21368>;
  <D.21367>:
  size = 12;
  <D.21368>:
  i = list_index_for_size (size);
  D.21369 = domain->thunk_free_lists;
  i.60 = (unsigned int) i;
  D.21371 = i.60 * 4;
  l = D.21369 + D.21371;
  goto <D.19033>;
  <D.19032>:
  D.21372 = *l;
  D.21373 = D.21372->size;
  size.61 = (unsigned int) size;
  if (D.21373 >= size.61) goto <D.21375>; else goto <D.21376>;
  <D.21375>:
  {
    struct MonoThunkFreeList * item;

    item = *l;
    D.21377 = item->next;
    *l = D.21377;
    D.21378 = item + 4;
    return D.21378;
  }
  <D.21376>:
  D.21372 = *l;
  l = &D.21372->next;
  <D.19033>:
  D.21372 = *l;
  if (D.21372 != 0B) goto <D.19032>; else goto <D.19034>;
  <D.19034>:
  goto <D.19036>;
  <D.19037>:
  {
    struct MonoThunkFreeList * item;

    D.21369 = domain->thunk_free_lists;
    i.60 = (unsigned int) i;
    D.21371 = i.60 * 4;
    D.21379 = D.21369 + D.21371;
    item = *D.21379;
    if (item == 0B) goto <D.21380>; else goto <D.21381>;
    <D.21380>:
    // predicted unlikely by continue predictor.
    goto <D.19036>;
    <D.21381>:
    D.21382 = item->size;
    size.61 = (unsigned int) size;
    D.21383 = D.21382 <= size.61;
    D.21384 = (long int) D.21383;
    D.21385 = __builtin_expect (D.21384, 0);
    if (D.21385 != 0) goto <D.21386>; else goto <D.21387>;
    <D.21386>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 1550, "item->size > size");
    <D.21387>:
    D.21369 = domain->thunk_free_lists;
    i.60 = (unsigned int) i;
    D.21371 = i.60 * 4;
    D.21379 = D.21369 + D.21371;
    D.21388 = item->next;
    *D.21379 = D.21388;
    D.21378 = item + 4;
    return D.21378;
  }
  <D.19036>:
  i = i + 1;
  if (i <= 11) goto <D.19037>; else goto <D.19038>;
  <D.19038>:
  inited.62 = inited;
  if (inited.62 == 0) goto <D.21390>; else goto <D.21391>;
  <D.21390>:
  mono_counters_register ("Generic virtual thunk bytes", 2048, &generic_virtual_thunks_size);
  inited = 1;
  <D.21391>:
  generic_virtual_thunks_size.63 = generic_virtual_thunks_size;
  generic_virtual_thunks_size.64 = generic_virtual_thunks_size.63 + size;
  generic_virtual_thunks_size = generic_virtual_thunks_size.64;
  p = mono_domain_code_reserve (domain, size);
  size.61 = (unsigned int) size;
  *p = size.61;
  {
    int ret;

    D.21394 = &domain->lock.mutex;
    ret = pthread_mutex_lock (D.21394);
    if (ret != 0) goto <D.21395>; else goto <D.21396>;
    <D.21395>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.21396>:
    D.21397 = ret != 0;
    D.21398 = (long int) D.21397;
    D.21399 = __builtin_expect (D.21398, 0);
    if (D.21399 != 0) goto <D.21400>; else goto <D.21401>;
    <D.21400>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 1566, "ret == 0");
    <D.21401>:
  }
  D.21402 = domain->generic_virtual_thunks;
  if (D.21402 == 0B) goto <D.21403>; else goto <D.21404>;
  <D.21403>:
  D.21405 = monoeg_g_hash_table_new (0B, 0B);
  domain->generic_virtual_thunks = D.21405;
  <D.21404>:
  D.21402 = domain->generic_virtual_thunks;
  monoeg_g_hash_table_insert_replace (D.21402, p, p, 0);
  {
    int ret;

    D.21394 = &domain->lock.mutex;
    ret = pthread_mutex_unlock (D.21394);
    if (ret != 0) goto <D.21406>; else goto <D.21407>;
    <D.21406>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.21407>:
    D.21408 = ret != 0;
    D.21409 = (long int) D.21408;
    D.21410 = __builtin_expect (D.21409, 0);
    if (D.21410 != 0) goto <D.21411>; else goto <D.21412>;
    <D.21411>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 1570, "ret == 0");
    <D.21412>:
  }
  D.21378 = p + 4;
  return D.21378;
}


init_thunk_free_lists (struct MonoDomain * domain)
{
  struct MonoThunkFreeList * * D.21414;
  void * D.21417;

  D.21414 = domain->thunk_free_lists;
  if (D.21414 != 0B) goto <D.21415>; else goto <D.21416>;
  <D.21415>:
  return;
  <D.21416>:
  D.21417 = mono_domain_alloc0 (domain, 48);
  domain->thunk_free_lists = D.21417;
}


list_index_for_size (int item_size)
{
  _Bool D.21419;
  _Bool D.21420;
  _Bool D.21421;
  int D.21422;
  int i;
  int size;

  i = 2;
  size = 64;
  goto <D.19020>;
  <D.19019>:
  i = i + 1;
  size = size << 1;
  <D.19020>:
  D.21419 = item_size > size;
  D.21420 = i <= 10;
  D.21421 = D.21419 & D.21420;
  if (D.21421 != 0) goto <D.19019>; else goto <D.19021>;
  <D.19021>:
  D.21422 = i;
  return D.21422;
}


mono_method_add_generic_virtual_invocation (struct MonoDomain * domain, struct MonoVTable * vtable, void * * vtable_slot, struct MonoMethod * method, void * code)
{
  union mono_mutex_t * D.21424;
  _Bool D.21427;
  long int D.21428;
  long int D.21429;
  struct GHashTable * D.21432;
  struct GHashTable * D.21435;
  struct MonoMethod * D.21436;
  void * D.21440;
  int inited.65;
  int num_added.66;
  int num_added.67;
  int D.21446;
  int D.21447;
  int vtable_slot.68;
  int vtable.69;
  int D.21454;
  void * (*<T24a4>) (int) D.21455;
  void * iftmp.70;
  void * (*<T24a4>) (int) D.21458;
  void *[0:] * D.21461;
  int D.21462;
  int D.21463;
  int D.21464;
  void * (*<T26dc>) (struct MonoVTable *, struct MonoDomain *, struct MonoIMTCheckItem * *, int, void *) imt_thunk_builder.71;
  unsigned int D.21467;
  int D.21468;
  void * * D.21469;
  void * D.21470;
  unsigned int i.72;
  unsigned int D.21472;
  void * * D.21473;
  void * D.21474;
  unsigned int i.73;
  _Bool D.21476;
  _Bool D.21477;
  _Bool D.21478;
  _Bool D.21483;
  long int D.21484;
  long int D.21485;
  static gboolean inited = 0;
  static int num_added = 0;
  struct GenericVirtualCase * gvc;
  struct GenericVirtualCase * list;
  struct MonoImtBuilderEntry * entries;
  int i;
  struct GPtrArray * sorted;

  {
    int ret;

    D.21424 = &domain->lock.mutex;
    ret = pthread_mutex_lock (D.21424);
    if (ret != 0) goto <D.21425>; else goto <D.21426>;
    <D.21425>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.21426>:
    D.21427 = ret != 0;
    D.21428 = (long int) D.21427;
    D.21429 = __builtin_expect (D.21428, 0);
    if (D.21429 != 0) goto <D.21430>; else goto <D.21431>;
    <D.21430>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 1699, "ret == 0");
    <D.21431>:
  }
  D.21432 = domain->generic_virtual_cases;
  if (D.21432 == 0B) goto <D.21433>; else goto <D.21434>;
  <D.21433>:
  D.21435 = monoeg_g_hash_table_new (mono_aligned_addr_hash, 0B);
  domain->generic_virtual_cases = D.21435;
  <D.21434>:
  D.21432 = domain->generic_virtual_cases;
  list = monoeg_g_hash_table_lookup (D.21432, vtable_slot);
  gvc = list;
  goto <D.19092>;
  <D.19091>:
  D.21436 = gvc->method;
  if (D.21436 == method) goto <D.19090>; else goto <D.21437>;
  <D.21437>:
  gvc = gvc->next;
  <D.19092>:
  if (gvc != 0B) goto <D.19091>; else goto <D.19090>;
  <D.19090>:
  if (gvc == 0B) goto <D.21438>; else goto <D.21439>;
  <D.21438>:
  gvc = mono_domain_alloc (domain, 16);
  gvc->method = method;
  gvc->code = code;
  gvc->count = 0;
  D.21432 = domain->generic_virtual_cases;
  D.21440 = monoeg_g_hash_table_lookup (D.21432, vtable_slot);
  gvc->next = D.21440;
  D.21432 = domain->generic_virtual_cases;
  monoeg_g_hash_table_insert_replace (D.21432, vtable_slot, gvc, 0);
  inited.65 = inited;
  if (inited.65 == 0) goto <D.21442>; else goto <D.21443>;
  <D.21442>:
  mono_counters_register ("Generic virtual cases", 2048, &num_added);
  inited = 1;
  <D.21443>:
  num_added.66 = num_added;
  num_added.67 = num_added.66 + 1;
  num_added = num_added.67;
  <D.21439>:
  D.21446 = gvc->count;
  D.21447 = D.21446 + 1;
  gvc->count = D.21447;
  D.21446 = gvc->count;
  if (D.21446 == 10) goto <D.21448>; else goto <D.21449>;
  <D.21448>:
  {
    void * * old_thunk;
    void * vtable_trampoline;
    void * imt_trampoline;

    old_thunk = *vtable_slot;
    vtable_trampoline = 0B;
    imt_trampoline = 0B;
    if (vtable_slot < vtable) goto <D.21450>; else goto <D.21451>;
    <D.21450>:
    {
      int displacement;
      int imt_slot;

      vtable_slot.68 = (int) vtable_slot;
      vtable.69 = (int) vtable;
      D.21454 = vtable_slot.68 - vtable.69;
      displacement = D.21454 /[ex] 4;
      imt_slot = displacement + 19;
      D.21455 = callbacks.get_imt_trampoline;
      imt_trampoline = D.21455 (imt_slot);
      *vtable_slot = imt_trampoline;
    }
    goto <D.21456>;
    <D.21451>:
    D.21458 = callbacks.get_vtable_trampoline;
    if (D.21458 != 0B) goto <D.21459>; else goto <D.21460>;
    <D.21459>:
    D.21458 = callbacks.get_vtable_trampoline;
    vtable_slot.68 = (int) vtable_slot;
    D.21461 = &vtable->vtable;
    D.21462 = (int) D.21461;
    D.21463 = vtable_slot.68 - D.21462;
    D.21464 = D.21463 /[ex] 4;
    iftmp.70 = D.21458 (D.21464);
    goto <D.21465>;
    <D.21460>:
    iftmp.70 = 0B;
    <D.21465>:
    vtable_trampoline = iftmp.70;
    entries = get_generic_virtual_entries (domain, vtable_slot);
    sorted = imt_sort_slot_entries (entries);
    imt_thunk_builder.71 = imt_thunk_builder;
    D.21467 = sorted->len;
    D.21468 = (int) D.21467;
    D.21469 = sorted->pdata;
    D.21470 = imt_thunk_builder.71 (0B, domain, D.21469, D.21468, vtable_trampoline);
    *vtable_slot = D.21470;
    goto <D.19100>;
    <D.19099>:
    {
      struct MonoImtBuilderEntry * next;

      next = entries->next;
      monoeg_g_free (entries);
      entries = next;
    }
    <D.19100>:
    if (entries != 0B) goto <D.19099>; else goto <D.19101>;
    <D.19101>:
    i = 0;
    goto <D.19103>;
    <D.19102>:
    D.21469 = sorted->pdata;
    i.72 = (unsigned int) i;
    D.21472 = i.72 * 4;
    D.21473 = D.21469 + D.21472;
    D.21474 = *D.21473;
    monoeg_g_free (D.21474);
    i = i + 1;
    <D.19103>:
    i.73 = (unsigned int) i;
    D.21467 = sorted->len;
    if (i.73 < D.21467) goto <D.19102>; else goto <D.19104>;
    <D.19104>:
    monoeg_g_ptr_array_free (sorted, 1);
    <D.21456>:
    D.21476 = old_thunk != vtable_trampoline;
    D.21477 = old_thunk != imt_trampoline;
    D.21478 = D.21476 & D.21477;
    if (D.21478 != 0) goto <D.21479>; else goto <D.21480>;
    <D.21479>:
    invalidate_generic_virtual_thunk (domain, old_thunk);
    <D.21480>:
  }
  <D.21449>:
  {
    int ret;

    D.21424 = &domain->lock.mutex;
    ret = pthread_mutex_unlock (D.21424);
    if (ret != 0) goto <D.21481>; else goto <D.21482>;
    <D.21481>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.21482>:
    D.21483 = ret != 0;
    D.21484 = (long int) D.21483;
    D.21485 = __builtin_expect (D.21484, 0);
    if (D.21485 != 0) goto <D.21486>; else goto <D.21487>;
    <D.21486>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 1770, "ret == 0");
    <D.21487>:
  }
}


invalidate_generic_virtual_thunk (struct MonoDomain * domain, void * code)
{
  union mono_mutex_t * D.21488;
  _Bool D.21491;
  long int D.21492;
  long int D.21493;
  struct GHashTable * D.21496;
  struct GHashTable * D.21499;
  void * D.21500;
  _Bool D.21505;
  long int D.21506;
  long int D.21507;
  struct MonoThunkFreeList * * D.21512;
  struct _MonoThunkFreeList * D.21513;
  struct MonoThunkFreeList * D.21514;
  int D.21515;
  unsigned int D.21516;
  int D.21517;
  unsigned int i.74;
  unsigned int D.21519;
  struct MonoThunkFreeList * * D.21520;
  struct MonoThunkFreeList * D.21521;
  int D.21523;
  struct MonoThunkFreeList * * D.21524;
  struct MonoThunkFreeList * D.21525;
  struct _MonoThunkFreeList * D.21528;
  int D.21529;
  _Bool D.21531;
  long int D.21532;
  long int D.21533;
  guint32 * p;
  struct MonoThunkFreeList * l;
  gboolean found;

  p = code;
  l = p + 4294967292;
  found = 0;
  {
    int ret;

    D.21488 = &domain->lock.mutex;
    ret = pthread_mutex_lock (D.21488);
    if (ret != 0) goto <D.21489>; else goto <D.21490>;
    <D.21489>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.21490>:
    D.21491 = ret != 0;
    D.21492 = (long int) D.21491;
    D.21493 = __builtin_expect (D.21492, 0);
    if (D.21493 != 0) goto <D.21494>; else goto <D.21495>;
    <D.21494>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 1585, "ret == 0");
    <D.21495>:
  }
  D.21496 = domain->generic_virtual_thunks;
  if (D.21496 == 0B) goto <D.21497>; else goto <D.21498>;
  <D.21497>:
  D.21499 = monoeg_g_hash_table_new (0B, 0B);
  domain->generic_virtual_thunks = D.21499;
  <D.21498>:
  D.21496 = domain->generic_virtual_thunks;
  D.21500 = monoeg_g_hash_table_lookup (D.21496, l);
  if (D.21500 != 0B) goto <D.21501>; else goto <D.21502>;
  <D.21501>:
  found = 1;
  <D.21502>:
  {
    int ret;

    D.21488 = &domain->lock.mutex;
    ret = pthread_mutex_unlock (D.21488);
    if (ret != 0) goto <D.21503>; else goto <D.21504>;
    <D.21503>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.21504>:
    D.21505 = ret != 0;
    D.21506 = (long int) D.21505;
    D.21507 = __builtin_expect (D.21506, 0);
    if (D.21507 != 0) goto <D.21508>; else goto <D.21509>;
    <D.21508>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 1590, "ret == 0");
    <D.21509>:
  }
  if (found == 0) goto <D.21510>; else goto <D.21511>;
  <D.21510>:
  return;
  <D.21511>:
  init_thunk_free_lists (domain);
  goto <D.19054>;
  <D.19053>:
  {
    struct MonoThunkFreeList * item;
    int length;
    int i;

    D.21512 = domain->thunk_free_lists;
    item = *D.21512;
    length = item->length;
    D.21512 = domain->thunk_free_lists;
    D.21513 = item->next;
    *D.21512 = D.21513;
    D.21512 = domain->thunk_free_lists;
    D.21514 = *D.21512;
    D.21515 = length + -1;
    D.21514->length = D.21515;
    D.21516 = item->size;
    D.21517 = (int) D.21516;
    i = list_index_for_size (D.21517);
    D.21512 = domain->thunk_free_lists;
    i.74 = (unsigned int) i;
    D.21519 = i.74 * 4;
    D.21520 = D.21512 + D.21519;
    D.21521 = *D.21520;
    item->next = D.21521;
    D.21512 = domain->thunk_free_lists;
    i.74 = (unsigned int) i;
    D.21519 = i.74 * 4;
    D.21520 = D.21512 + D.21519;
    *D.21520 = item;
  }
  <D.19054>:
  D.21512 = domain->thunk_free_lists;
  D.21514 = *D.21512;
  if (D.21514 != 0B) goto <D.21522>; else goto <D.19055>;
  <D.21522>:
  D.21512 = domain->thunk_free_lists;
  D.21514 = *D.21512;
  D.21523 = D.21514->length;
  if (D.21523 > 49) goto <D.19053>; else goto <D.19055>;
  <D.19055>:
  l->next = 0B;
  D.21512 = domain->thunk_free_lists;
  D.21524 = D.21512 + 4;
  D.21525 = *D.21524;
  if (D.21525 != 0B) goto <D.21526>; else goto <D.21527>;
  <D.21526>:
  D.21512 = domain->thunk_free_lists;
  D.21524 = D.21512 + 4;
  D.21512 = domain->thunk_free_lists;
  D.21524 = D.21512 + 4;
  D.21525 = *D.21524;
  D.21525->next = l;
  D.21528 = D.21525->next;
  *D.21524 = D.21528;
  D.21512 = domain->thunk_free_lists;
  D.21514 = *D.21512;
  D.21523 = D.21514->length;
  D.21529 = D.21523 + 1;
  D.21514->length = D.21529;
  goto <D.21530>;
  <D.21527>:
  D.21512 = domain->thunk_free_lists;
  D.21514 = *D.21512;
  D.21531 = D.21514 != 0B;
  D.21532 = (long int) D.21531;
  D.21533 = __builtin_expect (D.21532, 0);
  if (D.21533 != 0) goto <D.21534>; else goto <D.21535>;
  <D.21534>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 1618, "!domain->thunk_free_lists [0]");
  <D.21535>:
  D.21512 = domain->thunk_free_lists;
  D.21512 = domain->thunk_free_lists;
  D.21524 = D.21512 + 4;
  *D.21524 = l;
  D.21525 = *D.21524;
  *D.21512 = D.21525;
  D.21512 = domain->thunk_free_lists;
  D.21514 = *D.21512;
  D.21514->length = 1;
  <D.21530>:
}


mono_class_vtable (struct MonoDomain * domain, struct MonoClass * class)
{
  struct MonoVTable * D.21537;

  D.21537 = mono_class_vtable_full (domain, class, 0);
  return D.21537;
}


mono_class_vtable_full (struct MonoDomain * domain, struct MonoClass * class, gboolean raise_on_error)
{
  _Bool D.21539;
  long int D.21540;
  long int D.21541;
  unsigned char D.21544;
  struct MonoException * D.21549;
  struct MonoVTable * D.21550;
  short unsigned int D.21553;
  int D.21554;
  int D.21555;
  struct MonoVTable * D.21558;
  struct MonoClassRuntimeInfo * runtime_info;

  D.21539 = class == 0B;
  D.21540 = (long int) D.21539;
  D.21541 = __builtin_expect (D.21540, 0);
  if (D.21541 != 0) goto <D.21542>; else goto <D.21543>;
  <D.21542>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 1804, "class");
  <D.21543>:
  D.21544 = class->exception_type;
  if (D.21544 != 0) goto <D.21545>; else goto <D.21546>;
  <D.21545>:
  if (raise_on_error != 0) goto <D.21547>; else goto <D.21548>;
  <D.21547>:
  D.21549 = mono_class_get_exception_for_failure (class);
  mono_raise_exception (D.21549);
  <D.21548>:
  D.21550 = 0B;
  return D.21550;
  <D.21546>:
  runtime_info = class->runtime_info;
  if (runtime_info != 0B) goto <D.21551>; else goto <D.21552>;
  <D.21551>:
  D.21553 = runtime_info->max_domain;
  D.21554 = (int) D.21553;
  D.21555 = domain->domain_id;
  if (D.21554 >= D.21555) goto <D.21556>; else goto <D.21557>;
  <D.21556>:
  D.21555 = domain->domain_id;
  D.21558 = runtime_info->domain_vtables[D.21555];
  if (D.21558 != 0B) goto <D.21559>; else goto <D.21560>;
  <D.21559>:
  D.21555 = domain->domain_id;
  D.21550 = runtime_info->domain_vtables[D.21555];
  return D.21550;
  <D.21560>:
  <D.21557>:
  <D.21552>:
  D.21550 = mono_class_create_runtime_vtable (domain, class, raise_on_error);
  return D.21550;
}


mono_class_create_runtime_vtable (struct MonoDomain * domain, struct MonoClass * class, gboolean raise_on_error)
{
  union mono_mutex_t * D.21562;
  _Bool D.21565;
  long int D.21566;
  long int D.21567;
  short unsigned int D.21572;
  int D.21573;
  int D.21574;
  struct MonoVTable * D.21577;
  _Bool D.21582;
  long int D.21583;
  long int D.21584;
  struct MonoVTable * D.21587;
  unsigned char D.21590;
  unsigned char D.21591;
  unsigned char D.21593;
  int D.21596;
  _Bool D.21600;
  long int D.21601;
  long int D.21602;
  struct MonoException * D.21607;
  unsigned char D.21608;
  _Bool D.21609;
  _Bool D.21610;
  _Bool D.21611;
  unsigned char D.21614;
  unsigned char D.21615;
  unsigned char D.21618;
  int D.21621;
  _Bool D.21630;
  long int D.21631;
  long int D.21632;
  struct MonoException * D.21637;
  int D.21638;
  struct MonoGenericClass * D.21641;
  struct MonoMethod * * D.21644;
  _Bool D.21651;
  long int D.21652;
  long int D.21653;
  struct MonoException * D.21658;
  int D.21659;
  void * (*<T26dc>) (struct MonoVTable *, struct MonoDomain *, struct MonoIMTCheckItem * *, int, void *) imt_thunk_builder.75;
  unsigned int vtable_slots.76;
  unsigned int D.21666;
  short unsigned int D.21667;
  long unsigned int D.21670;
  long unsigned int D.21671;
  long unsigned int D.21672;
  long unsigned int D.21673;
  short unsigned int D.21675;
  unsigned int D.21676;
  unsigned int D.21677;
  unsigned int D.21678;
  long unsigned int D.21679;
  long unsigned int D.21680;
  long unsigned int D.21681;
  long unsigned int D.21682;
  sizetype imt_table_bytes.77;
  sizetype D.21687;
  sizetype D.21688;
  sizetype D.21689;
  unsigned char D.21690;
  void * D.21691;
  unsigned int D.21692;
  int D.21693;
  _Bool D.21694;
  long int D.21695;
  long int D.21696;
  unsigned char D.21699;
  <unnamed-unsigned:4> D.21700;
  unsigned char D.21703;
  unsigned char D.21704;
  int max_set.78;
  int D.21708;
  void * D.21709;
  void * D.21710;
  void * D.21714;
  long unsigned int D.21715;
  long unsigned int D.21716;
  struct MonoType * D.21717;
  short unsigned int D.21718;
  int D.21719;
  int D.21720;
  int D.21723;
  int D.19163;
  int iftmp.79;
  int D.19162;
  const char[9] * D.21729;
  unsigned char D.21730;
  int D.21731;
  unsigned char D.21732;
  int D.21733;
  _Bool D.21734;
  _Bool D.21735;
  _Bool D.21736;
  const unsigned char * D.21739;
  unsigned char D.21740;
  int D.21741;
  const unsigned char * D.21742;
  unsigned char D.21743;
  int D.21744;
  _Bool D.21745;
  _Bool D.21746;
  const unsigned char * D.21749;
  unsigned char D.21750;
  int D.21751;
  const unsigned char * D.21752;
  unsigned char D.21753;
  int D.21754;
  _Bool D.21755;
  _Bool D.21756;
  const unsigned char * D.21759;
  unsigned char D.21760;
  int D.21761;
  const unsigned char * D.21762;
  unsigned char D.21763;
  int D.21764;
  const char * D.21766;
  int D.21769;
  int iftmp.80;
  unsigned char D.21773;
  int D.21779;
  int D.21783;
  int max_set.81;
  int D.21788;
  int align.82;
  unsigned int align.83;
  unsigned int special_static.84;
  struct GHashTable * D.21792;
  struct GHashTable * D.21795;
  void * offset.85;
  int D.21799;
  signed short D.21802;
  _Bool D.21803;
  long int D.21804;
  long int D.21805;
  void * D.21808;
  int D.21809;
  sizetype D.21810;
  unsigned char D.21813;
  unsigned char D.21814;
  int D.21817;
  unsigned int D.21818;
  unsigned char D.21820;
  _Bool D.21821;
  _Bool D.21822;
  _Bool D.21823;
  int D.21824;
  _Bool D.21825;
  long int D.21826;
  long int D.21827;
  char D.21830;
  guint8 * D.21831;
  struct MonoClass * * D.21834;
  unsigned int i.86;
  unsigned int D.21836;
  struct MonoClass * * D.21837;
  struct MonoClass * D.21838;
  short unsigned int D.21839;
  guint16 * D.21840;
  unsigned int D.21841;
  guint16 * D.21842;
  short unsigned int D.21843;
  int D.21844;
  int D.21845;
  unsigned int D.21846;
  unsigned int D.21847;
  void * * D.21848;
  void * * D.21849;
  int D.21850;
  void * (*<T24a4>) (int) D.21851;
  void * D.21854;
  struct MonoMethod * * D.21856;
  void * (*<T1d2d>) (struct MonoMethod *) arch_create_jit_trampoline.87;
  void * D.21860;
  void * (*<T24a4>) (int) D.21865;
  void * * D.21868;
  void * D.21869;
  struct MonoClass * D.21871;
  struct MonoType * D.21874;
  struct MonoReflectionType * D.21875;
  void * D.21876;
  struct MonoClass * D.21877;
  int D.21880;
  void * D.21885;
  void * * D.21886;
  unsigned char D.21887;
  signed char D.21888;
  _Bool D.21889;
  struct GPtrArray * D.21890;
  short unsigned int D.21894;
  int D.21895;
  int D.21899;
  unsigned int new_size.88;
  unsigned int D.21901;
  unsigned int D.21902;
  struct MonoImage * D.21903;
  short unsigned int D.21904;
  short unsigned int D.21905;
  int D.21908;
  unsigned int D.21909;
  unsigned int D.21910;
  struct MonoVTable *[0:] * D.21911;
  struct MonoVTable *[0:] * D.21912;
  struct MonoReflectionType * D.21915;
  struct MonoClass * D.21916;
  int D.21919;
  void * D.21924;
  _Bool D.21927;
  long int D.21928;
  long int D.21929;
  int D.21932;
  struct MonoException * D.21939;
  struct MonoClass * D.21940;
  struct MonoVTable * vt;
  struct MonoClassRuntimeInfo * runtime_info;
  struct MonoClassRuntimeInfo * old_info;
  struct MonoClassField * field;
  char * t;
  int i;
  int vtable_slots;
  int imt_table_bytes;
  int gc_bits;
  guint32 vtable_size;
  guint32 class_size;
  guint32 cindex;
  void * iter;
  void * * interface_offsets;

  try
    {
      imt_table_bytes = 0;
      mono_loader_lock ();
      {
        int ret;

        D.21562 = &domain->lock.mutex;
        ret = pthread_mutex_lock (D.21562);
        if (ret != 0) goto <D.21563>; else goto <D.21564>;
        <D.21563>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
        <D.21564>:
        D.21565 = ret != 0;
        D.21566 = (long int) D.21565;
        D.21567 = __builtin_expect (D.21566, 0);
        if (D.21567 != 0) goto <D.21568>; else goto <D.21569>;
        <D.21568>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 1856, "ret == 0");
        <D.21569>:
      }
      runtime_info = class->runtime_info;
      if (runtime_info != 0B) goto <D.21570>; else goto <D.21571>;
      <D.21570>:
      D.21572 = runtime_info->max_domain;
      D.21573 = (int) D.21572;
      D.21574 = domain->domain_id;
      if (D.21573 >= D.21574) goto <D.21575>; else goto <D.21576>;
      <D.21575>:
      D.21574 = domain->domain_id;
      D.21577 = runtime_info->domain_vtables[D.21574];
      if (D.21577 != 0B) goto <D.21578>; else goto <D.21579>;
      <D.21578>:
      {
        int ret;

        D.21562 = &domain->lock.mutex;
        ret = pthread_mutex_unlock (D.21562);
        if (ret != 0) goto <D.21580>; else goto <D.21581>;
        <D.21580>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.21581>:
        D.21582 = ret != 0;
        D.21583 = (long int) D.21582;
        D.21584 = __builtin_expect (D.21583, 0);
        if (D.21584 != 0) goto <D.21585>; else goto <D.21586>;
        <D.21585>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 1859, "ret == 0");
        <D.21586>:
      }
      mono_loader_unlock ();
      D.21574 = domain->domain_id;
      D.21587 = runtime_info->domain_vtables[D.21574];
      return D.21587;
      <D.21579>:
      <D.21576>:
      <D.21571>:
      D.21590 = BIT_FIELD_REF <*class, 8, 160>;
      D.21591 = D.21590 & 1;
      if (D.21591 == 0) goto <D.21588>; else goto <D.21592>;
      <D.21592>:
      D.21593 = class->exception_type;
      if (D.21593 != 0) goto <D.21588>; else goto <D.21589>;
      <D.21588>:
      D.21596 = mono_class_init (class);
      if (D.21596 == 0) goto <D.21594>; else goto <D.21597>;
      <D.21597>:
      D.21593 = class->exception_type;
      if (D.21593 != 0) goto <D.21594>; else goto <D.21595>;
      <D.21594>:
      {
        int ret;

        D.21562 = &domain->lock.mutex;
        ret = pthread_mutex_unlock (D.21562);
        if (ret != 0) goto <D.21598>; else goto <D.21599>;
        <D.21598>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.21599>:
        D.21600 = ret != 0;
        D.21601 = (long int) D.21600;
        D.21602 = __builtin_expect (D.21601, 0);
        if (D.21602 != 0) goto <D.21603>; else goto <D.21604>;
        <D.21603>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 1865, "ret == 0");
        <D.21604>:
      }
      mono_loader_unlock ();
      if (raise_on_error != 0) goto <D.21605>; else goto <D.21606>;
      <D.21605>:
      D.21607 = mono_class_get_exception_for_failure (class);
      mono_raise_exception (D.21607);
      <D.21606>:
      D.21587 = 0B;
      return D.21587;
      <D.21595>:
      <D.21589>:
      D.21608 = class->byval_arg.type;
      D.21609 = D.21608 == 20;
      D.21610 = D.21608 == 29;
      D.21611 = D.21609 | D.21610;
      if (D.21611 != 0) goto <D.21612>; else goto <D.21613>;
      <D.21612>:
      {
        struct MonoClass * element_class;

        element_class = class->element_class;
        D.21614 = BIT_FIELD_REF <*element_class, 8, 160>;
        D.21615 = D.21614 & 1;
        if (D.21615 == 0) goto <D.21616>; else goto <D.21617>;
        <D.21616>:
        mono_class_init (element_class);
        <D.21617>:
        D.21618 = element_class->exception_type;
        if (D.21618 == 0) goto <D.21619>; else goto <D.21620>;
        <D.21619>:
        D.21621 = element_class->vtable_size;
        if (D.21621 == 0) goto <D.21622>; else goto <D.21623>;
        <D.21622>:
        mono_class_setup_vtable (element_class);
        <D.21623>:
        <D.21620>:
        D.21618 = element_class->exception_type;
        if (D.21618 != 0) goto <D.21624>; else goto <D.21625>;
        <D.21624>:
        D.21593 = class->exception_type;
        if (D.21593 == 0) goto <D.21626>; else goto <D.21627>;
        <D.21626>:
        mono_class_set_failure (class, 7, 0B);
        <D.21627>:
        {
          int ret;

          D.21562 = &domain->lock.mutex;
          ret = pthread_mutex_unlock (D.21562);
          if (ret != 0) goto <D.21628>; else goto <D.21629>;
          <D.21628>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
          <D.21629>:
          D.21630 = ret != 0;
          D.21631 = (long int) D.21630;
          D.21632 = __builtin_expect (D.21631, 0);
          if (D.21632 != 0) goto <D.21633>; else goto <D.21634>;
          <D.21633>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 1887, "ret == 0");
          <D.21634>:
        }
        mono_loader_unlock ();
        if (raise_on_error != 0) goto <D.21635>; else goto <D.21636>;
        <D.21635>:
        D.21637 = mono_class_get_exception_for_failure (class);
        mono_raise_exception (D.21637);
        <D.21636>:
        D.21587 = 0B;
        return D.21587;
        <D.21625>:
      }
      <D.21613>:
      D.21638 = class->vtable_size;
      if (D.21638 == 0) goto <D.21639>; else goto <D.21640>;
      <D.21639>:
      mono_class_setup_vtable (class);
      <D.21640>:
      D.21641 = class->generic_class;
      if (D.21641 != 0B) goto <D.21642>; else goto <D.21643>;
      <D.21642>:
      D.21644 = class->vtable;
      if (D.21644 == 0B) goto <D.21645>; else goto <D.21646>;
      <D.21645>:
      mono_class_check_vtable_constraints (class, 0B);
      <D.21646>:
      <D.21643>:
      mono_class_has_finalizer (class);
      D.21593 = class->exception_type;
      if (D.21593 != 0) goto <D.21647>; else goto <D.21648>;
      <D.21647>:
      {
        int ret;

        D.21562 = &domain->lock.mutex;
        ret = pthread_mutex_unlock (D.21562);
        if (ret != 0) goto <D.21649>; else goto <D.21650>;
        <D.21649>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.21650>:
        D.21651 = ret != 0;
        D.21652 = (long int) D.21651;
        D.21653 = __builtin_expect (D.21652, 0);
        if (D.21653 != 0) goto <D.21654>; else goto <D.21655>;
        <D.21654>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 1909, "ret == 0");
        <D.21655>:
      }
      mono_loader_unlock ();
      if (raise_on_error != 0) goto <D.21656>; else goto <D.21657>;
      <D.21656>:
      D.21658 = mono_class_get_exception_for_failure (class);
      mono_raise_exception (D.21658);
      <D.21657>:
      D.21587 = 0B;
      return D.21587;
      <D.21648>:
      vtable_slots = class->vtable_size;
      D.21659 = mono_class_data_size (class);
      class_size = (guint32) D.21659;
      if (class_size != 0) goto <D.21660>; else goto <D.21661>;
      <D.21660>:
      vtable_slots = vtable_slots + 1;
      <D.21661>:
      imt_thunk_builder.75 = imt_thunk_builder;
      if (imt_thunk_builder.75 != 0B) goto <D.21663>; else goto <D.21664>;
      <D.21663>:
      vtable_slots.76 = (unsigned int) vtable_slots;
      D.21666 = vtable_slots.76 + 8;
      vtable_size = D.21666 * 4;
      D.21667 = class->interface_offsets_count;
      if (D.21667 != 0) goto <D.21668>; else goto <D.21669>;
      <D.21668>:
      imt_table_bytes = 76;
      vtable_size = vtable_size + 76;
      D.21670 = mono_stats.imt_number_of_tables;
      D.21671 = D.21670 + 1;
      mono_stats.imt_number_of_tables = D.21671;
      D.21672 = mono_stats.imt_tables_size;
      D.21673 = D.21672 + 76;
      mono_stats.imt_tables_size = D.21673;
      <D.21669>:
      goto <D.21674>;
      <D.21664>:
      D.21675 = class->max_interface_id;
      D.21676 = (unsigned int) D.21675;
      vtable_slots.76 = (unsigned int) vtable_slots;
      D.21677 = D.21676 + vtable_slots.76;
      D.21678 = D.21677 + 9;
      vtable_size = D.21678 * 4;
      <D.21674>:
      D.21679 = mono_stats.used_class_count;
      D.21680 = D.21679 + 1;
      mono_stats.used_class_count = D.21680;
      D.21681 = mono_stats.class_vtable_size;
      D.21682 = D.21681 + vtable_size;
      mono_stats.class_vtable_size = D.21682;
      interface_offsets = mono_domain_alloc0 (domain, vtable_size);
      imt_thunk_builder.75 = imt_thunk_builder;
      if (imt_thunk_builder.75 != 0B) goto <D.21683>; else goto <D.21684>;
      <D.21683>:
      imt_table_bytes.77 = (sizetype) imt_table_bytes;
      vt = interface_offsets + imt_table_bytes.77;
      goto <D.21686>;
      <D.21684>:
      D.21675 = class->max_interface_id;
      D.21687 = (sizetype) D.21675;
      D.21688 = D.21687 + 1;
      D.21689 = D.21688 * 4;
      vt = interface_offsets + D.21689;
      <D.21686>:
      vt->klass = class;
      D.21690 = class->rank;
      vt->rank = D.21690;
      vt->domain = domain;
      mono_class_compute_gc_descriptor (class);
      D.21691 = class->gc_descr;
      vt->gc_descr = D.21691;
      D.21692 = mono_gc_get_vtable_bits (class);
      gc_bits = (int) D.21692;
      D.21693 = gc_bits & -16;
      D.21694 = D.21693 != 0;
      D.21695 = (long int) D.21694;
      D.21696 = __builtin_expect (D.21695, 0);
      if (D.21696 != 0) goto <D.21697>; else goto <D.21698>;
      <D.21697>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 1968, "!(gc_bits & ~((1 << MONO_VTABLE_AVAILABLE_GC_BITS) - 1))");
      <D.21698>:
      D.21699 = (unsigned char) gc_bits;
      D.21700 = (<unnamed-unsigned:4>) D.21699;
      vt->gc_bits = D.21700;
      if (class_size != 0) goto <D.21701>; else goto <D.21702>;
      <D.21701>:
      D.21703 = BIT_FIELD_REF <*class, 8, 184>;
      D.21704 = D.21703 & 16;
      if (D.21704 != 0) goto <D.21705>; else goto <D.21706>;
      <D.21705>:
      {
        void * statics_gc_descr;
        int max_set;
        gsize default_bitmap[4];
        gsize * bitmap;

        try
          {
            max_set = 0;
            default_bitmap = {};
            bitmap = compute_class_bitmap (class, &default_bitmap, 128, 0, &max_set, 1);
            max_set.78 = max_set;
            D.21708 = max_set.78 + 1;
            statics_gc_descr = mono_gc_make_descr_from_bitmap (bitmap, D.21708);
            D.21638 = class->vtable_size;
            D.21709 = mono_gc_alloc_fixed (class_size, statics_gc_descr);
            vt->vtable[D.21638] = D.21709;
            D.21638 = class->vtable_size;
            D.21710 = vt->vtable[D.21638];
            mono_domain_add_class_static_data (domain, class, D.21710, 0B);
            if (&default_bitmap != bitmap) goto <D.21711>; else goto <D.21712>;
            <D.21711>:
            monoeg_g_free (bitmap);
            <D.21712>:
          }
        finally
          {
            max_set = {CLOBBER};
            default_bitmap = {CLOBBER};
          }
      }
      goto <D.21713>;
      <D.21706>:
      D.21638 = class->vtable_size;
      D.21714 = mono_domain_alloc0 (domain, class_size);
      vt->vtable[D.21638] = D.21714;
      <D.21713>:
      vt->has_static_fields = 1;
      D.21715 = mono_stats.class_static_data_size;
      D.21716 = D.21715 + class_size;
      mono_stats.class_static_data_size = D.21716;
      <D.21702>:
      cindex = 4294967295;
      iter = 0B;
      goto <D.19154>;
      <D.19175>:
      D.21717 = field->type;
      D.21718 = D.21717->attrs;
      D.21719 = (int) D.21718;
      D.21720 = D.21719 & 16;
      if (D.21720 == 0) goto <D.21721>; else goto <D.21722>;
      <D.21721>:
      // predicted unlikely by continue predictor.
      goto <D.19154>;
      <D.21722>:
      D.21717 = field->type;
      D.21718 = D.21717->attrs;
      D.21719 = (int) D.21718;
      D.21723 = D.21719 & 1536;
      if (D.21723 != 0) goto <D.21724>; else goto <D.21725>;
      <D.21724>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          __s2 = mono_field_get_name (field);
          D.21729 = "_Deleted";
          D.21730 = MEM[(const unsigned char *)D.21729];
          D.21731 = (int) D.21730;
          D.21732 = *__s2;
          D.21733 = (int) D.21732;
          __result = D.21731 - D.21733;
          {
            D.21734 = __s2_len != 0;
            D.21735 = __result == 0;
            D.21736 = D.21734 & D.21735;
            if (D.21736 != 0) goto <D.21737>; else goto <D.21738>;
            <D.21737>:
            D.21739 = &MEM[(void *)"_Deleted" + 1B];
            D.21740 = *D.21739;
            D.21741 = (int) D.21740;
            D.21742 = __s2 + 1;
            D.21743 = *D.21742;
            D.21744 = (int) D.21743;
            __result = D.21741 - D.21744;
            D.21745 = __s2_len > 1;
            D.21735 = __result == 0;
            D.21746 = D.21745 & D.21735;
            if (D.21746 != 0) goto <D.21747>; else goto <D.21748>;
            <D.21747>:
            D.21749 = &MEM[(void *)"_Deleted" + 2B];
            D.21750 = *D.21749;
            D.21751 = (int) D.21750;
            D.21752 = __s2 + 2;
            D.21753 = *D.21752;
            D.21754 = (int) D.21753;
            __result = D.21751 - D.21754;
            D.21755 = __s2_len > 2;
            D.21735 = __result == 0;
            D.21756 = D.21755 & D.21735;
            if (D.21756 != 0) goto <D.21757>; else goto <D.21758>;
            <D.21757>:
            D.21759 = &MEM[(void *)"_Deleted" + 3B];
            D.21760 = *D.21759;
            D.21761 = (int) D.21760;
            D.21762 = __s2 + 3;
            D.21763 = *D.21762;
            D.21764 = (int) D.21763;
            __result = D.21761 - D.21764;
            <D.21758>:
            <D.21748>:
            <D.21738>:
          }
          D.19162 = __result;
        }
        iftmp.79 = -D.19162;
        goto <D.21765>;
        <D.21728>:
        D.21766 = mono_field_get_name (field);
        iftmp.79 = __builtin_strcmp (D.21766, "_Deleted");
        <D.21765>:
        D.19163 = iftmp.79;
      }
      if (D.19163 == 0) goto <D.21767>; else goto <D.21768>;
      <D.21767>:
      // predicted unlikely by continue predictor.
      goto <D.19154>;
      <D.21768>:
      <D.21725>:
      D.21717 = field->type;
      D.21718 = D.21717->attrs;
      D.21719 = (int) D.21718;
      D.21769 = D.21719 & 64;
      if (D.21769 == 0) goto <D.21770>; else goto <D.21771>;
      <D.21770>:
      {
        gint32 special_static;

        D.21703 = BIT_FIELD_REF <*class, 8, 184>;
        D.21773 = D.21703 & 32;
        if (D.21773 == 0) goto <D.21774>; else goto <D.21775>;
        <D.21774>:
        iftmp.80 = field_is_special_static (class, field);
        goto <D.21776>;
        <D.21775>:
        iftmp.80 = 0;
        <D.21776>:
        special_static = iftmp.80;
        if (special_static != 0) goto <D.21777>; else goto <D.21778>;
        <D.21777>:
        {
          guint32 size;
          guint32 offset;
          gint32 align;
          gsize default_bitmap[4];
          gsize * bitmap;
          int max_set;
          int numbits;
          struct MonoClass * fclass;

          try
            {
              default_bitmap = {};
              max_set = 0;
              D.21717 = field->type;
              D.21779 = mono_type_is_reference (D.21717);
              if (D.21779 != 0) goto <D.21780>; else goto <D.21781>;
              <D.21780>:
              default_bitmap[0] = 1;
              numbits = 1;
              bitmap = &default_bitmap;
              goto <D.21782>;
              <D.21781>:
              D.21717 = field->type;
              D.21783 = mono_type_is_struct (D.21717);
              if (D.21783 != 0) goto <D.21784>; else goto <D.21785>;
              <D.21784>:
              D.21717 = field->type;
              fclass = mono_class_from_mono_type (D.21717);
              bitmap = compute_class_bitmap (fclass, &default_bitmap, 128, -2, &max_set, 0);
              max_set.81 = max_set;
              numbits = max_set.81 + 1;
              goto <D.21787>;
              <D.21785>:
              default_bitmap[0] = 0;
              numbits = 0;
              bitmap = &default_bitmap;
              <D.21787>:
              <D.21782>:
              D.21717 = field->type;
              D.21788 = mono_type_size (D.21717, &align);
              size = (guint32) D.21788;
              align.82 = align;
              align.83 = (unsigned int) align.82;
              special_static.84 = (unsigned int) special_static;
              offset = mono_alloc_special_static_data (special_static.84, size, align.83, bitmap, numbits);
              D.21792 = domain->special_static_fields;
              if (D.21792 == 0B) goto <D.21793>; else goto <D.21794>;
              <D.21793>:
              D.21795 = monoeg_g_hash_table_new (0B, 0B);
              domain->special_static_fields = D.21795;
              <D.21794>:
              offset.85 = (void *) offset;
              D.21792 = domain->special_static_fields;
              monoeg_g_hash_table_insert_replace (D.21792, field, offset.85, 0);
              if (&default_bitmap != bitmap) goto <D.21797>; else goto <D.21798>;
              <D.21797>:
              monoeg_g_free (bitmap);
              <D.21798>:
              field->offset = -1;
              // predicted unlikely by continue predictor.
              goto <D.19154>;
            }
          finally
            {
              align = {CLOBBER};
              default_bitmap = {CLOBBER};
              max_set = {CLOBBER};
            }
        }
        <D.21778>:
      }
      <D.21771>:
      D.21717 = field->type;
      D.21718 = D.21717->attrs;
      D.21719 = (int) D.21718;
      D.21799 = D.21719 & 256;
      if (D.21799 != 0) goto <D.21800>; else goto <D.21801>;
      <D.21800>:
      {
        struct MonoClass * fklass;
        const char * data;

        D.21717 = field->type;
        fklass = mono_class_from_mono_type (D.21717);
        data = mono_field_get_data (field);
        D.21717 = field->type;
        D.21718 = D.21717->attrs;
        D.21802 = (signed short) D.21718;
        D.21803 = D.21802 < 0;
        D.21804 = (long int) D.21803;
        D.21805 = __builtin_expect (D.21804, 0);
        if (D.21805 != 0) goto <D.21806>; else goto <D.21807>;
        <D.21806>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 2043, "!(field->type->attrs & FIELD_ATTRIBUTE_HAS_DEFAULT)");
        <D.21807>:
        D.21808 = mono_vtable_get_static_field_data (vt);
        D.21809 = field->offset;
        D.21810 = (sizetype) D.21809;
        t = D.21808 + D.21810;
        if (data == 0B) goto <D.21811>; else goto <D.21812>;
        <D.21811>:
        // predicted unlikely by continue predictor.
        goto <D.19154>;
        <D.21812>:
        D.21813 = BIT_FIELD_REF <*fklass, 8, 160>;
        D.21814 = D.21813 & 8;
        if (D.21814 != 0) goto <D.21815>; else goto <D.21816>;
        <D.21815>:
        D.21817 = mono_class_value_size (fklass, 0B);
        D.21818 = (unsigned int) D.21817;
        memcpy (t, data, D.21818);
        goto <D.21819>;
        <D.21816>:
        D.21820 = fklass->byval_arg.type;
        D.21821 = D.21820 != 15;
        D.21822 = D.21820 != 27;
        D.21823 = D.21821 & D.21822;
        D.21824 = (int) D.21823;
        D.21825 = D.21824 != 0;
        D.21826 = (long int) D.21825;
        D.21827 = __builtin_expect (D.21826, 0);
        if (D.21827 != 0) goto <D.21828>; else goto <D.21829>;
        <D.21828>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 2052, "(fklass->byval_arg.type == MONO_TYPE_PTR) || (fklass->byval_arg.type == MONO_TYPE_FNPTR)");
        <D.21829>:
        D.21830 = MEM[(char *)data];
        *t = D.21830;
        <D.21819>:
        // predicted unlikely by continue predictor.
        goto <D.19154>;
      }
      <D.21801>:
      <D.19154>:
      field = mono_class_get_fields (class, &iter);
      if (field != 0B) goto <D.19175>; else goto <D.19176>;
      <D.19176>:
      D.21675 = class->max_interface_id;
      vt->max_interface_id = D.21675;
      D.21831 = class->interface_bitmap;
      vt->interface_bitmap = D.21831;
      imt_thunk_builder.75 = imt_thunk_builder;
      if (imt_thunk_builder.75 == 0B) goto <D.21832>; else goto <D.21833>;
      <D.21832>:
      i = 0;
      goto <D.19180>;
      <D.19179>:
      {
        int interface_id;
        int slot;

        D.21834 = class->interfaces_packed;
        i.86 = (unsigned int) i;
        D.21836 = i.86 * 4;
        D.21837 = D.21834 + D.21836;
        D.21838 = *D.21837;
        D.21839 = D.21838->interface_id;
        interface_id = (int) D.21839;
        D.21840 = class->interface_offsets_packed;
        i.86 = (unsigned int) i;
        D.21841 = i.86 * 2;
        D.21842 = D.21840 + D.21841;
        D.21843 = *D.21842;
        slot = (int) D.21843;
        D.21675 = class->max_interface_id;
        D.21844 = (int) D.21675;
        D.21845 = D.21844 - interface_id;
        D.21846 = (unsigned int) D.21845;
        D.21847 = D.21846 * 4;
        D.21848 = interface_offsets + D.21847;
        D.21849 = &vt->vtable[slot];
        *D.21848 = D.21849;
      }
      i = i + 1;
      <D.19180>:
      D.21667 = class->interface_offsets_count;
      D.21850 = (int) D.21667;
      if (D.21850 > i) goto <D.19179>; else goto <D.19181>;
      <D.19181>:
      <D.21833>:
      D.21851 = callbacks.get_vtable_trampoline;
      if (D.21851 != 0B) goto <D.21852>; else goto <D.21853>;
      <D.21852>:
      i = 0;
      goto <D.19183>;
      <D.19182>:
      D.21851 = callbacks.get_vtable_trampoline;
      D.21854 = D.21851 (i);
      vt->vtable[i] = D.21854;
      i = i + 1;
      <D.19183>:
      D.21638 = class->vtable_size;
      if (D.21638 > i) goto <D.19182>; else goto <D.19184>;
      <D.19184>:
      goto <D.21855>;
      <D.21853>:
      mono_class_setup_vtable (class);
      i = 0;
      goto <D.19187>;
      <D.19186>:
      {
        struct MonoMethod * cm;

        D.21644 = class->vtable;
        i.86 = (unsigned int) i;
        D.21836 = i.86 * 4;
        D.21856 = D.21644 + D.21836;
        cm = *D.21856;
        if (cm != 0B) goto <D.21857>; else goto <D.21858>;
        <D.21857>:
        arch_create_jit_trampoline.87 = arch_create_jit_trampoline;
        D.21860 = arch_create_jit_trampoline.87 (cm);
        vt->vtable[i] = D.21860;
        <D.21858>:
      }
      i = i + 1;
      <D.19187>:
      D.21638 = class->vtable_size;
      if (D.21638 > i) goto <D.19186>; else goto <D.19188>;
      <D.19188>:
      <D.21855>:
      imt_thunk_builder.75 = imt_thunk_builder;
      if (imt_thunk_builder.75 != 0B) goto <D.21861>; else goto <D.21862>;
      <D.21861>:
      if (imt_table_bytes != 0) goto <D.21863>; else goto <D.21864>;
      <D.21863>:
      D.21865 = callbacks.get_imt_trampoline;
      if (D.21865 != 0B) goto <D.21866>; else goto <D.21867>;
      <D.21866>:
      i = 0;
      goto <D.19190>;
      <D.19189>:
      i.86 = (unsigned int) i;
      D.21836 = i.86 * 4;
      D.21868 = interface_offsets + D.21836;
      D.21865 = callbacks.get_imt_trampoline;
      D.21869 = D.21865 (i);
      *D.21868 = D.21869;
      i = i + 1;
      <D.19190>:
      if (i <= 18) goto <D.19189>; else goto <D.19191>;
      <D.19191>:
      goto <D.21870>;
      <D.21867>:
      build_imt (class, vt, domain, interface_offsets, 0B);
      <D.21870>:
      <D.21864>:
      <D.21862>:
      D.21871 = mono_defaults.monotype_class;
      if (D.21871 != class) goto <D.21872>; else goto <D.21873>;
      <D.21872>:
      D.21874 = &class->byval_arg;
      D.21875 = mono_type_get_object (domain, D.21874);
      vt->type = D.21875;
      D.21876 = vt->type;
      D.21877 = mono_object_get_class (D.21876);
      D.21871 = mono_defaults.monotype_class;
      if (D.21877 != D.21871) goto <D.21878>; else goto <D.21879>;
      <D.21878>:
      D.21880 = mono_gc_is_moving ();
      if (D.21880 != 0) goto <D.21881>; else goto <D.21882>;
      <D.21881>:
      if (0 != 0) goto <D.21883>; else goto <D.21884>;
      <D.21883>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 2114, "sizeof (vt->type) == sizeof (MonoObject*)");
      <D.21884>:
      D.21885 = mono_gc_make_root_descr_all_refs (1);
      D.21886 = &vt->type;
      mono_gc_register_root (D.21886, 4, D.21885);
      <D.21882>:
      <D.21879>:
      <D.21873>:
      D.21887 = BIT_FIELD_REF <*class, 8, 176>;
      D.21888 = (signed char) D.21887;
      D.21889 = D.21888 < 0;
      vt->remote = D.21889;
      D.21890 = domain->class_vtable_array;
      monoeg_g_ptr_array_add (D.21890, vt);
      mono_memory_barrier ();
      old_info = class->runtime_info;
      if (old_info != 0B) goto <D.21893>; else goto <D.21891>;
      <D.21893>:
      D.21894 = old_info->max_domain;
      D.21895 = (int) D.21894;
      D.21574 = domain->domain_id;
      if (D.21895 >= D.21574) goto <D.21896>; else goto <D.21891>;
      <D.21896>:
      D.21574 = domain->domain_id;
      old_info->domain_vtables[D.21574] = vt;
      goto <D.21892>;
      <D.21891>:
      {
        int new_size;

        new_size = domain->domain_id;
        if (old_info != 0B) goto <D.21897>; else goto <D.21898>;
        <D.21897>:
        D.21894 = old_info->max_domain;
        D.21899 = (int) D.21894;
        new_size = MAX_EXPR <D.21899, new_size>;
        <D.21898>:
        new_size = new_size + 1;
        i = 2;
        goto <D.19194>;
        <D.19193>:
        i = i << 1;
        <D.19194>:
        if (new_size > i) goto <D.19193>; else goto <D.19195>;
        <D.19195>:
        new_size = i;
        new_size.88 = (unsigned int) new_size;
        D.21901 = new_size.88 + 1;
        D.21902 = D.21901 * 4;
        D.21903 = class->image;
        runtime_info = mono_image_alloc0 (D.21903, D.21902);
        D.21904 = (short unsigned int) new_size;
        D.21905 = D.21904 + 65535;
        runtime_info->max_domain = D.21905;
        if (old_info != 0B) goto <D.21906>; else goto <D.21907>;
        <D.21906>:
        D.21894 = old_info->max_domain;
        D.21899 = (int) D.21894;
        D.21908 = D.21899 + 1;
        D.21909 = (unsigned int) D.21908;
        D.21910 = D.21909 * 4;
        D.21911 = &old_info->domain_vtables;
        D.21912 = &runtime_info->domain_vtables;
        memcpy (D.21912, D.21911, D.21910);
        <D.21907>:
        D.21574 = domain->domain_id;
        runtime_info->domain_vtables[D.21574] = vt;
        mono_memory_barrier ();
        class->runtime_info = runtime_info;
      }
      <D.21892>:
      D.21871 = mono_defaults.monotype_class;
      if (D.21871 == class) goto <D.21913>; else goto <D.21914>;
      <D.21913>:
      D.21874 = &class->byval_arg;
      D.21915 = mono_type_get_object (domain, D.21874);
      vt->type = D.21915;
      D.21876 = vt->type;
      D.21916 = mono_object_get_class (D.21876);
      D.21871 = mono_defaults.monotype_class;
      if (D.21916 != D.21871) goto <D.21917>; else goto <D.21918>;
      <D.21917>:
      D.21919 = mono_gc_is_moving ();
      if (D.21919 != 0) goto <D.21920>; else goto <D.21921>;
      <D.21920>:
      if (0 != 0) goto <D.21922>; else goto <D.21923>;
      <D.21922>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 2168, "sizeof (vt->type) == sizeof (MonoObject*)");
      <D.21923>:
      D.21924 = mono_gc_make_root_descr_all_refs (1);
      D.21886 = &vt->type;
      mono_gc_register_root (D.21886, 4, D.21924);
      <D.21921>:
      <D.21918>:
      <D.21914>:
      {
        int ret;

        D.21562 = &domain->lock.mutex;
        ret = pthread_mutex_unlock (D.21562);
        if (ret != 0) goto <D.21925>; else goto <D.21926>;
        <D.21925>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.21926>:
        D.21927 = ret != 0;
        D.21928 = (long int) D.21927;
        D.21929 = __builtin_expect (D.21928, 0);
        if (D.21929 != 0) goto <D.21930>; else goto <D.21931>;
        <D.21930>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 2171, "ret == 0");
        <D.21931>:
      }
      mono_loader_unlock ();
      D.21932 = mono_is_security_manager_active ();
      if (D.21932 != 0) goto <D.21933>; else goto <D.21934>;
      <D.21933>:
      D.21593 = class->exception_type;
      if (D.21593 == 2) goto <D.21935>; else goto <D.21936>;
      <D.21935>:
      if (raise_on_error != 0) goto <D.21937>; else goto <D.21938>;
      <D.21937>:
      D.21939 = mono_class_get_exception_for_failure (class);
      mono_raise_exception (D.21939);
      <D.21938>:
      <D.21936>:
      <D.21934>:
      D.21940 = class->parent;
      if (D.21940 != 0B) goto <D.21941>; else goto <D.21942>;
      <D.21941>:
      D.21940 = class->parent;
      mono_class_vtable_full (domain, D.21940, raise_on_error);
      <D.21942>:
      D.21587 = vt;
      return D.21587;
    }
  finally
    {
      iter = {CLOBBER};
    }
}


field_is_special_static (struct MonoClass * fklass, struct MonoClassField * field)
{
  gint32 D.21948;
  struct MonoMethod * D.21949;
  struct MonoImage * D.21950;
  struct MonoImage * D.21951;
  int D.18850;
  int iftmp.89;
  int D.18849;
  const char[22] * D.21957;
  unsigned char D.21958;
  int D.21959;
  unsigned char D.21960;
  int D.21961;
  _Bool D.21962;
  _Bool D.21963;
  _Bool D.21964;
  const unsigned char * D.21967;
  unsigned char D.21968;
  int D.21969;
  const unsigned char * D.21970;
  unsigned char D.21971;
  int D.21972;
  _Bool D.21973;
  _Bool D.21974;
  const unsigned char * D.21977;
  unsigned char D.21978;
  int D.21979;
  const unsigned char * D.21980;
  unsigned char D.21981;
  int D.21982;
  _Bool D.21983;
  _Bool D.21984;
  const unsigned char * D.21987;
  unsigned char D.21988;
  int D.21989;
  const unsigned char * D.21990;
  unsigned char D.21991;
  int D.21992;
  const char * D.21994;
  int D.18859;
  int iftmp.90;
  int D.18858;
  const char[23] * D.22000;
  unsigned char D.22001;
  int D.22002;
  unsigned char D.22003;
  int D.22004;
  _Bool D.22005;
  _Bool D.22006;
  _Bool D.22007;
  const unsigned char * D.22010;
  unsigned char D.22011;
  int D.22012;
  const unsigned char * D.22013;
  unsigned char D.22014;
  int D.22015;
  _Bool D.22016;
  _Bool D.22017;
  const unsigned char * D.22020;
  unsigned char D.22021;
  int D.22022;
  const unsigned char * D.22023;
  unsigned char D.22024;
  int D.22025;
  _Bool D.22026;
  _Bool D.22027;
  const unsigned char * D.22030;
  unsigned char D.22031;
  int D.22032;
  const unsigned char * D.22033;
  unsigned char D.22034;
  int D.22035;
  int D.22039;
  struct MonoCustomAttrInfo * ainfo;
  int i;

  ainfo = mono_custom_attrs_from_field (fklass, field);
  if (ainfo == 0B) goto <D.21946>; else goto <D.21947>;
  <D.21946>:
  D.21948 = 0;
  return D.21948;
  <D.21947>:
  i = 0;
  goto <D.18861>;
  <D.18860>:
  {
    struct MonoClass * klass;

    D.21949 = ainfo->attrs[i].ctor;
    klass = D.21949->klass;
    D.21950 = klass->image;
    D.21951 = mono_defaults.corlib;
    if (D.21950 == D.21951) goto <D.21952>; else goto <D.21953>;
    <D.21952>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = klass->name;
        D.21957 = "ThreadStaticAttribute";
        D.21958 = MEM[(const unsigned char *)D.21957];
        D.21959 = (int) D.21958;
        D.21960 = *__s2;
        D.21961 = (int) D.21960;
        __result = D.21959 - D.21961;
        {
          D.21962 = __s2_len != 0;
          D.21963 = __result == 0;
          D.21964 = D.21962 & D.21963;
          if (D.21964 != 0) goto <D.21965>; else goto <D.21966>;
          <D.21965>:
          D.21967 = &MEM[(void *)"ThreadStaticAttribute" + 1B];
          D.21968 = *D.21967;
          D.21969 = (int) D.21968;
          D.21970 = __s2 + 1;
          D.21971 = *D.21970;
          D.21972 = (int) D.21971;
          __result = D.21969 - D.21972;
          D.21973 = __s2_len > 1;
          D.21963 = __result == 0;
          D.21974 = D.21973 & D.21963;
          if (D.21974 != 0) goto <D.21975>; else goto <D.21976>;
          <D.21975>:
          D.21977 = &MEM[(void *)"ThreadStaticAttribute" + 2B];
          D.21978 = *D.21977;
          D.21979 = (int) D.21978;
          D.21980 = __s2 + 2;
          D.21981 = *D.21980;
          D.21982 = (int) D.21981;
          __result = D.21979 - D.21982;
          D.21983 = __s2_len > 2;
          D.21963 = __result == 0;
          D.21984 = D.21983 & D.21963;
          if (D.21984 != 0) goto <D.21985>; else goto <D.21986>;
          <D.21985>:
          D.21987 = &MEM[(void *)"ThreadStaticAttribute" + 3B];
          D.21988 = *D.21987;
          D.21989 = (int) D.21988;
          D.21990 = __s2 + 3;
          D.21991 = *D.21990;
          D.21992 = (int) D.21991;
          __result = D.21989 - D.21992;
          <D.21986>:
          <D.21976>:
          <D.21966>:
        }
        D.18849 = __result;
      }
      iftmp.89 = -D.18849;
      goto <D.21993>;
      <D.21956>:
      D.21994 = klass->name;
      iftmp.89 = __builtin_strcmp (D.21994, "ThreadStaticAttribute");
      <D.21993>:
      D.18850 = iftmp.89;
    }
    if (D.18850 == 0) goto <D.21995>; else goto <D.21996>;
    <D.21995>:
    mono_custom_attrs_free (ainfo);
    D.21948 = 1;
    return D.21948;
    <D.21996>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = klass->name;
        D.22000 = "ContextStaticAttribute";
        D.22001 = MEM[(const unsigned char *)D.22000];
        D.22002 = (int) D.22001;
        D.22003 = *__s2;
        D.22004 = (int) D.22003;
        __result = D.22002 - D.22004;
        {
          D.22005 = __s2_len != 0;
          D.22006 = __result == 0;
          D.22007 = D.22005 & D.22006;
          if (D.22007 != 0) goto <D.22008>; else goto <D.22009>;
          <D.22008>:
          D.22010 = &MEM[(void *)"ContextStaticAttribute" + 1B];
          D.22011 = *D.22010;
          D.22012 = (int) D.22011;
          D.22013 = __s2 + 1;
          D.22014 = *D.22013;
          D.22015 = (int) D.22014;
          __result = D.22012 - D.22015;
          D.22016 = __s2_len > 1;
          D.22006 = __result == 0;
          D.22017 = D.22016 & D.22006;
          if (D.22017 != 0) goto <D.22018>; else goto <D.22019>;
          <D.22018>:
          D.22020 = &MEM[(void *)"ContextStaticAttribute" + 2B];
          D.22021 = *D.22020;
          D.22022 = (int) D.22021;
          D.22023 = __s2 + 2;
          D.22024 = *D.22023;
          D.22025 = (int) D.22024;
          __result = D.22022 - D.22025;
          D.22026 = __s2_len > 2;
          D.22006 = __result == 0;
          D.22027 = D.22026 & D.22006;
          if (D.22027 != 0) goto <D.22028>; else goto <D.22029>;
          <D.22028>:
          D.22030 = &MEM[(void *)"ContextStaticAttribute" + 3B];
          D.22031 = *D.22030;
          D.22032 = (int) D.22031;
          D.22033 = __s2 + 3;
          D.22034 = *D.22033;
          D.22035 = (int) D.22034;
          __result = D.22032 - D.22035;
          <D.22029>:
          <D.22019>:
          <D.22009>:
        }
        D.18858 = __result;
      }
      iftmp.90 = -D.18858;
      goto <D.22036>;
      <D.21999>:
      D.21994 = klass->name;
      iftmp.90 = __builtin_strcmp (D.21994, "ContextStaticAttribute");
      <D.22036>:
      D.18859 = iftmp.90;
    }
    if (D.18859 == 0) goto <D.22037>; else goto <D.22038>;
    <D.22037>:
    mono_custom_attrs_free (ainfo);
    D.21948 = 2;
    return D.21948;
    <D.22038>:
    <D.21953>:
  }
  i = i + 1;
  <D.18861>:
  D.22039 = ainfo->num_attrs;
  if (D.22039 > i) goto <D.18860>; else goto <D.18862>;
  <D.18862>:
  mono_custom_attrs_free (ainfo);
  D.21948 = 0;
  return D.21948;
}


build_imt (struct MonoClass * klass, struct MonoVTable * vt, struct MonoDomain * domain, void * * imt, struct GSList * extra_interfaces)
{
  build_imt_slots (klass, vt, domain, imt, extra_interfaces, -1);
}


mono_class_try_get_vtable (struct MonoDomain * domain, struct MonoClass * class)
{
  _Bool D.22041;
  long int D.22042;
  long int D.22043;
  short unsigned int D.22048;
  int D.22049;
  int D.22050;
  struct MonoVTable * D.22053;
  struct MonoVTable * D.22056;
  struct MonoClassRuntimeInfo * runtime_info;

  D.22041 = class == 0B;
  D.22042 = (long int) D.22041;
  D.22043 = __builtin_expect (D.22042, 0);
  if (D.22043 != 0) goto <D.22044>; else goto <D.22045>;
  <D.22044>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 1832, "class");
  <D.22045>:
  runtime_info = class->runtime_info;
  if (runtime_info != 0B) goto <D.22046>; else goto <D.22047>;
  <D.22046>:
  D.22048 = runtime_info->max_domain;
  D.22049 = (int) D.22048;
  D.22050 = domain->domain_id;
  if (D.22049 >= D.22050) goto <D.22051>; else goto <D.22052>;
  <D.22051>:
  D.22050 = domain->domain_id;
  D.22053 = runtime_info->domain_vtables[D.22050];
  if (D.22053 != 0B) goto <D.22054>; else goto <D.22055>;
  <D.22054>:
  D.22050 = domain->domain_id;
  D.22056 = runtime_info->domain_vtables[D.22050];
  return D.22056;
  <D.22055>:
  <D.22052>:
  <D.22047>:
  D.22056 = 0B;
  return D.22056;
}


mono_class_field_is_special_static (struct MonoClassField * field)
{
  struct MonoType * D.22058;
  short unsigned int D.22059;
  int D.22060;
  int D.22061;
  gboolean D.22064;
  int D.22065;
  int D.19271;
  int iftmp.91;
  int D.19270;
  const char[9] * D.22071;
  unsigned char D.22072;
  int D.22073;
  unsigned char D.22074;
  int D.22075;
  _Bool D.22076;
  _Bool D.22077;
  _Bool D.22078;
  const unsigned char * D.22081;
  unsigned char D.22082;
  int D.22083;
  const unsigned char * D.22084;
  unsigned char D.22085;
  int D.22086;
  _Bool D.22087;
  _Bool D.22088;
  const unsigned char * D.22091;
  unsigned char D.22092;
  int D.22093;
  const unsigned char * D.22094;
  unsigned char D.22095;
  int D.22096;
  _Bool D.22097;
  _Bool D.22098;
  const unsigned char * D.22101;
  unsigned char D.22102;
  int D.22103;
  const unsigned char * D.22104;
  unsigned char D.22105;
  int D.22106;
  const char * D.22108;
  int D.22111;
  struct MonoClass * D.22114;
  int D.22115;

  D.22058 = field->type;
  D.22059 = D.22058->attrs;
  D.22060 = (int) D.22059;
  D.22061 = D.22060 & 16;
  if (D.22061 == 0) goto <D.22062>; else goto <D.22063>;
  <D.22062>:
  D.22064 = 0;
  return D.22064;
  <D.22063>:
  D.22058 = field->type;
  D.22059 = D.22058->attrs;
  D.22060 = (int) D.22059;
  D.22065 = D.22060 & 1536;
  if (D.22065 != 0) goto <D.22066>; else goto <D.22067>;
  <D.22066>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = mono_field_get_name (field);
      D.22071 = "_Deleted";
      D.22072 = MEM[(const unsigned char *)D.22071];
      D.22073 = (int) D.22072;
      D.22074 = *__s2;
      D.22075 = (int) D.22074;
      __result = D.22073 - D.22075;
      {
        D.22076 = __s2_len != 0;
        D.22077 = __result == 0;
        D.22078 = D.22076 & D.22077;
        if (D.22078 != 0) goto <D.22079>; else goto <D.22080>;
        <D.22079>:
        D.22081 = &MEM[(void *)"_Deleted" + 1B];
        D.22082 = *D.22081;
        D.22083 = (int) D.22082;
        D.22084 = __s2 + 1;
        D.22085 = *D.22084;
        D.22086 = (int) D.22085;
        __result = D.22083 - D.22086;
        D.22087 = __s2_len > 1;
        D.22077 = __result == 0;
        D.22088 = D.22087 & D.22077;
        if (D.22088 != 0) goto <D.22089>; else goto <D.22090>;
        <D.22089>:
        D.22091 = &MEM[(void *)"_Deleted" + 2B];
        D.22092 = *D.22091;
        D.22093 = (int) D.22092;
        D.22094 = __s2 + 2;
        D.22095 = *D.22094;
        D.22096 = (int) D.22095;
        __result = D.22093 - D.22096;
        D.22097 = __s2_len > 2;
        D.22077 = __result == 0;
        D.22098 = D.22097 & D.22077;
        if (D.22098 != 0) goto <D.22099>; else goto <D.22100>;
        <D.22099>:
        D.22101 = &MEM[(void *)"_Deleted" + 3B];
        D.22102 = *D.22101;
        D.22103 = (int) D.22102;
        D.22104 = __s2 + 3;
        D.22105 = *D.22104;
        D.22106 = (int) D.22105;
        __result = D.22103 - D.22106;
        <D.22100>:
        <D.22090>:
        <D.22080>:
      }
      D.19270 = __result;
    }
    iftmp.91 = -D.19270;
    goto <D.22107>;
    <D.22070>:
    D.22108 = mono_field_get_name (field);
    iftmp.91 = __builtin_strcmp (D.22108, "_Deleted");
    <D.22107>:
    D.19271 = iftmp.91;
  }
  if (D.19271 == 0) goto <D.22109>; else goto <D.22110>;
  <D.22109>:
  D.22064 = 0;
  return D.22064;
  <D.22110>:
  <D.22067>:
  D.22058 = field->type;
  D.22059 = D.22058->attrs;
  D.22060 = (int) D.22059;
  D.22111 = D.22060 & 64;
  if (D.22111 == 0) goto <D.22112>; else goto <D.22113>;
  <D.22112>:
  D.22114 = field->parent;
  D.22115 = field_is_special_static (D.22114, field);
  if (D.22115 != 0) goto <D.22116>; else goto <D.22117>;
  <D.22116>:
  D.22064 = 1;
  return D.22064;
  <D.22117>:
  <D.22113>:
  D.22064 = 0;
  return D.22064;
}


mono_class_field_get_special_static_type (struct MonoClassField * field)
{
  struct MonoType * D.22119;
  short unsigned int D.22120;
  int D.22121;
  int D.22122;
  guint32 D.22125;
  int D.22126;
  int D.19283;
  int iftmp.92;
  int D.19282;
  const char[9] * D.22132;
  unsigned char D.22133;
  int D.22134;
  unsigned char D.22135;
  int D.22136;
  _Bool D.22137;
  _Bool D.22138;
  _Bool D.22139;
  const unsigned char * D.22142;
  unsigned char D.22143;
  int D.22144;
  const unsigned char * D.22145;
  unsigned char D.22146;
  int D.22147;
  _Bool D.22148;
  _Bool D.22149;
  const unsigned char * D.22152;
  unsigned char D.22153;
  int D.22154;
  const unsigned char * D.22155;
  unsigned char D.22156;
  int D.22157;
  _Bool D.22158;
  _Bool D.22159;
  const unsigned char * D.22162;
  unsigned char D.22163;
  int D.22164;
  const unsigned char * D.22165;
  unsigned char D.22166;
  int D.22167;
  const char * D.22169;
  int D.22172;
  struct MonoClass * D.22175;
  int D.22176;

  D.22119 = field->type;
  D.22120 = D.22119->attrs;
  D.22121 = (int) D.22120;
  D.22122 = D.22121 & 16;
  if (D.22122 == 0) goto <D.22123>; else goto <D.22124>;
  <D.22123>:
  D.22125 = 0;
  return D.22125;
  <D.22124>:
  D.22119 = field->type;
  D.22120 = D.22119->attrs;
  D.22121 = (int) D.22120;
  D.22126 = D.22121 & 1536;
  if (D.22126 != 0) goto <D.22127>; else goto <D.22128>;
  <D.22127>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = mono_field_get_name (field);
      D.22132 = "_Deleted";
      D.22133 = MEM[(const unsigned char *)D.22132];
      D.22134 = (int) D.22133;
      D.22135 = *__s2;
      D.22136 = (int) D.22135;
      __result = D.22134 - D.22136;
      {
        D.22137 = __s2_len != 0;
        D.22138 = __result == 0;
        D.22139 = D.22137 & D.22138;
        if (D.22139 != 0) goto <D.22140>; else goto <D.22141>;
        <D.22140>:
        D.22142 = &MEM[(void *)"_Deleted" + 1B];
        D.22143 = *D.22142;
        D.22144 = (int) D.22143;
        D.22145 = __s2 + 1;
        D.22146 = *D.22145;
        D.22147 = (int) D.22146;
        __result = D.22144 - D.22147;
        D.22148 = __s2_len > 1;
        D.22138 = __result == 0;
        D.22149 = D.22148 & D.22138;
        if (D.22149 != 0) goto <D.22150>; else goto <D.22151>;
        <D.22150>:
        D.22152 = &MEM[(void *)"_Deleted" + 2B];
        D.22153 = *D.22152;
        D.22154 = (int) D.22153;
        D.22155 = __s2 + 2;
        D.22156 = *D.22155;
        D.22157 = (int) D.22156;
        __result = D.22154 - D.22157;
        D.22158 = __s2_len > 2;
        D.22138 = __result == 0;
        D.22159 = D.22158 & D.22138;
        if (D.22159 != 0) goto <D.22160>; else goto <D.22161>;
        <D.22160>:
        D.22162 = &MEM[(void *)"_Deleted" + 3B];
        D.22163 = *D.22162;
        D.22164 = (int) D.22163;
        D.22165 = __s2 + 3;
        D.22166 = *D.22165;
        D.22167 = (int) D.22166;
        __result = D.22164 - D.22167;
        <D.22161>:
        <D.22151>:
        <D.22141>:
      }
      D.19282 = __result;
    }
    iftmp.92 = -D.19282;
    goto <D.22168>;
    <D.22131>:
    D.22169 = mono_field_get_name (field);
    iftmp.92 = __builtin_strcmp (D.22169, "_Deleted");
    <D.22168>:
    D.19283 = iftmp.92;
  }
  if (D.19283 == 0) goto <D.22170>; else goto <D.22171>;
  <D.22170>:
  D.22125 = 0;
  return D.22125;
  <D.22171>:
  <D.22128>:
  D.22119 = field->type;
  D.22120 = D.22119->attrs;
  D.22121 = (int) D.22120;
  D.22172 = D.22121 & 64;
  if (D.22172 == 0) goto <D.22173>; else goto <D.22174>;
  <D.22173>:
  D.22175 = field->parent;
  D.22176 = field_is_special_static (D.22175, field);
  D.22125 = (guint32) D.22176;
  return D.22125;
  <D.22174>:
  D.22125 = 0;
  return D.22125;
}


mono_class_has_special_static_fields (struct MonoClass * klass)
{
  struct MonoClass * D.22178;
  _Bool D.22179;
  long int D.22180;
  long int D.22181;
  int D.22184;
  gboolean D.22187;
  struct MonoClassField * field;
  void * iter;

  try
    {
      iter = 0B;
      goto <D.19290>;
      <D.19289>:
      D.22178 = field->parent;
      D.22179 = D.22178 != klass;
      D.22180 = (long int) D.22179;
      D.22181 = __builtin_expect (D.22180, 0);
      if (D.22181 != 0) goto <D.22182>; else goto <D.22183>;
      <D.22182>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 2420, "field->parent == klass");
      <D.22183>:
      D.22184 = mono_class_field_is_special_static (field);
      if (D.22184 != 0) goto <D.22185>; else goto <D.22186>;
      <D.22185>:
      D.22187 = 1;
      return D.22187;
      <D.22186>:
      <D.19290>:
      field = mono_class_get_fields (klass, &iter);
      if (field != 0B) goto <D.19289>; else goto <D.19291>;
      <D.19291>:
      D.22187 = 0;
      return D.22187;
    }
  finally
    {
      iter = {CLOBBER};
    }
}


mono_remote_class (struct MonoDomain * domain, struct MonoString * class_name, struct MonoClass * proxy_class)
{
  union mono_mutex_t * D.22190;
  _Bool D.22193;
  long int D.22194;
  long int D.22195;
  struct GHashTable * D.22198;
  _Bool D.22203;
  long int D.22204;
  long int D.22205;
  struct MonoRemoteClass * D.22208;
  struct MonoMemPool * D.22209;
  int D.22210;
  _Bool D.22215;
  long int D.22216;
  long int D.22217;
  unsigned int D.22220;
  unsigned int D.22221;
  struct MonoClass * D.22224;
  int D.22226;
  int D.22227;
  struct MonoPerfCounters * mono_perfcounters.93;
  unsigned int D.22229;
  unsigned int D.22230;
  unsigned int D.22231;
  _Bool D.22234;
  long int D.22235;
  long int D.22236;
  struct MonoError error;
  struct MonoRemoteClass * rc;
  void * * key;
  void * * mp_key;
  char * name;

  try
    {
      key = create_remote_class_key (0B, proxy_class);
      {
        int ret;

        D.22190 = &domain->lock.mutex;
        ret = pthread_mutex_lock (D.22190);
        if (ret != 0) goto <D.22191>; else goto <D.22192>;
        <D.22191>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
        <D.22192>:
        D.22193 = ret != 0;
        D.22194 = (long int) D.22193;
        D.22195 = __builtin_expect (D.22194, 0);
        if (D.22195 != 0) goto <D.22196>; else goto <D.22197>;
        <D.22196>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 2515, "ret == 0");
        <D.22197>:
      }
      D.22198 = domain->proxy_vtable_hash;
      rc = monoeg_g_hash_table_lookup (D.22198, key);
      if (rc != 0B) goto <D.22199>; else goto <D.22200>;
      <D.22199>:
      monoeg_g_free (key);
      {
        int ret;

        D.22190 = &domain->lock.mutex;
        ret = pthread_mutex_unlock (D.22190);
        if (ret != 0) goto <D.22201>; else goto <D.22202>;
        <D.22201>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.22202>:
        D.22203 = ret != 0;
        D.22204 = (long int) D.22203;
        D.22205 = __builtin_expect (D.22204, 0);
        if (D.22205 != 0) goto <D.22206>; else goto <D.22207>;
        <D.22206>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 2520, "ret == 0");
        <D.22207>:
      }
      D.22208 = rc;
      return D.22208;
      <D.22200>:
      D.22209 = domain->mp;
      name = mono_string_to_utf8_mp (D.22209, class_name, &error);
      D.22210 = mono_error_ok (&error);
      if (D.22210 == 0) goto <D.22211>; else goto <D.22212>;
      <D.22211>:
      monoeg_g_free (key);
      {
        int ret;

        D.22190 = &domain->lock.mutex;
        ret = pthread_mutex_unlock (D.22190);
        if (ret != 0) goto <D.22213>; else goto <D.22214>;
        <D.22213>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.22214>:
        D.22215 = ret != 0;
        D.22216 = (long int) D.22215;
        D.22217 = __builtin_expect (D.22216, 0);
        if (D.22217 != 0) goto <D.22218>; else goto <D.22219>;
        <D.22218>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 2527, "ret == 0");
        <D.22219>:
      }
      mono_error_raise_exception (&error);
      <D.22212>:
      mp_key = copy_remote_class_key (domain, key);
      monoeg_g_free (key);
      key = mp_key;
      D.22220 = proxy_class->flags;
      D.22221 = D.22220 & 32;
      if (D.22221 != 0) goto <D.22222>; else goto <D.22223>;
      <D.22222>:
      rc = mono_domain_alloc (domain, 24);
      rc->interface_count = 1;
      rc->interfaces[0] = proxy_class;
      D.22224 = mono_defaults.marshalbyrefobject_class;
      rc->proxy_class = D.22224;
      goto <D.22225>;
      <D.22223>:
      rc = mono_domain_alloc (domain, 20);
      rc->interface_count = 0;
      rc->proxy_class = proxy_class;
      <D.22225>:
      rc->default_vtable = 0B;
      rc->xdomain_vtable = 0B;
      rc->proxy_class_name = name;
      D.22226 = mono_string_length (class_name);
      D.22227 = D.22226 + 1;
      mono_perfcounters.93 = mono_perfcounters;
      mono_perfcounters.93 = mono_perfcounters;
      D.22229 = mono_perfcounters.93->loader_bytes;
      D.22230 = (unsigned int) D.22227;
      D.22231 = D.22229 + D.22230;
      mono_perfcounters.93->loader_bytes = D.22231;
      D.22198 = domain->proxy_vtable_hash;
      monoeg_g_hash_table_insert_replace (D.22198, key, rc, 0);
      {
        int ret;

        D.22190 = &domain->lock.mutex;
        ret = pthread_mutex_unlock (D.22190);
        if (ret != 0) goto <D.22232>; else goto <D.22233>;
        <D.22232>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.22233>:
        D.22234 = ret != 0;
        D.22235 = (long int) D.22234;
        D.22236 = __builtin_expect (D.22235, 0);
        if (D.22236 != 0) goto <D.22237>; else goto <D.22238>;
        <D.22237>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 2555, "ret == 0");
        <D.22238>:
      }
      D.22208 = rc;
      return D.22208;
    }
  finally
    {
      error = {CLOBBER};
    }
}


create_remote_class_key (struct MonoRemoteClass * remote_class, struct MonoClass * extra_class)
{
  unsigned int D.22243;
  unsigned int D.22244;
  void * * D.22247;
  struct MonoClass * D.22248;
  void * * D.22249;
  unsigned int D.22255;
  unsigned int D.22256;
  unsigned int D.22257;
  unsigned int D.22258;
  void * D.22259;
  struct MonoClass * D.22260;
  struct MonoClass * D.22263;
  int j.94;
  unsigned int j.95;
  unsigned int D.22268;
  void * * D.22269;
  unsigned int j.96;
  unsigned int D.22271;
  void * * D.22272;
  unsigned int i.97;
  unsigned int D.22276;
  unsigned int D.22277;
  void * D.22278;
  struct MonoClass * iftmp.98;
  int D.22283;
  unsigned int D.22284;
  unsigned int D.22285;
  void * * D.22286;
  void * * D.22287;
  void * * key;
  int i;
  int j;

  if (remote_class == 0B) goto <D.22241>; else goto <D.22242>;
  <D.22241>:
  D.22243 = extra_class->flags;
  D.22244 = D.22243 & 32;
  if (D.22244 != 0) goto <D.22245>; else goto <D.22246>;
  <D.22245>:
  key = monoeg_malloc (12);
  *key = 2B;
  D.22247 = key + 4;
  D.22248 = mono_defaults.marshalbyrefobject_class;
  *D.22247 = D.22248;
  D.22249 = key + 8;
  *D.22249 = extra_class;
  goto <D.22250>;
  <D.22246>:
  key = monoeg_malloc (8);
  *key = 1B;
  D.22247 = key + 4;
  *D.22247 = extra_class;
  <D.22250>:
  goto <D.22251>;
  <D.22242>:
  if (extra_class != 0B) goto <D.22253>; else goto <D.22252>;
  <D.22253>:
  D.22243 = extra_class->flags;
  D.22244 = D.22243 & 32;
  if (D.22244 != 0) goto <D.22254>; else goto <D.22252>;
  <D.22254>:
  D.22255 = remote_class->interface_count;
  D.22256 = D.22255 + 3;
  D.22257 = D.22256 * 4;
  key = monoeg_malloc (D.22257);
  D.22255 = remote_class->interface_count;
  D.22258 = D.22255 + 2;
  D.22259 = (void *) D.22258;
  *key = D.22259;
  D.22247 = key + 4;
  D.22260 = remote_class->proxy_class;
  *D.22247 = D.22260;
  i = 0;
  j = 2;
  goto <D.19300>;
  <D.19299>:
  if (extra_class != 0B) goto <D.22261>; else goto <D.22262>;
  <D.22261>:
  D.22263 = remote_class->interfaces[i];
  if (D.22263 > extra_class) goto <D.22264>; else goto <D.22265>;
  <D.22264>:
  j.94 = j;
  j = j.94 + 1;
  j.95 = (unsigned int) j.94;
  D.22268 = j.95 * 4;
  D.22269 = key + D.22268;
  *D.22269 = extra_class;
  extra_class = 0B;
  <D.22265>:
  <D.22262>:
  j.96 = (unsigned int) j;
  D.22271 = j.96 * 4;
  D.22272 = key + D.22271;
  D.22263 = remote_class->interfaces[i];
  *D.22272 = D.22263;
  i = i + 1;
  j = j + 1;
  <D.19300>:
  i.97 = (unsigned int) i;
  D.22255 = remote_class->interface_count;
  if (i.97 < D.22255) goto <D.19299>; else goto <D.19301>;
  <D.19301>:
  if (extra_class != 0B) goto <D.22274>; else goto <D.22275>;
  <D.22274>:
  j.96 = (unsigned int) j;
  D.22271 = j.96 * 4;
  D.22272 = key + D.22271;
  *D.22272 = extra_class;
  <D.22275>:
  goto <D.19304>;
  <D.22252>:
  D.22255 = remote_class->interface_count;
  D.22258 = D.22255 + 2;
  D.22276 = D.22258 * 4;
  key = monoeg_malloc (D.22276);
  D.22255 = remote_class->interface_count;
  D.22277 = D.22255 + 1;
  D.22278 = (void *) D.22277;
  *key = D.22278;
  D.22247 = key + 4;
  if (extra_class == 0B) goto <D.22280>; else goto <D.22281>;
  <D.22280>:
  iftmp.98 = remote_class->proxy_class;
  goto <D.22282>;
  <D.22281>:
  iftmp.98 = extra_class;
  <D.22282>:
  *D.22247 = iftmp.98;
  i = 0;
  goto <D.19303>;
  <D.19302>:
  D.22283 = i + 2;
  D.22284 = (unsigned int) D.22283;
  D.22285 = D.22284 * 4;
  D.22286 = key + D.22285;
  D.22263 = remote_class->interfaces[i];
  *D.22286 = D.22263;
  i = i + 1;
  <D.19303>:
  i.97 = (unsigned int) i;
  D.22255 = remote_class->interface_count;
  if (i.97 < D.22255) goto <D.19302>; else goto <D.19304>;
  <D.19304>:
  <D.22251>:
  D.22287 = key;
  return D.22287;
}


copy_remote_class_key (struct MonoDomain * domain, void * * key)
{
  void * D.22289;
  unsigned int D.22290;
  unsigned int D.22291;
  unsigned int D.22292;
  unsigned int key_size.99;
  unsigned int key_size.100;
  void * * D.22295;
  int key_size;
  void * * mp_key;

  D.22289 = *key;
  D.22290 = (unsigned int) D.22289;
  D.22291 = D.22290 + 1;
  D.22292 = D.22291 * 4;
  key_size = (int) D.22292;
  key_size.99 = (unsigned int) key_size;
  mp_key = mono_domain_alloc (domain, key_size.99);
  key_size.100 = (unsigned int) key_size;
  memcpy (mp_key, key, key_size.100);
  D.22295 = mp_key;
  return D.22295;
}


mono_remote_class_vtable (struct MonoDomain * domain, struct MonoRemoteClass * remote_class, struct MonoRealProxy * rp)
{
  union mono_mutex_t * D.22297;
  _Bool D.22300;
  long int D.22301;
  long int D.22302;
  int D.22305;
  struct MonoVTable * D.22308;
  struct MonoVTable * D.22311;
  _Bool D.22314;
  long int D.22315;
  long int D.22316;
  void * D.22319;
  struct MonoVTable * D.22320;
  struct MonoReflectionType * D.22323;
  unsigned char D.22327;
  unsigned char D.22328;
  struct MonoClass * D.22330;
  struct MonoClass * D.22332;
  struct MonoDomain * D.22333;
  struct MonoVTable * D.22334;
  unsigned char D.22335;
  unsigned char D.22336;
  struct MonoVTable * D.22338;
  struct MonoVTable * D.22339;
  _Bool D.22342;
  long int D.22343;
  long int D.22344;

  mono_loader_lock ();
  {
    int ret;

    D.22297 = &domain->lock.mutex;
    ret = pthread_mutex_lock (D.22297);
    if (ret != 0) goto <D.22298>; else goto <D.22299>;
    <D.22298>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.22299>:
    D.22300 = ret != 0;
    D.22301 = (long int) D.22300;
    D.22302 = __builtin_expect (D.22301, 0);
    if (D.22302 != 0) goto <D.22303>; else goto <D.22304>;
    <D.22303>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 2617, "ret == 0");
    <D.22304>:
  }
  D.22305 = rp->target_domain_id;
  if (D.22305 != -1) goto <D.22306>; else goto <D.22307>;
  <D.22306>:
  D.22308 = remote_class->xdomain_vtable;
  if (D.22308 == 0B) goto <D.22309>; else goto <D.22310>;
  <D.22309>:
  D.22311 = mono_class_proxy_vtable (domain, remote_class, 1);
  remote_class->xdomain_vtable = D.22311;
  <D.22310>:
  {
    int ret;

    D.22297 = &domain->lock.mutex;
    ret = pthread_mutex_unlock (D.22297);
    if (ret != 0) goto <D.22312>; else goto <D.22313>;
    <D.22312>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.22313>:
    D.22314 = ret != 0;
    D.22315 = (long int) D.22314;
    D.22316 = __builtin_expect (D.22315, 0);
    if (D.22316 != 0) goto <D.22317>; else goto <D.22318>;
    <D.22317>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 2621, "ret == 0");
    <D.22318>:
  }
  mono_loader_unlock ();
  D.22319 = remote_class->xdomain_vtable;
  return D.22319;
  <D.22307>:
  D.22320 = remote_class->default_vtable;
  if (D.22320 == 0B) goto <D.22321>; else goto <D.22322>;
  <D.22321>:
  {
    struct MonoType * type;
    struct MonoClass * klass;

    D.22323 = rp->class_to_proxy;
    type = D.22323->type;
    klass = mono_class_from_mono_type (type);
    D.22327 = BIT_FIELD_REF <*klass, 8, 184>;
    D.22328 = D.22327 & 64;
    if (D.22328 != 0) goto <D.22324>; else goto <D.22329>;
    <D.22329>:
    D.22330 = mono_class_get_com_object_class ();
    if (D.22330 != 0B) goto <D.22331>; else goto <D.22325>;
    <D.22331>:
    D.22332 = mono_class_get_com_object_class ();
    if (D.22332 == klass) goto <D.22324>; else goto <D.22325>;
    <D.22324>:
    D.22333 = mono_domain_get ();
    D.22334 = mono_class_vtable (D.22333, klass);
    D.22335 = BIT_FIELD_REF <*D.22334, 8, 184>;
    D.22336 = D.22335 & 1;
    if (D.22336 == 0) goto <D.22337>; else goto <D.22325>;
    <D.22337>:
    D.22338 = mono_class_proxy_vtable (domain, remote_class, 2);
    remote_class->default_vtable = D.22338;
    goto <D.22326>;
    <D.22325>:
    D.22339 = mono_class_proxy_vtable (domain, remote_class, 0);
    remote_class->default_vtable = D.22339;
    <D.22326>:
  }
  <D.22322>:
  {
    int ret;

    D.22297 = &domain->lock.mutex;
    ret = pthread_mutex_unlock (D.22297);
    if (ret != 0) goto <D.22340>; else goto <D.22341>;
    <D.22340>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.22341>:
    D.22342 = ret != 0;
    D.22343 = (long int) D.22342;
    D.22344 = __builtin_expect (D.22343, 0);
    if (D.22344 != 0) goto <D.22345>; else goto <D.22346>;
    <D.22345>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 2638, "ret == 0");
    <D.22346>:
  }
  mono_loader_unlock ();
  D.22319 = remote_class->default_vtable;
  return D.22319;
}


mono_class_proxy_vtable (struct MonoDomain * domain, struct MonoRemoteClass * remote_class, MonoRemotingTarget target_type)
{
  _Bool D.22348;
  long int D.22349;
  long int D.22350;
  short unsigned int D.22353;
  short unsigned int D.22354;
  short unsigned int D.22355;
  guint8 * D.22358;
  short unsigned int D.22359;
  sizetype D.22360;
  guint8 * D.22361;
  unsigned char D.22362;
  int D.22363;
  int D.22364;
  int D.22365;
  int D.22366;
  int D.22367;
  struct GSList * D.22370;
  int D.22373;
  _Bool D.22374;
  long int D.22375;
  long int D.22376;
  void * * D.22381;
  unsigned int i.101;
  unsigned int D.22383;
  void * * D.22384;
  short unsigned int D.22385;
  short unsigned int D.22388;
  sizetype D.22389;
  guint8 * D.22390;
  unsigned char D.22391;
  int D.22392;
  int D.22393;
  int D.22394;
  int D.22395;
  int D.22396;
  struct GSList * D.22399;
  int D.22402;
  unsigned int i.102;
  unsigned int D.22404;
  unsigned int method_count.103;
  unsigned int D.22406;
  unsigned int extra_interface_vtsize.104;
  unsigned int D.22408;
  short unsigned int D.22409;
  int D.22410;
  unsigned int j.105;
  unsigned int D.22414;
  void * (*<T26dc>) (struct MonoVTable *, struct MonoDomain *, struct MonoIMTCheckItem * *, int, void *) imt_thunk_builder.106;
  long unsigned int D.22418;
  long unsigned int D.22419;
  long unsigned int D.22420;
  long unsigned int D.22421;
  int D.22422;
  unsigned int D.22423;
  unsigned int D.22424;
  unsigned int D.22425;
  unsigned int max_interface_id.107;
  unsigned int D.22428;
  unsigned int D.22429;
  unsigned int D.22430;
  long unsigned int D.22431;
  int D.22432;
  long unsigned int D.22433;
  long unsigned int D.22434;
  unsigned int D.22435;
  sizetype max_interface_id.108;
  sizetype D.22440;
  sizetype D.22441;
  unsigned int D.22442;
  unsigned int D.22443;
  struct MonoClass * D.22444;
  void * D.22445;
  struct MonoMethod * * D.22446;
  struct MonoMethod * * D.22447;
  void * (*<T1d36>) (struct MonoDomain *, struct MonoMethod *, MonoRemotingTarget) arch_create_remoting_trampoline.109;
  void * D.22451;
  unsigned int D.22453;
  unsigned int D.22454;
  short int D.22457;
  int D.22458;
  void * D.22459;
  void * D.22462;
  short unsigned int D.22463;
  int D.22464;
  unsigned int bsize.110;
  struct MonoClass * * D.22468;
  struct MonoClass * * D.22469;
  struct MonoClass * D.22470;
  short unsigned int D.22471;
  guint16 * D.22472;
  unsigned int D.22473;
  guint16 * D.22474;
  short unsigned int D.22475;
  int D.22476;
  int D.22477;
  unsigned int D.22478;
  unsigned int D.22479;
  void * * D.22480;
  void * * D.22481;
  short unsigned int D.22482;
  int D.22483;
  int D.22484;
  sizetype D.22485;
  uint8_t * D.22486;
  unsigned char D.22487;
  signed char D.22488;
  int D.22489;
  int D.22490;
  signed char D.22491;
  signed char D.22492;
  unsigned char D.22493;
  short unsigned int D.22498;
  int D.22499;
  int D.22500;
  unsigned int D.22501;
  unsigned int D.22502;
  void * * D.22503;
  void * * D.22504;
  short unsigned int D.22505;
  sizetype D.22506;
  uint8_t * D.22507;
  unsigned char D.22508;
  signed char D.22509;
  int D.22510;
  int D.22511;
  signed char D.22512;
  signed char D.22513;
  unsigned char D.22514;
  int j.111;
  int D.22516;
  void * D.22517;
  int D.22518;
  struct MonoVTable * D.22525;
  struct MonoError error;
  struct MonoVTable * vt;
  struct MonoVTable * pvt;
  int i;
  int j;
  int vtsize;
  int max_interface_id;
  int extra_interface_vtsize;
  struct MonoClass * k;
  struct GSList * extra_interfaces;
  struct MonoClass * class;
  void * * interface_offsets;
  uint8_t * bitmap;
  int bsize;

  try
    {
      extra_interface_vtsize = 0;
      extra_interfaces = 0B;
      class = remote_class->proxy_class;
      vt = mono_class_vtable (domain, class);
      D.22348 = vt == 0B;
      D.22349 = (long int) D.22348;
      D.22350 = __builtin_expect (D.22349, 0);
      if (D.22350 != 0) goto <D.22351>; else goto <D.22352>;
      <D.22351>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 2215, "vt");
      <D.22352>:
      D.22353 = vt->max_interface_id;
      max_interface_id = (int) D.22353;
      j = 0;
      goto <D.19226>;
      <D.19225>:
      {
        struct MonoClass * iclass;
        struct GPtrArray * ifaces;
        int method_count;

        iclass = remote_class->interfaces[j];
        D.22354 = iclass->interface_id;
        D.22355 = class->max_interface_id;
        if (D.22354 <= D.22355) goto <D.22356>; else goto <D.22357>;
        <D.22356>:
        D.22358 = class->interface_bitmap;
        D.22354 = iclass->interface_id;
        D.22359 = D.22354 >> 3;
        D.22360 = (sizetype) D.22359;
        D.22361 = D.22358 + D.22360;
        D.22362 = *D.22361;
        D.22363 = (int) D.22362;
        D.22354 = iclass->interface_id;
        D.22364 = (int) D.22354;
        D.22365 = D.22364 & 7;
        D.22366 = D.22363 >> D.22365;
        D.22367 = D.22366 & 1;
        if (D.22367 != 0) goto <D.22368>; else goto <D.22369>;
        <D.22368>:
        // predicted unlikely by continue predictor.
        goto <D.19219>;
        <D.22369>:
        <D.22357>:
        D.22370 = monoeg_g_slist_find (extra_interfaces, iclass);
        if (D.22370 != 0B) goto <D.22371>; else goto <D.22372>;
        <D.22371>:
        // predicted unlikely by continue predictor.
        goto <D.19219>;
        <D.22372>:
        extra_interfaces = monoeg_g_slist_prepend (extra_interfaces, iclass);
        method_count = mono_class_num_methods (iclass);
        ifaces = mono_class_get_implemented_interfaces (iclass, &error);
        D.22373 = mono_error_ok (&error);
        D.22374 = D.22373 == 0;
        D.22375 = (long int) D.22374;
        D.22376 = __builtin_expect (D.22375, 0);
        if (D.22376 != 0) goto <D.22377>; else goto <D.22378>;
        <D.22377>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 2235, "mono_error_ok (&error)");
        <D.22378>:
        if (ifaces != 0B) goto <D.22379>; else goto <D.22380>;
        <D.22379>:
        i = 0;
        goto <D.19223>;
        <D.19222>:
        {
          struct MonoClass * ic;

          D.22381 = ifaces->pdata;
          i.101 = (unsigned int) i;
          D.22383 = i.101 * 4;
          D.22384 = D.22381 + D.22383;
          ic = *D.22384;
          D.22385 = ic->interface_id;
          D.22355 = class->max_interface_id;
          if (D.22385 <= D.22355) goto <D.22386>; else goto <D.22387>;
          <D.22386>:
          D.22358 = class->interface_bitmap;
          D.22385 = ic->interface_id;
          D.22388 = D.22385 >> 3;
          D.22389 = (sizetype) D.22388;
          D.22390 = D.22358 + D.22389;
          D.22391 = *D.22390;
          D.22392 = (int) D.22391;
          D.22385 = ic->interface_id;
          D.22393 = (int) D.22385;
          D.22394 = D.22393 & 7;
          D.22395 = D.22392 >> D.22394;
          D.22396 = D.22395 & 1;
          if (D.22396 != 0) goto <D.22397>; else goto <D.22398>;
          <D.22397>:
          // predicted unlikely by continue predictor.
          goto <D.19221>;
          <D.22398>:
          <D.22387>:
          D.22399 = monoeg_g_slist_find (extra_interfaces, ic);
          if (D.22399 != 0B) goto <D.22400>; else goto <D.22401>;
          <D.22400>:
          // predicted unlikely by continue predictor.
          goto <D.19221>;
          <D.22401>:
          extra_interfaces = monoeg_g_slist_prepend (extra_interfaces, ic);
          D.22402 = mono_class_num_methods (ic);
          method_count = D.22402 + method_count;
        }
        <D.19221>:
        i = i + 1;
        <D.19223>:
        i.102 = (unsigned int) i;
        D.22404 = ifaces->len;
        if (i.102 < D.22404) goto <D.19222>; else goto <D.19224>;
        <D.19224>:
        monoeg_g_ptr_array_free (ifaces, 1);
        <D.22380>:
        method_count.103 = (unsigned int) method_count;
        D.22406 = method_count.103 * 4;
        extra_interface_vtsize.104 = (unsigned int) extra_interface_vtsize;
        D.22408 = D.22406 + extra_interface_vtsize.104;
        extra_interface_vtsize = (int) D.22408;
        D.22409 = iclass->max_interface_id;
        D.22410 = (int) D.22409;
        if (D.22410 > max_interface_id) goto <D.22411>; else goto <D.22412>;
        <D.22411>:
        D.22409 = iclass->max_interface_id;
        max_interface_id = (int) D.22409;
        <D.22412>:
      }
      <D.19219>:
      j = j + 1;
      <D.19226>:
      j.105 = (unsigned int) j;
      D.22414 = remote_class->interface_count;
      if (j.105 < D.22414) goto <D.19225>; else goto <D.19227>;
      <D.19227>:
      imt_thunk_builder.106 = imt_thunk_builder;
      if (imt_thunk_builder.106 != 0B) goto <D.22416>; else goto <D.22417>;
      <D.22416>:
      D.22418 = mono_stats.imt_number_of_tables;
      D.22419 = D.22418 + 1;
      mono_stats.imt_number_of_tables = D.22419;
      D.22420 = mono_stats.imt_tables_size;
      D.22421 = D.22420 + 76;
      mono_stats.imt_tables_size = D.22421;
      D.22422 = class->vtable_size;
      D.22423 = (unsigned int) D.22422;
      D.22424 = D.22423 + 27;
      D.22425 = D.22424 * 4;
      vtsize = (int) D.22425;
      goto <D.22426>;
      <D.22417>:
      D.22422 = class->vtable_size;
      D.22423 = (unsigned int) D.22422;
      max_interface_id.107 = (unsigned int) max_interface_id;
      D.22428 = D.22423 + max_interface_id.107;
      D.22429 = D.22428 + 9;
      D.22430 = D.22429 * 4;
      vtsize = (int) D.22430;
      <D.22426>:
      D.22431 = mono_stats.class_vtable_size;
      D.22432 = vtsize + extra_interface_vtsize;
      D.22433 = (long unsigned int) D.22432;
      D.22434 = D.22431 + D.22433;
      mono_stats.class_vtable_size = D.22434;
      D.22432 = vtsize + extra_interface_vtsize;
      D.22435 = (unsigned int) D.22432;
      interface_offsets = mono_domain_alloc0 (domain, D.22435);
      imt_thunk_builder.106 = imt_thunk_builder;
      if (imt_thunk_builder.106 != 0B) goto <D.22436>; else goto <D.22437>;
      <D.22436>:
      pvt = interface_offsets + 76;
      goto <D.22438>;
      <D.22437>:
      max_interface_id.108 = (sizetype) max_interface_id;
      D.22440 = max_interface_id.108 + 1;
      D.22441 = D.22440 * 4;
      pvt = interface_offsets + D.22441;
      <D.22438>:
      D.22422 = class->vtable_size;
      D.22423 = (unsigned int) D.22422;
      D.22442 = D.22423 + 8;
      D.22443 = D.22442 * 4;
      memcpy (pvt, vt, D.22443);
      D.22444 = mono_defaults.transparent_proxy_class;
      pvt->klass = D.22444;
      D.22444 = mono_defaults.transparent_proxy_class;
      D.22445 = D.22444->gc_descr;
      pvt->gc_descr = D.22445;
      mono_class_setup_vtable (class);
      i = 0;
      goto <D.19230>;
      <D.19229>:
      {
        struct MonoMethod * cm;

        D.22446 = class->vtable;
        i.101 = (unsigned int) i;
        D.22383 = i.101 * 4;
        D.22447 = D.22446 + D.22383;
        cm = *D.22447;
        if (cm != 0B) goto <D.22448>; else goto <D.22449>;
        <D.22448>:
        arch_create_remoting_trampoline.109 = arch_create_remoting_trampoline;
        D.22451 = arch_create_remoting_trampoline.109 (domain, cm, target_type);
        pvt->vtable[i] = D.22451;
        goto <D.22452>;
        <D.22449>:
        pvt->vtable[i] = 0B;
        <D.22452>:
      }
      i = i + 1;
      <D.19230>:
      D.22422 = class->vtable_size;
      if (D.22422 > i) goto <D.19229>; else goto <D.19231>;
      <D.19231>:
      D.22453 = class->flags;
      D.22454 = D.22453 & 128;
      if (D.22454 != 0) goto <D.22455>; else goto <D.22456>;
      <D.22455>:
      k = class;
      goto <D.19238>;
      <D.19237>:
      {
        struct MonoMethod * m;
        void * iter;

        try
          {
            iter = 0B;
            goto <D.19235>;
            <D.19234>:
            D.22457 = m->slot;
            D.22458 = (int) D.22457;
            D.22459 = pvt->vtable[D.22458];
            if (D.22459 == 0B) goto <D.22460>; else goto <D.22461>;
            <D.22460>:
            D.22457 = m->slot;
            D.22458 = (int) D.22457;
            arch_create_remoting_trampoline.109 = arch_create_remoting_trampoline;
            D.22462 = arch_create_remoting_trampoline.109 (domain, m, target_type);
            pvt->vtable[D.22458] = D.22462;
            <D.22461>:
            <D.19235>:
            m = mono_class_get_methods (k, &iter);
            if (m != 0B) goto <D.19234>; else goto <D.19236>;
            <D.19236>:
          }
        finally
          {
            iter = {CLOBBER};
          }
      }
      k = k->parent;
      <D.19238>:
      if (k != 0B) goto <D.19237>; else goto <D.19239>;
      <D.19239>:
      <D.22456>:
      D.22463 = (short unsigned int) max_interface_id;
      pvt->max_interface_id = D.22463;
      D.22464 = max_interface_id / 8;
      bsize = D.22464 + 1;
      bsize.110 = (unsigned int) bsize;
      bitmap = mono_domain_alloc0 (domain, bsize.110);
      imt_thunk_builder.106 = imt_thunk_builder;
      if (imt_thunk_builder.106 == 0B) goto <D.22466>; else goto <D.22467>;
      <D.22466>:
      i = 0;
      goto <D.19243>;
      <D.19242>:
      {
        int interface_id;
        int slot;

        D.22468 = class->interfaces_packed;
        i.101 = (unsigned int) i;
        D.22383 = i.101 * 4;
        D.22469 = D.22468 + D.22383;
        D.22470 = *D.22469;
        D.22471 = D.22470->interface_id;
        interface_id = (int) D.22471;
        D.22472 = class->interface_offsets_packed;
        i.101 = (unsigned int) i;
        D.22473 = i.101 * 2;
        D.22474 = D.22472 + D.22473;
        D.22475 = *D.22474;
        slot = (int) D.22475;
        D.22355 = class->max_interface_id;
        D.22476 = (int) D.22355;
        D.22477 = D.22476 - interface_id;
        D.22478 = (unsigned int) D.22477;
        D.22479 = D.22478 * 4;
        D.22480 = interface_offsets + D.22479;
        D.22481 = &pvt->vtable[slot];
        *D.22480 = D.22481;
      }
      i = i + 1;
      <D.19243>:
      D.22482 = class->interface_offsets_count;
      D.22483 = (int) D.22482;
      if (D.22483 > i) goto <D.19242>; else goto <D.19244>;
      <D.19244>:
      <D.22467>:
      i = 0;
      goto <D.19247>;
      <D.19246>:
      {
        int interface_id;

        D.22468 = class->interfaces_packed;
        i.101 = (unsigned int) i;
        D.22383 = i.101 * 4;
        D.22469 = D.22468 + D.22383;
        D.22470 = *D.22469;
        D.22471 = D.22470->interface_id;
        interface_id = (int) D.22471;
        D.22484 = interface_id >> 3;
        D.22485 = (sizetype) D.22484;
        D.22486 = bitmap + D.22485;
        D.22484 = interface_id >> 3;
        D.22485 = (sizetype) D.22484;
        D.22486 = bitmap + D.22485;
        D.22487 = *D.22486;
        D.22488 = (signed char) D.22487;
        D.22489 = interface_id & 7;
        D.22490 = 1 << D.22489;
        D.22491 = (signed char) D.22490;
        D.22492 = D.22488 | D.22491;
        D.22493 = (unsigned char) D.22492;
        *D.22486 = D.22493;
      }
      i = i + 1;
      <D.19247>:
      D.22482 = class->interface_offsets_count;
      D.22483 = (int) D.22482;
      if (D.22483 > i) goto <D.19246>; else goto <D.19248>;
      <D.19248>:
      if (extra_interfaces != 0B) goto <D.22494>; else goto <D.22495>;
      <D.22494>:
      {
        int slot;
        struct MonoClass * interf;
        void * iter;
        struct MonoMethod * cm;
        struct GSList * list_item;

        try
          {
            slot = class->vtable_size;
            list_item = extra_interfaces;
            goto <D.19258>;
            <D.19257>:
            interf = list_item->data;
            imt_thunk_builder.106 = imt_thunk_builder;
            if (imt_thunk_builder.106 == 0B) goto <D.22496>; else goto <D.22497>;
            <D.22496>:
            D.22498 = interf->interface_id;
            D.22499 = (int) D.22498;
            D.22500 = max_interface_id - D.22499;
            D.22501 = (unsigned int) D.22500;
            D.22502 = D.22501 * 4;
            D.22503 = interface_offsets + D.22502;
            D.22504 = &pvt->vtable[slot];
            *D.22503 = D.22504;
            <D.22497>:
            D.22498 = interf->interface_id;
            D.22505 = D.22498 >> 3;
            D.22506 = (sizetype) D.22505;
            D.22507 = bitmap + D.22506;
            D.22498 = interf->interface_id;
            D.22505 = D.22498 >> 3;
            D.22506 = (sizetype) D.22505;
            D.22507 = bitmap + D.22506;
            D.22508 = *D.22507;
            D.22509 = (signed char) D.22508;
            D.22498 = interf->interface_id;
            D.22499 = (int) D.22498;
            D.22510 = D.22499 & 7;
            D.22511 = 1 << D.22510;
            D.22512 = (signed char) D.22511;
            D.22513 = D.22509 | D.22512;
            D.22514 = (unsigned char) D.22513;
            *D.22507 = D.22514;
            iter = 0B;
            j = 0;
            goto <D.19255>;
            <D.19254>:
            j.111 = j;
            j = j.111 + 1;
            D.22516 = j.111 + slot;
            arch_create_remoting_trampoline.109 = arch_create_remoting_trampoline;
            D.22517 = arch_create_remoting_trampoline.109 (domain, cm, target_type);
            pvt->vtable[D.22516] = D.22517;
            <D.19255>:
            cm = mono_class_get_methods (interf, &iter);
            if (cm != 0B) goto <D.19254>; else goto <D.19256>;
            <D.19256>:
            D.22518 = mono_class_num_methods (interf);
            slot = D.22518 + slot;
            list_item = list_item->next;
            <D.19258>:
            if (list_item != 0B) goto <D.19257>; else goto <D.19259>;
            <D.19259>:
            imt_thunk_builder.106 = imt_thunk_builder;
            if (imt_thunk_builder.106 == 0B) goto <D.22519>; else goto <D.22520>;
            <D.22519>:
            monoeg_g_slist_free (extra_interfaces);
            <D.22520>:
          }
        finally
          {
            iter = {CLOBBER};
          }
      }
      <D.22495>:
      imt_thunk_builder.106 = imt_thunk_builder;
      if (imt_thunk_builder.106 != 0B) goto <D.22521>; else goto <D.22522>;
      <D.22521>:
      build_imt (class, pvt, domain, interface_offsets, extra_interfaces);
      if (extra_interfaces != 0B) goto <D.22523>; else goto <D.22524>;
      <D.22523>:
      monoeg_g_slist_free (extra_interfaces);
      <D.22524>:
      <D.22522>:
      pvt->interface_bitmap = bitmap;
      D.22525 = pvt;
      return D.22525;
    }
  finally
    {
      error = {CLOBBER};
    }
}


mono_upgrade_remote_class (struct MonoDomain * domain, struct MonoObject * proxy_object, struct MonoClass * klass)
{
  union mono_mutex_t * D.22528;
  _Bool D.22531;
  long int D.22532;
  long int D.22533;
  unsigned int D.22536;
  unsigned int D.22537;
  struct MonoClass * D.22540;
  unsigned int i.112;
  unsigned int D.22544;
  struct MonoClass * D.22547;
  _Bool D.22548;
  struct MonoRemoteClass * D.22551;
  struct MonoRealProxy * D.22552;
  struct MonoRemoteClass * D.22553;
  void * D.22554;
  _Bool D.22557;
  long int D.22558;
  long int D.22559;
  struct MonoTransparentProxy * tproxy;
  struct MonoRemoteClass * remote_class;
  gboolean redo_vtable;

  mono_loader_lock ();
  {
    int ret;

    D.22528 = &domain->lock.mutex;
    ret = pthread_mutex_lock (D.22528);
    if (ret != 0) goto <D.22529>; else goto <D.22530>;
    <D.22529>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.22530>:
    D.22531 = ret != 0;
    D.22532 = (long int) D.22531;
    D.22533 = __builtin_expect (D.22532, 0);
    if (D.22533 != 0) goto <D.22534>; else goto <D.22535>;
    <D.22534>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 2661, "ret == 0");
    <D.22535>:
  }
  tproxy = proxy_object;
  remote_class = tproxy->remote_class;
  D.22536 = klass->flags;
  D.22537 = D.22536 & 32;
  if (D.22537 != 0) goto <D.22538>; else goto <D.22539>;
  <D.22538>:
  {
    int i;

    redo_vtable = 1;
    i = 0;
    goto <D.19359>;
    <D.19358>:
    D.22540 = remote_class->interfaces[i];
    if (D.22540 == klass) goto <D.22541>; else goto <D.22542>;
    <D.22541>:
    redo_vtable = 0;
    <D.22542>:
    i = i + 1;
    <D.19359>:
    i.112 = (unsigned int) i;
    D.22544 = remote_class->interface_count;
    if (i.112 < D.22544) goto <D.22545>; else goto <D.19360>;
    <D.22545>:
    if (redo_vtable != 0) goto <D.19358>; else goto <D.19360>;
    <D.19360>:
  }
  goto <D.22546>;
  <D.22539>:
  D.22547 = remote_class->proxy_class;
  D.22548 = D.22547 != klass;
  redo_vtable = (gboolean) D.22548;
  <D.22546>:
  if (redo_vtable != 0) goto <D.22549>; else goto <D.22550>;
  <D.22549>:
  D.22551 = clone_remote_class (domain, remote_class, klass);
  tproxy->remote_class = D.22551;
  D.22552 = tproxy->rp;
  D.22553 = tproxy->remote_class;
  D.22554 = mono_remote_class_vtable (domain, D.22553, D.22552);
  proxy_object->vtable = D.22554;
  <D.22550>:
  {
    int ret;

    D.22528 = &domain->lock.mutex;
    ret = pthread_mutex_unlock (D.22528);
    if (ret != 0) goto <D.22555>; else goto <D.22556>;
    <D.22555>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.22556>:
    D.22557 = ret != 0;
    D.22558 = (long int) D.22557;
    D.22559 = __builtin_expect (D.22558, 0);
    if (D.22559 != 0) goto <D.22560>; else goto <D.22561>;
    <D.22560>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 2682, "ret == 0");
    <D.22561>:
  }
  mono_loader_unlock ();
}


clone_remote_class (struct MonoDomain * domain, struct MonoRemoteClass * remote_class, struct MonoClass * extra_class)
{
  struct GHashTable * D.22562;
  struct MonoRemoteClass * D.22565;
  unsigned int D.22566;
  unsigned int D.22567;
  unsigned int D.22570;
  unsigned int D.22571;
  unsigned int D.22572;
  struct MonoClass * D.22573;
  unsigned int D.22574;
  struct MonoClass * D.22575;
  int j.113;
  unsigned int i.114;
  unsigned int D.22585;
  unsigned int D.22586;
  unsigned int D.22587;
  unsigned int D.22590;
  struct MonoClass *[0:] * D.22591;
  struct MonoClass *[0:] * D.22592;
  char * D.22593;
  struct MonoRemoteClass * rc;
  void * * key;
  void * * mp_key;

  key = create_remote_class_key (remote_class, extra_class);
  D.22562 = domain->proxy_vtable_hash;
  rc = monoeg_g_hash_table_lookup (D.22562, key);
  if (rc != 0B) goto <D.22563>; else goto <D.22564>;
  <D.22563>:
  monoeg_g_free (key);
  D.22565 = rc;
  return D.22565;
  <D.22564>:
  mp_key = copy_remote_class_key (domain, key);
  monoeg_g_free (key);
  key = mp_key;
  D.22566 = extra_class->flags;
  D.22567 = D.22566 & 32;
  if (D.22567 != 0) goto <D.22568>; else goto <D.22569>;
  <D.22568>:
  {
    int i;
    int j;

    D.22570 = remote_class->interface_count;
    D.22571 = D.22570 + 6;
    D.22572 = D.22571 * 4;
    rc = mono_domain_alloc (domain, D.22572);
    D.22573 = remote_class->proxy_class;
    rc->proxy_class = D.22573;
    D.22570 = remote_class->interface_count;
    D.22574 = D.22570 + 1;
    rc->interface_count = D.22574;
    i = 0;
    j = 0;
    goto <D.19336>;
    <D.19335>:
    D.22575 = remote_class->interfaces[i];
    if (D.22575 > extra_class) goto <D.22576>; else goto <D.22577>;
    <D.22576>:
    if (i == j) goto <D.22578>; else goto <D.22579>;
    <D.22578>:
    j.113 = j;
    j = j.113 + 1;
    rc->interfaces[j.113] = extra_class;
    <D.22579>:
    <D.22577>:
    D.22575 = remote_class->interfaces[i];
    rc->interfaces[j] = D.22575;
    i = i + 1;
    j = j + 1;
    <D.19336>:
    i.114 = (unsigned int) i;
    D.22570 = remote_class->interface_count;
    if (i.114 < D.22570) goto <D.19335>; else goto <D.19337>;
    <D.19337>:
    if (i == j) goto <D.22582>; else goto <D.22583>;
    <D.22582>:
    rc->interfaces[j] = extra_class;
    <D.22583>:
  }
  goto <D.22584>;
  <D.22569>:
  D.22570 = remote_class->interface_count;
  D.22585 = D.22570 + 5;
  D.22586 = D.22585 * 4;
  rc = mono_domain_alloc (domain, D.22586);
  rc->proxy_class = extra_class;
  D.22570 = remote_class->interface_count;
  rc->interface_count = D.22570;
  D.22587 = rc->interface_count;
  if (D.22587 != 0) goto <D.22588>; else goto <D.22589>;
  <D.22588>:
  D.22587 = rc->interface_count;
  D.22590 = D.22587 * 4;
  D.22591 = &remote_class->interfaces;
  D.22592 = &rc->interfaces;
  memcpy (D.22592, D.22591, D.22590);
  <D.22589>:
  <D.22584>:
  rc->default_vtable = 0B;
  rc->xdomain_vtable = 0B;
  D.22593 = remote_class->proxy_class_name;
  rc->proxy_class_name = D.22593;
  D.22562 = domain->proxy_vtable_hash;
  monoeg_g_hash_table_insert_replace (D.22562, key, rc, 0);
  D.22565 = rc;
  return D.22565;
}


mono_object_get_virtual_method (struct MonoObject * obj, struct MonoMethod * method)
{
  struct MonoVTable * D.22595;
  struct MonoClass * D.22596;
  struct MonoRemoteClass * D.22599;
  short unsigned int D.22602;
  unsigned int D.22603;
  unsigned int D.22604;
  struct MonoMethod * D.22607;
  short int D.22608;
  unsigned char D.22611;
  unsigned char D.22612;
  struct MonoMethod * D.22615;
  short int D.22616;
  _Bool D.22617;
  long int D.22618;
  long int D.22619;
  struct MonoClass * D.22627;
  unsigned int D.22628;
  unsigned int D.22629;
  _Bool D.22634;
  long int D.22635;
  long int D.22636;
  int D.22639;
  int D.22640;
  unsigned int D.22641;
  unsigned int D.22642;
  struct MonoMethod * * D.22643;
  unsigned int D.22645;
  unsigned int D.22646;
  struct MonoMethod * * D.22647;
  struct MonoMethodSignature * D.22653;
  short unsigned int D.22654;
  struct MonoMethodSignature * D.22655;
  short unsigned int D.22656;
  struct MonoClass * D.22663;
  unsigned char D.22665;
  unsigned char D.22666;
  struct MonoGenericContext * D.22670;
  _Bool D.22671;
  long int D.22672;
  long int D.22673;
  struct MonoClass * klass;
  struct MonoMethod * * vtable;
  gboolean is_proxy;
  struct MonoMethod * res;

  is_proxy = 0;
  res = 0B;
  D.22595 = obj->vtable;
  klass = D.22595->klass;
  D.22596 = mono_defaults.transparent_proxy_class;
  if (D.22596 == klass) goto <D.22597>; else goto <D.22598>;
  <D.22597>:
  D.22599 = MEM[(struct MonoTransparentProxy *)obj].remote_class;
  klass = D.22599->proxy_class;
  is_proxy = 1;
  <D.22598>:
  if (is_proxy == 0) goto <D.22600>; else goto <D.22601>;
  <D.22600>:
  D.22602 = method->flags;
  D.22603 = (unsigned int) D.22602;
  D.22604 = D.22603 & 96;
  if (D.22604 != 64) goto <D.22605>; else goto <D.22606>;
  <D.22605>:
  D.22607 = method;
  return D.22607;
  <D.22606>:
  <D.22601>:
  mono_class_setup_vtable (klass);
  vtable = klass->vtable;
  D.22608 = method->slot;
  if (D.22608 == -1) goto <D.22609>; else goto <D.22610>;
  <D.22609>:
  D.22611 = BIT_FIELD_REF <*method, 8, 168>;
  D.22612 = D.22611 & 16;
  if (D.22612 != 0) goto <D.22613>; else goto <D.22614>;
  <D.22613>:
  D.22615 = MEM[(struct MonoMethodInflated *)method].declaring;
  D.22616 = D.22615->slot;
  D.22617 = D.22616 == -1;
  D.22618 = (long int) D.22617;
  D.22619 = __builtin_expect (D.22618, 0);
  if (D.22619 != 0) goto <D.22620>; else goto <D.22621>;
  <D.22620>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 2721, "((MonoMethodInflated*)method)->declaring->slot != -1");
  <D.22621>:
  D.22615 = MEM[(struct MonoMethodInflated *)method].declaring;
  D.22616 = D.22615->slot;
  method->slot = D.22616;
  goto <D.22622>;
  <D.22614>:
  if (is_proxy == 0) goto <D.22623>; else goto <D.22624>;
  <D.22623>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "object.c", 2725);
  <D.22624>:
  <D.22622>:
  <D.22610>:
  D.22608 = method->slot;
  if (D.22608 != -1) goto <D.22625>; else goto <D.22626>;
  <D.22625>:
  D.22627 = method->klass;
  D.22628 = D.22627->flags;
  D.22629 = D.22628 & 32;
  if (D.22629 != 0) goto <D.22630>; else goto <D.22631>;
  <D.22630>:
  if (is_proxy == 0) goto <D.22632>; else goto <D.22633>;
  <D.22632>:
  {
    gboolean variance_used;
    int iface_offset;

    try
      {
        variance_used = 0;
        D.22627 = method->klass;
        iface_offset = mono_class_interface_offset_with_variance (klass, D.22627, &variance_used);
        D.22634 = iface_offset <= 0;
        D.22635 = (long int) D.22634;
        D.22636 = __builtin_expect (D.22635, 0);
        if (D.22636 != 0) goto <D.22637>; else goto <D.22638>;
        <D.22637>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 2735, "iface_offset > 0");
        <D.22638>:
        D.22608 = method->slot;
        D.22639 = (int) D.22608;
        D.22640 = D.22639 + iface_offset;
        D.22641 = (unsigned int) D.22640;
        D.22642 = D.22641 * 4;
        D.22643 = vtable + D.22642;
        res = *D.22643;
      }
    finally
      {
        variance_used = {CLOBBER};
      }
  }
  <D.22633>:
  goto <D.22644>;
  <D.22631>:
  D.22608 = method->slot;
  D.22645 = (unsigned int) D.22608;
  D.22646 = D.22645 * 4;
  D.22647 = vtable + D.22646;
  res = *D.22647;
  <D.22644>:
  <D.22626>:
  if (is_proxy != 0) goto <D.22648>; else goto <D.22649>;
  <D.22648>:
  if (res == 0B) goto <D.22650>; else goto <D.22652>;
  <D.22652>:
  D.22653 = mono_method_signature (res);
  D.22654 = D.22653->generic_param_count;
  if (D.22654 != 0) goto <D.22650>; else goto <D.22651>;
  <D.22650>:
  res = method;
  <D.22651>:
  D.22655 = mono_method_signature (res);
  D.22656 = D.22655->generic_param_count;
  if (D.22656 != 0) goto <D.22657>; else goto <D.22658>;
  <D.22657>:
  res = mono_marshal_get_remoting_invoke_with_check (res);
  goto <D.22659>;
  <D.22658>:
  D.22663 = mono_class_get_com_object_class ();
  if (D.22663 == klass) goto <D.22660>; else goto <D.22664>;
  <D.22664>:
  D.22665 = BIT_FIELD_REF <*klass, 8, 184>;
  D.22666 = D.22665 & 64;
  if (D.22666 != 0) goto <D.22660>; else goto <D.22661>;
  <D.22660>:
  res = mono_cominterop_get_invoke (res);
  goto <D.22662>;
  <D.22661>:
  res = mono_marshal_get_remoting_invoke (res);
  <D.22662>:
  <D.22659>:
  goto <D.22667>;
  <D.22649>:
  D.22611 = BIT_FIELD_REF <*method, 8, 168>;
  D.22612 = D.22611 & 16;
  if (D.22612 != 0) goto <D.22668>; else goto <D.22669>;
  <D.22668>:
  D.22670 = &MEM[(struct MonoMethodInflated *)method].context;
  res = mono_class_inflate_generic_method (res, D.22670);
  <D.22669>:
  <D.22667>:
  D.22671 = res == 0B;
  D.22672 = (long int) D.22671;
  D.22673 = __builtin_expect (D.22672, 0);
  if (D.22673 != 0) goto <D.22674>; else goto <D.22675>;
  <D.22674>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 2769, "res");
  <D.22675>:
  D.22607 = res;
  return D.22607;
}


mono_runtime_invoke (struct MonoMethod * method, void * obj, void * * params, struct MonoObject * * exc)
{
  int D.22677;
  char * D.22680;
  <unnamed type> D.22681;
  unsigned int D.22682;
  struct MonoObject * (*<T11c7>) (struct MonoMethod *, void *, void * *, struct MonoObject * *) default_mono_runtime_invoke.115;
  <unnamed type> D.22686;
  unsigned int D.22687;
  struct MonoObject * D.22690;
  struct MonoObject * result;

  D.22677 = mono_runtime_get_no_exec ();
  if (D.22677 != 0) goto <D.22678>; else goto <D.22679>;
  <D.22678>:
  D.22680 = mono_method_full_name (method, 1);
  monoeg_g_log (0B, 16, "Invoking method \'%s\' when running in no-exec mode.\n", D.22680);
  <D.22679>:
  D.22681 = mono_profiler_get_events ();
  D.22682 = D.22681 & 65536;
  if (D.22682 != 0) goto <D.22683>; else goto <D.22684>;
  <D.22683>:
  mono_profiler_method_start_invoke (method);
  <D.22684>:
  default_mono_runtime_invoke.115 = default_mono_runtime_invoke;
  result = default_mono_runtime_invoke.115 (method, obj, params, exc);
  D.22686 = mono_profiler_get_events ();
  D.22687 = D.22686 & 65536;
  if (D.22687 != 0) goto <D.22688>; else goto <D.22689>;
  <D.22688>:
  mono_profiler_method_end_invoke (method);
  <D.22689>:
  D.22690 = result;
  return D.22690;
}


dummy_mono_runtime_invoke (struct MonoMethod * method, void * obj, void * * params, struct MonoObject * * exc)
{
  struct MonoObject * D.22692;

  monoeg_g_log (0B, 4, "runtime invoke called on uninitialized runtime");
  <D.19378>:
  goto <D.19378>;
  D.22692 = 0B;
  return D.22692;
}


mono_method_get_unmanaged_thunk (struct MonoMethod * method)
{
  void * D.22694;

  method = mono_marshal_get_thunk_invoke_wrapper (method);
  D.22694 = mono_compile_method (method);
  return D.22694;
}


mono_field_set_value (struct MonoObject * obj, struct MonoClassField * field, void * value)
{
  struct MonoType * D.22696;
  short unsigned int D.22697;
  int D.22698;
  int D.22699;
  int D.22702;
  sizetype D.22703;
  void * dest;

  D.22696 = field->type;
  D.22697 = D.22696->attrs;
  D.22698 = (int) D.22697;
  D.22699 = D.22698 & 16;
  if (D.22699 != 0) goto <D.22700>; else goto <D.22701>;
  <D.22700>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "object.c", 3003, "!(field->type->attrs & FIELD_ATTRIBUTE_STATIC)");
  return;
  <D.22701>:
  D.22702 = field->offset;
  D.22703 = (sizetype) D.22702;
  dest = obj + D.22703;
  D.22696 = field->type;
  set_value (D.22696, dest, value, 0);
}


set_value (struct MonoType * type, void * dest, void * value, int deref_pointer)
{
  unsigned char D.22705;
  unsigned char D.22706;
  unsigned char D.22709;
  guint8 iftmp.116;
  guint16 iftmp.117;
  int iftmp.118;
  gint64 iftmp.119;
  float iftmp.120;
  double iftmp.121;
  struct MonoObject * iftmp.122;
  void * iftmp.123;
  struct MonoClass * D.22744;
  unsigned char D.22745;
  unsigned char D.22746;
  struct MonoType * D.22748;
  unsigned char D.22749;
  unsigned int size.124;
  struct MonoGenericClass * D.22754;
  struct MonoClass * D.22755;
  unsigned char D.22756;
  int D.22757;
  int t;
  void handle_enum = <<< error >>>;

  D.22705 = BIT_FIELD_REF <*type, 8, 56>;
  D.22706 = D.22705 & 64;
  if (D.22706 != 0) goto <D.22707>; else goto <D.22708>;
  <D.22707>:
  {
    void * * p;

    p = dest;
    *p = value;
    return;
  }
  <D.22708>:
  D.22709 = type->type;
  t = (int) D.22709;
  handle_enum:
  switch (t) <default: <D.19431>, case 2: <D.19399>, case 3: <D.19405>, case 4: <D.19400>, case 5: <D.19401>, case 6: <D.19403>, case 7: <D.19404>, case 8: <D.19409>, case 9: <D.19410>, case 10: <D.19412>, case 11: <D.19413>, case 12: <D.19415>, case 13: <D.19417>, case 14: <D.19419>, case 15: <D.19425>, case 17: <D.19427>, case 18: <D.19421>, case 20: <D.19423>, case 21: <D.19430>, case 24: <D.19407>, case 25: <D.19408>, case 27: <D.19424>, case 28: <D.19422>, case 29: <D.19420>>
  <D.19399>:
  <D.19400>:
  <D.19401>:
  {
    guint8 * p;

    p = dest;
    if (value != 0B) goto <D.22711>; else goto <D.22712>;
    <D.22711>:
    iftmp.116 = MEM[(guint8 *)value];
    goto <D.22713>;
    <D.22712>:
    iftmp.116 = 0;
    <D.22713>:
    *p = iftmp.116;
    return;
  }
  <D.19403>:
  <D.19404>:
  <D.19405>:
  {
    guint16 * p;

    p = dest;
    if (value != 0B) goto <D.22715>; else goto <D.22716>;
    <D.22715>:
    iftmp.117 = MEM[(guint16 *)value];
    goto <D.22717>;
    <D.22716>:
    iftmp.117 = 0;
    <D.22717>:
    *p = iftmp.117;
    return;
  }
  <D.19407>:
  <D.19408>:
  <D.19409>:
  <D.19410>:
  {
    gint32 * p;

    p = dest;
    if (value != 0B) goto <D.22719>; else goto <D.22720>;
    <D.22719>:
    iftmp.118 = MEM[(gint32 *)value];
    goto <D.22721>;
    <D.22720>:
    iftmp.118 = 0;
    <D.22721>:
    *p = iftmp.118;
    return;
  }
  <D.19412>:
  <D.19413>:
  {
    gint64 * p;

    p = dest;
    if (value != 0B) goto <D.22723>; else goto <D.22724>;
    <D.22723>:
    iftmp.119 = MEM[(gint64 *)value];
    goto <D.22725>;
    <D.22724>:
    iftmp.119 = 0;
    <D.22725>:
    *p = iftmp.119;
    return;
  }
  <D.19415>:
  {
    float * p;

    p = dest;
    if (value != 0B) goto <D.22727>; else goto <D.22728>;
    <D.22727>:
    iftmp.120 = MEM[(float *)value];
    goto <D.22729>;
    <D.22728>:
    iftmp.120 = 0.0;
    <D.22729>:
    *p = iftmp.120;
    return;
  }
  <D.19417>:
  {
    double * p;

    p = dest;
    if (value != 0B) goto <D.22731>; else goto <D.22732>;
    <D.22731>:
    iftmp.121 = MEM[(double *)value];
    goto <D.22733>;
    <D.22732>:
    iftmp.121 = 0.0;
    <D.22733>:
    *p = iftmp.121;
    return;
  }
  <D.19419>:
  <D.19420>:
  <D.19421>:
  <D.19422>:
  <D.19423>:
  if (deref_pointer != 0) goto <D.22735>; else goto <D.22736>;
  <D.22735>:
  iftmp.122 = MEM[(void * *)value];
  goto <D.22737>;
  <D.22736>:
  iftmp.122 = value;
  <D.22737>:
  mono_gc_wbarrier_generic_store (dest, iftmp.122);
  return;
  <D.19424>:
  <D.19425>:
  {
    void * * p;

    p = dest;
    if (deref_pointer != 0) goto <D.22739>; else goto <D.22740>;
    <D.22739>:
    iftmp.123 = MEM[(void * *)value];
    goto <D.22741>;
    <D.22740>:
    iftmp.123 = value;
    <D.22741>:
    *p = iftmp.123;
    return;
  }
  <D.19427>:
  D.22709 = type->type;
  if (D.22709 == 17) goto <D.22743>; else goto <D.22742>;
  <D.22743>:
  D.22744 = type->data.klass;
  D.22745 = BIT_FIELD_REF <*D.22744, 8, 160>;
  D.22746 = D.22745 & 16;
  if (D.22746 != 0) goto <D.22747>; else goto <D.22742>;
  <D.22747>:
  D.22744 = type->data.klass;
  D.22748 = mono_class_enum_basetype (D.22744);
  D.22749 = D.22748->type;
  t = (int) D.22749;
  goto handle_enum;
  <D.22742>:
  {
    struct MonoClass * class;
    int size;

    class = mono_class_from_mono_type (type);
    size = mono_class_value_size (class, 0B);
    if (value == 0B) goto <D.22750>; else goto <D.22751>;
    <D.22750>:
    size.124 = (unsigned int) size;
    mono_gc_bzero_atomic (dest, size.124);
    goto <D.22753>;
    <D.22751>:
    mono_gc_wbarrier_value_copy (dest, value, 1, class);
    <D.22753>:
  }
  return;
  <D.19430>:
  D.22754 = type->data.generic_class;
  D.22755 = D.22754->container_class;
  D.22756 = D.22755->byval_arg.type;
  t = (int) D.22756;
  goto handle_enum;
  <D.19431>:
  D.22709 = type->type;
  D.22757 = (int) D.22709;
  monoeg_g_log (0B, 4, "got type %x", D.22757);
  <D.19432>:
  goto <D.19432>;
}


mono_field_static_set_value (struct MonoVTable * vt, struct MonoClassField * field, void * value)
{
  struct MonoType * D.22759;
  short unsigned int D.22760;
  int D.22761;
  int D.22762;
  int D.22765;
  int D.22768;
  struct MonoDomain * D.22771;
  union mono_mutex_t * D.22772;
  _Bool D.22775;
  long int D.22776;
  long int D.22777;
  struct GHashTable * D.22780;
  _Bool D.22783;
  long int D.22784;
  long int D.22785;
  unsigned int addr.125;
  void * D.22790;
  sizetype D.22791;
  void * dest;

  D.22759 = field->type;
  D.22760 = D.22759->attrs;
  D.22761 = (int) D.22760;
  D.22762 = D.22761 & 16;
  if (D.22762 == 0) goto <D.22763>; else goto <D.22764>;
  <D.22763>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "object.c", 3024, "field->type->attrs & FIELD_ATTRIBUTE_STATIC");
  return;
  <D.22764>:
  D.22759 = field->type;
  D.22760 = D.22759->attrs;
  D.22761 = (int) D.22760;
  D.22765 = D.22761 & 64;
  if (D.22765 != 0) goto <D.22766>; else goto <D.22767>;
  <D.22766>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "object.c", 3026, "!(field->type->attrs & FIELD_ATTRIBUTE_LITERAL)");
  return;
  <D.22767>:
  D.22768 = field->offset;
  if (D.22768 == -1) goto <D.22769>; else goto <D.22770>;
  <D.22769>:
  {
    void * addr;

    {
      int ret;

      D.22771 = vt->domain;
      D.22772 = &D.22771->lock.mutex;
      ret = pthread_mutex_lock (D.22772);
      if (ret != 0) goto <D.22773>; else goto <D.22774>;
      <D.22773>:
      monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
      <D.22774>:
      D.22775 = ret != 0;
      D.22776 = (long int) D.22775;
      D.22777 = __builtin_expect (D.22776, 0);
      if (D.22777 != 0) goto <D.22778>; else goto <D.22779>;
      <D.22778>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 3032, "ret == 0");
      <D.22779>:
    }
    D.22771 = vt->domain;
    D.22780 = D.22771->special_static_fields;
    addr = monoeg_g_hash_table_lookup (D.22780, field);
    {
      int ret;

      D.22771 = vt->domain;
      D.22772 = &D.22771->lock.mutex;
      ret = pthread_mutex_unlock (D.22772);
      if (ret != 0) goto <D.22781>; else goto <D.22782>;
      <D.22781>:
      monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
      <D.22782>:
      D.22783 = ret != 0;
      D.22784 = (long int) D.22783;
      D.22785 = __builtin_expect (D.22784, 0);
      if (D.22785 != 0) goto <D.22786>; else goto <D.22787>;
      <D.22786>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 3034, "ret == 0");
      <D.22787>:
    }
    addr.125 = (unsigned int) addr;
    dest = mono_get_special_static_data (addr.125);
  }
  goto <D.22789>;
  <D.22770>:
  D.22790 = mono_vtable_get_static_field_data (vt);
  D.22768 = field->offset;
  D.22791 = (sizetype) D.22768;
  dest = D.22790 + D.22791;
  <D.22789>:
  D.22759 = field->type;
  set_value (D.22759, dest, value, 0);
}


mono_vtable_get_static_field_data (struct MonoVTable * vt)
{
  unsigned char D.22793;
  unsigned char D.22794;
  void * D.22797;
  struct MonoClass * D.22798;
  int D.22799;

  D.22793 = BIT_FIELD_REF <*vt, 8, 184>;
  D.22794 = D.22793 & 8;
  if (D.22794 == 0) goto <D.22795>; else goto <D.22796>;
  <D.22795>:
  D.22797 = 0B;
  return D.22797;
  <D.22796>:
  D.22798 = vt->klass;
  D.22799 = D.22798->vtable_size;
  D.22797 = vt->vtable[D.22799];
  return D.22797;
}


mono_field_get_value (struct MonoObject * obj, struct MonoClassField * field, void * value)
{
  _Bool D.22801;
  long int D.22802;
  long int D.22803;
  struct MonoType * D.22806;
  short unsigned int D.22807;
  int D.22808;
  int D.22809;
  int D.22812;
  sizetype D.22813;
  void * src;

  D.22801 = obj == 0B;
  D.22802 = (long int) D.22801;
  D.22803 = __builtin_expect (D.22802, 0);
  if (D.22803 != 0) goto <D.22804>; else goto <D.22805>;
  <D.22804>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 3103, "obj");
  <D.22805>:
  D.22806 = field->type;
  D.22807 = D.22806->attrs;
  D.22808 = (int) D.22807;
  D.22809 = D.22808 & 16;
  if (D.22809 != 0) goto <D.22810>; else goto <D.22811>;
  <D.22810>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "object.c", 3105, "!(field->type->attrs & FIELD_ATTRIBUTE_STATIC)");
  return;
  <D.22811>:
  D.22812 = field->offset;
  D.22813 = (sizetype) D.22812;
  src = obj + D.22813;
  D.22806 = field->type;
  set_value (D.22806, value, src, 1);
}


mono_field_get_value_object (struct MonoDomain * domain, struct MonoClassField * field, struct MonoObject * obj)
{
  int D.22815;
  unsigned char D.22818;
  int D.22819;
  <unnamed-unsigned:1> D.22820;
  int D.22821;
  _Bool D.22822;
  struct MonoObject * D.22823;
  short unsigned int D.22824;
  int D.22825;
  int D.22826;
  int D.22829;
  struct MonoClass * D.22834;
  unsigned char D.22835;
  unsigned char D.22836;
  _Bool D.22840;
  long int D.22841;
  long int D.22842;
  struct MonoMethod * m.126;
  struct MonoClass * ptr_klass.129;
  struct MonoClass * tmp_klass.127;
  struct MonoImage * D.22863;
  struct MonoClass * tmp_klass.128;
  _Bool D.22865;
  long int D.22866;
  long int D.22867;
  struct MonoMethod * m.130;
  _Bool D.22871;
  long int D.22872;
  long int D.22873;
  void * * ptr.131;
  void * D.22883;
  struct MonoDomain * D.22884;
  struct MonoReflectionType * D.22885;
  int D.22886;
  guint8 * D.22889;
  struct MonoObject * o.132;
  struct MonoObject * o.133;
  struct MonoObject * o;
  struct MonoClass * klass;
  struct MonoVTable * vtable;
  gchar * v;
  gboolean is_static;
  gboolean is_ref;
  gboolean is_literal;
  gboolean is_ptr;
  struct MonoError error;
  struct MonoType * type;

  try
    {
      vtable = 0B;
      is_static = 0;
      is_ref = 0;
      is_literal = 0;
      is_ptr = 0;
      type = mono_field_get_type_checked (field, &error);
      D.22815 = mono_error_ok (&error);
      if (D.22815 == 0) goto <D.22816>; else goto <D.22817>;
      <D.22816>:
      mono_error_raise_exception (&error);
      <D.22817>:
      D.22818 = type->type;
      D.22819 = (int) D.22818;
      switch (D.22819) <default: <D.19504>, case 2: <D.19489>, case 3: <D.19492>, case 4: <D.19488>, case 5: <D.19487>, case 6: <D.19491>, case 7: <D.19490>, case 8: <D.19496>, case 9: <D.19495>, case 10: <D.19499>, case 11: <D.19498>, case 12: <D.19497>, case 13: <D.19500>, case 14: <D.19481>, case 15: <D.19503>, case 17: <D.19501>, case 18: <D.19483>, case 20: <D.19484>, case 21: <D.19502>, case 24: <D.19494>, case 25: <D.19493>, case 28: <D.19482>, case 29: <D.19485>>
      <D.19481>:
      <D.19482>:
      <D.19483>:
      <D.19484>:
      <D.19485>:
      is_ref = 1;
      goto <D.19486>;
      <D.19487>:
      <D.19488>:
      <D.19489>:
      <D.19490>:
      <D.19491>:
      <D.19492>:
      <D.19493>:
      <D.19494>:
      <D.19495>:
      <D.19496>:
      <D.19497>:
      <D.19498>:
      <D.19499>:
      <D.19500>:
      <D.19501>:
      D.22820 = type->byref;
      is_ref = (gboolean) D.22820;
      goto <D.19486>;
      <D.19502>:
      D.22821 = mono_type_generic_inst_is_valuetype (type);
      D.22822 = D.22821 == 0;
      is_ref = (gboolean) D.22822;
      goto <D.19486>;
      <D.19503>:
      is_ptr = 1;
      goto <D.19486>;
      <D.19504>:
      D.22818 = type->type;
      D.22819 = (int) D.22818;
      monoeg_g_log (0B, 4, "type 0x%x not handled in mono_field_get_value_object", D.22819);
      <D.19505>:
      goto <D.19505>;
      D.22823 = 0B;
      return D.22823;
      <D.19486>:
      D.22824 = type->attrs;
      D.22825 = (int) D.22824;
      D.22826 = D.22825 & 64;
      if (D.22826 != 0) goto <D.22827>; else goto <D.22828>;
      <D.22827>:
      is_literal = 1;
      <D.22828>:
      D.22824 = type->attrs;
      D.22825 = (int) D.22824;
      D.22829 = D.22825 & 16;
      if (D.22829 != 0) goto <D.22830>; else goto <D.22831>;
      <D.22830>:
      is_static = 1;
      if (is_literal == 0) goto <D.22832>; else goto <D.22833>;
      <D.22832>:
      D.22834 = field->parent;
      vtable = mono_class_vtable_full (domain, D.22834, 1);
      D.22835 = BIT_FIELD_REF <*vtable, 8, 184>;
      D.22836 = D.22835 & 2;
      if (D.22836 == 0) goto <D.22837>; else goto <D.22838>;
      <D.22837>:
      mono_runtime_class_init (vtable);
      <D.22838>:
      <D.22833>:
      goto <D.22839>;
      <D.22831>:
      D.22840 = obj == 0B;
      D.22841 = (long int) D.22840;
      D.22842 = __builtin_expect (D.22841, 0);
      if (D.22842 != 0) goto <D.22843>; else goto <D.22844>;
      <D.22843>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 3187, "obj");
      <D.22844>:
      <D.22839>:
      if (is_ref != 0) goto <D.22845>; else goto <D.22846>;
      <D.22845>:
      if (is_literal != 0) goto <D.22847>; else goto <D.22848>;
      <D.22847>:
      get_default_field_value (domain, field, &o);
      goto <D.22849>;
      <D.22848>:
      if (is_static != 0) goto <D.22850>; else goto <D.22851>;
      <D.22850>:
      mono_field_static_get_value (vtable, field, &o);
      goto <D.22852>;
      <D.22851>:
      mono_field_get_value (obj, field, &o);
      <D.22852>:
      <D.22849>:
      D.22823 = o;
      return D.22823;
      <D.22846>:
      if (is_ptr != 0) goto <D.22853>; else goto <D.22854>;
      <D.22853>:
      {
        static struct MonoMethod * m;
        void * args[2];
        void * * ptr;
        void * v;

        try
          {
            m.126 = m;
            if (m.126 == 0B) goto <D.22856>; else goto <D.22857>;
            <D.22856>:
            {
              struct MonoClass * ptr_klass;

              {
                static struct MonoClass * tmp_klass;

                {
                  tmp_klass.127 = tmp_klass;
                  if (tmp_klass.127 == 0B) goto <D.22859>; else goto <D.22860>;
                  <D.22859>:
                  if (0 != 0) goto <D.22861>; else goto <D.22862>;
                  <D.22861>:
                  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 3208, "mono_defaults.corlib == mono_defaults.corlib");
                  <D.22862>:
                  D.22863 = mono_defaults.corlib;
                  tmp_klass.128 = mono_class_from_name (D.22863, "System.Reflection", "Pointer");
                  tmp_klass = tmp_klass.128;
                  tmp_klass.127 = tmp_klass;
                  D.22865 = tmp_klass.127 == 0B;
                  D.22866 = (long int) D.22865;
                  D.22867 = __builtin_expect (D.22866, 0);
                  if (D.22867 != 0) goto <D.22868>; else goto <D.22869>;
                  <D.22868>:
                  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 3208, "tmp_klass");
                  <D.22869>:
                  <D.22860>:
                }
                ptr_klass.129 = tmp_klass;
              }
              ptr_klass = ptr_klass.129;
              m.130 = mono_class_get_method_from_name_flags (ptr_klass, "Box", 2, 16);
              m = m.130;
              m.126 = m;
              D.22871 = m.126 == 0B;
              D.22872 = (long int) D.22871;
              D.22873 = __builtin_expect (D.22872, 0);
              if (D.22873 != 0) goto <D.22874>; else goto <D.22875>;
              <D.22874>:
              monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 3210, "m");
              <D.22875>:
            }
            <D.22857>:
            v = &ptr;
            if (is_literal != 0) goto <D.22876>; else goto <D.22877>;
            <D.22876>:
            get_default_field_value (domain, field, v);
            goto <D.22878>;
            <D.22877>:
            if (is_static != 0) goto <D.22879>; else goto <D.22880>;
            <D.22879>:
            mono_field_static_get_value (vtable, field, v);
            goto <D.22881>;
            <D.22880>:
            mono_field_get_value (obj, field, v);
            <D.22881>:
            <D.22878>:
            ptr.131 = ptr;
            D.22883 = *ptr.131;
            args[0] = D.22883;
            D.22884 = mono_domain_get ();
            D.22885 = mono_type_get_object (D.22884, type);
            args[1] = D.22885;
            m.126 = m;
            D.22823 = mono_runtime_invoke (m.126, 0B, &args, 0B);
            return D.22823;
          }
        finally
          {
            args = {CLOBBER};
            ptr = {CLOBBER};
          }
      }
      <D.22854>:
      klass = mono_class_from_mono_type (type);
      D.22886 = mono_class_is_nullable (klass);
      if (D.22886 != 0) goto <D.22887>; else goto <D.22888>;
      <D.22887>:
      D.22889 = mono_field_get_addr (obj, vtable, field);
      D.22823 = mono_nullable_box (D.22889, klass);
      return D.22823;
      <D.22888>:
      o.132 = mono_object_new (domain, klass);
      o = o.132;
      o.133 = o;
      v = o.133 + 8;
      if (is_literal != 0) goto <D.22892>; else goto <D.22893>;
      <D.22892>:
      get_default_field_value (domain, field, v);
      goto <D.22894>;
      <D.22893>:
      if (is_static != 0) goto <D.22895>; else goto <D.22896>;
      <D.22895>:
      mono_field_static_get_value (vtable, field, v);
      goto <D.22897>;
      <D.22896>:
      mono_field_get_value (obj, field, v);
      <D.22897>:
      <D.22894>:
      D.22823 = o;
      return D.22823;
    }
  finally
    {
      o = {CLOBBER};
      error = {CLOBBER};
    }
}


mono_field_get_addr (struct MonoObject * obj, struct MonoVTable * vt, struct MonoClassField * field)
{
  struct MonoType * D.22901;
  short unsigned int D.22902;
  int D.22903;
  int D.22904;
  int D.22907;
  struct MonoDomain * D.22910;
  union mono_mutex_t * D.22911;
  _Bool D.22914;
  long int D.22915;
  long int D.22916;
  struct GHashTable * D.22919;
  _Bool D.22922;
  long int D.22923;
  long int D.22924;
  unsigned int addr.134;
  void * D.22929;
  sizetype D.22930;
  guint8 * D.22932;
  guint8 * src;

  D.22901 = field->type;
  D.22902 = D.22901->attrs;
  D.22903 = (int) D.22902;
  D.22904 = D.22903 & 16;
  if (D.22904 != 0) goto <D.22905>; else goto <D.22906>;
  <D.22905>:
  D.22907 = field->offset;
  if (D.22907 == -1) goto <D.22908>; else goto <D.22909>;
  <D.22908>:
  {
    void * addr;

    {
      int ret;

      D.22910 = vt->domain;
      D.22911 = &D.22910->lock.mutex;
      ret = pthread_mutex_lock (D.22911);
      if (ret != 0) goto <D.22912>; else goto <D.22913>;
      <D.22912>:
      monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
      <D.22913>:
      D.22914 = ret != 0;
      D.22915 = (long int) D.22914;
      D.22916 = __builtin_expect (D.22915, 0);
      if (D.22916 != 0) goto <D.22917>; else goto <D.22918>;
      <D.22917>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 3067, "ret == 0");
      <D.22918>:
    }
    D.22910 = vt->domain;
    D.22919 = D.22910->special_static_fields;
    addr = monoeg_g_hash_table_lookup (D.22919, field);
    {
      int ret;

      D.22910 = vt->domain;
      D.22911 = &D.22910->lock.mutex;
      ret = pthread_mutex_unlock (D.22911);
      if (ret != 0) goto <D.22920>; else goto <D.22921>;
      <D.22920>:
      monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
      <D.22921>:
      D.22922 = ret != 0;
      D.22923 = (long int) D.22922;
      D.22924 = __builtin_expect (D.22923, 0);
      if (D.22924 != 0) goto <D.22925>; else goto <D.22926>;
      <D.22925>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 3069, "ret == 0");
      <D.22926>:
    }
    addr.134 = (unsigned int) addr;
    src = mono_get_special_static_data (addr.134);
  }
  goto <D.22928>;
  <D.22909>:
  D.22929 = mono_vtable_get_static_field_data (vt);
  D.22907 = field->offset;
  D.22930 = (sizetype) D.22907;
  src = D.22929 + D.22930;
  <D.22928>:
  goto <D.22931>;
  <D.22906>:
  D.22907 = field->offset;
  D.22930 = (sizetype) D.22907;
  src = obj + D.22930;
  <D.22931>:
  D.22932 = src;
  return D.22932;
}


get_default_field_value (struct MonoDomain * domain, struct MonoClassField * field, void * value)
{
  <unnamed type> def_type.135;
  MonoTypeEnum def_type;
  const char * data;

  try
    {
      data = mono_class_get_field_default_value (field, &def_type);
      def_type.135 = def_type;
      mono_get_constant_value_from_blob (domain, def_type.135, data, value);
    }
  finally
    {
      def_type = {CLOBBER};
    }
}


mono_get_constant_value_from_blob (struct MonoDomain * domain, MonoTypeEnum type, const char * blob, void * value)
{
  const char * p.136;
  char D.22936;
  unsigned char D.22937;
  short unsigned int D.22938;
  unsigned int D.22939;
  long long unsigned int D.22940;
  float D.22941;
  double D.22942;
  struct MonoString * D.22943;
  int D.22944;
  int retval;
  const char * p;

  try
    {
      retval = 0;
      p = blob;
      p.136 = p;
      mono_metadata_decode_blob_size (p.136, &p);
      switch (type) <default: <D.19538>, case 2: <D.19521>, case 3: <D.19525>, case 4: <D.19523>, case 5: <D.19522>, case 6: <D.19527>, case 7: <D.19526>, case 8: <D.19529>, case 9: <D.19528>, case 10: <D.19531>, case 11: <D.19530>, case 12: <D.19532>, case 13: <D.19534>, case 14: <D.19536>, case 18: <D.19537>>
      <D.19521>:
      <D.19522>:
      <D.19523>:
      p.136 = p;
      D.22936 = *p.136;
      D.22937 = (unsigned char) D.22936;
      MEM[(guint8 *)value] = D.22937;
      goto <D.19524>;
      <D.19525>:
      <D.19526>:
      <D.19527>:
      p.136 = p;
      D.22938 = MEM[(const guint16 *)p.136];
      MEM[(guint16 *)value] = D.22938;
      goto <D.19524>;
      <D.19528>:
      <D.19529>:
      p.136 = p;
      D.22939 = MEM[(const guint32 *)p.136];
      MEM[(guint32 *)value] = D.22939;
      goto <D.19524>;
      <D.19530>:
      <D.19531>:
      p.136 = p;
      D.22940 = MEM[(const guint64 *)p.136];
      MEM[(guint64 *)value] = D.22940;
      goto <D.19524>;
      <D.19532>:
      {
        union mono_rfloat mf;

        try
          {
            p.136 = p;
            D.22939 = MEM[(const guint32 *)p.136];
            mf.ival = D.22939;
            D.22941 = mf.fval;
            MEM[(float *)value] = D.22941;
          }
        finally
          {
            mf = {CLOBBER};
          }
      }
      goto <D.19524>;
      <D.19534>:
      {
        union mono_rdouble mf;

        try
          {
            p.136 = p;
            D.22940 = MEM[(const guint64 *)p.136];
            mf.ival = D.22940;
            D.22942 = mf.fval;
            MEM[(double *)value] = D.22942;
          }
        finally
          {
            mf = {CLOBBER};
          }
      }
      goto <D.19524>;
      <D.19536>:
      D.22943 = mono_ldstr_metadata_sig (domain, blob);
      MEM[(void * *)value] = D.22943;
      goto <D.19524>;
      <D.19537>:
      MEM[(void * *)value] = 0B;
      goto <D.19524>;
      <D.19538>:
      retval = -1;
      monoeg_g_log (0B, 16, "type 0x%02x should not be in constant table", type);
      <D.19524>:
      D.22944 = retval;
      return D.22944;
    }
  finally
    {
      p = {CLOBBER};
    }
}


mono_ldstr_metadata_sig (struct MonoDomain * domain, const char * sig)
{
  const char * str.137;
  int len2.138;
  _Bool D.22951;
  long int D.22952;
  long int D.22953;
  struct MonoGHashTable * D.22956;
  _Bool D.22961;
  long int D.22962;
  long int D.22963;
  struct MonoString * D.22966;
  _Bool D.22971;
  long int D.22972;
  long int D.22973;
  const char * str;
  struct MonoString * o;
  struct MonoString * interned;
  size_t len2;

  try
    {
      str = sig;
      str.137 = str;
      len2 = mono_metadata_decode_blob_size (str.137, &str);
      len2 = len2 >> 1;
      len2.138 = (int) len2;
      str.137 = str;
      o = mono_string_new_utf16 (domain, str.137, len2.138);
      {
        int ret;

        ret = pthread_mutex_lock (&ldstr_section.mutex);
        if (ret != 0) goto <D.22949>; else goto <D.22950>;
        <D.22949>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
        <D.22950>:
        D.22951 = ret != 0;
        D.22952 = (long int) D.22951;
        D.22953 = __builtin_expect (D.22952, 0);
        if (D.22953 != 0) goto <D.22954>; else goto <D.22955>;
        <D.22954>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 5487, "ret == 0");
        <D.22955>:
      }
      D.22956 = domain->ldstr_table;
      interned = mono_g_hash_table_lookup (D.22956, o);
      if (interned != 0B) goto <D.22957>; else goto <D.22958>;
      <D.22957>:
      {
        int ret;

        ret = pthread_mutex_unlock (&ldstr_section.mutex);
        if (ret != 0) goto <D.22959>; else goto <D.22960>;
        <D.22959>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.22960>:
        D.22961 = ret != 0;
        D.22962 = (long int) D.22961;
        D.22963 = __builtin_expect (D.22962, 0);
        if (D.22963 != 0) goto <D.22964>; else goto <D.22965>;
        <D.22964>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 5489, "ret == 0");
        <D.22965>:
      }
      D.22966 = interned;
      return D.22966;
      <D.22958>:
      o = mono_string_get_pinned (o);
      if (o != 0B) goto <D.22967>; else goto <D.22968>;
      <D.22967>:
      D.22956 = domain->ldstr_table;
      mono_g_hash_table_insert (D.22956, o, o);
      <D.22968>:
      {
        int ret;

        ret = pthread_mutex_unlock (&ldstr_section.mutex);
        if (ret != 0) goto <D.22969>; else goto <D.22970>;
        <D.22969>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.22970>:
        D.22971 = ret != 0;
        D.22972 = (long int) D.22971;
        D.22973 = __builtin_expect (D.22972, 0);
        if (D.22973 != 0) goto <D.22974>; else goto <D.22975>;
        <D.22974>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 5497, "ret == 0");
        <D.22975>:
      }
      D.22966 = o;
      return D.22966;
    }
  finally
    {
      str = {CLOBBER};
    }
}


mono_string_get_pinned (struct MonoString * str)
{
  int D.22978;
  int D.22979;
  int D.22980;
  unsigned int D.22981;
  unsigned int D.22982;
  unsigned int size.139;
  struct MonoVTable * D.22984;
  int D.22987;
  int D.22988;
  unsigned int D.22989;
  mono_unichar2 * D.22990;
  mono_unichar2 * D.22991;
  int D.22992;
  struct MonoString * D.22993;
  int size;
  struct MonoString * news;

  D.22978 = mono_string_length (str);
  D.22979 = D.22978 + 1;
  D.22980 = D.22979 * 2;
  D.22981 = (unsigned int) D.22980;
  D.22982 = D.22981 + 12;
  size = (int) D.22982;
  size.139 = (unsigned int) size;
  D.22984 = MEM[(struct MonoObject *)str].vtable;
  news = mono_gc_alloc_pinned_obj (D.22984, size.139);
  if (news != 0B) goto <D.22985>; else goto <D.22986>;
  <D.22985>:
  D.22987 = mono_string_length (str);
  D.22988 = D.22987 * 2;
  D.22989 = (unsigned int) D.22988;
  D.22990 = mono_string_chars (str);
  D.22991 = mono_string_chars (news);
  memcpy (D.22991, D.22990, D.22989);
  D.22992 = mono_string_length (str);
  news->length = D.22992;
  <D.22986>:
  D.22993 = news;
  return D.22993;
}


mono_field_static_get_value_for_thread (struct MonoInternalThread * thread, struct MonoVTable * vt, struct MonoClassField * field, void * value)
{
  struct MonoType * D.22995;
  short unsigned int D.22996;
  int D.22997;
  int D.22998;
  int D.23001;
  struct MonoDomain * D.23004;
  int D.23005;
  struct GHashTable * D.23008;
  unsigned int addr.140;
  void * D.23011;
  sizetype D.23012;
  void * src;

  D.22995 = field->type;
  D.22996 = D.22995->attrs;
  D.22997 = (int) D.22996;
  D.22998 = D.22997 & 16;
  if (D.22998 == 0) goto <D.22999>; else goto <D.23000>;
  <D.22999>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "object.c", 3309, "field->type->attrs & FIELD_ATTRIBUTE_STATIC");
  return;
  <D.23000>:
  D.22995 = field->type;
  D.22996 = D.22995->attrs;
  D.22997 = (int) D.22996;
  D.23001 = D.22997 & 64;
  if (D.23001 != 0) goto <D.23002>; else goto <D.23003>;
  <D.23002>:
  D.23004 = vt->domain;
  get_default_field_value (D.23004, field, value);
  return;
  <D.23003>:
  D.23005 = field->offset;
  if (D.23005 == -1) goto <D.23006>; else goto <D.23007>;
  <D.23006>:
  {
    void * addr;

    D.23004 = vt->domain;
    D.23008 = D.23004->special_static_fields;
    addr = monoeg_g_hash_table_lookup (D.23008, field);
    addr.140 = (unsigned int) addr;
    src = mono_get_special_static_data_for_thread (thread, addr.140);
  }
  goto <D.23010>;
  <D.23007>:
  D.23011 = mono_vtable_get_static_field_data (vt);
  D.23005 = field->offset;
  D.23012 = (sizetype) D.23005;
  src = D.23011 + D.23012;
  <D.23010>:
  D.22995 = field->type;
  set_value (D.22995, value, src, 1);
}


mono_field_static_get_value (struct MonoVTable * vt, struct MonoClassField * field, void * value)
{
  struct MonoInternalThread * D.23014;

  D.23014 = mono_thread_internal_current ();
  mono_field_static_get_value_for_thread (D.23014, vt, field, value);
  return;
}


mono_property_set_value (struct MonoProperty * prop, void * obj, void * * params, struct MonoObject * * exc)
{
  struct MonoObject * (*<T11c7>) (struct MonoMethod *, void *, void * *, struct MonoObject * *) default_mono_runtime_invoke.141;
  struct MonoMethod * D.23017;

  default_mono_runtime_invoke.141 = default_mono_runtime_invoke;
  D.23017 = prop->set;
  default_mono_runtime_invoke.141 (D.23017, obj, params, exc);
}


mono_property_get_value (struct MonoProperty * prop, void * obj, void * * params, struct MonoObject * * exc)
{
  struct MonoObject * D.23018;
  struct MonoObject * (*<T11c7>) (struct MonoMethod *, void *, void * *, struct MonoObject * *) default_mono_runtime_invoke.142;
  struct MonoMethod * D.23020;

  default_mono_runtime_invoke.142 = default_mono_runtime_invoke;
  D.23020 = prop->get;
  D.23018 = default_mono_runtime_invoke.142 (D.23020, obj, params, exc);
  return D.23018;
}


mono_nullable_init (guint8 * buf, struct MonoObject * value, struct MonoClass * klass)
{
  unsigned char D.23022;
  unsigned char D.23023;
  _Bool D.23024;
  long int D.23025;
  long int D.23026;
  struct MonoClassField * D.23029;
  struct MonoType * D.23030;
  struct MonoClass * D.23031;
  _Bool D.23032;
  long int D.23033;
  long int D.23034;
  struct MonoClassField * D.23037;
  struct MonoType * D.23038;
  struct MonoClass * D.23039;
  struct MonoClass * D.23040;
  _Bool D.23041;
  long int D.23042;
  long int D.23043;
  int D.23046;
  sizetype D.23047;
  sizetype D.23048;
  guint8 * D.23049;
  _Bool D.23050;
  unsigned char D.23051;
  unsigned char D.23054;
  unsigned char D.23055;
  void * D.23058;
  int D.23059;
  sizetype D.23060;
  sizetype D.23061;
  guint8 * D.23062;
  int D.23064;
  unsigned int D.23065;
  void * D.23066;
  int D.23068;
  unsigned int D.23069;
  struct MonoClass * param_class;

  param_class = klass->cast_class;
  mono_class_setup_fields_locking (klass);
  D.23022 = BIT_FIELD_REF <*klass, 8, 192>;
  D.23023 = D.23022 & 32;
  D.23024 = D.23023 == 0;
  D.23025 = (long int) D.23024;
  D.23026 = __builtin_expect (D.23025, 0);
  if (D.23026 != 0) goto <D.23027>; else goto <D.23028>;
  <D.23027>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 3412, "klass->fields_inited");
  <D.23028>:
  D.23029 = klass->fields;
  D.23030 = D.23029->type;
  D.23031 = mono_class_from_mono_type (D.23030);
  D.23032 = D.23031 != param_class;
  D.23033 = (long int) D.23032;
  D.23034 = __builtin_expect (D.23033, 0);
  if (D.23034 != 0) goto <D.23035>; else goto <D.23036>;
  <D.23035>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 3414, "mono_class_from_mono_type (klass->fields [0].type) == param_class");
  <D.23036>:
  D.23029 = klass->fields;
  D.23037 = D.23029 + 16;
  D.23038 = D.23037->type;
  D.23039 = mono_class_from_mono_type (D.23038);
  D.23040 = mono_defaults.boolean_class;
  D.23041 = D.23039 != D.23040;
  D.23042 = (long int) D.23041;
  D.23043 = __builtin_expect (D.23042, 0);
  if (D.23043 != 0) goto <D.23044>; else goto <D.23045>;
  <D.23044>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 3415, "mono_class_from_mono_type (klass->fields [1].type) == mono_defaults.boolean_class");
  <D.23045>:
  D.23029 = klass->fields;
  D.23037 = D.23029 + 16;
  D.23046 = D.23037->offset;
  D.23047 = (sizetype) D.23046;
  D.23048 = D.23047 + 4294967288;
  D.23049 = buf + D.23048;
  D.23050 = value != 0B;
  D.23051 = (unsigned char) D.23050;
  *D.23049 = D.23051;
  if (value != 0B) goto <D.23052>; else goto <D.23053>;
  <D.23052>:
  D.23054 = BIT_FIELD_REF <*param_class, 8, 184>;
  D.23055 = D.23054 & 8;
  if (D.23055 != 0) goto <D.23056>; else goto <D.23057>;
  <D.23056>:
  D.23058 = mono_object_unbox (value);
  D.23029 = klass->fields;
  D.23059 = D.23029->offset;
  D.23060 = (sizetype) D.23059;
  D.23061 = D.23060 + 4294967288;
  D.23062 = buf + D.23061;
  mono_gc_wbarrier_value_copy (D.23062, D.23058, 1, param_class);
  goto <D.23063>;
  <D.23057>:
  D.23064 = mono_class_value_size (param_class, 0B);
  D.23065 = (unsigned int) D.23064;
  D.23066 = mono_object_unbox (value);
  D.23029 = klass->fields;
  D.23059 = D.23029->offset;
  D.23060 = (sizetype) D.23059;
  D.23061 = D.23060 + 4294967288;
  D.23062 = buf + D.23061;
  mono_gc_memmove_atomic (D.23062, D.23066, D.23065);
  <D.23063>:
  goto <D.23067>;
  <D.23053>:
  D.23068 = mono_class_value_size (param_class, 0B);
  D.23069 = (unsigned int) D.23068;
  D.23029 = klass->fields;
  D.23059 = D.23029->offset;
  D.23060 = (sizetype) D.23059;
  D.23061 = D.23060 + 4294967288;
  D.23062 = buf + D.23061;
  mono_gc_bzero_atomic (D.23062, D.23069);
  <D.23067>:
}


mono_nullable_box (guint8 * buf, struct MonoClass * klass)
{
  unsigned char D.23070;
  unsigned char D.23071;
  _Bool D.23072;
  long int D.23073;
  long int D.23074;
  struct MonoClassField * D.23077;
  struct MonoType * D.23078;
  struct MonoClass * D.23079;
  _Bool D.23080;
  long int D.23081;
  long int D.23082;
  struct MonoClassField * D.23085;
  struct MonoType * D.23086;
  struct MonoClass * D.23087;
  struct MonoClass * D.23088;
  _Bool D.23089;
  long int D.23090;
  long int D.23091;
  int D.23094;
  sizetype D.23095;
  sizetype D.23096;
  guint8 * D.23097;
  unsigned char D.23098;
  struct MonoDomain * D.23101;
  unsigned char D.23102;
  unsigned char D.23103;
  int D.23106;
  sizetype D.23107;
  sizetype D.23108;
  guint8 * D.23109;
  void * D.23110;
  int D.23112;
  unsigned int D.23113;
  void * D.23114;
  struct MonoObject * D.23115;
  struct MonoClass * param_class;

  param_class = klass->cast_class;
  mono_class_setup_fields_locking (klass);
  D.23070 = BIT_FIELD_REF <*klass, 8, 192>;
  D.23071 = D.23070 & 32;
  D.23072 = D.23071 == 0;
  D.23073 = (long int) D.23072;
  D.23074 = __builtin_expect (D.23073, 0);
  if (D.23074 != 0) goto <D.23075>; else goto <D.23076>;
  <D.23075>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 3442, "klass->fields_inited");
  <D.23076>:
  D.23077 = klass->fields;
  D.23078 = D.23077->type;
  D.23079 = mono_class_from_mono_type (D.23078);
  D.23080 = D.23079 != param_class;
  D.23081 = (long int) D.23080;
  D.23082 = __builtin_expect (D.23081, 0);
  if (D.23082 != 0) goto <D.23083>; else goto <D.23084>;
  <D.23083>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 3444, "mono_class_from_mono_type (klass->fields [0].type) == param_class");
  <D.23084>:
  D.23077 = klass->fields;
  D.23085 = D.23077 + 16;
  D.23086 = D.23085->type;
  D.23087 = mono_class_from_mono_type (D.23086);
  D.23088 = mono_defaults.boolean_class;
  D.23089 = D.23087 != D.23088;
  D.23090 = (long int) D.23089;
  D.23091 = __builtin_expect (D.23090, 0);
  if (D.23091 != 0) goto <D.23092>; else goto <D.23093>;
  <D.23092>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 3445, "mono_class_from_mono_type (klass->fields [1].type) == mono_defaults.boolean_class");
  <D.23093>:
  D.23077 = klass->fields;
  D.23085 = D.23077 + 16;
  D.23094 = D.23085->offset;
  D.23095 = (sizetype) D.23094;
  D.23096 = D.23095 + 4294967288;
  D.23097 = buf + D.23096;
  D.23098 = *D.23097;
  if (D.23098 != 0) goto <D.23099>; else goto <D.23100>;
  <D.23099>:
  {
    struct MonoObject * o;

    D.23101 = mono_domain_get ();
    o = mono_object_new (D.23101, param_class);
    D.23102 = BIT_FIELD_REF <*param_class, 8, 184>;
    D.23103 = D.23102 & 8;
    if (D.23103 != 0) goto <D.23104>; else goto <D.23105>;
    <D.23104>:
    D.23077 = klass->fields;
    D.23106 = D.23077->offset;
    D.23107 = (sizetype) D.23106;
    D.23108 = D.23107 + 4294967288;
    D.23109 = buf + D.23108;
    D.23110 = mono_object_unbox (o);
    mono_gc_wbarrier_value_copy (D.23110, D.23109, 1, param_class);
    goto <D.23111>;
    <D.23105>:
    D.23112 = mono_class_value_size (param_class, 0B);
    D.23113 = (unsigned int) D.23112;
    D.23077 = klass->fields;
    D.23106 = D.23077->offset;
    D.23107 = (sizetype) D.23106;
    D.23108 = D.23107 + 4294967288;
    D.23109 = buf + D.23108;
    D.23114 = mono_object_unbox (o);
    mono_gc_memmove_atomic (D.23114, D.23109, D.23113);
    <D.23111>:
    D.23115 = o;
    return D.23115;
  }
  <D.23100>:
  D.23115 = 0B;
  return D.23115;
}


mono_get_delegate_invoke (struct MonoClass * klass)
{
  unsigned char D.23117;
  struct MonoMethod * D.23120;
  struct MonoMethod * im;

  mono_class_setup_methods (klass);
  D.23117 = klass->exception_type;
  if (D.23117 != 0) goto <D.23118>; else goto <D.23119>;
  <D.23118>:
  D.23120 = 0B;
  return D.23120;
  <D.23119>:
  im = mono_class_get_method_from_name (klass, "Invoke", -1);
  D.23120 = im;
  return D.23120;
}


mono_get_delegate_begin_invoke (struct MonoClass * klass)
{
  unsigned char D.23122;
  struct MonoMethod * D.23125;
  struct MonoMethod * im;

  mono_class_setup_methods (klass);
  D.23122 = klass->exception_type;
  if (D.23122 != 0) goto <D.23123>; else goto <D.23124>;
  <D.23123>:
  D.23125 = 0B;
  return D.23125;
  <D.23124>:
  im = mono_class_get_method_from_name (klass, "BeginInvoke", -1);
  D.23125 = im;
  return D.23125;
}


mono_get_delegate_end_invoke (struct MonoClass * klass)
{
  unsigned char D.23127;
  struct MonoMethod * D.23130;
  struct MonoMethod * im;

  mono_class_setup_methods (klass);
  D.23127 = klass->exception_type;
  if (D.23127 != 0) goto <D.23128>; else goto <D.23129>;
  <D.23128>:
  D.23130 = 0B;
  return D.23130;
  <D.23129>:
  im = mono_class_get_method_from_name (klass, "EndInvoke", -1);
  D.23130 = im;
  return D.23130;
}


mono_runtime_delegate_invoke (struct MonoObject * delegate, void * * params, struct MonoObject * * exc)
{
  struct MonoVTable * D.23132;
  char * D.23135;
  struct MonoObject * D.23136;
  struct MonoMethod * im;
  struct MonoClass * klass;

  D.23132 = delegate->vtable;
  klass = D.23132->klass;
  im = mono_get_delegate_invoke (klass);
  if (im == 0B) goto <D.23133>; else goto <D.23134>;
  <D.23133>:
  D.23135 = mono_type_get_full_name (klass);
  monoeg_g_log (0B, 4, "Could not lookup delegate invoke method for delegate %s", D.23135);
  <D.19602>:
  goto <D.19602>;
  <D.23134>:
  D.23136 = mono_runtime_invoke (im, delegate, params, exc);
  return D.23136;
}


mono_runtime_get_main_args ()
{
  char * * main_args.143;
  struct MonoArray * D.23141;
  int num_main_args.144;
  unsigned int num_main_args.145;
  struct MonoClass * D.23144;
  unsigned int i.146;
  unsigned int i.147;
  unsigned int D.23147;
  char * * D.23148;
  char * D.23149;
  struct MonoString * D.23150;
  struct MonoArray * res;
  int i;
  struct MonoDomain * domain;

  domain = mono_domain_get ();
  main_args.143 = main_args;
  if (main_args.143 == 0B) goto <D.23139>; else goto <D.23140>;
  <D.23139>:
  D.23141 = 0B;
  return D.23141;
  <D.23140>:
  num_main_args.144 = num_main_args;
  num_main_args.145 = (unsigned int) num_main_args.144;
  D.23144 = mono_defaults.string_class;
  res = mono_array_new (domain, D.23144, num_main_args.145);
  i = 0;
  goto <D.19613>;
  <D.19612>:
  {
    void * * __p;

    i.146 = (unsigned int) i;
    __p = mono_array_addr_with_size (res, 4, i.146);
    main_args.143 = main_args;
    i.147 = (unsigned int) i;
    D.23147 = i.147 * 4;
    D.23148 = main_args.143 + D.23147;
    D.23149 = *D.23148;
    D.23150 = mono_string_new (domain, D.23149);
    mono_gc_wbarrier_set_arrayref (res, __p, D.23150);
  }
  i = i + 1;
  <D.19613>:
  num_main_args.144 = num_main_args;
  if (i < num_main_args.144) goto <D.19612>; else goto <D.19614>;
  <D.19614>:
  D.23141 = res;
  return D.23141;
}


mono_runtime_run_main (struct MonoMethod * method, int argc, char * * argv, struct MonoObject * * exc)
{
  _Bool D.23152;
  long int D.23153;
  long int D.23154;
  struct MonoThread * D.23157;
  unsigned int argc.148;
  unsigned int D.23159;
  void * main_args.149;
  char * D.23161;
  int D.23162;
  struct MonoClass * D.23165;
  struct MonoImage * D.23166;
  struct MonoAssembly * D.23167;
  char * D.23168;
  char * * main_args.150;
  unsigned int i.151;
  unsigned int D.23176;
  char * * D.23177;
  char * D.23178;
  char * * D.23181;
  short unsigned int D.23184;
  unsigned int argc.152;
  struct MonoClass * D.23188;
  unsigned int i.153;
  int D.23191;
  int i;
  struct MonoArray * args;
  struct MonoDomain * domain;
  gchar * utf8_fullpath;
  struct MonoMethodSignature * sig;

  args = 0B;
  domain = mono_domain_get ();
  D.23152 = method == 0B;
  D.23153 = (long int) D.23152;
  D.23154 = __builtin_expect (D.23153, 0);
  if (D.23154 != 0) goto <D.23155>; else goto <D.23156>;
  <D.23155>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 3601, "method != NULL");
  <D.23156>:
  D.23157 = mono_thread_current ();
  mono_thread_set_main (D.23157);
  argc.148 = (unsigned int) argc;
  D.23159 = argc.148 * 4;
  main_args.149 = monoeg_malloc0 (D.23159);
  main_args = main_args.149;
  num_main_args = argc;
  D.23161 = *argv;
  D.23162 = monoeg_g_path_is_absolute (D.23161);
  if (D.23162 == 0) goto <D.23163>; else goto <D.23164>;
  <D.23163>:
  {
    gchar * basename;
    gchar * fullpath;

    D.23161 = *argv;
    basename = monoeg_g_path_get_basename (D.23161);
    D.23165 = method->klass;
    D.23166 = D.23165->image;
    D.23167 = D.23166->assembly;
    D.23168 = D.23167->basedir;
    fullpath = monoeg_g_build_path ("/", D.23168, basename, 0B);
    utf8_fullpath = mono_utf8_from_external (fullpath);
    if (utf8_fullpath == 0B) goto <D.23169>; else goto <D.23170>;
    <D.23169>:
    monoeg_g_print ("\nCannot determine the text encoding for the assembly location: %s\n", fullpath);
    monoeg_g_print ("Please add the correct encoding to MONO_EXTERNAL_ENCODINGS and try again.\n");
    exit (-1);
    <D.23170>:
    monoeg_g_free (fullpath);
    monoeg_g_free (basename);
  }
  goto <D.23171>;
  <D.23164>:
  D.23161 = *argv;
  utf8_fullpath = mono_utf8_from_external (D.23161);
  if (utf8_fullpath == 0B) goto <D.23172>; else goto <D.23173>;
  <D.23172>:
  D.23161 = *argv;
  monoeg_g_print ("\nCannot determine the text encoding for the assembly location: %s\n", D.23161);
  monoeg_g_print ("Please add the correct encoding to MONO_EXTERNAL_ENCODINGS and try again.\n");
  exit (-1);
  <D.23173>:
  <D.23171>:
  main_args.150 = main_args;
  *main_args.150 = utf8_fullpath;
  i = 1;
  goto <D.19637>;
  <D.19636>:
  {
    gchar * utf8_arg;

    i.151 = (unsigned int) i;
    D.23176 = i.151 * 4;
    D.23177 = argv + D.23176;
    D.23178 = *D.23177;
    utf8_arg = mono_utf8_from_external (D.23178);
    if (utf8_arg == 0B) goto <D.23179>; else goto <D.23180>;
    <D.23179>:
    i.151 = (unsigned int) i;
    D.23176 = i.151 * 4;
    D.23177 = argv + D.23176;
    D.23178 = *D.23177;
    monoeg_g_print ("\nCannot determine the text encoding for argument %d (%s).\n", i, D.23178);
    monoeg_g_print ("Please add the correct encoding to MONO_EXTERNAL_ENCODINGS and try again.\n");
    exit (-1);
    <D.23180>:
    main_args.150 = main_args;
    i.151 = (unsigned int) i;
    D.23176 = i.151 * 4;
    D.23181 = main_args.150 + D.23176;
    *D.23181 = utf8_arg;
  }
  i = i + 1;
  <D.19637>:
  if (i < argc) goto <D.19636>; else goto <D.19638>;
  <D.19638>:
  argc = argc + -1;
  argv = argv + 4;
  sig = mono_method_signature (method);
  if (sig == 0B) goto <D.23182>; else goto <D.23183>;
  <D.23182>:
  monoeg_g_print ("Unable to load Main method.\n");
  exit (-1);
  <D.23183>:
  D.23184 = sig->param_count;
  if (D.23184 != 0) goto <D.23185>; else goto <D.23186>;
  <D.23185>:
  argc.152 = (unsigned int) argc;
  D.23188 = mono_defaults.string_class;
  args = mono_array_new (domain, D.23188, argc.152);
  i = 0;
  goto <D.19643>;
  <D.19642>:
  {
    gchar * str;
    struct MonoString * arg;

    i.151 = (unsigned int) i;
    D.23176 = i.151 * 4;
    D.23177 = argv + D.23176;
    D.23178 = *D.23177;
    str = mono_utf8_from_external (D.23178);
    arg = mono_string_new (domain, str);
    {
      void * * __p;

      i.153 = (unsigned int) i;
      __p = mono_array_addr_with_size (args, 4, i.153);
      mono_gc_wbarrier_set_arrayref (args, __p, arg);
    }
    monoeg_g_free (str);
  }
  i = i + 1;
  <D.19643>:
  if (i < argc) goto <D.19642>; else goto <D.19644>;
  <D.19644>:
  goto <D.23190>;
  <D.23186>:
  D.23188 = mono_defaults.string_class;
  args = mono_array_new (domain, D.23188, 0);
  <D.23190>:
  D.23165 = method->klass;
  D.23166 = D.23165->image;
  D.23167 = D.23166->assembly;
  mono_assembly_set_main (D.23167);
  D.23191 = mono_runtime_exec_main (method, args, exc);
  return D.23191;
}


mono_object_xdomain_representation (struct MonoObject * obj, struct MonoDomain * target_domain, struct MonoObject * * exc)
{
  struct MonoVTable * D.23193;
  struct MonoClass * D.23194;
  unsigned char D.23195;
  unsigned char D.23196;
  struct MonoDomain * D.23200;
  int failure.154;
  struct MonoObject * D.23206;
  struct MonoObject * deserialized;
  gboolean failure;

  try
    {
      deserialized = 0B;
      failure = 0;
      *exc = 0B;
      D.23193 = obj->vtable;
      D.23194 = D.23193->klass;
      D.23195 = BIT_FIELD_REF <*D.23194, 8, 176>;
      D.23196 = D.23195 & 64;
      if (D.23196 != 0) goto <D.23197>; else goto <D.23198>;
      <D.23197>:
      deserialized = make_transparent_proxy (obj, &failure, exc);
      goto <D.23199>;
      <D.23198>:
      {
        struct MonoDomain * domain;
        struct MonoObject * serialized;

        domain = mono_domain_get ();
        D.23193 = obj->vtable;
        D.23200 = D.23193->domain;
        mono_domain_set_internal_with_options (D.23200, 0);
        serialized = serialize_object (obj, &failure, exc);
        mono_domain_set_internal_with_options (target_domain, 0);
        failure.154 = failure;
        if (failure.154 == 0) goto <D.23202>; else goto <D.23203>;
        <D.23202>:
        deserialized = deserialize_object (serialized, &failure, exc);
        <D.23203>:
        if (domain != target_domain) goto <D.23204>; else goto <D.23205>;
        <D.23204>:
        mono_domain_set_internal_with_options (domain, 0);
        <D.23205>:
      }
      <D.23199>:
      D.23206 = deserialized;
      return D.23206;
    }
  finally
    {
      failure = {CLOBBER};
    }
}


make_transparent_proxy (struct MonoObject * obj, gboolean * failure, struct MonoObject * * exc)
{
  struct MonoMethod * get_proxy_method.155;
  struct MonoClass * D.23212;
  struct MonoMethod * get_proxy_method.156;
  struct MonoVTable * D.23214;
  struct MonoClass * D.23215;
  unsigned char D.23216;
  unsigned char D.23217;
  _Bool D.23218;
  long int D.23219;
  long int D.23220;
  struct MonoType * D.23223;
  struct MonoReflectionType * * D.23224;
  struct MonoObject * * D.23225;
  struct MonoObject * D.23226;
  struct MonoObject * D.23229;
  static struct MonoMethod * get_proxy_method;
  struct MonoDomain * domain;
  struct MonoRealProxy * real_proxy;
  struct MonoReflectionType * reflection_type;
  struct MonoTransparentProxy * transparent_proxy;

  domain = mono_domain_get ();
  get_proxy_method.155 = get_proxy_method;
  if (get_proxy_method.155 == 0B) goto <D.23210>; else goto <D.23211>;
  <D.23210>:
  D.23212 = mono_defaults.real_proxy_class;
  get_proxy_method.156 = mono_class_get_method_from_name (D.23212, "GetTransparentProxy", 0);
  get_proxy_method = get_proxy_method.156;
  <D.23211>:
  D.23214 = obj->vtable;
  D.23215 = D.23214->klass;
  D.23216 = BIT_FIELD_REF <*D.23215, 8, 176>;
  D.23217 = D.23216 & 64;
  D.23218 = D.23217 == 0;
  D.23219 = (long int) D.23218;
  D.23220 = __builtin_expect (D.23219, 0);
  if (D.23220 != 0) goto <D.23221>; else goto <D.23222>;
  <D.23221>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 3751, "mono_class_is_marshalbyref (obj->vtable->klass)");
  <D.23222>:
  D.23212 = mono_defaults.real_proxy_class;
  real_proxy = mono_object_new (domain, D.23212);
  D.23214 = obj->vtable;
  D.23215 = D.23214->klass;
  D.23223 = &D.23215->byval_arg;
  reflection_type = mono_type_get_object (domain, D.23223);
  D.23224 = &real_proxy->class_to_proxy;
  mono_gc_wbarrier_set_field (real_proxy, D.23224, reflection_type);
  D.23225 = &real_proxy->unwrapped_server;
  mono_gc_wbarrier_set_field (real_proxy, D.23225, obj);
  *exc = 0B;
  get_proxy_method.155 = get_proxy_method;
  transparent_proxy = mono_runtime_invoke (get_proxy_method.155, real_proxy, 0B, exc);
  D.23226 = *exc;
  if (D.23226 != 0B) goto <D.23227>; else goto <D.23228>;
  <D.23227>:
  *failure = 1;
  <D.23228>:
  D.23229 = transparent_proxy;
  return D.23229;
}


serialize_object (struct MonoObject * obj, gboolean * failure, struct MonoObject * * exc)
{
  struct MonoMethod * serialize_method.157;
  struct MonoImage * D.23234;
  struct MonoMethod * serialize_method.158;
  struct MonoObject * D.23238;
  struct MonoVTable * D.23239;
  struct MonoClass * D.23240;
  unsigned char D.23241;
  unsigned char D.23242;
  _Bool D.23243;
  long int D.23244;
  long int D.23245;
  struct MonoObject * D.23248;
  static struct MonoMethod * serialize_method;
  void * params[1];
  struct MonoObject * array;

  try
    {
      serialize_method.157 = serialize_method;
      if (serialize_method.157 == 0B) goto <D.23232>; else goto <D.23233>;
      <D.23232>:
      {
        struct MonoClass * klass;

        D.23234 = mono_defaults.corlib;
        klass = mono_class_from_name (D.23234, "System.Runtime.Remoting", "RemotingServices");
        serialize_method.158 = mono_class_get_method_from_name (klass, "SerializeCallData", -1);
        serialize_method = serialize_method.158;
      }
      <D.23233>:
      serialize_method.157 = serialize_method;
      if (serialize_method.157 == 0B) goto <D.23236>; else goto <D.23237>;
      <D.23236>:
      *failure = 1;
      D.23238 = 0B;
      return D.23238;
      <D.23237>:
      D.23239 = obj->vtable;
      D.23240 = D.23239->klass;
      D.23241 = BIT_FIELD_REF <*D.23240, 8, 176>;
      D.23242 = D.23241 & 64;
      D.23243 = D.23242 != 0;
      D.23244 = (long int) D.23243;
      D.23245 = __builtin_expect (D.23244, 0);
      if (D.23245 != 0) goto <D.23246>; else goto <D.23247>;
      <D.23246>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 3700, "!mono_class_is_marshalbyref (mono_object_class (obj))");
      <D.23247>:
      params[0] = obj;
      *exc = 0B;
      serialize_method.157 = serialize_method;
      array = mono_runtime_invoke (serialize_method.157, 0B, &params, exc);
      D.23248 = *exc;
      if (D.23248 != 0B) goto <D.23249>; else goto <D.23250>;
      <D.23249>:
      *failure = 1;
      <D.23250>:
      D.23238 = array;
      return D.23238;
    }
  finally
    {
      params = {CLOBBER};
    }
}


deserialize_object (struct MonoObject * obj, gboolean * failure, struct MonoObject * * exc)
{
  struct MonoMethod * deserialize_method.159;
  struct MonoImage * D.23256;
  struct MonoMethod * deserialize_method.160;
  struct MonoObject * D.23260;
  struct MonoObject * D.23261;
  static struct MonoMethod * deserialize_method;
  void * params[1];
  struct MonoObject * result;

  try
    {
      deserialize_method.159 = deserialize_method;
      if (deserialize_method.159 == 0B) goto <D.23254>; else goto <D.23255>;
      <D.23254>:
      {
        struct MonoClass * klass;

        D.23256 = mono_defaults.corlib;
        klass = mono_class_from_name (D.23256, "System.Runtime.Remoting", "RemotingServices");
        deserialize_method.160 = mono_class_get_method_from_name (klass, "DeserializeCallData", -1);
        deserialize_method = deserialize_method.160;
      }
      <D.23255>:
      deserialize_method.159 = deserialize_method;
      if (deserialize_method.159 == 0B) goto <D.23258>; else goto <D.23259>;
      <D.23258>:
      *failure = 1;
      D.23260 = 0B;
      return D.23260;
      <D.23259>:
      params[0] = obj;
      *exc = 0B;
      deserialize_method.159 = deserialize_method;
      result = mono_runtime_invoke (deserialize_method.159, 0B, &params, exc);
      D.23261 = *exc;
      if (D.23261 != 0B) goto <D.23262>; else goto <D.23263>;
      <D.23262>:
      *failure = 1;
      <D.23263>:
      D.23260 = result;
      return D.23260;
    }
  finally
    {
      params = {CLOBBER};
    }
}


mono_runtime_unhandled_exception_policy_set (MonoRuntimeUnhandledExceptionPolicy policy)
{
  runtime_unhandled_exception_policy = policy;
}


mono_runtime_unhandled_exception_policy_get ()
{
  MonoRuntimeUnhandledExceptionPolicy D.23266;

  D.23266 = runtime_unhandled_exception_policy;
  return D.23266;
}


mono_unhandled_exception (struct MonoObject * exc)
{
  struct MonoClass * D.23268;
  _Bool D.23269;
  long int D.23270;
  long int D.23271;
  struct MonoVTable * D.23274;
  struct MonoClass * D.23275;
  struct MonoClass * D.23276;
  int iftmp.161;
  struct MonoThread * main_thread.162;
  struct MonoInternalThread * D.23286;
  struct _MonoInternalThread * D.23287;
  <unnamed type> D.23288;
  struct MonoAppDomain * D.23289;
  int D.23290;
  sizetype D.23291;
  struct MonoObject * * D.23292;
  struct MonoAppDomain * D.23295;
  struct MonoObject * * D.23296;
  _Bool D.23298;
  _Bool D.23299;
  _Bool D.23300;
  struct MonoDomain * current_domain;
  struct MonoDomain * root_domain;
  struct MonoClassField * field;
  struct MonoObject * current_appdomain_delegate;
  struct MonoObject * root_appdomain_delegate;

  current_domain = mono_domain_get ();
  root_domain = mono_get_root_domain ();
  D.23268 = mono_defaults.appdomain_class;
  field = mono_class_get_field_from_name (D.23268, "UnhandledException");
  D.23269 = field == 0B;
  D.23270 = (long int) D.23269;
  D.23271 = __builtin_expect (D.23270, 0);
  if (D.23271 != 0) goto <D.23272>; else goto <D.23273>;
  <D.23272>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 3940, "field");
  <D.23273>:
  D.23274 = exc->vtable;
  D.23275 = D.23274->klass;
  D.23276 = mono_defaults.threadabortexception_class;
  if (D.23275 != D.23276) goto <D.23277>; else goto <D.23278>;
  <D.23277>:
  {
    gboolean abort_process;

    main_thread.162 = main_thread;
    if (main_thread.162 != 0B) goto <D.23285>; else goto <D.23280>;
    <D.23285>:
    D.23286 = mono_thread_internal_current ();
    main_thread.162 = main_thread;
    D.23287 = main_thread.162->internal_thread;
    if (D.23286 == D.23287) goto <D.23281>; else goto <D.23280>;
    <D.23280>:
    D.23288 = mono_runtime_unhandled_exception_policy_get ();
    if (D.23288 == 1) goto <D.23281>; else goto <D.23282>;
    <D.23281>:
    iftmp.161 = 1;
    goto <D.23283>;
    <D.23282>:
    iftmp.161 = 0;
    <D.23283>:
    abort_process = iftmp.161;
    D.23289 = root_domain->domain;
    D.23290 = field->offset;
    D.23291 = (sizetype) D.23290;
    D.23292 = D.23289 + D.23291;
    root_appdomain_delegate = *D.23292;
    if (current_domain != root_domain) goto <D.23293>; else goto <D.23294>;
    <D.23293>:
    D.23295 = current_domain->domain;
    D.23290 = field->offset;
    D.23291 = (sizetype) D.23290;
    D.23296 = D.23295 + D.23291;
    current_appdomain_delegate = *D.23296;
    goto <D.23297>;
    <D.23294>:
    current_appdomain_delegate = 0B;
    <D.23297>:
    D.23298 = current_appdomain_delegate == 0B;
    D.23299 = root_appdomain_delegate == 0B;
    D.23300 = D.23298 & D.23299;
    if (D.23300 != 0) goto <D.23301>; else goto <D.23302>;
    <D.23301>:
    if (abort_process != 0) goto <D.23303>; else goto <D.23304>;
    <D.23303>:
    mono_environment_exitcode_set (1);
    <D.23304>:
    mono_print_unhandled_exception (exc);
    goto <D.23305>;
    <D.23302>:
    if (root_appdomain_delegate != 0B) goto <D.23306>; else goto <D.23307>;
    <D.23306>:
    call_unhandled_exception_delegate (root_domain, root_appdomain_delegate, exc);
    <D.23307>:
    if (current_appdomain_delegate != 0B) goto <D.23308>; else goto <D.23309>;
    <D.23308>:
    call_unhandled_exception_delegate (current_domain, current_appdomain_delegate, exc);
    <D.23309>:
    <D.23305>:
  }
  <D.23278>:
}


call_unhandled_exception_delegate (struct MonoDomain * domain, struct MonoObject * delegate, struct MonoObject * exc)
{
  struct MonoAppDomain * D.23312;
  struct MonoVTable * D.23313;
  struct MonoDomain * D.23314;
  _Bool D.23315;
  long int D.23316;
  long int D.23317;
  struct MonoVTable * D.23320;
  struct MonoDomain * D.23321;
  struct MonoObject * serialization_exc.163;
  _Bool D.23329;
  long int D.23330;
  long int D.23331;
  struct MonoImage * D.23335;
  _Bool D.23336;
  long int D.23337;
  long int D.23338;
  struct MonoObject * D.23341;
  struct MonoObject * e.164;
  struct MonoString * D.23347;
  int D.23348;
  struct MonoObject * e;
  void * pa[2];
  struct MonoDomain * current_domain;

  try
    {
      e = 0B;
      current_domain = mono_domain_get ();
      if (domain != current_domain) goto <D.23310>; else goto <D.23311>;
      <D.23310>:
      mono_domain_set_internal_with_options (domain, 0);
      <D.23311>:
      D.23312 = domain->domain;
      D.23313 = MEM[(struct MonoObject *)D.23312].vtable;
      D.23314 = D.23313->domain;
      D.23315 = D.23314 != domain;
      D.23316 = (long int) D.23315;
      D.23317 = __builtin_expect (D.23316, 0);
      if (D.23317 != 0) goto <D.23318>; else goto <D.23319>;
      <D.23318>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 3850, "domain == mono_object_domain (domain->domain)");
      <D.23319>:
      D.23320 = exc->vtable;
      D.23321 = D.23320->domain;
      if (D.23321 != domain) goto <D.23322>; else goto <D.23323>;
      <D.23322>:
      {
        struct MonoObject * serialization_exc;

        try
          {
            exc = mono_object_xdomain_representation (exc, domain, &serialization_exc);
            if (exc == 0B) goto <D.23324>; else goto <D.23325>;
            <D.23324>:
            serialization_exc.163 = serialization_exc;
            if (serialization_exc.163 != 0B) goto <D.23327>; else goto <D.23328>;
            <D.23327>:
            {
              struct MonoObject * dummy;

              try
                {
                  serialization_exc.163 = serialization_exc;
                  exc = mono_object_xdomain_representation (serialization_exc.163, domain, &dummy);
                  D.23329 = exc == 0B;
                  D.23330 = (long int) D.23329;
                  D.23331 = __builtin_expect (D.23330, 0);
                  if (D.23331 != 0) goto <D.23332>; else goto <D.23333>;
                  <D.23332>:
                  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 3860, "exc");
                  <D.23333>:
                }
              finally
                {
                  dummy = {CLOBBER};
                }
            }
            goto <D.23334>;
            <D.23328>:
            D.23335 = mono_get_corlib ();
            exc = mono_exception_from_name_msg (D.23335, "System.Runtime.Serialization", "SerializationException", "Could not serialize unhandled exception.");
            <D.23334>:
            <D.23325>:
          }
        finally
          {
            serialization_exc = {CLOBBER};
          }
      }
      <D.23323>:
      D.23320 = exc->vtable;
      D.23321 = D.23320->domain;
      D.23336 = D.23321 != domain;
      D.23337 = (long int) D.23336;
      D.23338 = __builtin_expect (D.23337, 0);
      if (D.23338 != 0) goto <D.23339>; else goto <D.23340>;
      <D.23339>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 3868, "mono_object_domain (exc) == domain");
      <D.23340>:
      D.23312 = domain->domain;
      pa[0] = D.23312;
      D.23341 = create_unhandled_exception_eventargs (exc);
      pa[1] = D.23341;
      mono_runtime_delegate_invoke (delegate, &pa, &e);
      if (domain != current_domain) goto <D.23342>; else goto <D.23343>;
      <D.23342>:
      mono_domain_set_internal_with_options (current_domain, 0);
      <D.23343>:
      e.164 = e;
      if (e.164 != 0B) goto <D.23345>; else goto <D.23346>;
      <D.23345>:
      {
        struct MonoError error;
        gchar * msg;

        try
          {
            e.164 = e;
            D.23347 = MEM[(struct MonoException *)e.164].message;
            msg = mono_string_to_utf8_checked (D.23347, &error);
            D.23348 = mono_error_ok (&error);
            if (D.23348 == 0) goto <D.23349>; else goto <D.23350>;
            <D.23349>:
            monoeg_g_log (0B, 16, "Exception inside UnhandledException handler with invalid message (Invalid characters)\n");
            mono_error_cleanup (&error);
            goto <D.23351>;
            <D.23350>:
            monoeg_g_log (0B, 16, "exception inside UnhandledException handler: %s\n", msg);
            monoeg_g_free (msg);
            <D.23351>:
          }
        finally
          {
            error = {CLOBBER};
          }
      }
      <D.23346>:
    }
  finally
    {
      e = {CLOBBER};
      pa = {CLOBBER};
    }
}


create_unhandled_exception_eventargs (struct MonoObject * exc)
{
  struct MonoImage * D.23352;
  _Bool D.23353;
  long int D.23354;
  long int D.23355;
  _Bool D.23358;
  long int D.23359;
  long int D.23360;
  struct MonoDomain * D.23363;
  struct MonoObject * D.23364;
  struct MonoClass * klass;
  void * args[2];
  struct MonoMethod * method;
  MonoBoolean is_terminating;
  struct MonoObject * obj;

  try
    {
      method = 0B;
      is_terminating = 1;
      D.23352 = mono_defaults.corlib;
      klass = mono_class_from_name (D.23352, "System", "UnhandledExceptionEventArgs");
      D.23353 = klass == 0B;
      D.23354 = (long int) D.23353;
      D.23355 = __builtin_expect (D.23354, 0);
      if (D.23355 != 0) goto <D.23356>; else goto <D.23357>;
      <D.23356>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 3823, "klass");
      <D.23357>:
      mono_class_init (klass);
      method = mono_class_get_method_from_name_flags (klass, ".ctor", 2, 6);
      D.23358 = method == 0B;
      D.23359 = (long int) D.23358;
      D.23360 = __builtin_expect (D.23359, 0);
      if (D.23360 != 0) goto <D.23361>; else goto <D.23362>;
      <D.23361>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 3829, "method");
      <D.23362>:
      args[0] = exc;
      args[1] = &is_terminating;
      D.23363 = mono_domain_get ();
      obj = mono_object_new (D.23363, klass);
      mono_runtime_invoke (method, obj, &args, 0B);
      D.23364 = obj;
      return D.23364;
    }
  finally
    {
      args = {CLOBBER};
      is_terminating = {CLOBBER};
    }
}


mono_runtime_exec_managed_code (struct MonoDomain * domain, void (*MonoMainThreadFunc) (void *) main_func, void * main_args)
{
  mono_thread_create (domain, main_func, main_args);
  mono_thread_manage ();
}


mono_runtime_exec_main (struct MonoMethod * method, struct MonoArray * args, struct MonoObject * * exc)
{
  _Bool D.23367;
  long int D.23368;
  long int D.23369;
  struct MonoVTable * D.23372;
  struct MonoAssembly * D.23373;
  struct MonoClass * D.23376;
  struct MonoImage * D.23377;
  struct MonoAppDomainSetup * D.23378;
  struct MonoString * D.23379;
  char * D.23382;
  struct MonoString * D.23383;
  struct MonoString * * D.23384;
  struct MonoString * D.23385;
  struct MonoImage * D.23388;
  char * D.23389;
  struct MonoString * D.23390;
  struct MonoString * * D.23391;
  struct MonoClass * stathread_attribute.165;
  struct MonoImage * D.23397;
  struct MonoClass * stathread_attribute.166;
  int D.23399;
  struct MonoMethodSignature * D.23406;
  struct MonoType * D.23407;
  unsigned char D.23408;
  struct MonoObject * D.23415;
  guint32 * D.23416;
  unsigned int D.23417;
  int D.23423;
  struct MonoDomain * domain;
  void * pa[1];
  int rval;
  struct MonoCustomAttrInfo * cinfo;
  gboolean has_stathread_attribute;
  struct MonoInternalThread * thread;

  try
    {
      thread = mono_thread_internal_current ();
      D.23367 = args == 0B;
      D.23368 = (long int) D.23367;
      D.23369 = __builtin_expect (D.23368, 0);
      if (D.23369 != 0) goto <D.23370>; else goto <D.23371>;
      <D.23370>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 4008, "args");
      <D.23371>:
      pa[0] = args;
      D.23372 = MEM[(struct MonoObject *)args].vtable;
      domain = D.23372->domain;
      D.23373 = domain->entry_assembly;
      if (D.23373 == 0B) goto <D.23374>; else goto <D.23375>;
      <D.23374>:
      {
        gchar * str;
        struct MonoAssembly * assembly;

        D.23376 = method->klass;
        D.23377 = D.23376->image;
        assembly = D.23377->assembly;
        domain->entry_assembly = assembly;
        D.23378 = domain->setup;
        D.23379 = D.23378->application_base;
        if (D.23379 == 0B) goto <D.23380>; else goto <D.23381>;
        <D.23380>:
        D.23382 = assembly->basedir;
        D.23383 = mono_string_new (domain, D.23382);
        D.23378 = domain->setup;
        D.23384 = &D.23378->application_base;
        D.23378 = domain->setup;
        mono_gc_wbarrier_set_field (D.23378, D.23384, D.23383);
        <D.23381>:
        D.23378 = domain->setup;
        D.23385 = D.23378->configuration_file;
        if (D.23385 == 0B) goto <D.23386>; else goto <D.23387>;
        <D.23386>:
        D.23388 = assembly->image;
        D.23389 = D.23388->name;
        str = monoeg_g_strconcat (D.23389, ".config", 0B);
        D.23390 = mono_string_new (domain, str);
        D.23378 = domain->setup;
        D.23391 = &D.23378->configuration_file;
        D.23378 = domain->setup;
        mono_gc_wbarrier_set_field (D.23378, D.23391, D.23390);
        monoeg_g_free (str);
        mono_set_private_bin_path_from_config (domain);
        <D.23387>:
      }
      <D.23375>:
      cinfo = mono_custom_attrs_from_method (method);
      if (cinfo != 0B) goto <D.23392>; else goto <D.23393>;
      <D.23392>:
      {
        static struct MonoClass * stathread_attribute = 0B;

        stathread_attribute.165 = stathread_attribute;
        if (stathread_attribute.165 == 0B) goto <D.23395>; else goto <D.23396>;
        <D.23395>:
        D.23397 = mono_defaults.corlib;
        stathread_attribute.166 = mono_class_from_name (D.23397, "System", "STAThreadAttribute");
        stathread_attribute = stathread_attribute.166;
        <D.23396>:
        stathread_attribute.165 = stathread_attribute;
        has_stathread_attribute = mono_custom_attrs_has_attr (cinfo, stathread_attribute.165);
        D.23399 = cinfo->cached;
        if (D.23399 == 0) goto <D.23400>; else goto <D.23401>;
        <D.23400>:
        mono_custom_attrs_free (cinfo);
        <D.23401>:
      }
      goto <D.23402>;
      <D.23393>:
      has_stathread_attribute = 0;
      <D.23402>:
      if (has_stathread_attribute != 0) goto <D.23403>; else goto <D.23404>;
      <D.23403>:
      thread->apartment_state = 0;
      goto <D.23405>;
      <D.23404>:
      thread->apartment_state = 1;
      <D.23405>:
      mono_thread_init_apartment_state ();
      D.23406 = mono_method_signature (method);
      D.23407 = D.23406->ret;
      D.23408 = D.23407->type;
      if (D.23408 == 8) goto <D.23409>; else goto <D.23410>;
      <D.23409>:
      {
        struct MonoObject * res;

        res = mono_runtime_invoke (method, 0B, &pa, exc);
        if (exc == 0B) goto <D.23411>; else goto <D.23414>;
        <D.23414>:
        D.23415 = *exc;
        if (D.23415 == 0B) goto <D.23411>; else goto <D.23412>;
        <D.23411>:
        D.23416 = res + 8;
        D.23417 = *D.23416;
        rval = (int) D.23417;
        goto <D.23413>;
        <D.23412>:
        rval = -1;
        <D.23413>:
        mono_environment_exitcode_set (rval);
      }
      goto <D.23418>;
      <D.23410>:
      mono_runtime_invoke (method, 0B, &pa, exc);
      if (exc == 0B) goto <D.23419>; else goto <D.23422>;
      <D.23422>:
      D.23415 = *exc;
      if (D.23415 == 0B) goto <D.23419>; else goto <D.23420>;
      <D.23419>:
      rval = 0;
      goto <D.23421>;
      <D.23420>:
      rval = -1;
      mono_environment_exitcode_set (rval);
      <D.23421>:
      <D.23418>:
      D.23423 = rval;
      return D.23423;
    }
  finally
    {
      pa = {CLOBBER};
    }
}


mono_install_runtime_invoke (struct MonoObject * (*MonoInvokeFunc) (struct MonoMethod *, void *, void * *, struct MonoObject * *) func)
{
  struct MonoObject * (*<T11c7>) (struct MonoMethod *, void *, void * *, struct MonoObject * *) iftmp.167;

  if (func != 0B) goto <D.23427>; else goto <D.23428>;
  <D.23427>:
  iftmp.167 = func;
  goto <D.23429>;
  <D.23428>:
  iftmp.167 = dummy_mono_runtime_invoke;
  <D.23429>:
  default_mono_runtime_invoke = iftmp.167;
}


mono_runtime_invoke_array (struct MonoMethod * method, void * obj, struct MonoArray * params, struct MonoObject * * exc)
{
  unsigned int D.23432;
  unsigned int D.23433;
  unsigned char D.23434;
  int D.23435;
  struct MonoType * D.23439;
  struct MonoClass * D.23440;
  int D.23441;
  unsigned int i.168;
  unsigned int D.23444;
  void * * D.23445;
  unsigned int i.169;
  char * D.23447;
  struct MonoObject * D.23448;
  unsigned char D.23449;
  unsigned char D.23450;
  char * D.23453;
  struct MonoObject * D.23454;
  struct MonoClass * D.23457;
  struct MonoDomain * D.23458;
  struct MonoObject * D.23459;
  char * D.23462;
  void * D.23463;
  struct MonoVTable * D.23464;
  struct MonoClass * D.23465;
  struct MonoDomain * D.23466;
  char * D.23467;
  struct MonoObject * D.23468;
  void * D.23469;
  char * D.23472;
  char * D.23474;
  struct MonoObject * D.23475;
  struct MonoGenericClass * D.23478;
  struct MonoClass * D.23479;
  char * D.23481;
  struct MonoVTable * D.23485;
  struct MonoClass * D.23486;
  struct MonoClass * D.23487;
  _Bool D.23488;
  long int D.23489;
  long int D.23490;
  void * D.23493;
  unsigned char D.23494;
  int D.23495;
  unsigned int D.23496;
  int D.19795;
  int iftmp.170;
  int D.19794;
  const char[6] * D.23501;
  unsigned char D.23502;
  int D.23503;
  unsigned char D.23504;
  int D.23505;
  _Bool D.23506;
  _Bool D.23507;
  _Bool D.23508;
  const unsigned char * D.23511;
  unsigned char D.23512;
  int D.23513;
  const unsigned char * D.23514;
  unsigned char D.23515;
  int D.23516;
  _Bool D.23517;
  _Bool D.23518;
  const unsigned char * D.23521;
  unsigned char D.23522;
  int D.23523;
  const unsigned char * D.23524;
  unsigned char D.23525;
  int D.23526;
  _Bool D.23527;
  _Bool D.23528;
  const unsigned char * D.23531;
  unsigned char D.23532;
  int D.23533;
  const unsigned char * D.23534;
  unsigned char D.23535;
  int D.23536;
  const char * D.23538;
  struct MonoClass * D.23540;
  struct MonoClass * D.23541;
  int D.23543;
  _Bool D.23546;
  long int D.23547;
  long int D.23548;
  struct MonoObject * D.23553;
  void * D.23554;
  struct MonoClass * D.23555;
  struct MonoDomain * D.23556;
  struct MonoDomain * D.23559;
  _Bool D.23560;
  long int D.23561;
  long int D.23562;
  struct MonoVTable * D.23565;
  struct MonoClass * D.23566;
  struct MonoClass * D.23567;
  struct MonoMethod * iftmp.171;
  short int D.23571;
  struct MonoMethod * * D.23574;
  unsigned int D.23575;
  unsigned int D.23576;
  struct MonoMethod * * D.23577;
  unsigned char D.23579;
  unsigned char D.23580;
  struct MonoDomain * D.23587;
  int D.23588;
  struct MonoDomain * D.23591;
  struct MonoDomain * D.23592;
  struct MonoObject * D.23593;
  void * D.23594;
  struct MonoType * D.23595;
  unsigned char D.23596;
  struct MonoClass * pointer_class.174;
  struct MonoClass * tmp_klass.172;
  struct MonoImage * D.23604;
  struct MonoClass * tmp_klass.173;
  _Bool D.23606;
  long int D.23607;
  long int D.23608;
  struct MonoMethod * box_method.175;
  struct MonoMethod * box_method.176;
  struct MonoVTable * D.23615;
  struct MonoClass * D.23616;
  _Bool D.23617;
  long int D.23618;
  long int D.23619;
  void * D.23622;
  struct MonoDomain * D.23623;
  struct MonoReflectionType * D.23624;
  struct MonoObject * box_exc.177;
  _Bool D.23626;
  long int D.23627;
  long int D.23628;
  short unsigned int D.23633;
  short unsigned int D.23634;
  struct MonoClass * D.23637;
  int D.23638;
  void * D.23641;
  unsigned int D.23642;
  struct MonoMethodSignature * sig;
  void * * pa;
  struct MonoObject * res;
  int i;
  gboolean has_byref_nullables;
  void again = <<< error >>>;

  sig = mono_method_signature (method);
  pa = 0B;
  has_byref_nullables = 0;
  if (params != 0B) goto <D.23430>; else goto <D.23431>;
  <D.23430>:
  D.23432 = mono_array_length (params);
  D.23433 = D.23432 * 4;
  pa = __builtin_alloca (D.23433);
  i = 0;
  goto <D.19785>;
  <D.19784>:
  {
    struct MonoType * t;

    t = sig->params[i];
    again:
    D.23434 = t->type;
    D.23435 = (int) D.23434;
    switch (D.23435) <default: <D.19782>, case 2: <D.19756>, case 3: <D.19759>, case 4: <D.19755>, case 5: <D.19754>, case 6: <D.19758>, case 7: <D.19757>, case 8: <D.19763>, case 9: <D.19762>, case 10: <D.19765>, case 11: <D.19764>, case 12: <D.19766>, case 13: <D.19767>, case 14: <D.19774>, case 15: <D.19780>, case 17: <D.19768>, case 18: <D.19776>, case 20: <D.19777>, case 21: <D.19779>, case 24: <D.19761>, case 25: <D.19760>, case 28: <D.19775>, case 29: <D.19778>>
    <D.19754>:
    <D.19755>:
    <D.19756>:
    <D.19757>:
    <D.19758>:
    <D.19759>:
    <D.19760>:
    <D.19761>:
    <D.19762>:
    <D.19763>:
    <D.19764>:
    <D.19765>:
    <D.19766>:
    <D.19767>:
    <D.19768>:
    D.23434 = t->type;
    if (D.23434 == 17) goto <D.23438>; else goto <D.23436>;
    <D.23438>:
    D.23439 = sig->params[i];
    D.23440 = mono_class_from_mono_type (D.23439);
    D.23441 = mono_class_is_nullable (D.23440);
    if (D.23441 != 0) goto <D.23442>; else goto <D.23436>;
    <D.23442>:
    i.168 = (unsigned int) i;
    D.23444 = i.168 * 4;
    D.23445 = pa + D.23444;
    i.169 = (unsigned int) i;
    D.23447 = mono_array_addr_with_size (params, 4, i.169);
    D.23448 = MEM[(struct MonoObject * *)D.23447];
    *D.23445 = D.23448;
    D.23449 = BIT_FIELD_REF <*t, 8, 56>;
    D.23450 = D.23449 & 64;
    if (D.23450 != 0) goto <D.23451>; else goto <D.23452>;
    <D.23451>:
    has_byref_nullables = 1;
    <D.23452>:
    goto <D.23437>;
    <D.23436>:
    i.169 = (unsigned int) i;
    D.23453 = mono_array_addr_with_size (params, 4, i.169);
    D.23454 = MEM[(struct MonoObject * *)D.23453];
    if (D.23454 == 0B) goto <D.23455>; else goto <D.23456>;
    <D.23455>:
    {
      void * * __p;

      i.169 = (unsigned int) i;
      __p = mono_array_addr_with_size (params, 4, i.169);
      D.23439 = sig->params[i];
      D.23457 = mono_class_from_mono_type (D.23439);
      D.23458 = mono_domain_get ();
      D.23459 = mono_object_new (D.23458, D.23457);
      mono_gc_wbarrier_set_arrayref (params, __p, D.23459);
    }
    <D.23456>:
    D.23449 = BIT_FIELD_REF <*t, 8, 56>;
    D.23450 = D.23449 & 64;
    if (D.23450 != 0) goto <D.23460>; else goto <D.23461>;
    <D.23460>:
    {
      struct MonoObject * orig;
      struct MonoObject * copy;

      i.169 = (unsigned int) i;
      D.23462 = mono_array_addr_with_size (params, 4, i.169);
      orig = MEM[(struct MonoObject * *)D.23462];
      D.23463 = mono_object_unbox (orig);
      D.23464 = orig->vtable;
      D.23465 = D.23464->klass;
      D.23466 = mono_domain_get ();
      copy = mono_value_box (D.23466, D.23465, D.23463);
      {
        void * * __p;

        i.169 = (unsigned int) i;
        __p = mono_array_addr_with_size (params, 4, i.169);
        mono_gc_wbarrier_set_arrayref (params, __p, copy);
      }
    }
    <D.23461>:
    i.168 = (unsigned int) i;
    D.23444 = i.168 * 4;
    D.23445 = pa + D.23444;
    i.169 = (unsigned int) i;
    D.23467 = mono_array_addr_with_size (params, 4, i.169);
    D.23468 = MEM[(struct MonoObject * *)D.23467];
    D.23469 = mono_object_unbox (D.23468);
    *D.23445 = D.23469;
    <D.23437>:
    goto <D.19773>;
    <D.19774>:
    <D.19775>:
    <D.19776>:
    <D.19777>:
    <D.19778>:
    D.23449 = BIT_FIELD_REF <*t, 8, 56>;
    D.23450 = D.23449 & 64;
    if (D.23450 != 0) goto <D.23470>; else goto <D.23471>;
    <D.23470>:
    i.168 = (unsigned int) i;
    D.23444 = i.168 * 4;
    D.23445 = pa + D.23444;
    i.169 = (unsigned int) i;
    D.23472 = mono_array_addr_with_size (params, 4, i.169);
    *D.23445 = D.23472;
    goto <D.23473>;
    <D.23471>:
    i.168 = (unsigned int) i;
    D.23444 = i.168 * 4;
    D.23445 = pa + D.23444;
    i.169 = (unsigned int) i;
    D.23474 = mono_array_addr_with_size (params, 4, i.169);
    D.23475 = MEM[(struct MonoObject * *)D.23474];
    *D.23445 = D.23475;
    <D.23473>:
    goto <D.19773>;
    <D.19779>:
    D.23449 = BIT_FIELD_REF <*t, 8, 56>;
    D.23450 = D.23449 & 64;
    if (D.23450 != 0) goto <D.23476>; else goto <D.23477>;
    <D.23476>:
    D.23478 = t->data.generic_class;
    D.23479 = D.23478->container_class;
    t = &D.23479->this_arg;
    goto <D.23480>;
    <D.23477>:
    D.23478 = t->data.generic_class;
    D.23479 = D.23478->container_class;
    t = &D.23479->byval_arg;
    <D.23480>:
    goto again;
    <D.19780>:
    {
      struct MonoObject * arg;

      i.169 = (unsigned int) i;
      D.23481 = mono_array_addr_with_size (params, 4, i.169);
      arg = MEM[(struct MonoObject * *)D.23481];
      if (arg == 0B) goto <D.23482>; else goto <D.23483>;
      <D.23482>:
      i.168 = (unsigned int) i;
      D.23444 = i.168 * 4;
      D.23445 = pa + D.23444;
      *D.23445 = 0B;
      goto <D.23484>;
      <D.23483>:
      D.23485 = arg->vtable;
      D.23486 = D.23485->klass;
      D.23487 = mono_defaults.int_class;
      D.23488 = D.23486 != D.23487;
      D.23489 = (long int) D.23488;
      D.23490 = __builtin_expect (D.23489, 0);
      if (D.23490 != 0) goto <D.23491>; else goto <D.23492>;
      <D.23491>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 4211, "arg->vtable->klass == mono_defaults.int_class");
      <D.23492>:
      i.168 = (unsigned int) i;
      D.23444 = i.168 * 4;
      D.23445 = pa + D.23444;
      D.23493 = MEM[(struct MonoIntPtr *)arg].m_value;
      *D.23445 = D.23493;
      <D.23484>:
      goto <D.19773>;
    }
    <D.19782>:
    D.23439 = sig->params[i];
    D.23494 = D.23439->type;
    D.23495 = (int) D.23494;
    monoeg_g_log (0B, 4, "type 0x%x not handled in mono_runtime_invoke_array", D.23495);
    <D.19783>:
    goto <D.19783>;
    <D.19773>:
  }
  i = i + 1;
  <D.19785>:
  i.169 = (unsigned int) i;
  D.23496 = mono_array_length (params);
  if (i.169 < D.23496) goto <D.19784>; else goto <D.19786>;
  <D.19786>:
  <D.23431>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = method->name;
      D.23501 = ".ctor";
      D.23502 = MEM[(const unsigned char *)D.23501];
      D.23503 = (int) D.23502;
      D.23504 = *__s2;
      D.23505 = (int) D.23504;
      __result = D.23503 - D.23505;
      {
        D.23506 = __s2_len != 0;
        D.23507 = __result == 0;
        D.23508 = D.23506 & D.23507;
        if (D.23508 != 0) goto <D.23509>; else goto <D.23510>;
        <D.23509>:
        D.23511 = &MEM[(void *)".ctor" + 1B];
        D.23512 = *D.23511;
        D.23513 = (int) D.23512;
        D.23514 = __s2 + 1;
        D.23515 = *D.23514;
        D.23516 = (int) D.23515;
        __result = D.23513 - D.23516;
        D.23517 = __s2_len > 1;
        D.23507 = __result == 0;
        D.23518 = D.23517 & D.23507;
        if (D.23518 != 0) goto <D.23519>; else goto <D.23520>;
        <D.23519>:
        D.23521 = &MEM[(void *)".ctor" + 2B];
        D.23522 = *D.23521;
        D.23523 = (int) D.23522;
        D.23524 = __s2 + 2;
        D.23525 = *D.23524;
        D.23526 = (int) D.23525;
        __result = D.23523 - D.23526;
        D.23527 = __s2_len > 2;
        D.23507 = __result == 0;
        D.23528 = D.23527 & D.23507;
        if (D.23528 != 0) goto <D.23529>; else goto <D.23530>;
        <D.23529>:
        D.23531 = &MEM[(void *)".ctor" + 3B];
        D.23532 = *D.23531;
        D.23533 = (int) D.23532;
        D.23534 = __s2 + 3;
        D.23535 = *D.23534;
        D.23536 = (int) D.23535;
        __result = D.23533 - D.23536;
        <D.23530>:
        <D.23520>:
        <D.23510>:
      }
      D.19794 = __result;
    }
    iftmp.170 = -D.19794;
    goto <D.23537>;
    <D.23500>:
    D.23538 = method->name;
    iftmp.170 = __builtin_strcmp (D.23538, ".ctor");
    <D.23537>:
    D.19795 = iftmp.170;
  }
  if (D.19795 == 0) goto <D.23539>; else goto <D.23497>;
  <D.23539>:
  D.23540 = method->klass;
  D.23541 = mono_defaults.string_class;
  if (D.23540 != D.23541) goto <D.23542>; else goto <D.23497>;
  <D.23542>:
  {
    void * o;

    o = obj;
    D.23540 = method->klass;
    D.23543 = mono_class_is_nullable (D.23540);
    if (D.23543 != 0) goto <D.23544>; else goto <D.23545>;
    <D.23544>:
    D.23546 = obj != 0B;
    D.23547 = (long int) D.23546;
    D.23548 = __builtin_expect (D.23547, 0);
    if (D.23548 != 0) goto <D.23549>; else goto <D.23550>;
    <D.23549>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 4227, "!obj");
    <D.23550>:
    if (params == 0B) goto <D.23551>; else goto <D.23552>;
    <D.23551>:
    D.23553 = 0B;
    return D.23553;
    <D.23552>:
    D.23554 = *pa;
    D.23540 = method->klass;
    D.23555 = D.23540->cast_class;
    D.23556 = mono_domain_get ();
    D.23553 = mono_value_box (D.23556, D.23555, D.23554);
    return D.23553;
    <D.23545>:
    if (obj == 0B) goto <D.23557>; else goto <D.23558>;
    <D.23557>:
    D.23540 = method->klass;
    D.23559 = mono_domain_get ();
    obj = mono_object_new (D.23559, D.23540);
    D.23560 = obj == 0B;
    D.23561 = (long int) D.23560;
    D.23562 = __builtin_expect (D.23561, 0);
    if (D.23562 != 0) goto <D.23563>; else goto <D.23564>;
    <D.23563>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 4237, "obj");
    <D.23564>:
    D.23565 = MEM[(struct MonoObject *)obj].vtable;
    D.23566 = D.23565->klass;
    D.23567 = mono_defaults.transparent_proxy_class;
    if (D.23566 == D.23567) goto <D.23568>; else goto <D.23569>;
    <D.23568>:
    D.23571 = method->slot;
    if (D.23571 != -1) goto <D.23572>; else goto <D.23573>;
    <D.23572>:
    D.23540 = method->klass;
    D.23574 = D.23540->vtable;
    D.23571 = method->slot;
    D.23575 = (unsigned int) D.23571;
    D.23576 = D.23575 * 4;
    D.23577 = D.23574 + D.23576;
    iftmp.171 = *D.23577;
    goto <D.23578>;
    <D.23573>:
    iftmp.171 = method;
    <D.23578>:
    method = mono_marshal_get_remoting_invoke (iftmp.171);
    <D.23569>:
    D.23540 = method->klass;
    D.23579 = BIT_FIELD_REF <*D.23540, 8, 160>;
    D.23580 = D.23579 & 8;
    if (D.23580 != 0) goto <D.23581>; else goto <D.23582>;
    <D.23581>:
    o = mono_object_unbox (obj);
    goto <D.23583>;
    <D.23582>:
    o = obj;
    <D.23583>:
    goto <D.23584>;
    <D.23558>:
    D.23540 = method->klass;
    D.23579 = BIT_FIELD_REF <*D.23540, 8, 160>;
    D.23580 = D.23579 & 8;
    if (D.23580 != 0) goto <D.23585>; else goto <D.23586>;
    <D.23585>:
    D.23540 = method->klass;
    D.23587 = mono_domain_get ();
    obj = mono_value_box (D.23587, D.23540, obj);
    <D.23586>:
    <D.23584>:
    mono_runtime_invoke (method, o, pa, exc);
    D.23553 = obj;
    return D.23553;
  }
  <D.23497>:
  D.23540 = method->klass;
  D.23588 = mono_class_is_nullable (D.23540);
  if (D.23588 != 0) goto <D.23589>; else goto <D.23590>;
  <D.23589>:
  {
    struct MonoObject * nullable;

    D.23540 = method->klass;
    D.23591 = mono_domain_get ();
    nullable = mono_object_new (D.23591, D.23540);
    D.23540 = method->klass;
    D.23540 = method->klass;
    D.23555 = D.23540->cast_class;
    D.23592 = mono_domain_get ();
    D.23593 = mono_value_box (D.23592, D.23555, obj);
    D.23594 = mono_object_unbox (nullable);
    mono_nullable_init (D.23594, D.23593, D.23540);
    obj = mono_object_unbox (nullable);
  }
  <D.23590>:
  res = mono_runtime_invoke (method, obj, pa, exc);
  D.23595 = sig->ret;
  D.23596 = D.23595->type;
  if (D.23596 == 15) goto <D.23597>; else goto <D.23598>;
  <D.23597>:
  {
    struct MonoClass * pointer_class;
    static struct MonoMethod * box_method;
    void * box_args[2];
    struct MonoObject * box_exc;

    try
      {
        {
          static struct MonoClass * tmp_klass;

          {
            tmp_klass.172 = tmp_klass;
            if (tmp_klass.172 == 0B) goto <D.23600>; else goto <D.23601>;
            <D.23600>:
            if (0 != 0) goto <D.23602>; else goto <D.23603>;
            <D.23602>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 4277, "mono_defaults.corlib == mono_defaults.corlib");
            <D.23603>:
            D.23604 = mono_defaults.corlib;
            tmp_klass.173 = mono_class_from_name (D.23604, "System.Reflection", "Pointer");
            tmp_klass = tmp_klass.173;
            tmp_klass.172 = tmp_klass;
            D.23606 = tmp_klass.172 == 0B;
            D.23607 = (long int) D.23606;
            D.23608 = __builtin_expect (D.23607, 0);
            if (D.23608 != 0) goto <D.23609>; else goto <D.23610>;
            <D.23609>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 4277, "tmp_klass");
            <D.23610>:
            <D.23601>:
          }
          pointer_class.174 = tmp_klass;
        }
        pointer_class = pointer_class.174;
        box_method.175 = box_method;
        if (box_method.175 == 0B) goto <D.23612>; else goto <D.23613>;
        <D.23612>:
        box_method.176 = mono_class_get_method_from_name (pointer_class, "Box", -1);
        box_method = box_method.176;
        <D.23613>:
        D.23615 = res->vtable;
        D.23616 = D.23615->klass;
        D.23487 = mono_defaults.int_class;
        D.23617 = D.23616 != D.23487;
        D.23618 = (long int) D.23617;
        D.23619 = __builtin_expect (D.23618, 0);
        if (D.23619 != 0) goto <D.23620>; else goto <D.23621>;
        <D.23620>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 4281, "res->vtable->klass == mono_defaults.int_class");
        <D.23621>:
        D.23622 = MEM[(struct MonoIntPtr *)res].m_value;
        box_args[0] = D.23622;
        D.23595 = sig->ret;
        D.23623 = mono_domain_get ();
        D.23624 = mono_type_get_object (D.23623, D.23595);
        box_args[1] = D.23624;
        box_method.175 = box_method;
        res = mono_runtime_invoke (box_method.175, 0B, &box_args, &box_exc);
        box_exc.177 = box_exc;
        D.23626 = box_exc.177 != 0B;
        D.23627 = (long int) D.23626;
        D.23628 = __builtin_expect (D.23627, 0);
        if (D.23628 != 0) goto <D.23629>; else goto <D.23630>;
        <D.23629>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 4285, "!box_exc");
        <D.23630>:
      }
    finally
      {
        box_args = {CLOBBER};
        box_exc = {CLOBBER};
      }
  }
  <D.23598>:
  if (has_byref_nullables != 0) goto <D.23631>; else goto <D.23632>;
  <D.23631>:
  i = 0;
  goto <D.19807>;
  <D.19806>:
  {
    struct MonoType * t;

    t = sig->params[i];
    D.23633 = BIT_FIELD_REF <*t, 16, 48>;
    D.23634 = D.23633 & 16639;
    if (D.23634 == 16405) goto <D.23635>; else goto <D.23636>;
    <D.23635>:
    D.23637 = mono_class_from_mono_type (t);
    D.23638 = mono_class_is_nullable (D.23637);
    if (D.23638 != 0) goto <D.23639>; else goto <D.23640>;
    <D.23639>:
    {
      void * * __p;

      i.169 = (unsigned int) i;
      __p = mono_array_addr_with_size (params, 4, i.169);
      i.168 = (unsigned int) i;
      D.23444 = i.168 * 4;
      D.23445 = pa + D.23444;
      D.23641 = *D.23445;
      mono_gc_wbarrier_set_arrayref (params, __p, D.23641);
    }
    <D.23640>:
    <D.23636>:
  }
  i = i + 1;
  <D.19807>:
  i.169 = (unsigned int) i;
  D.23642 = mono_array_length (params);
  if (i.169 < D.23642) goto <D.19806>; else goto <D.19808>;
  <D.19808>:
  <D.23632>:
  D.23553 = res;
  return D.23553;
}


mono_object_new (struct MonoDomain * domain, struct MonoClass * klass)
{
  struct MonoObject * D.23646;
  struct MonoVTable * vtable;

  vtable = mono_class_vtable (domain, klass);
  if (vtable == 0B) goto <D.23644>; else goto <D.23645>;
  <D.23644>:
  D.23646 = 0B;
  return D.23646;
  <D.23645>:
  D.23646 = mono_object_new_specific (vtable);
  return D.23646;
}


mono_object_new_pinned (struct MonoDomain * domain, struct MonoClass * klass)
{
  struct MonoObject * D.23650;
  int D.23651;
  unsigned int D.23652;
  struct MonoVTable * vtable;

  vtable = mono_class_vtable (domain, klass);
  if (vtable == 0B) goto <D.23648>; else goto <D.23649>;
  <D.23648>:
  D.23650 = 0B;
  return D.23650;
  <D.23649>:
  D.23651 = mono_class_instance_size (klass);
  D.23652 = (unsigned int) D.23651;
  D.23650 = mono_gc_alloc_pinned_obj (vtable, D.23652);
  return D.23650;
}


mono_object_new_specific (struct MonoVTable * vtable)
{
  unsigned char D.23656;
  unsigned char D.23657;
  struct MonoClass * D.23659;
  unsigned char D.23660;
  unsigned char D.23661;
  struct MonoDomain * D.23662;
  struct MonoImage * D.23665;
  unsigned char D.23666;
  unsigned char D.23667;
  _Bool D.23670;
  long int D.23671;
  long int D.23672;
  struct MonoType * D.23675;
  struct MonoDomain * D.23676;
  struct MonoReflectionType * D.23677;
  struct MonoObject * D.23680;
  struct MonoObject * o;

  D.23656 = BIT_FIELD_REF <*vtable, 8, 184>;
  D.23657 = D.23656 & 1;
  if (D.23657 != 0) goto <D.23654>; else goto <D.23658>;
  <D.23658>:
  D.23659 = vtable->klass;
  D.23660 = BIT_FIELD_REF <*D.23659, 8, 184>;
  D.23661 = D.23660 & 64;
  if (D.23661 != 0) goto <D.23654>; else goto <D.23655>;
  <D.23654>:
  {
    void * pa[1];
    struct MonoMethod * im;

    try
      {
        D.23662 = vtable->domain;
        im = D.23662->create_proxy_for_type_method;
        if (im == 0B) goto <D.23663>; else goto <D.23664>;
        <D.23663>:
        {
          struct MonoClass * klass;

          D.23665 = mono_defaults.corlib;
          klass = mono_class_from_name (D.23665, "System.Runtime.Remoting.Activation", "ActivationServices");
          D.23666 = BIT_FIELD_REF <*klass, 8, 160>;
          D.23667 = D.23666 & 1;
          if (D.23667 == 0) goto <D.23668>; else goto <D.23669>;
          <D.23668>:
          mono_class_init (klass);
          <D.23669>:
          im = mono_class_get_method_from_name (klass, "CreateProxyForType", 1);
          D.23670 = im == 0B;
          D.23671 = (long int) D.23670;
          D.23672 = __builtin_expect (D.23671, 0);
          if (D.23672 != 0) goto <D.23673>; else goto <D.23674>;
          <D.23673>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 4430, "im");
          <D.23674>:
          D.23662 = vtable->domain;
          D.23662->create_proxy_for_type_method = im;
        }
        <D.23664>:
        D.23659 = vtable->klass;
        D.23675 = &D.23659->byval_arg;
        D.23676 = mono_domain_get ();
        D.23677 = mono_type_get_object (D.23676, D.23675);
        pa[0] = D.23677;
        o = mono_runtime_invoke (im, 0B, &pa, 0B);
        if (o != 0B) goto <D.23678>; else goto <D.23679>;
        <D.23678>:
        D.23680 = o;
        return D.23680;
        <D.23679>:
      }
    finally
      {
        pa = {CLOBBER};
      }
  }
  <D.23655>:
  D.23680 = mono_object_new_alloc_specific (vtable);
  return D.23680;
}


mono_object_new_alloc_specific (struct MonoVTable * vtable)
{
  struct MonoClass * D.23684;
  unsigned char D.23685;
  unsigned char D.23686;
  void * D.23690;
  int D.23693;
  unsigned int D.23694;
  unsigned char D.23696;
  unsigned char D.23697;
  _Bool D.23698;
  long int D.23699;
  long int D.23700;
  int profile_allocs.178;
  _Bool D.23704;
  long int D.23705;
  long int D.23706;
  struct MonoObject * D.23709;
  struct MonoObject * o;

  D.23684 = vtable->klass;
  D.23685 = BIT_FIELD_REF <*D.23684, 8, 184>;
  D.23686 = D.23685 & 8;
  if (D.23686 == 0) goto <D.23687>; else goto <D.23688>;
  <D.23687>:
  o = mono_object_new_ptrfree (vtable);
  goto <D.23689>;
  <D.23688>:
  D.23690 = vtable->gc_descr;
  if (D.23690 != 0B) goto <D.23691>; else goto <D.23692>;
  <D.23691>:
  D.23684 = vtable->klass;
  D.23693 = D.23684->instance_size;
  D.23694 = (unsigned int) D.23693;
  o = mono_object_allocate_spec (D.23694, vtable);
  goto <D.23695>;
  <D.23692>:
  D.23684 = vtable->klass;
  D.23693 = D.23684->instance_size;
  D.23694 = (unsigned int) D.23693;
  o = mono_object_allocate (D.23694, vtable);
  <D.23695>:
  <D.23689>:
  D.23684 = vtable->klass;
  D.23696 = BIT_FIELD_REF <*D.23684, 8, 176>;
  D.23697 = D.23696 & 32;
  D.23698 = D.23697 != 0;
  D.23699 = (long int) D.23698;
  D.23700 = __builtin_expect (D.23699, 0);
  if (D.23700 != 0) goto <D.23701>; else goto <D.23702>;
  <D.23701>:
  mono_object_register_finalizer (o);
  <D.23702>:
  profile_allocs.178 = profile_allocs;
  D.23704 = profile_allocs.178 != 0;
  D.23705 = (long int) D.23704;
  D.23706 = __builtin_expect (D.23705, 0);
  if (D.23706 != 0) goto <D.23707>; else goto <D.23708>;
  <D.23707>:
  D.23684 = vtable->klass;
  mono_profiler_allocation (o, D.23684);
  <D.23708>:
  D.23709 = o;
  return D.23709;
}


mono_object_allocate_spec (size_t size, struct MonoVTable * vtable)
{
  long long unsigned int D.23711;
  long long unsigned int D.23712;
  void * D.23713;
  void * o;

  o = mono_gc_alloc_obj (vtable, size);
  D.23711 = mono_stats.new_object_count;
  D.23712 = D.23711 + 1;
  mono_stats.new_object_count = D.23712;
  D.23713 = o;
  return D.23713;
}


mono_object_allocate (size_t size, struct MonoVTable * vtable)
{
  long long unsigned int D.23715;
  long long unsigned int D.23716;
  void * D.23717;
  struct MonoObject * o;

  D.23715 = mono_stats.new_object_count;
  D.23716 = D.23715 + 1;
  mono_stats.new_object_count = D.23716;
  o = mono_gc_alloc_obj (vtable, size);
  D.23717 = o;
  return D.23717;
}


mono_object_new_fast (struct MonoVTable * vtable)
{
  struct MonoClass * D.23719;
  int D.23720;
  unsigned int D.23721;
  struct MonoObject * D.23722;
  struct MonoObject * o;

  D.23719 = vtable->klass;
  D.23720 = D.23719->instance_size;
  D.23721 = (unsigned int) D.23720;
  o = mono_gc_alloc_obj (vtable, D.23721);
  D.23722 = o;
  return D.23722;
}


mono_class_get_allocation_ftn (struct MonoVTable * vtable, gboolean for_box, gboolean * pass_size_in_words)
{
  <unnamed type> D.23724;
  unsigned int D.23725;
  struct MonoClass * D.23730;
  int D.23731;
  unsigned char D.23733;
  unsigned char D.23734;
  <unnamed type> D.23736;
  unsigned int D.23737;
  void * D.23738;
  unsigned char D.23739;
  unsigned char D.23740;
  void * D.23745;

  *pass_size_in_words = 0;
  D.23724 = mono_profiler_get_events ();
  D.23725 = D.23724 & 128;
  if (D.23725 == 0) goto <D.23726>; else goto <D.23727>;
  <D.23726>:
  profile_allocs = 0;
  <D.23727>:
  D.23730 = vtable->klass;
  D.23731 = mono_class_has_finalizer (D.23730);
  if (D.23731 != 0) goto <D.23728>; else goto <D.23732>;
  <D.23732>:
  D.23730 = vtable->klass;
  D.23733 = BIT_FIELD_REF <*D.23730, 8, 176>;
  D.23734 = D.23733 & 64;
  if (D.23734 != 0) goto <D.23728>; else goto <D.23735>;
  <D.23735>:
  D.23736 = mono_profiler_get_events ();
  D.23737 = D.23736 & 128;
  if (D.23737 != 0) goto <D.23728>; else goto <D.23729>;
  <D.23728>:
  D.23738 = mono_object_new_specific;
  return D.23738;
  <D.23729>:
  D.23730 = vtable->klass;
  D.23739 = BIT_FIELD_REF <*D.23730, 8, 184>;
  D.23740 = D.23739 & 8;
  if (D.23740 == 0) goto <D.23741>; else goto <D.23742>;
  <D.23741>:
  if (for_box != 0) goto <D.23743>; else goto <D.23744>;
  <D.23743>:
  D.23738 = mono_object_new_ptrfree_box;
  return D.23738;
  <D.23744>:
  D.23738 = mono_object_new_ptrfree;
  return D.23738;
  <D.23742>:
  D.23745 = vtable->gc_descr;
  if (D.23745 != 0B) goto <D.23746>; else goto <D.23747>;
  <D.23746>:
  D.23738 = mono_object_new_fast;
  return D.23738;
  <D.23747>:
  D.23738 = mono_object_new_specific;
  return D.23738;
}


mono_object_new_from_token (struct MonoDomain * domain, struct MonoImage * image, guint32 token)
{
  struct MonoObject * D.23749;
  struct MonoClass * class;

  class = mono_class_get (image, token);
  D.23749 = mono_object_new (domain, class);
  return D.23749;
}


mono_object_clone (struct MonoObject * obj)
{
  struct MonoVTable * D.23751;
  struct MonoClass * D.23752;
  unsigned char D.23753;
  struct MonoObject * D.23756;
  unsigned int size.179;
  unsigned char D.23758;
  unsigned char D.23759;
  unsigned int size.180;
  unsigned int D.23764;
  const void * D.23765;
  void * D.23766;
  int profile_allocs.181;
  _Bool D.23768;
  long int D.23769;
  long int D.23770;
  unsigned char D.23773;
  unsigned char D.23774;
  struct MonoObject * o;
  int size;

  D.23751 = obj->vtable;
  D.23752 = D.23751->klass;
  size = D.23752->instance_size;
  D.23751 = obj->vtable;
  D.23752 = D.23751->klass;
  D.23753 = D.23752->rank;
  if (D.23753 != 0) goto <D.23754>; else goto <D.23755>;
  <D.23754>:
  D.23756 = mono_array_clone (obj);
  return D.23756;
  <D.23755>:
  D.23751 = obj->vtable;
  size.179 = (unsigned int) size;
  o = mono_object_allocate (size.179, D.23751);
  D.23751 = obj->vtable;
  D.23752 = D.23751->klass;
  D.23758 = BIT_FIELD_REF <*D.23752, 8, 184>;
  D.23759 = D.23758 & 8;
  if (D.23759 != 0) goto <D.23760>; else goto <D.23761>;
  <D.23760>:
  mono_gc_wbarrier_object_copy (o, obj);
  goto <D.23762>;
  <D.23761>:
  {
    int size;

    D.23751 = obj->vtable;
    D.23752 = D.23751->klass;
    size = D.23752->instance_size;
    size.180 = (unsigned int) size;
    D.23764 = size.180 + 4294967288;
    D.23765 = obj + 8;
    D.23766 = o + 8;
    mono_gc_memmove_atomic (D.23766, D.23765, D.23764);
  }
  <D.23762>:
  profile_allocs.181 = profile_allocs;
  D.23768 = profile_allocs.181 != 0;
  D.23769 = (long int) D.23768;
  D.23770 = __builtin_expect (D.23769, 0);
  if (D.23770 != 0) goto <D.23771>; else goto <D.23772>;
  <D.23771>:
  D.23751 = obj->vtable;
  D.23752 = D.23751->klass;
  mono_profiler_allocation (o, D.23752);
  <D.23772>:
  D.23751 = obj->vtable;
  D.23752 = D.23751->klass;
  D.23773 = BIT_FIELD_REF <*D.23752, 8, 176>;
  D.23774 = D.23773 & 32;
  if (D.23774 != 0) goto <D.23775>; else goto <D.23776>;
  <D.23775>:
  mono_object_register_finalizer (o);
  <D.23776>:
  D.23756 = o;
  return D.23756;
}


mono_array_full_copy (struct MonoArray * src, struct MonoArray * dest)
{
  struct MonoVTable * D.23778;
  struct MonoVTable * D.23779;
  struct MonoClass * D.23780;
  _Bool D.23781;
  long int D.23782;
  long int D.23783;
  unsigned int D.23786;
  _Bool D.23787;
  long int D.23788;
  long int D.23789;
  int D.23792;
  unsigned int D.23793;
  struct MonoClass * D.23794;
  unsigned char D.23795;
  unsigned char D.23796;
  unsigned char D.23799;
  unsigned char D.23800;
  unsigned int D.23803;
  int D.23804;
  double[0:] * D.23805;
  double[0:] * D.23807;
  unsigned int D.23809;
  int D.23810;
  uintptr_t size;
  struct MonoClass * klass;

  D.23778 = src->obj.vtable;
  klass = D.23778->klass;
  D.23779 = dest->obj.vtable;
  D.23780 = D.23779->klass;
  D.23781 = D.23780 != klass;
  D.23782 = (long int) D.23781;
  D.23783 = __builtin_expect (D.23782, 0);
  if (D.23783 != 0) goto <D.23784>; else goto <D.23785>;
  <D.23784>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 4619, "klass == dest->obj.vtable->klass");
  <D.23785>:
  size = mono_array_length (src);
  D.23786 = mono_array_length (dest);
  D.23787 = D.23786 != size;
  D.23788 = (long int) D.23787;
  D.23789 = __builtin_expect (D.23788, 0);
  if (D.23789 != 0) goto <D.23790>; else goto <D.23791>;
  <D.23790>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 4622, "size == mono_array_length (dest)");
  <D.23791>:
  D.23792 = mono_array_element_size (klass);
  D.23793 = (unsigned int) D.23792;
  size = D.23793 * size;
  D.23794 = klass->element_class;
  D.23795 = BIT_FIELD_REF <*D.23794, 8, 160>;
  D.23796 = D.23795 & 8;
  if (D.23796 != 0) goto <D.23797>; else goto <D.23798>;
  <D.23797>:
  D.23794 = klass->element_class;
  D.23799 = BIT_FIELD_REF <*D.23794, 8, 184>;
  D.23800 = D.23799 & 8;
  if (D.23800 != 0) goto <D.23801>; else goto <D.23802>;
  <D.23801>:
  D.23803 = mono_array_length (src);
  D.23804 = (int) D.23803;
  D.23805 = &src->vector;
  mono_value_copy_array (dest, 0, D.23805, D.23804);
  goto <D.23806>;
  <D.23802>:
  D.23805 = &src->vector;
  D.23807 = &dest->vector;
  mono_gc_memmove_atomic (D.23807, D.23805, size);
  <D.23806>:
  goto <D.23808>;
  <D.23798>:
  {
    void * * __p;
    void * * __s;

    __p = mono_array_addr_with_size (dest, 4, 0);
    __s = mono_array_addr_with_size (src, 4, 0);
    D.23809 = mono_array_length (src);
    D.23810 = (int) D.23809;
    mono_gc_wbarrier_arrayref_copy (__p, __s, D.23810);
  }
  <D.23808>:
}


mono_array_clone_in_domain (struct MonoDomain * domain, struct MonoArray * array)
{
  struct MonoVTable * D.23811;
  struct MonoArrayBounds * D.23812;
  unsigned int size.182;
  int D.23816;
  unsigned int D.23817;
  unsigned int size.183;
  unsigned int size.184;
  struct MonoClass * D.23820;
  unsigned char D.23821;
  unsigned char D.23822;
  unsigned char D.23825;
  unsigned char D.23826;
  unsigned int D.23829;
  int D.23830;
  double[0:] * D.23831;
  double[0:] * D.23833;
  unsigned int D.23835;
  int D.23836;
  struct MonoArray * D.23837;
  unsigned char D.23838;
  unsigned int D.23839;
  unsigned int D.23840;
  int D.23841;
  unsigned int size.185;
  unsigned int D.23843;
  uintptr_t * D.23844;
  unsigned int D.23845;
  struct MonoArrayBounds * D.23846;
  unsigned int D.23847;
  unsigned int size.186;
  unsigned int D.23849;
  unsigned int D.23850;
  unsigned int D.23851;
  uintptr_t * D.23852;
  int D.23853;
  unsigned int D.23854;
  unsigned int D.23855;
  intptr_t * D.23856;
  unsigned int D.23861;
  int D.23862;
  unsigned int D.23865;
  int D.23866;
  struct MonoArray * o;
  uintptr_t size;
  uintptr_t i;
  uintptr_t * sizes;
  struct MonoClass * klass;

  try
    {
      D.23811 = array->obj.vtable;
      klass = D.23811->klass;
      D.23812 = array->bounds;
      if (D.23812 == 0B) goto <D.23813>; else goto <D.23814>;
      <D.23813>:
      size.182 = mono_array_length (array);
      size = size.182;
      o = mono_array_new_full (domain, klass, &size, 0B);
      D.23816 = mono_array_element_size (klass);
      D.23817 = (unsigned int) D.23816;
      size.183 = size;
      size.184 = D.23817 * size.183;
      size = size.184;
      D.23820 = klass->element_class;
      D.23821 = BIT_FIELD_REF <*D.23820, 8, 160>;
      D.23822 = D.23821 & 8;
      if (D.23822 != 0) goto <D.23823>; else goto <D.23824>;
      <D.23823>:
      D.23820 = klass->element_class;
      D.23825 = BIT_FIELD_REF <*D.23820, 8, 184>;
      D.23826 = D.23825 & 8;
      if (D.23826 != 0) goto <D.23827>; else goto <D.23828>;
      <D.23827>:
      D.23829 = mono_array_length (array);
      D.23830 = (int) D.23829;
      D.23831 = &array->vector;
      mono_value_copy_array (o, 0, D.23831, D.23830);
      goto <D.23832>;
      <D.23828>:
      size.183 = size;
      D.23831 = &array->vector;
      D.23833 = &o->vector;
      mono_gc_memmove_atomic (D.23833, D.23831, size.183);
      <D.23832>:
      goto <D.23834>;
      <D.23824>:
      {
        void * * __p;
        void * * __s;

        __p = mono_array_addr_with_size (o, 4, 0);
        __s = mono_array_addr_with_size (array, 4, 0);
        D.23835 = mono_array_length (array);
        D.23836 = (int) D.23835;
        mono_gc_wbarrier_arrayref_copy (__p, __s, D.23836);
      }
      <D.23834>:
      D.23837 = o;
      return D.23837;
      <D.23814>:
      D.23838 = klass->rank;
      D.23839 = (unsigned int) D.23838;
      D.23840 = D.23839 * 8;
      sizes = __builtin_alloca (D.23840);
      D.23841 = mono_array_element_size (klass);
      size.185 = (unsigned int) D.23841;
      size = size.185;
      i = 0;
      goto <D.19897>;
      <D.19896>:
      D.23843 = i * 4;
      D.23844 = sizes + D.23843;
      D.23812 = array->bounds;
      D.23845 = i * 8;
      D.23846 = D.23812 + D.23845;
      D.23847 = D.23846->length;
      *D.23844 = D.23847;
      D.23812 = array->bounds;
      D.23845 = i * 8;
      D.23846 = D.23812 + D.23845;
      D.23847 = D.23846->length;
      size.183 = size;
      size.186 = D.23847 * size.183;
      size = size.186;
      D.23838 = klass->rank;
      D.23849 = (unsigned int) D.23838;
      D.23850 = D.23849 + i;
      D.23851 = D.23850 * 4;
      D.23852 = sizes + D.23851;
      D.23812 = array->bounds;
      D.23845 = i * 8;
      D.23846 = D.23812 + D.23845;
      D.23853 = D.23846->lower_bound;
      D.23854 = (unsigned int) D.23853;
      *D.23852 = D.23854;
      i = i + 1;
      <D.19897>:
      D.23838 = klass->rank;
      D.23849 = (unsigned int) D.23838;
      if (D.23849 > i) goto <D.19896>; else goto <D.19898>;
      <D.19898>:
      D.23838 = klass->rank;
      D.23839 = (unsigned int) D.23838;
      D.23855 = D.23839 * 4;
      D.23856 = sizes + D.23855;
      o = mono_array_new_full (domain, klass, sizes, D.23856);
      D.23820 = klass->element_class;
      D.23821 = BIT_FIELD_REF <*D.23820, 8, 160>;
      D.23822 = D.23821 & 8;
      if (D.23822 != 0) goto <D.23857>; else goto <D.23858>;
      <D.23857>:
      D.23820 = klass->element_class;
      D.23825 = BIT_FIELD_REF <*D.23820, 8, 184>;
      D.23826 = D.23825 & 8;
      if (D.23826 != 0) goto <D.23859>; else goto <D.23860>;
      <D.23859>:
      D.23861 = mono_array_length (array);
      D.23862 = (int) D.23861;
      D.23831 = &array->vector;
      mono_value_copy_array (o, 0, D.23831, D.23862);
      goto <D.23863>;
      <D.23860>:
      size.183 = size;
      D.23831 = &array->vector;
      D.23833 = &o->vector;
      mono_gc_memmove_atomic (D.23833, D.23831, size.183);
      <D.23863>:
      goto <D.23864>;
      <D.23858>:
      {
        void * * __p;
        void * * __s;

        __p = mono_array_addr_with_size (o, 4, 0);
        __s = mono_array_addr_with_size (array, 4, 0);
        D.23865 = mono_array_length (array);
        D.23866 = (int) D.23865;
        mono_gc_wbarrier_arrayref_copy (__p, __s, D.23866);
      }
      <D.23864>:
      D.23837 = o;
      return D.23837;
    }
  finally
    {
      size = {CLOBBER};
    }
}


mono_array_clone (struct MonoArray * array)
{
  struct MonoArray * D.23869;
  struct MonoVTable * D.23870;
  struct MonoDomain * D.23871;

  D.23870 = MEM[(struct MonoObject *)array].vtable;
  D.23871 = D.23870->domain;
  D.23869 = mono_array_clone_in_domain (D.23871, array);
  return D.23869;
}


mono_array_calc_byte_len (struct MonoClass * class, uintptr_t len, uintptr_t * res)
{
  int D.23873;
  int iftmp.187;
  _Bool D.23877;
  _Bool D.23878;
  _Bool D.23879;
  unsigned int D.23881;
  _Bool D.23883;
  long int D.23884;
  long int D.23885;
  gboolean D.23888;
  _Bool D.23889;
  long int D.23890;
  long int D.23891;
  uintptr_t byte_len;

  D.23873 = mono_array_element_size (class);
  byte_len = (uintptr_t) D.23873;
  D.23877 = byte_len != 0;
  D.23878 = len != 0;
  D.23879 = D.23877 & D.23878;
  if (D.23879 != 0) goto <D.23880>; else goto <D.23875>;
  <D.23880>:
  D.23881 = 4294967295 / byte_len;
  if (D.23881 < len) goto <D.23882>; else goto <D.23875>;
  <D.23882>:
  iftmp.187 = 1;
  goto <D.23876>;
  <D.23875>:
  iftmp.187 = 0;
  <D.23876>:
  D.23883 = iftmp.187 != 0;
  D.23884 = (long int) D.23883;
  D.23885 = __builtin_expect (D.23884, 0);
  if (D.23885 != 0) goto <D.23886>; else goto <D.23887>;
  <D.23886>:
  D.23888 = 0;
  return D.23888;
  <D.23887>:
  byte_len = byte_len * len;
  D.23889 = byte_len > 4294967279;
  D.23890 = (long int) D.23889;
  D.23891 = __builtin_expect (D.23890, 0);
  if (D.23891 != 0) goto <D.23892>; else goto <D.23893>;
  <D.23892>:
  D.23888 = 0;
  return D.23888;
  <D.23893>:
  byte_len = byte_len + 16;
  *res = byte_len;
  D.23888 = 1;
  return D.23888;
}


mono_array_new_full (struct MonoDomain * domain, struct MonoClass * array_class, uintptr_t * lengths, intptr_t * lower_bounds)
{
  unsigned char D.23895;
  unsigned char D.23896;
  unsigned char D.23901;
  unsigned char D.23903;
  int D.23906;
  signed int len.188;
  unsigned int D.23910;
  unsigned int i.189;
  unsigned int D.23912;
  uintptr_t * D.23913;
  unsigned int D.23914;
  signed int D.23915;
  int iftmp.190;
  unsigned int D.23923;
  _Bool D.23925;
  long int D.23926;
  long int D.23927;
  int D.23930;
  int D.23931;
  unsigned int byte_len.191;
  _Bool D.23937;
  long int D.23938;
  long int D.23939;
  unsigned int D.23942;
  unsigned int byte_len.192;
  unsigned int D.23944;
  _Bool D.23945;
  long int D.23946;
  long int D.23947;
  unsigned int byte_len.193;
  long long unsigned int D.23954;
  long long unsigned int D.23955;
  unsigned int D.23958;
  struct MonoArrayBounds * D.23959;
  intptr_t * D.23962;
  int D.23963;
  int profile_allocs.194;
  _Bool D.23965;
  long int D.23966;
  long int D.23967;
  struct MonoArray * D.23970;
  uintptr_t byte_len;
  uintptr_t len;
  uintptr_t bounds_size;
  struct MonoObject * o;
  struct MonoArray * array;
  struct MonoArrayBounds * bounds;
  struct MonoVTable * vtable;
  int i;

  try
    {
      D.23895 = BIT_FIELD_REF <*array_class, 8, 160>;
      D.23896 = D.23895 & 1;
      if (D.23896 == 0) goto <D.23897>; else goto <D.23898>;
      <D.23897>:
      mono_class_init (array_class);
      <D.23898>:
      len = 1;
      D.23901 = array_class->rank;
      if (D.23901 == 1) goto <D.23902>; else goto <D.23899>;
      <D.23902>:
      D.23903 = array_class->byval_arg.type;
      if (D.23903 == 29) goto <D.23900>; else goto <D.23904>;
      <D.23904>:
      if (lower_bounds != 0B) goto <D.23905>; else goto <D.23899>;
      <D.23905>:
      D.23906 = *lower_bounds;
      if (D.23906 == 0) goto <D.23900>; else goto <D.23899>;
      <D.23900>:
      len = *lengths;
      len.188 = (signed int) len;
      if (len.188 < 0) goto <D.23908>; else goto <D.23909>;
      <D.23908>:
      arith_overflow ();
      <D.23909>:
      bounds_size = 0;
      goto <D.19926>;
      <D.23899>:
      D.23901 = array_class->rank;
      D.23910 = (unsigned int) D.23901;
      bounds_size = D.23910 * 8;
      i = 0;
      goto <D.19925>;
      <D.19924>:
      i.189 = (unsigned int) i;
      D.23912 = i.189 * 4;
      D.23913 = lengths + D.23912;
      D.23914 = *D.23913;
      D.23915 = (signed int) D.23914;
      if (D.23915 < 0) goto <D.23916>; else goto <D.23917>;
      <D.23916>:
      arith_overflow ();
      <D.23917>:
      if (len != 0) goto <D.23921>; else goto <D.23919>;
      <D.23921>:
      i.189 = (unsigned int) i;
      D.23912 = i.189 * 4;
      D.23913 = lengths + D.23912;
      D.23914 = *D.23913;
      if (D.23914 != 0) goto <D.23922>; else goto <D.23919>;
      <D.23922>:
      i.189 = (unsigned int) i;
      D.23912 = i.189 * 4;
      D.23913 = lengths + D.23912;
      D.23914 = *D.23913;
      D.23923 = 4294967295 / len;
      if (D.23914 > D.23923) goto <D.23924>; else goto <D.23919>;
      <D.23924>:
      iftmp.190 = 1;
      goto <D.23920>;
      <D.23919>:
      iftmp.190 = 0;
      <D.23920>:
      D.23925 = iftmp.190 != 0;
      D.23926 = (long int) D.23925;
      D.23927 = __builtin_expect (D.23926, 0);
      if (D.23927 != 0) goto <D.23928>; else goto <D.23929>;
      <D.23928>:
      mono_gc_out_of_memory (4294967295);
      <D.23929>:
      i.189 = (unsigned int) i;
      D.23912 = i.189 * 4;
      D.23913 = lengths + D.23912;
      D.23914 = *D.23913;
      len = D.23914 * len;
      i = i + 1;
      <D.19925>:
      D.23901 = array_class->rank;
      D.23930 = (int) D.23901;
      if (D.23930 > i) goto <D.19924>; else goto <D.19926>;
      <D.19926>:
      D.23931 = mono_array_calc_byte_len (array_class, len, &byte_len);
      if (D.23931 == 0) goto <D.23932>; else goto <D.23933>;
      <D.23932>:
      mono_gc_out_of_memory (4294967295);
      <D.23933>:
      if (bounds_size != 0) goto <D.23934>; else goto <D.23935>;
      <D.23934>:
      byte_len.191 = byte_len;
      D.23937 = byte_len.191 > 4294967292;
      D.23938 = (long int) D.23937;
      D.23939 = __builtin_expect (D.23938, 0);
      if (D.23939 != 0) goto <D.23940>; else goto <D.23941>;
      <D.23940>:
      mono_gc_out_of_memory (4294967295);
      <D.23941>:
      byte_len.191 = byte_len;
      D.23942 = byte_len.191 + 3;
      byte_len.192 = D.23942 & 4294967292;
      byte_len = byte_len.192;
      D.23944 = ~bounds_size;
      byte_len.191 = byte_len;
      D.23945 = D.23944 < byte_len.191;
      D.23946 = (long int) D.23945;
      D.23947 = __builtin_expect (D.23946, 0);
      if (D.23947 != 0) goto <D.23948>; else goto <D.23949>;
      <D.23948>:
      mono_gc_out_of_memory (4294967295);
      <D.23949>:
      byte_len.191 = byte_len;
      byte_len.193 = byte_len.191 + bounds_size;
      byte_len = byte_len.193;
      <D.23935>:
      vtable = mono_class_vtable_full (domain, array_class, 1);
      if (bounds_size != 0) goto <D.23951>; else goto <D.23952>;
      <D.23951>:
      byte_len.191 = byte_len;
      o = mono_gc_alloc_array (vtable, byte_len.191, len, bounds_size);
      goto <D.23953>;
      <D.23952>:
      byte_len.191 = byte_len;
      o = mono_gc_alloc_vector (vtable, byte_len.191, len);
      <D.23953>:
      array = o;
      D.23954 = mono_stats.new_object_count;
      D.23955 = D.23954 + 1;
      mono_stats.new_object_count = D.23955;
      bounds = array->bounds;
      if (bounds_size != 0) goto <D.23956>; else goto <D.23957>;
      <D.23956>:
      i = 0;
      goto <D.19928>;
      <D.19927>:
      i.189 = (unsigned int) i;
      D.23958 = i.189 * 8;
      D.23959 = bounds + D.23958;
      i.189 = (unsigned int) i;
      D.23912 = i.189 * 4;
      D.23913 = lengths + D.23912;
      D.23914 = *D.23913;
      D.23959->length = D.23914;
      if (lower_bounds != 0B) goto <D.23960>; else goto <D.23961>;
      <D.23960>:
      i.189 = (unsigned int) i;
      D.23958 = i.189 * 8;
      D.23959 = bounds + D.23958;
      i.189 = (unsigned int) i;
      D.23912 = i.189 * 4;
      D.23962 = lower_bounds + D.23912;
      D.23963 = *D.23962;
      D.23959->lower_bound = D.23963;
      <D.23961>:
      i = i + 1;
      <D.19928>:
      D.23901 = array_class->rank;
      D.23930 = (int) D.23901;
      if (D.23930 > i) goto <D.19927>; else goto <D.19929>;
      <D.19929>:
      <D.23957>:
      profile_allocs.194 = profile_allocs;
      D.23965 = profile_allocs.194 != 0;
      D.23966 = (long int) D.23965;
      D.23967 = __builtin_expect (D.23966, 0);
      if (D.23967 != 0) goto <D.23968>; else goto <D.23969>;
      <D.23968>:
      mono_profiler_allocation (o, array_class);
      <D.23969>:
      D.23970 = array;
      return D.23970;
    }
  finally
    {
      byte_len = {CLOBBER};
    }
}


arith_overflow ()
{
  struct MonoException * D.23973;

  D.23973 = mono_get_exception_overflow ();
  mono_raise_exception (D.23973);
}


mono_array_new (struct MonoDomain * domain, struct MonoClass * eclass, uintptr_t n)
{
  _Bool D.23974;
  long int D.23975;
  long int D.23976;
  struct MonoArray * D.23979;
  struct MonoVTable * D.23980;
  struct MonoClass * ac;

  ac = mono_array_class_get (eclass, 1);
  D.23974 = ac == 0B;
  D.23975 = (long int) D.23974;
  D.23976 = __builtin_expect (D.23975, 0);
  if (D.23976 != 0) goto <D.23977>; else goto <D.23978>;
  <D.23977>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 4869, "ac");
  <D.23978>:
  D.23980 = mono_class_vtable_full (domain, ac, 1);
  D.23979 = mono_array_new_specific (D.23980, n);
  return D.23979;
}


mono_array_new_specific (struct MonoVTable * vtable, uintptr_t n)
{
  signed int n.195;
  _Bool D.23983;
  long int D.23984;
  long int D.23985;
  struct MonoArray * D.23988;
  struct MonoClass * D.23989;
  int D.23990;
  unsigned int byte_len.196;
  long long unsigned int D.23994;
  long long unsigned int D.23995;
  int profile_allocs.197;
  _Bool D.23997;
  long int D.23998;
  long int D.23999;
  struct MonoObject * o;
  struct MonoArray * ao;
  uintptr_t byte_len;

  try
    {
      n.195 = (signed int) n;
      D.23983 = n.195 < 0;
      D.23984 = (long int) D.23983;
      D.23985 = __builtin_expect (D.23984, 0);
      if (D.23985 != 0) goto <D.23986>; else goto <D.23987>;
      <D.23986>:
      arith_overflow ();
      D.23988 = 0B;
      return D.23988;
      <D.23987>:
      D.23989 = vtable->klass;
      D.23990 = mono_array_calc_byte_len (D.23989, n, &byte_len);
      if (D.23990 == 0) goto <D.23991>; else goto <D.23992>;
      <D.23991>:
      mono_gc_out_of_memory (4294967295);
      D.23988 = 0B;
      return D.23988;
      <D.23992>:
      byte_len.196 = byte_len;
      o = mono_gc_alloc_vector (vtable, byte_len.196, n);
      ao = o;
      D.23994 = mono_stats.new_object_count;
      D.23995 = D.23994 + 1;
      mono_stats.new_object_count = D.23995;
      profile_allocs.197 = profile_allocs;
      D.23997 = profile_allocs.197 != 0;
      D.23998 = (long int) D.23997;
      D.23999 = __builtin_expect (D.23998, 0);
      if (D.23999 != 0) goto <D.24000>; else goto <D.24001>;
      <D.24000>:
      D.23989 = vtable->klass;
      mono_profiler_allocation (o, D.23989);
      <D.24001>:
      D.23988 = ao;
      return D.23988;
    }
  finally
    {
      byte_len = {CLOBBER};
    }
}


mono_string_new_utf16 (struct MonoDomain * domain, const guint16 * text, gint32 len)
{
  _Bool D.24004;
  long int D.24005;
  long int D.24006;
  int D.24009;
  unsigned int D.24010;
  mono_unichar2 * D.24011;
  struct MonoString * D.24012;
  struct MonoString * s;

  s = mono_string_new_size (domain, len);
  D.24004 = s == 0B;
  D.24005 = (long int) D.24004;
  D.24006 = __builtin_expect (D.24005, 0);
  if (D.24006 != 0) goto <D.24007>; else goto <D.24008>;
  <D.24007>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 4941, "s != NULL");
  <D.24008>:
  D.24009 = len * 2;
  D.24010 = (unsigned int) D.24009;
  D.24011 = mono_string_chars (s);
  memcpy (D.24011, text, D.24010);
  D.24012 = s;
  return D.24012;
}


mono_string_new_size (struct MonoDomain * domain, gint32 len)
{
  int D.24014;
  int D.24015;
  unsigned int D.24016;
  unsigned int len.198;
  struct MonoClass * D.24020;
  _Bool D.24021;
  long int D.24022;
  long int D.24023;
  int profile_allocs.199;
  _Bool D.24027;
  long int D.24028;
  long int D.24029;
  struct MonoString * D.24032;
  struct MonoString * s;
  struct MonoVTable * vtable;
  size_t size;

  D.24014 = len + 1;
  D.24015 = D.24014 * 2;
  D.24016 = (unsigned int) D.24015;
  size = D.24016 + 12;
  len.198 = (unsigned int) len;
  if (len.198 > size) goto <D.24018>; else goto <D.24019>;
  <D.24018>:
  mono_gc_out_of_memory (4294967295);
  <D.24019>:
  D.24020 = mono_defaults.string_class;
  vtable = mono_class_vtable (domain, D.24020);
  D.24021 = vtable == 0B;
  D.24022 = (long int) D.24021;
  D.24023 = __builtin_expect (D.24022, 0);
  if (D.24023 != 0) goto <D.24024>; else goto <D.24025>;
  <D.24024>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 4967, "vtable");
  <D.24025>:
  s = mono_gc_alloc_string (vtable, size, len);
  profile_allocs.199 = profile_allocs;
  D.24027 = profile_allocs.199 != 0;
  D.24028 = (long int) D.24027;
  D.24029 = __builtin_expect (D.24028, 0);
  if (D.24029 != 0) goto <D.24030>; else goto <D.24031>;
  <D.24030>:
  D.24020 = mono_defaults.string_class;
  mono_profiler_allocation (s, D.24020);
  <D.24031>:
  D.24032 = s;
  return D.24032;
}


mono_string_new_len (struct MonoDomain * domain, const char * text, guint length)
{
  long int length.200;
  struct GError * error.201;
  long int items_written.202;
  struct MonoString * D.24040;
  struct GError * error;
  struct MonoString * o;
  guint16 * ut;
  glong items_written;

  try
    {
      error = 0B;
      o = 0B;
      length.200 = (long int) length;
      ut = eg_utf8_to_utf16_with_nuls (text, length.200, 0B, &items_written, &error);
      error.201 = error;
      if (error.201 == 0B) goto <D.24036>; else goto <D.24037>;
      <D.24036>:
      items_written.202 = items_written;
      o = mono_string_new_utf16 (domain, ut, items_written.202);
      goto <D.24039>;
      <D.24037>:
      error.201 = error;
      monoeg_g_error_free (error.201);
      <D.24039>:
      monoeg_g_free (ut);
      D.24040 = o;
      return D.24040;
    }
  finally
    {
      error = {CLOBBER};
      items_written = {CLOBBER};
    }
}


mono_string_new (struct MonoDomain * domain, const char * text)
{
  unsigned int D.24043;
  struct GError * error.203;
  long int items_written.204;
  struct MonoString * D.24049;
  struct GError * error;
  struct MonoString * o;
  guint16 * ut;
  glong items_written;
  int l;

  try
    {
      error = 0B;
      o = 0B;
      D.24043 = strlen (text);
      l = (int) D.24043;
      ut = monoeg_g_utf8_to_utf16 (text, l, 0B, &items_written, &error);
      error.203 = error;
      if (error.203 == 0B) goto <D.24045>; else goto <D.24046>;
      <D.24045>:
      items_written.204 = items_written;
      o = mono_string_new_utf16 (domain, ut, items_written.204);
      goto <D.24048>;
      <D.24046>:
      error.203 = error;
      monoeg_g_error_free (error.203);
      <D.24048>:
      monoeg_g_free (ut);
      D.24049 = o;
      return D.24049;
    }
  finally
    {
      error = {CLOBBER};
      items_written = {CLOBBER};
    }
}


mono_string_new_wrapper (const char * text)
{
  struct MonoString * D.24054;
  struct MonoDomain * domain;

  domain = mono_domain_get ();
  if (text != 0B) goto <D.24052>; else goto <D.24053>;
  <D.24052>:
  D.24054 = mono_string_new (domain, text);
  return D.24054;
  <D.24053>:
  D.24054 = 0B;
  return D.24054;
}


mono_value_box (struct MonoDomain * domain, struct MonoClass * class, void * value)
{
  unsigned char D.24056;
  unsigned char D.24057;
  _Bool D.24058;
  long int D.24059;
  long int D.24060;
  int D.24063;
  struct MonoObject * D.24066;
  int profile_allocs.205;
  _Bool D.24070;
  long int D.24071;
  long int D.24072;
  unsigned int size.206;
  unsigned int D.24076;
  int D.24077;
  _Bool D.24078;
  long int D.24079;
  long int D.24080;
  void * D.24083;
  unsigned char D.24084;
  unsigned char D.24085;
  struct MonoObject * res;
  int size;
  struct MonoVTable * vtable;

  D.24056 = BIT_FIELD_REF <*class, 8, 160>;
  D.24057 = D.24056 & 8;
  D.24058 = D.24057 == 0;
  D.24059 = (long int) D.24058;
  D.24060 = __builtin_expect (D.24059, 0);
  if (D.24060 != 0) goto <D.24061>; else goto <D.24062>;
  <D.24061>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 5092, "class->valuetype");
  <D.24062>:
  D.24063 = mono_class_is_nullable (class);
  if (D.24063 != 0) goto <D.24064>; else goto <D.24065>;
  <D.24064>:
  D.24066 = mono_nullable_box (value, class);
  return D.24066;
  <D.24065>:
  vtable = mono_class_vtable (domain, class);
  if (vtable == 0B) goto <D.24067>; else goto <D.24068>;
  <D.24067>:
  D.24066 = 0B;
  return D.24066;
  <D.24068>:
  size = mono_class_instance_size (class);
  res = mono_object_new_alloc_specific (vtable);
  profile_allocs.205 = profile_allocs;
  D.24070 = profile_allocs.205 != 0;
  D.24071 = (long int) D.24070;
  D.24072 = __builtin_expect (D.24071, 0);
  if (D.24072 != 0) goto <D.24073>; else goto <D.24074>;
  <D.24073>:
  mono_profiler_allocation (res, class);
  <D.24074>:
  size.206 = (unsigned int) size;
  D.24076 = size.206 + 4294967288;
  size = (int) D.24076;
  D.24077 = mono_class_value_size (class, 0B);
  D.24078 = D.24077 != size;
  D.24079 = (long int) D.24078;
  D.24080 = __builtin_expect (D.24079, 0);
  if (D.24080 != 0) goto <D.24081>; else goto <D.24082>;
  <D.24081>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 5107, "size == mono_class_value_size (class, NULL)");
  <D.24082>:
  D.24083 = res + 8;
  mono_gc_wbarrier_value_copy (D.24083, value, 1, class);
  D.24084 = BIT_FIELD_REF <*class, 8, 176>;
  D.24085 = D.24084 & 32;
  if (D.24085 != 0) goto <D.24086>; else goto <D.24087>;
  <D.24086>:
  mono_object_register_finalizer (res);
  <D.24087>:
  D.24066 = res;
  return D.24066;
}


mono_value_copy (void * dest, void * src, struct MonoClass * klass)
{
  mono_gc_wbarrier_value_copy (dest, src, 1, klass);
}


mono_value_copy_array (struct MonoArray * dest, int dest_idx, void * src, int count)
{
  struct MonoVTable * D.24089;
  struct MonoClass * D.24090;
  double[0:] * D.24091;
  int D.24092;
  sizetype D.24093;
  struct MonoVTable * D.24094;
  struct MonoClass * D.24095;
  struct MonoClass * D.24096;
  int D.24097;
  _Bool D.24098;
  long int D.24099;
  long int D.24100;
  int size;
  char * d;

  D.24089 = dest->obj.vtable;
  D.24090 = D.24089->klass;
  size = mono_array_element_size (D.24090);
  D.24091 = &dest->vector;
  D.24092 = size * dest_idx;
  D.24093 = (sizetype) D.24092;
  d = D.24091 + D.24093;
  D.24094 = MEM[(struct MonoObject *)dest].vtable;
  D.24095 = D.24094->klass;
  D.24096 = D.24095->element_class;
  D.24097 = mono_class_value_size (D.24096, 0B);
  D.24098 = D.24097 != size;
  D.24099 = (long int) D.24098;
  D.24100 = __builtin_expect (D.24099, 0);
  if (D.24100 != 0) goto <D.24101>; else goto <D.24102>;
  <D.24101>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 5167, "size == mono_class_value_size (mono_object_class (dest)->element_class, NULL)");
  <D.24102>:
  D.24094 = MEM[(struct MonoObject *)dest].vtable;
  D.24095 = D.24094->klass;
  D.24096 = D.24095->element_class;
  mono_gc_wbarrier_value_copy (d, src, count, D.24096);
}


mono_object_get_domain (struct MonoObject * obj)
{
  struct MonoDomain * D.24103;
  struct MonoVTable * D.24104;

  D.24104 = obj->vtable;
  D.24103 = D.24104->domain;
  return D.24103;
}


mono_object_get_class (struct MonoObject * obj)
{
  struct MonoClass * D.24106;
  struct MonoVTable * D.24107;

  D.24107 = obj->vtable;
  D.24106 = D.24107->klass;
  return D.24106;
}


mono_object_get_size (struct MonoObject * o)
{
  struct MonoVTable * D.24109;
  struct MonoClass * D.24110;
  unsigned int D.24113;
  int D.24114;
  int D.24115;
  unsigned int D.24116;
  unsigned char D.24117;
  int D.24120;
  unsigned int D.24121;
  unsigned int D.24122;
  unsigned int D.24123;
  struct MonoArrayBounds * D.24124;
  unsigned int D.24127;
  unsigned int D.24128;
  int D.24129;
  struct MonoClass * klass;

  D.24109 = o->vtable;
  klass = D.24109->klass;
  D.24110 = mono_defaults.string_class;
  if (D.24110 == klass) goto <D.24111>; else goto <D.24112>;
  <D.24111>:
  D.24114 = mono_string_length (o);
  D.24115 = D.24114 * 2;
  D.24116 = (unsigned int) D.24115;
  D.24113 = D.24116 + 14;
  return D.24113;
  <D.24112>:
  D.24109 = o->vtable;
  D.24117 = D.24109->rank;
  if (D.24117 != 0) goto <D.24118>; else goto <D.24119>;
  <D.24118>:
  {
    struct MonoArray * array;
    size_t size;

    array = o;
    D.24120 = mono_array_element_size (klass);
    D.24121 = (unsigned int) D.24120;
    D.24122 = mono_array_length (array);
    D.24123 = D.24121 * D.24122;
    size = D.24123 + 16;
    D.24124 = array->bounds;
    if (D.24124 != 0B) goto <D.24125>; else goto <D.24126>;
    <D.24125>:
    size = size + 3;
    size = size & 4294967292;
    D.24109 = o->vtable;
    D.24117 = D.24109->rank;
    D.24127 = (unsigned int) D.24117;
    D.24128 = D.24127 * 8;
    size = D.24128 + size;
    <D.24126>:
    D.24113 = size;
    return D.24113;
  }
  <D.24119>:
  D.24129 = mono_class_instance_size (klass);
  D.24113 = (unsigned int) D.24129;
  return D.24113;
}


mono_object_unbox (struct MonoObject * obj)
{
  struct MonoVTable * D.24131;
  struct MonoClass * D.24132;
  unsigned char D.24133;
  unsigned char D.24134;
  _Bool D.24135;
  long int D.24136;
  long int D.24137;
  void * D.24140;

  D.24131 = obj->vtable;
  D.24132 = D.24131->klass;
  D.24133 = BIT_FIELD_REF <*D.24132, 8, 160>;
  D.24134 = D.24133 & 8;
  D.24135 = D.24134 == 0;
  D.24136 = (long int) D.24135;
  D.24137 = __builtin_expect (D.24136, 0);
  if (D.24137 != 0) goto <D.24138>; else goto <D.24139>;
  <D.24138>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 5233, "obj->vtable->klass->valuetype");
  <D.24139>:
  D.24140 = obj + 8;
  return D.24140;
}


mono_object_isinst (struct MonoObject * obj, struct MonoClass * klass)
{
  unsigned char D.24142;
  unsigned char D.24143;
  unsigned char D.24148;
  unsigned char D.24149;
  unsigned int D.24151;
  unsigned int D.24152;
  struct MonoObject * D.24153;
  struct MonoObject * iftmp.207;
  struct MonoVTable * D.24157;
  struct MonoClass * D.24158;
  int D.24159;

  D.24142 = BIT_FIELD_REF <*klass, 8, 160>;
  D.24143 = D.24142 & 1;
  if (D.24143 == 0) goto <D.24144>; else goto <D.24145>;
  <D.24144>:
  mono_class_init (klass);
  <D.24145>:
  D.24148 = BIT_FIELD_REF <*klass, 8, 176>;
  D.24149 = D.24148 & 64;
  if (D.24149 != 0) goto <D.24146>; else goto <D.24150>;
  <D.24150>:
  D.24151 = klass->flags;
  D.24152 = D.24151 & 32;
  if (D.24152 != 0) goto <D.24146>; else goto <D.24147>;
  <D.24146>:
  D.24153 = mono_object_isinst_mbyref (obj, klass);
  return D.24153;
  <D.24147>:
  if (obj == 0B) goto <D.24154>; else goto <D.24155>;
  <D.24154>:
  D.24153 = 0B;
  return D.24153;
  <D.24155>:
  D.24157 = obj->vtable;
  D.24158 = D.24157->klass;
  D.24159 = mono_class_is_assignable_from (klass, D.24158);
  if (D.24159 != 0) goto <D.24160>; else goto <D.24161>;
  <D.24160>:
  iftmp.207 = obj;
  goto <D.24162>;
  <D.24161>:
  iftmp.207 = 0B;
  <D.24162>:
  D.24153 = iftmp.207;
  return D.24153;
}


mono_object_isinst_mbyref (struct MonoObject * obj, struct MonoClass * klass)
{
  struct MonoObject * D.24166;
  unsigned int D.24167;
  unsigned int D.24168;
  short unsigned int D.24171;
  short unsigned int D.24172;
  guint8 * D.24175;
  short unsigned int D.24176;
  sizetype D.24177;
  guint8 * D.24178;
  unsigned char D.24179;
  int D.24180;
  int D.24181;
  int D.24182;
  int D.24183;
  int D.24184;
  int D.24187;
  struct MonoVTable * D.24190;
  struct MonoClass * D.24191;
  int D.24192;
  struct MonoClass * D.24196;
  struct MonoRemoteClass * D.24199;
  short unsigned int D.24200;
  short unsigned int D.24201;
  struct MonoClass * * D.24204;
  sizetype D.24205;
  sizetype D.24206;
  sizetype D.24207;
  struct MonoClass * * D.24208;
  struct MonoClass * D.24209;
  struct MonoClass * D.24212;
  unsigned char D.24215;
  _Bool D.24218;
  long int D.24219;
  long int D.24220;
  struct MonoType * D.24223;
  struct MonoReflectionType * D.24224;
  void * D.24225;
  unsigned char D.24226;
  struct MonoVTable * vt;

  if (obj == 0B) goto <D.24164>; else goto <D.24165>;
  <D.24164>:
  D.24166 = 0B;
  return D.24166;
  <D.24165>:
  vt = obj->vtable;
  D.24167 = klass->flags;
  D.24168 = D.24167 & 32;
  if (D.24168 != 0) goto <D.24169>; else goto <D.24170>;
  <D.24169>:
  D.24171 = klass->interface_id;
  D.24172 = vt->max_interface_id;
  if (D.24171 <= D.24172) goto <D.24173>; else goto <D.24174>;
  <D.24173>:
  D.24175 = vt->interface_bitmap;
  D.24171 = klass->interface_id;
  D.24176 = D.24171 >> 3;
  D.24177 = (sizetype) D.24176;
  D.24178 = D.24175 + D.24177;
  D.24179 = *D.24178;
  D.24180 = (int) D.24179;
  D.24171 = klass->interface_id;
  D.24181 = (int) D.24171;
  D.24182 = D.24181 & 7;
  D.24183 = D.24180 >> D.24182;
  D.24184 = D.24183 & 1;
  if (D.24184 != 0) goto <D.24185>; else goto <D.24186>;
  <D.24185>:
  D.24166 = obj;
  return D.24166;
  <D.24186>:
  <D.24174>:
  D.24187 = mono_class_has_variant_generic_params (klass);
  if (D.24187 != 0) goto <D.24188>; else goto <D.24189>;
  <D.24188>:
  D.24190 = obj->vtable;
  D.24191 = D.24190->klass;
  D.24192 = mono_class_is_assignable_from (klass, D.24191);
  if (D.24192 != 0) goto <D.24193>; else goto <D.24194>;
  <D.24193>:
  D.24166 = obj;
  return D.24166;
  <D.24194>:
  <D.24189>:
  goto <D.24195>;
  <D.24170>:
  {
    struct MonoClass * oklass;

    oklass = vt->klass;
    D.24196 = mono_defaults.transparent_proxy_class;
    if (D.24196 == oklass) goto <D.24197>; else goto <D.24198>;
    <D.24197>:
    D.24199 = MEM[(struct MonoTransparentProxy *)obj].remote_class;
    oklass = D.24199->proxy_class;
    <D.24198>:
    mono_class_setup_supertypes (klass);
    D.24200 = oklass->idepth;
    D.24201 = klass->idepth;
    if (D.24200 >= D.24201) goto <D.24202>; else goto <D.24203>;
    <D.24202>:
    D.24204 = oklass->supertypes;
    D.24201 = klass->idepth;
    D.24205 = (sizetype) D.24201;
    D.24206 = D.24205 + 1073741823;
    D.24207 = D.24206 * 4;
    D.24208 = D.24204 + D.24207;
    D.24209 = *D.24208;
    if (D.24209 == klass) goto <D.24210>; else goto <D.24211>;
    <D.24210>:
    D.24166 = obj;
    return D.24166;
    <D.24211>:
    <D.24203>:
  }
  <D.24195>:
  D.24212 = vt->klass;
  D.24196 = mono_defaults.transparent_proxy_class;
  if (D.24212 == D.24196) goto <D.24213>; else goto <D.24214>;
  <D.24213>:
  D.24215 = MEM[(struct MonoTransparentProxy *)obj].custom_type_info;
  if (D.24215 != 0) goto <D.24216>; else goto <D.24217>;
  <D.24216>:
  {
    struct MonoDomain * domain;
    struct MonoObject * res;
    struct MonoObject * rp;
    struct MonoClass * rpklass;
    struct MonoMethod * im;
    void * pa[2];

    try
      {
        domain = mono_domain_get ();
        rp = MEM[(struct MonoTransparentProxy *)obj].rp;
        rpklass = mono_defaults.iremotingtypeinfo_class;
        im = 0B;
        im = mono_class_get_method_from_name (rpklass, "CanCastTo", -1);
        im = mono_object_get_virtual_method (rp, im);
        D.24218 = im == 0B;
        D.24219 = (long int) D.24218;
        D.24220 = __builtin_expect (D.24219, 0);
        if (D.24220 != 0) goto <D.24221>; else goto <D.24222>;
        <D.24221>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 5298, "im");
        <D.24222>:
        D.24223 = &klass->byval_arg;
        D.24224 = mono_type_get_object (domain, D.24223);
        pa[0] = D.24224;
        pa[1] = obj;
        res = mono_runtime_invoke (im, rp, &pa, 0B);
        D.24225 = mono_object_unbox (res);
        D.24226 = MEM[(MonoBoolean *)D.24225];
        if (D.24226 != 0) goto <D.24227>; else goto <D.24228>;
        <D.24227>:
        mono_upgrade_remote_class (domain, obj, klass);
        D.24166 = obj;
        return D.24166;
        <D.24228>:
      }
    finally
      {
        pa = {CLOBBER};
      }
  }
  <D.24217>:
  <D.24214>:
  D.24166 = 0B;
  return D.24166;
}


mono_object_castclass_mbyref (struct MonoObject * obj, struct MonoClass * klass)
{
  struct MonoObject * D.24234;
  struct MonoObject * D.24235;
  struct MonoImage * D.24238;
  struct MonoException * D.24239;

  if (obj == 0B) goto <D.24232>; else goto <D.24233>;
  <D.24232>:
  D.24234 = 0B;
  return D.24234;
  <D.24233>:
  D.24235 = mono_object_isinst_mbyref (obj, klass);
  if (D.24235 != 0B) goto <D.24236>; else goto <D.24237>;
  <D.24236>:
  D.24234 = obj;
  return D.24234;
  <D.24237>:
  D.24238 = mono_defaults.corlib;
  D.24239 = mono_exception_from_name (D.24238, "System", "InvalidCastException");
  mono_raise_exception (D.24239);
  D.24234 = 0B;
  return D.24234;
}


mono_string_is_interned (struct MonoString * o)
{
  struct MonoString * D.24241;

  D.24241 = mono_string_is_interned_lookup (o, 0);
  return D.24241;
}


mono_string_is_interned_lookup (struct MonoString * str, int insert)
{
  struct MonoVTable * D.24243;
  _Bool D.24246;
  long int D.24247;
  long int D.24248;
  _Bool D.24255;
  long int D.24256;
  long int D.24257;
  struct MonoString * D.24260;
  _Bool D.24267;
  long int D.24268;
  long int D.24269;
  struct MonoString * D.24272;
  _Bool D.24277;
  long int D.24278;
  long int D.24279;
  _Bool D.24284;
  long int D.24285;
  long int D.24286;
  struct MonoGHashTable * ldstr_table;
  struct MonoString * res;
  struct MonoDomain * domain;

  D.24243 = MEM[(struct MonoObject *)str].vtable;
  domain = D.24243->domain;
  ldstr_table = domain->ldstr_table;
  {
    int ret;

    ret = pthread_mutex_lock (&ldstr_section.mutex);
    if (ret != 0) goto <D.24244>; else goto <D.24245>;
    <D.24244>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.24245>:
    D.24246 = ret != 0;
    D.24247 = (long int) D.24246;
    D.24248 = __builtin_expect (D.24247, 0);
    if (D.24248 != 0) goto <D.24249>; else goto <D.24250>;
    <D.24249>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 5378, "ret == 0");
    <D.24250>:
  }
  res = mono_g_hash_table_lookup (ldstr_table, str);
  if (res != 0B) goto <D.24251>; else goto <D.24252>;
  <D.24251>:
  {
    int ret;

    ret = pthread_mutex_unlock (&ldstr_section.mutex);
    if (ret != 0) goto <D.24253>; else goto <D.24254>;
    <D.24253>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.24254>:
    D.24255 = ret != 0;
    D.24256 = (long int) D.24255;
    D.24257 = __builtin_expect (D.24256, 0);
    if (D.24257 != 0) goto <D.24258>; else goto <D.24259>;
    <D.24258>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 5380, "ret == 0");
    <D.24259>:
  }
  D.24260 = res;
  return D.24260;
  <D.24252>:
  if (insert != 0) goto <D.24261>; else goto <D.24262>;
  <D.24261>:
  str = mono_string_get_pinned (str);
  if (str != 0B) goto <D.24263>; else goto <D.24264>;
  <D.24263>:
  mono_g_hash_table_insert (ldstr_table, str, str);
  <D.24264>:
  {
    int ret;

    ret = pthread_mutex_unlock (&ldstr_section.mutex);
    if (ret != 0) goto <D.24265>; else goto <D.24266>;
    <D.24265>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.24266>:
    D.24267 = ret != 0;
    D.24268 = (long int) D.24267;
    D.24269 = __builtin_expect (D.24268, 0);
    if (D.24269 != 0) goto <D.24270>; else goto <D.24271>;
    <D.24270>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 5387, "ret == 0");
    <D.24271>:
  }
  D.24260 = str;
  return D.24260;
  <D.24262>:
  {
    struct LDStrInfo ldstr_info;

    try
      {
        ldstr_info.orig_domain = domain;
        ldstr_info.ins = str;
        ldstr_info.res = 0B;
        mono_domain_foreach (str_lookup, &ldstr_info);
        D.24272 = ldstr_info.res;
        if (D.24272 != 0B) goto <D.24273>; else goto <D.24274>;
        <D.24273>:
        mono_g_hash_table_insert (ldstr_table, str, str);
        {
          int ret;

          ret = pthread_mutex_unlock (&ldstr_section.mutex);
          if (ret != 0) goto <D.24275>; else goto <D.24276>;
          <D.24275>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
          <D.24276>:
          D.24277 = ret != 0;
          D.24278 = (long int) D.24277;
          D.24279 = __builtin_expect (D.24278, 0);
          if (D.24279 != 0) goto <D.24280>; else goto <D.24281>;
          <D.24280>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 5402, "ret == 0");
          <D.24281>:
        }
        D.24260 = str;
        return D.24260;
        <D.24274>:
      }
    finally
      {
        ldstr_info = {CLOBBER};
      }
  }
  {
    int ret;

    ret = pthread_mutex_unlock (&ldstr_section.mutex);
    if (ret != 0) goto <D.24282>; else goto <D.24283>;
    <D.24282>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.24283>:
    D.24284 = ret != 0;
    D.24285 = (long int) D.24284;
    D.24286 = __builtin_expect (D.24285, 0);
    if (D.24286 != 0) goto <D.24287>; else goto <D.24288>;
    <D.24287>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 5406, "ret == 0");
    <D.24288>:
  }
  D.24260 = 0B;
  return D.24260;
}


str_lookup (struct MonoDomain * domain, void * user_data)
{
  struct MonoString * D.24294;
  struct MonoDomain * D.24296;
  struct MonoString * D.24297;
  struct MonoGHashTable * D.24298;
  void * D.24299;
  struct LDStrInfo * info;

  info = user_data;
  D.24294 = info->res;
  if (D.24294 != 0B) goto <D.24292>; else goto <D.24295>;
  <D.24295>:
  D.24296 = info->orig_domain;
  if (D.24296 == domain) goto <D.24292>; else goto <D.24293>;
  <D.24292>:
  return;
  <D.24293>:
  D.24297 = info->ins;
  D.24298 = domain->ldstr_table;
  D.24299 = mono_g_hash_table_lookup (D.24298, D.24297);
  info->res = D.24299;
}


mono_string_intern (struct MonoString * str)
{
  struct MonoString * D.24301;

  D.24301 = mono_string_is_interned_lookup (str, 1);
  return D.24301;
}


mono_ldstr (struct MonoDomain * domain, struct MonoImage * image, guint32 idx)
{
  unsigned char D.24303;
  unsigned char D.24304;
  unsigned int D.24307;
  struct MonoString * D.24308;
  int D.24309;
  const char * D.24312;

  D.24303 = BIT_FIELD_REF <*image, 8, 128>;
  D.24304 = D.24303 & 8;
  if (D.24304 != 0) goto <D.24305>; else goto <D.24306>;
  <D.24305>:
  {
    struct MonoString * str;

    D.24307 = idx | 1879048192;
    str = mono_lookup_dynamic_token (image, D.24307, 0B);
    D.24308 = str;
    return D.24308;
  }
  <D.24306>:
  D.24309 = mono_verifier_verify_string_signature (image, idx, 0B);
  if (D.24309 == 0) goto <D.24310>; else goto <D.24311>;
  <D.24310>:
  D.24308 = 0B;
  return D.24308;
  <D.24311>:
  D.24312 = mono_metadata_user_string (image, idx);
  D.24308 = mono_ldstr_metadata_sig (domain, D.24312);
  return D.24308;
}


mono_string_to_utf8 (struct MonoString * s)
{
  int D.24314;
  char * D.24317;
  struct MonoError error;
  char * result;

  try
    {
      result = mono_string_to_utf8_checked (s, &error);
      D.24314 = mono_error_ok (&error);
      if (D.24314 == 0) goto <D.24315>; else goto <D.24316>;
      <D.24315>:
      mono_error_raise_exception (&error);
      <D.24316>:
      D.24317 = result;
      return D.24317;
    }
  finally
    {
      error = {CLOBBER};
    }
}


mono_string_to_utf8_checked (struct MonoString * s, struct MonoError * error)
{
  char * D.24322;
  int D.24323;
  mono_unichar2 * D.24326;
  struct GError * gerror.208;
  gchar * D.24330;
  long int written.209;
  unsigned int D.24334;
  unsigned int written.210;
  long int written;
  char * as;
  struct GError * gerror;

  try
    {
      written = 0;
      gerror = 0B;
      mono_error_init (error);
      if (s == 0B) goto <D.24320>; else goto <D.24321>;
      <D.24320>:
      D.24322 = 0B;
      return D.24322;
      <D.24321>:
      D.24323 = s->length;
      if (D.24323 == 0) goto <D.24324>; else goto <D.24325>;
      <D.24324>:
      D.24322 = monoeg_strdup ("");
      return D.24322;
      <D.24325>:
      D.24323 = s->length;
      D.24326 = mono_string_chars (s);
      as = monoeg_g_utf16_to_utf8 (D.24326, D.24323, 0B, &written, &gerror);
      gerror.208 = gerror;
      if (gerror.208 != 0B) goto <D.24328>; else goto <D.24329>;
      <D.24328>:
      gerror.208 = gerror;
      D.24330 = gerror.208->message;
      mono_error_set_argument (error, "string", "%s", D.24330);
      gerror.208 = gerror;
      monoeg_g_error_free (gerror.208);
      D.24322 = 0B;
      return D.24322;
      <D.24329>:
      D.24323 = s->length;
      written.209 = written;
      if (D.24323 > written.209) goto <D.24332>; else goto <D.24333>;
      <D.24332>:
      {
        char * as2;

        D.24323 = s->length;
        D.24334 = (unsigned int) D.24323;
        as2 = monoeg_malloc0 (D.24334);
        written.209 = written;
        written.210 = (unsigned int) written.209;
        memcpy (as2, as, written.210);
        monoeg_g_free (as);
        as = as2;
      }
      <D.24333>:
      D.24322 = as;
      return D.24322;
    }
  finally
    {
      written = {CLOBBER};
      gerror = {CLOBBER};
    }
}


mono_string_to_utf8_ignore (struct MonoString * s)
{
  char * D.24340;
  int D.24341;
  mono_unichar2 * D.24344;
  long int written.211;
  unsigned int D.24348;
  unsigned int written.212;
  long int written;
  char * as;

  try
    {
      written = 0;
      if (s == 0B) goto <D.24338>; else goto <D.24339>;
      <D.24338>:
      D.24340 = 0B;
      return D.24340;
      <D.24339>:
      D.24341 = s->length;
      if (D.24341 == 0) goto <D.24342>; else goto <D.24343>;
      <D.24342>:
      D.24340 = monoeg_strdup ("");
      return D.24340;
      <D.24343>:
      D.24341 = s->length;
      D.24344 = mono_string_chars (s);
      as = monoeg_g_utf16_to_utf8 (D.24344, D.24341, 0B, &written, 0B);
      D.24341 = s->length;
      written.211 = written;
      if (D.24341 > written.211) goto <D.24346>; else goto <D.24347>;
      <D.24346>:
      {
        char * as2;

        D.24341 = s->length;
        D.24348 = (unsigned int) D.24341;
        as2 = monoeg_malloc0 (D.24348);
        written.211 = written;
        written.212 = (unsigned int) written.211;
        memcpy (as2, as, written.212);
        monoeg_g_free (as);
        as = as2;
      }
      <D.24347>:
      D.24340 = as;
      return D.24340;
    }
  finally
    {
      written = {CLOBBER};
    }
}


mono_string_to_utf8_image_ignore (struct MonoImage * image, struct MonoString * s)
{
  char * D.24352;

  D.24352 = mono_string_to_utf8_internal (0B, image, s, 1, 0B);
  return D.24352;
}


mono_string_to_utf8_internal (struct MonoMemPool * mp, struct MonoImage * image, struct MonoString * s, gboolean ignore_error, struct MonoError * error)
{
  int D.24357;
  char * D.24360;
  _Bool D.24361;
  _Bool D.24362;
  _Bool D.24363;
  unsigned int D.24366;
  unsigned int D.24367;
  unsigned int len.213;
  unsigned int len.214;
  unsigned int len.215;
  char * r;
  char * mp_s;
  int len;

  if (ignore_error != 0) goto <D.24354>; else goto <D.24355>;
  <D.24354>:
  r = mono_string_to_utf8_ignore (s);
  goto <D.24356>;
  <D.24355>:
  r = mono_string_to_utf8_checked (s, error);
  D.24357 = mono_error_ok (error);
  if (D.24357 == 0) goto <D.24358>; else goto <D.24359>;
  <D.24358>:
  D.24360 = 0B;
  return D.24360;
  <D.24359>:
  <D.24356>:
  D.24361 = mp == 0B;
  D.24362 = image == 0B;
  D.24363 = D.24361 & D.24362;
  if (D.24363 != 0) goto <D.24364>; else goto <D.24365>;
  <D.24364>:
  D.24360 = r;
  return D.24360;
  <D.24365>:
  D.24366 = strlen (r);
  D.24367 = D.24366 + 1;
  len = (int) D.24367;
  if (mp != 0B) goto <D.24368>; else goto <D.24369>;
  <D.24368>:
  len.213 = (unsigned int) len;
  mp_s = mono_mempool_alloc (mp, len.213);
  goto <D.24371>;
  <D.24369>:
  len.214 = (unsigned int) len;
  mp_s = mono_image_alloc (image, len.214);
  <D.24371>:
  len.215 = (unsigned int) len;
  memcpy (mp_s, r, len.215);
  monoeg_g_free (r);
  D.24360 = mp_s;
  return D.24360;
}


mono_string_to_utf8_mp_ignore (struct MonoMemPool * mp, struct MonoString * s)
{
  char * D.24375;

  D.24375 = mono_string_to_utf8_internal (mp, 0B, s, 1, 0B);
  return D.24375;
}


mono_string_to_utf16 (struct MonoString * s)
{
  mono_unichar2 * D.24379;
  int D.24380;
  int D.24381;
  int D.24382;
  unsigned int D.24383;
  int D.24384;
  sizetype D.24385;
  char * D.24386;
  sizetype D.24387;
  char * D.24388;
  unsigned int D.24391;
  mono_unichar2 * D.24392;
  char * as;

  if (s == 0B) goto <D.24377>; else goto <D.24378>;
  <D.24377>:
  D.24379 = 0B;
  return D.24379;
  <D.24378>:
  D.24380 = s->length;
  D.24381 = D.24380 + 1;
  D.24382 = D.24381 * 2;
  D.24383 = (unsigned int) D.24382;
  as = monoeg_malloc (D.24383);
  D.24380 = s->length;
  D.24384 = D.24380 * 2;
  D.24385 = (sizetype) D.24384;
  D.24386 = as + D.24385;
  *D.24386 = 0;
  D.24380 = s->length;
  D.24384 = D.24380 * 2;
  D.24385 = (sizetype) D.24384;
  D.24387 = D.24385 + 1;
  D.24388 = as + D.24387;
  *D.24388 = 0;
  D.24380 = s->length;
  if (D.24380 == 0) goto <D.24389>; else goto <D.24390>;
  <D.24389>:
  D.24379 = as;
  return D.24379;
  <D.24390>:
  D.24380 = s->length;
  D.24384 = D.24380 * 2;
  D.24391 = (unsigned int) D.24384;
  D.24392 = mono_string_chars (s);
  memcpy (as, D.24392, D.24391);
  D.24379 = as;
  return D.24379;
}


mono_string_from_utf16 (gunichar2 * data)
{
  struct MonoString * D.24396;
  unsigned int len.216;
  unsigned int D.24398;
  gunichar2 * D.24399;
  short unsigned int D.24400;
  struct MonoDomain * domain;
  int len;

  domain = mono_domain_get ();
  len = 0;
  if (data == 0B) goto <D.24394>; else goto <D.24395>;
  <D.24394>:
  D.24396 = 0B;
  return D.24396;
  <D.24395>:
  goto <D.20122>;
  <D.20121>:
  len = len + 1;
  <D.20122>:
  len.216 = (unsigned int) len;
  D.24398 = len.216 * 2;
  D.24399 = data + D.24398;
  D.24400 = *D.24399;
  if (D.24400 != 0) goto <D.20121>; else goto <D.20123>;
  <D.20123>:
  D.24396 = mono_string_new_utf16 (domain, data, len);
  return D.24396;
}


mono_string_to_utf8_image (struct MonoImage * image, struct MonoString * s, struct MonoError * error)
{
  char * D.24402;

  D.24402 = mono_string_to_utf8_internal (0B, image, s, 0, error);
  return D.24402;
}


mono_string_to_utf8_mp (struct MonoMemPool * mp, struct MonoString * s, struct MonoError * error)
{
  char * D.24404;

  D.24404 = mono_string_to_utf8_internal (mp, 0B, s, 0, error);
  return D.24404;
}


mono_install_eh_callbacks (struct MonoRuntimeExceptionHandlingCallbacks * cbs)
{
  eh_callbacks = *cbs;
}


mono_get_eh_callbacks ()
{
  struct MonoRuntimeExceptionHandlingCallbacks * D.24406;

  D.24406 = &eh_callbacks;
  return D.24406;
}


mono_raise_exception (struct MonoException * ex)
{
  void (*<T24cd>) (struct MonoException *) D.24408;

  D.24408 = eh_callbacks.mono_raise_exception;
  D.24408 (ex);
}


mono_raise_exception_with_context (struct MonoException * ex, struct MonoContext * ctx)
{
  void (*<T24d1>) (struct MonoException *, struct MonoContext *) D.24409;

  D.24409 = eh_callbacks.mono_raise_exception_with_ctx;
  D.24409 (ex, ctx);
}


mono_wait_handle_new (struct MonoDomain * domain, void * handle)
{
  struct MonoClass * D.24410;
  struct MonoMethod * handle_set.217;
  struct MonoProperty * D.24414;
  struct MonoMethod * handle_set.218;
  struct MonoWaitHandle * D.24416;
  struct MonoWaitHandle * res;
  void * params[1];
  static struct MonoMethod * handle_set;

  try
    {
      D.24410 = mono_defaults.manualresetevent_class;
      res = mono_object_new (domain, D.24410);
      handle_set.217 = handle_set;
      if (handle_set.217 == 0B) goto <D.24412>; else goto <D.24413>;
      <D.24412>:
      D.24410 = mono_defaults.manualresetevent_class;
      D.24414 = mono_class_get_property_from_name (D.24410, "Handle");
      handle_set.218 = D.24414->set;
      handle_set = handle_set.218;
      <D.24413>:
      params[0] = &handle;
      handle_set.217 = handle_set;
      mono_runtime_invoke (handle_set.217, res, &params, 0B);
      D.24416 = res;
      return D.24416;
    }
  finally
    {
      params = {CLOBBER};
    }
}


mono_wait_handle_get_handle (struct MonoWaitHandle * handle)
{
  struct MonoClassField * f_os_handle.219;
  struct MonoClassField * f_safe_handle.220;
  struct MonoClass * D.24425;
  struct MonoClassField * f_os_handle.221;
  struct MonoClassField * f_safe_handle.222;
  void * D.24430;
  struct MonoSafeHandle * sh.223;
  static struct MonoClassField * f_os_handle;
  static struct MonoClassField * f_safe_handle;

  f_os_handle.219 = f_os_handle;
  if (f_os_handle.219 == 0B) goto <D.24420>; else goto <D.24421>;
  <D.24420>:
  f_safe_handle.220 = f_safe_handle;
  if (f_safe_handle.220 == 0B) goto <D.24423>; else goto <D.24424>;
  <D.24423>:
  D.24425 = mono_defaults.manualresetevent_class;
  f_os_handle.221 = mono_class_get_field_from_name (D.24425, "os_handle");
  f_os_handle = f_os_handle.221;
  D.24425 = mono_defaults.manualresetevent_class;
  f_safe_handle.222 = mono_class_get_field_from_name (D.24425, "safe_wait_handle");
  f_safe_handle = f_safe_handle.222;
  <D.24424>:
  <D.24421>:
  f_os_handle.219 = f_os_handle;
  if (f_os_handle.219 != 0B) goto <D.24428>; else goto <D.24429>;
  <D.24428>:
  {
    void * retval;

    try
      {
        f_os_handle.219 = f_os_handle;
        mono_field_get_value (handle, f_os_handle.219, &retval);
        D.24430 = retval;
        return D.24430;
      }
    finally
      {
        retval = {CLOBBER};
      }
  }
  <D.24429>:
  {
    struct MonoSafeHandle * sh;

    try
      {
        f_safe_handle.220 = f_safe_handle;
        mono_field_get_value (handle, f_safe_handle.220, &sh);
        sh.223 = sh;
        D.24430 = sh.223->handle;
        return D.24430;
      }
    finally
      {
        sh = {CLOBBER};
      }
  }
}


mono_async_result_new (struct MonoDomain * domain, void * handle, struct MonoObject * state, void * data, struct MonoObject * object_data)
{
  struct MonoClass * D.24435;
  struct MonoObject * * D.24438;
  struct MonoObject * * D.24439;
  struct MonoObject * * D.24440;
  struct MonoWaitHandle * D.24443;
  struct MonoObject * * D.24444;
  struct MonoAsyncResult * D.24445;
  struct MonoAsyncResult * res;
  struct MonoObject * context;

  D.24435 = mono_defaults.asyncresult_class;
  res = mono_object_new (domain, D.24435);
  context = mono_runtime_capture_context (domain);
  if (context != 0B) goto <D.24436>; else goto <D.24437>;
  <D.24436>:
  D.24438 = &res->execution_context;
  mono_gc_wbarrier_set_field (res, D.24438, context);
  <D.24437>:
  res->data = data;
  D.24439 = &res->object_data;
  mono_gc_wbarrier_set_field (res, D.24439, object_data);
  D.24440 = &res->async_state;
  mono_gc_wbarrier_set_field (res, D.24440, state);
  if (handle != 0B) goto <D.24441>; else goto <D.24442>;
  <D.24441>:
  D.24443 = mono_wait_handle_new (domain, handle);
  D.24444 = &res->handle;
  mono_gc_wbarrier_set_field (res, D.24444, D.24443);
  <D.24442>:
  res->sync_completed = 0;
  res->completed = 0;
  D.24445 = res;
  return D.24445;
}


mono_runtime_capture_context (struct MonoDomain * domain)
{
  void * D.24449;
  void * D.24451;
  struct MonoObject * D.24454;
  void * D.24455;
  void * D.24456;
  struct MonoObject * (*RuntimeInvokeFunction) (struct MonoObject *, void * *, struct MonoObject * *, void *) runtime_invoke;

  D.24449 = domain->capture_context_runtime_invoke;
  if (D.24449 == 0B) goto <D.24447>; else goto <D.24450>;
  <D.24450>:
  D.24451 = domain->capture_context_method;
  if (D.24451 == 0B) goto <D.24447>; else goto <D.24448>;
  <D.24447>:
  {
    struct MonoMethod * method;
    struct MonoMethod * wrapper;

    method = mono_get_context_capture_method ();
    if (method == 0B) goto <D.24452>; else goto <D.24453>;
    <D.24452>:
    D.24454 = 0B;
    return D.24454;
    <D.24453>:
    wrapper = mono_marshal_get_runtime_invoke (method, 0);
    D.24455 = mono_compile_method (wrapper);
    domain->capture_context_runtime_invoke = D.24455;
    D.24456 = mono_compile_method (method);
    domain->capture_context_method = D.24456;
  }
  <D.24448>:
  D.24449 = domain->capture_context_runtime_invoke;
  runtime_invoke = (struct MonoObject * (*RuntimeInvokeFunction) (struct MonoObject *, void * *, struct MonoObject * *, void *)) D.24449;
  D.24451 = domain->capture_context_method;
  D.24454 = runtime_invoke (0B, 0B, 0B, D.24451);
  return D.24454;
}


mono_message_init (struct MonoDomain * domain, struct MonoMethodMessage * this, struct MonoReflectionMethod * method, struct MonoArray * out_args)
{
  struct MonoMethod * D.24458;
  struct MonoClass * object_array_klass.224;
  struct MonoClass * D.24462;
  _Bool D.24463;
  long int D.24464;
  long int D.24465;
  struct MonoClass * D.24468;
  struct MonoClass * D.24471;
  struct MonoReflectionMethod * * D.24474;
  short unsigned int D.24475;
  unsigned int D.24476;
  struct MonoVTable * D.24477;
  struct MonoArray * D.24478;
  struct MonoArray * * D.24479;
  struct MonoClass * byte_array_klass.225;
  struct MonoVTable * D.24481;
  struct MonoArray * D.24482;
  struct MonoArray * * D.24483;
  unsigned int D.24484;
  unsigned int D.24485;
  struct MonoClass * string_array_klass.226;
  struct MonoVTable * D.24487;
  struct MonoArray * D.24488;
  struct MonoArray * * D.24489;
  unsigned int i.227;
  unsigned int D.24491;
  char * * D.24492;
  char * D.24493;
  unsigned int i.228;
  struct MonoArray * D.24495;
  int D.24496;
  struct MonoType * D.24497;
  unsigned char D.24498;
  unsigned char D.24499;
  unsigned int j.229;
  char * D.24505;
  struct MonoArray * D.24506;
  short unsigned int D.24507;
  int D.24508;
  int D.24509;
  struct MonoArray * D.24515;
  static struct MonoClass * object_array_klass;
  static struct MonoClass * byte_array_klass;
  static struct MonoClass * string_array_klass;
  struct MonoMethodSignature * sig;
  struct MonoString * name;
  int i;
  int j;
  char * * names;
  guint8 arg_type;

  D.24458 = method->method;
  sig = mono_method_signature (D.24458);
  object_array_klass.224 = object_array_klass;
  if (object_array_klass.224 == 0B) goto <D.24460>; else goto <D.24461>;
  <D.24460>:
  {
    struct MonoClass * klass;

    D.24462 = mono_defaults.byte_class;
    klass = mono_array_class_get (D.24462, 1);
    D.24463 = klass == 0B;
    D.24464 = (long int) D.24463;
    D.24465 = __builtin_expect (D.24464, 0);
    if (D.24465 != 0) goto <D.24466>; else goto <D.24467>;
    <D.24466>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 5891, "klass");
    <D.24467>:
    byte_array_klass = klass;
    D.24468 = mono_defaults.string_class;
    klass = mono_array_class_get (D.24468, 1);
    D.24463 = klass == 0B;
    D.24464 = (long int) D.24463;
    D.24465 = __builtin_expect (D.24464, 0);
    if (D.24465 != 0) goto <D.24469>; else goto <D.24470>;
    <D.24469>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 5895, "klass");
    <D.24470>:
    string_array_klass = klass;
    D.24471 = mono_defaults.object_class;
    klass = mono_array_class_get (D.24471, 1);
    D.24463 = klass == 0B;
    D.24464 = (long int) D.24463;
    D.24465 = __builtin_expect (D.24464, 0);
    if (D.24465 != 0) goto <D.24472>; else goto <D.24473>;
    <D.24472>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 5899, "klass");
    <D.24473>:
    object_array_klass = klass;
  }
  <D.24461>:
  D.24474 = &this->method;
  mono_gc_wbarrier_set_field (this, D.24474, method);
  D.24475 = sig->param_count;
  D.24476 = (unsigned int) D.24475;
  object_array_klass.224 = object_array_klass;
  D.24477 = mono_class_vtable (domain, object_array_klass.224);
  D.24478 = mono_array_new_specific (D.24477, D.24476);
  D.24479 = &this->args;
  mono_gc_wbarrier_set_field (this, D.24479, D.24478);
  D.24475 = sig->param_count;
  D.24476 = (unsigned int) D.24475;
  byte_array_klass.225 = byte_array_klass;
  D.24481 = mono_class_vtable (domain, byte_array_klass.225);
  D.24482 = mono_array_new_specific (D.24481, D.24476);
  D.24483 = &this->arg_types;
  mono_gc_wbarrier_set_field (this, D.24483, D.24482);
  this->async_result = 0B;
  this->call_type = 0;
  D.24475 = sig->param_count;
  D.24484 = (unsigned int) D.24475;
  D.24485 = D.24484 * 4;
  names = monoeg_malloc (D.24485);
  D.24458 = method->method;
  mono_method_get_param_names (D.24458, names);
  D.24475 = sig->param_count;
  D.24476 = (unsigned int) D.24475;
  string_array_klass.226 = string_array_klass;
  D.24487 = mono_class_vtable (domain, string_array_klass.226);
  D.24488 = mono_array_new_specific (D.24487, D.24476);
  D.24489 = &this->names;
  mono_gc_wbarrier_set_field (this, D.24489, D.24488);
  i = 0;
  goto <D.20205>;
  <D.20204>:
  i.227 = (unsigned int) i;
  D.24491 = i.227 * 4;
  D.24492 = names + D.24491;
  D.24493 = *D.24492;
  name = mono_string_new (domain, D.24493);
  {
    void * * __p;

    i.228 = (unsigned int) i;
    D.24495 = this->names;
    __p = mono_array_addr_with_size (D.24495, 4, i.228);
    D.24495 = this->names;
    mono_gc_wbarrier_set_arrayref (D.24495, __p, name);
  }
  i = i + 1;
  <D.20205>:
  D.24475 = sig->param_count;
  D.24496 = (int) D.24475;
  if (D.24496 > i) goto <D.20204>; else goto <D.20206>;
  <D.20206>:
  monoeg_g_free (names);
  i = 0;
  j = 0;
  goto <D.20211>;
  <D.20210>:
  D.24497 = sig->params[i];
  D.24498 = BIT_FIELD_REF <*D.24497, 8, 56>;
  D.24499 = D.24498 & 64;
  if (D.24499 != 0) goto <D.24500>; else goto <D.24501>;
  <D.24500>:
  if (out_args != 0B) goto <D.24502>; else goto <D.24503>;
  <D.24502>:
  {
    struct MonoObject * arg;

    j.229 = (unsigned int) j;
    D.24505 = mono_array_addr_with_size (out_args, 4, j.229);
    arg = MEM[(void * *)D.24505];
    {
      void * * __p;

      i.228 = (unsigned int) i;
      D.24506 = this->args;
      __p = mono_array_addr_with_size (D.24506, 4, i.228);
      D.24506 = this->args;
      mono_gc_wbarrier_set_arrayref (D.24506, __p, arg);
    }
    j = j + 1;
  }
  <D.24503>:
  arg_type = 2;
  D.24497 = sig->params[i];
  D.24507 = D.24497->attrs;
  D.24508 = (int) D.24507;
  D.24509 = D.24508 & 2;
  if (D.24509 == 0) goto <D.24510>; else goto <D.24511>;
  <D.24510>:
  arg_type = arg_type | 1;
  <D.24511>:
  goto <D.24512>;
  <D.24501>:
  arg_type = 1;
  D.24497 = sig->params[i];
  D.24507 = D.24497->attrs;
  D.24508 = (int) D.24507;
  D.24509 = D.24508 & 2;
  if (D.24509 != 0) goto <D.24513>; else goto <D.24514>;
  <D.24513>:
  arg_type = arg_type | 4;
  <D.24514>:
  <D.24512>:
  {
    guint8 * __p;

    i.228 = (unsigned int) i;
    D.24515 = this->arg_types;
    __p = mono_array_addr_with_size (D.24515, 1, i.228);
    *__p = arg_type;
  }
  i = i + 1;
  <D.20211>:
  D.24475 = sig->param_count;
  D.24496 = (int) D.24475;
  if (D.24496 > i) goto <D.20210>; else goto <D.20212>;
  <D.20212>:
}


mono_remoting_invoke (struct MonoObject * real_proxy, struct MonoMethodMessage * msg, struct MonoObject * * exc, struct MonoArray * * out_args)
{
  struct MonoVTable * D.24516;
  struct MonoDomain * D.24517;
  struct MonoClass * D.24520;
  _Bool D.24521;
  long int D.24522;
  long int D.24523;
  struct MonoObject * D.24526;
  struct MonoMethod * im;
  void * pa[4];

  try
    {
      D.24516 = real_proxy->vtable;
      D.24517 = D.24516->domain;
      im = D.24517->private_invoke_method;
      if (im == 0B) goto <D.24518>; else goto <D.24519>;
      <D.24518>:
      D.24520 = mono_defaults.real_proxy_class;
      im = mono_class_get_method_from_name (D.24520, "PrivateInvoke", 4);
      D.24521 = im == 0B;
      D.24522 = (long int) D.24521;
      D.24523 = __builtin_expect (D.24522, 0);
      if (D.24523 != 0) goto <D.24524>; else goto <D.24525>;
      <D.24524>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 5966, "im");
      <D.24525>:
      D.24516 = real_proxy->vtable;
      D.24517 = D.24516->domain;
      D.24517->private_invoke_method = im;
      <D.24519>:
      pa[0] = real_proxy;
      pa[1] = msg;
      pa[2] = exc;
      pa[3] = out_args;
      D.24526 = mono_runtime_invoke (im, 0B, &pa, exc);
      return D.24526;
    }
  finally
    {
      pa = {CLOBBER};
    }
}


mono_message_invoke (struct MonoObject * target, struct MonoMethodMessage * msg, struct MonoObject * * exc, struct MonoArray * * out_args)
{
  struct MonoVTable * D.24531;
  struct MonoClass * D.24532;
  struct MonoClass * D.24533;
  struct MonoRemoteClass * D.24538;
  struct MonoClass * D.24539;
  unsigned char D.24540;
  unsigned char D.24541;
  struct MonoRealProxy * D.24543;
  struct MonoObject * D.24544;
  struct MonoAppContext * D.24545;
  struct MonoObject * D.24547;
  struct MonoReflectionMethod * D.24548;
  struct MonoType * D.24549;
  unsigned char D.24550;
  unsigned char D.24551;
  short unsigned int D.24554;
  int D.24555;
  struct MonoClass * object_array_klass.230;
  struct MonoClass * D.24559;
  _Bool D.24560;
  long int D.24561;
  long int D.24562;
  unsigned int outarg_count.231;
  struct MonoVTable * D.24566;
  struct MonoArray * D.24567;
  struct MonoArray * D.24568;
  void * iftmp.232;
  struct MonoClass * D.24570;
  unsigned char D.24571;
  unsigned char D.24572;
  unsigned int i.233;
  char * D.24579;
  unsigned int j.234;
  struct MonoArray * D.24581;
  static struct MonoClass * object_array_klass;
  struct MonoDomain * domain;
  struct MonoMethod * method;
  struct MonoMethodSignature * sig;
  struct MonoObject * ret;
  int i;
  int j;
  int outarg_count;

  outarg_count = 0;
  if (target != 0B) goto <D.24529>; else goto <D.24530>;
  <D.24529>:
  D.24531 = target->vtable;
  D.24532 = D.24531->klass;
  D.24533 = mono_defaults.transparent_proxy_class;
  if (D.24532 == D.24533) goto <D.24534>; else goto <D.24535>;
  <D.24534>:
  {
    struct MonoTransparentProxy * tp;

    tp = target;
    D.24538 = tp->remote_class;
    D.24539 = D.24538->proxy_class;
    D.24540 = BIT_FIELD_REF <*D.24539, 8, 176>;
    D.24541 = D.24540 & 128;
    if (D.24541 != 0) goto <D.24542>; else goto <D.24536>;
    <D.24542>:
    D.24543 = tp->rp;
    D.24544 = D.24543->context;
    D.24545 = mono_context_get ();
    if (D.24544 == D.24545) goto <D.24546>; else goto <D.24536>;
    <D.24546>:
    D.24543 = tp->rp;
    target = D.24543->unwrapped_server;
    goto <D.24537>;
    <D.24536>:
    D.24543 = tp->rp;
    D.24547 = mono_remoting_invoke (D.24543, msg, exc, out_args);
    return D.24547;
    <D.24537>:
  }
  <D.24535>:
  <D.24530>:
  domain = mono_domain_get ();
  D.24548 = msg->method;
  method = D.24548->method;
  sig = mono_method_signature (method);
  i = 0;
  goto <D.20237>;
  <D.20236>:
  D.24549 = sig->params[i];
  D.24550 = BIT_FIELD_REF <*D.24549, 8, 56>;
  D.24551 = D.24550 & 64;
  if (D.24551 != 0) goto <D.24552>; else goto <D.24553>;
  <D.24552>:
  outarg_count = outarg_count + 1;
  <D.24553>:
  i = i + 1;
  <D.20237>:
  D.24554 = sig->param_count;
  D.24555 = (int) D.24554;
  if (D.24555 > i) goto <D.20236>; else goto <D.20238>;
  <D.20238>:
  object_array_klass.230 = object_array_klass;
  if (object_array_klass.230 == 0B) goto <D.24557>; else goto <D.24558>;
  <D.24557>:
  {
    struct MonoClass * klass;

    D.24559 = mono_defaults.object_class;
    klass = mono_array_class_get (D.24559, 1);
    D.24560 = klass == 0B;
    D.24561 = (long int) D.24560;
    D.24562 = __builtin_expect (D.24561, 0);
    if (D.24562 != 0) goto <D.24563>; else goto <D.24564>;
    <D.24563>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 6014, "klass");
    <D.24564>:
    mono_memory_barrier ();
    object_array_klass = klass;
  }
  <D.24558>:
  outarg_count.231 = (unsigned int) outarg_count;
  object_array_klass.230 = object_array_klass;
  D.24566 = mono_class_vtable (domain, object_array_klass.230);
  D.24567 = mono_array_new_specific (D.24566, outarg_count.231);
  *out_args = D.24567;
  *exc = 0B;
  D.24568 = msg->args;
  D.24570 = method->klass;
  D.24571 = BIT_FIELD_REF <*D.24570, 8, 160>;
  D.24572 = D.24571 & 8;
  if (D.24572 != 0) goto <D.24573>; else goto <D.24574>;
  <D.24573>:
  iftmp.232 = mono_object_unbox (target);
  goto <D.24575>;
  <D.24574>:
  iftmp.232 = target;
  <D.24575>:
  ret = mono_runtime_invoke_array (method, iftmp.232, D.24568, exc);
  i = 0;
  j = 0;
  goto <D.20243>;
  <D.20242>:
  D.24549 = sig->params[i];
  D.24550 = BIT_FIELD_REF <*D.24549, 8, 56>;
  D.24551 = D.24550 & 64;
  if (D.24551 != 0) goto <D.24576>; else goto <D.24577>;
  <D.24576>:
  {
    struct MonoObject * arg;

    i.233 = (unsigned int) i;
    D.24568 = msg->args;
    D.24579 = mono_array_addr_with_size (D.24568, 4, i.233);
    arg = MEM[(void * *)D.24579];
    {
      void * * __p;

      j.234 = (unsigned int) j;
      D.24581 = *out_args;
      __p = mono_array_addr_with_size (D.24581, 4, j.234);
      D.24581 = *out_args;
      mono_gc_wbarrier_set_arrayref (D.24581, __p, arg);
    }
    j = j + 1;
  }
  <D.24577>:
  i = i + 1;
  <D.20243>:
  D.24554 = sig->param_count;
  D.24555 = (int) D.24554;
  if (D.24555 > i) goto <D.20242>; else goto <D.20244>;
  <D.20244>:
  D.24547 = ret;
  return D.24547;
}


mono_object_to_string (struct MonoObject * obj, struct MonoObject * * exc)
{
  _Bool D.24583;
  long int D.24584;
  long int D.24585;
  struct MonoMethod * to_string.235;
  struct MonoClass * D.24591;
  struct MonoMethod * to_string.236;
  struct MonoClass * D.24593;
  int D.24594;
  struct MonoString * D.24597;
  static struct MonoMethod * to_string = 0B;
  struct MonoMethod * method;
  void * target;

  target = obj;
  D.24583 = obj == 0B;
  D.24584 = (long int) D.24583;
  D.24585 = __builtin_expect (D.24584, 0);
  if (D.24585 != 0) goto <D.24586>; else goto <D.24587>;
  <D.24586>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 6052, "obj");
  <D.24587>:
  to_string.235 = to_string;
  if (to_string.235 == 0B) goto <D.24589>; else goto <D.24590>;
  <D.24589>:
  D.24591 = mono_get_object_class ();
  to_string.236 = mono_class_get_method_from_name_flags (D.24591, "ToString", 0, 70);
  to_string = to_string.236;
  <D.24590>:
  to_string.235 = to_string;
  method = mono_object_get_virtual_method (obj, to_string.235);
  D.24593 = mono_method_get_class (method);
  D.24594 = mono_class_is_valuetype (D.24593);
  if (D.24594 != 0) goto <D.24595>; else goto <D.24596>;
  <D.24595>:
  target = mono_object_unbox (obj);
  <D.24596>:
  D.24597 = mono_runtime_invoke (method, target, 0B, exc);
  return D.24597;
}


mono_print_unhandled_exception (struct MonoObject * exc)
{
  struct MonoVTable * D.24599;
  struct MonoDomain * D.24600;
  struct MonoException * D.24601;
  struct MonoArray * D.24605;
  struct MonoObject * other_exc.237;
  int D.24615;
  struct MonoString * str;
  char * message;
  gboolean free_message;
  struct MonoError error;

  try
    {
      message = "";
      free_message = 0;
      D.24599 = exc->vtable;
      D.24600 = D.24599->domain;
      D.24601 = D.24600->out_of_memory_ex;
      if (D.24601 == exc) goto <D.24602>; else goto <D.24603>;
      <D.24602>:
      message = monoeg_strdup ("OutOfMemoryException");
      free_message = 1;
      goto <D.24604>;
      <D.24603>:
      D.24605 = MEM[(struct MonoException *)exc].native_trace_ips;
      if (D.24605 != 0B) goto <D.24606>; else goto <D.24607>;
      <D.24606>:
      message = mono_exception_get_native_backtrace (exc);
      free_message = 1;
      goto <D.24608>;
      <D.24607>:
      {
        struct MonoObject * other_exc;

        try
          {
            other_exc = 0B;
            str = mono_object_to_string (exc, &other_exc);
            other_exc.237 = other_exc;
            if (other_exc.237 != 0B) goto <D.24610>; else goto <D.24611>;
            <D.24610>:
            {
              char * original_backtrace;
              char * nested_backtrace;

              original_backtrace = mono_exception_get_managed_backtrace (exc);
              other_exc.237 = other_exc;
              nested_backtrace = mono_exception_get_managed_backtrace (other_exc.237);
              message = monoeg_g_strdup_printf ("Nested exception detected.\nOriginal Exception: %s\nNested exception:%s\n", original_backtrace, nested_backtrace);
              monoeg_g_free (original_backtrace);
              monoeg_g_free (nested_backtrace);
              free_message = 1;
            }
            goto <D.24612>;
            <D.24611>:
            if (str != 0B) goto <D.24613>; else goto <D.24614>;
            <D.24613>:
            message = mono_string_to_utf8_checked (str, &error);
            D.24615 = mono_error_ok (&error);
            if (D.24615 == 0) goto <D.24616>; else goto <D.24617>;
            <D.24616>:
            mono_error_cleanup (&error);
            message = "";
            goto <D.24618>;
            <D.24617>:
            free_message = 1;
            <D.24618>:
            <D.24614>:
            <D.24612>:
          }
        finally
          {
            other_exc = {CLOBBER};
          }
      }
      <D.24608>:
      <D.24604>:
      monoeg_g_printerr ("\nUnhandled Exception:\n%s\n", message);
      if (free_message != 0) goto <D.24619>; else goto <D.24620>;
      <D.24619>:
      monoeg_g_free (message);
      <D.24620>:
    }
  finally
    {
      error = {CLOBBER};
    }
}


mono_delegate_ctor_with_method (struct MonoObject * this, struct MonoObject * target, void * addr, struct MonoMethod * method)
{
  _Bool D.24621;
  long int D.24622;
  long int D.24623;
  _Bool D.24626;
  long int D.24627;
  long int D.24628;
  struct MonoVTable * D.24633;
  long unsigned int D.24634;
  long unsigned int D.24635;
  struct MonoVTable * D.24639;
  struct MonoClass * D.24640;
  struct MonoClass * D.24641;
  _Bool D.24643;
  long int D.24644;
  long int D.24645;
  void * D.24648;
  struct MonoObject * * D.24649;
  void * (*<T1d3b>) (struct MonoDomain *, struct MonoClass *) arch_create_delegate_trampoline.238;
  struct MonoVTable * D.24651;
  struct MonoClass * D.24652;
  struct MonoDomain * D.24653;
  void * D.24654;
  struct MonoDelegate * delegate;
  struct MonoClass * class;

  delegate = this;
  D.24621 = this == 0B;
  D.24622 = (long int) D.24621;
  D.24623 = __builtin_expect (D.24622, 0);
  if (D.24623 != 0) goto <D.24624>; else goto <D.24625>;
  <D.24624>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 6142, "this");
  <D.24625>:
  D.24626 = addr == 0B;
  D.24627 = (long int) D.24626;
  D.24628 = __builtin_expect (D.24627, 0);
  if (D.24628 != 0) goto <D.24629>; else goto <D.24630>;
  <D.24629>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 6143, "addr");
  <D.24630>:
  if (method != 0B) goto <D.24631>; else goto <D.24632>;
  <D.24631>:
  delegate->method = method;
  <D.24632>:
  D.24633 = this->vtable;
  class = D.24633->klass;
  D.24634 = mono_stats.delegate_creations;
  D.24635 = D.24634 + 1;
  mono_stats.delegate_creations = D.24635;
  if (target != 0B) goto <D.24638>; else goto <D.24636>;
  <D.24638>:
  D.24639 = target->vtable;
  D.24640 = D.24639->klass;
  D.24641 = mono_defaults.transparent_proxy_class;
  if (D.24640 == D.24641) goto <D.24642>; else goto <D.24636>;
  <D.24642>:
  D.24643 = method == 0B;
  D.24644 = (long int) D.24643;
  D.24645 = __builtin_expect (D.24644, 0);
  if (D.24645 != 0) goto <D.24646>; else goto <D.24647>;
  <D.24646>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 6153, "method");
  <D.24647>:
  method = mono_marshal_get_remoting_invoke (method);
  D.24648 = mono_compile_method (method);
  delegate->method_ptr = D.24648;
  D.24649 = &delegate->target;
  mono_gc_wbarrier_set_field (delegate, D.24649, target);
  goto <D.24637>;
  <D.24636>:
  delegate->method_ptr = addr;
  D.24649 = &delegate->target;
  mono_gc_wbarrier_set_field (delegate, D.24649, target);
  <D.24637>:
  arch_create_delegate_trampoline.238 = arch_create_delegate_trampoline;
  D.24651 = delegate->object.vtable;
  D.24652 = D.24651->klass;
  D.24651 = delegate->object.vtable;
  D.24653 = D.24651->domain;
  D.24654 = arch_create_delegate_trampoline.238 (D.24653, D.24652);
  delegate->invoke_impl = D.24654;
}


mono_delegate_ctor (struct MonoObject * this, struct MonoObject * target, void * addr)
{
  _Bool D.24655;
  long int D.24656;
  long int D.24657;
  void * D.24660;
  struct MonoDomain * D.24663;
  void * D.24666;
  struct MonoDomain * D.24667;
  struct MonoClass * D.24670;
  struct MonoGenericContainer * D.24671;
  _Bool D.24672;
  long int D.24673;
  long int D.24674;
  struct MonoDomain * domain;
  struct MonoJitInfo * ji;
  struct MonoMethod * method;

  domain = mono_domain_get ();
  method = 0B;
  D.24655 = addr == 0B;
  D.24656 = (long int) D.24655;
  D.24657 = __builtin_expect (D.24656, 0);
  if (D.24657 != 0) goto <D.24658>; else goto <D.24659>;
  <D.24658>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 6182, "addr");
  <D.24659>:
  D.24660 = mono_get_addr_from_ftnptr (addr);
  ji = mono_jit_info_table_find (domain, D.24660);
  if (ji == 0B) goto <D.24661>; else goto <D.24662>;
  <D.24661>:
  D.24663 = mono_get_root_domain ();
  if (D.24663 != domain) goto <D.24664>; else goto <D.24665>;
  <D.24664>:
  D.24666 = mono_get_addr_from_ftnptr (addr);
  D.24667 = mono_get_root_domain ();
  ji = mono_jit_info_table_find (D.24667, D.24666);
  <D.24665>:
  <D.24662>:
  if (ji != 0B) goto <D.24668>; else goto <D.24669>;
  <D.24668>:
  method = mono_jit_info_get_method (ji);
  D.24670 = method->klass;
  D.24671 = D.24670->generic_container;
  D.24672 = D.24671 != 0B;
  D.24673 = (long int) D.24672;
  D.24674 = __builtin_expect (D.24673, 0);
  if (D.24674 != 0) goto <D.24675>; else goto <D.24676>;
  <D.24675>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 6190, "!method->klass->generic_container");
  <D.24676>:
  <D.24669>:
  mono_delegate_ctor_with_method (this, target, addr, method);
}


mono_method_call_message_new (struct MonoMethod * method, void * * params, struct MonoMethod * invoke, struct MonoDelegate * * cb, struct MonoObject * * state)
{
  struct MonoClass * D.24677;
  struct MonoReflectionMethod * D.24680;
  short unsigned int D.24681;
  int D.24682;
  struct MonoReflectionMethod * D.24684;
  struct MonoType * D.24685;
  unsigned char D.24686;
  unsigned char D.24687;
  unsigned int i.239;
  unsigned int D.24691;
  void * * D.24692;
  void * D.24693;
  unsigned char D.24695;
  unsigned char D.24696;
  unsigned char D.24697;
  unsigned int i.240;
  struct MonoArray * D.24702;
  _Bool D.24703;
  _Bool D.24704;
  _Bool D.24705;
  struct MonoDelegate * D.24708;
  struct MonoObject * D.24709;
  struct MonoMethodMessage * D.24710;
  struct MonoDomain * domain;
  struct MonoMethodSignature * sig;
  struct MonoMethodMessage * msg;
  int i;
  int count;
  int type;

  domain = mono_domain_get ();
  sig = mono_method_signature (method);
  D.24677 = mono_defaults.mono_method_message_class;
  msg = mono_object_new (domain, D.24677);
  if (invoke != 0B) goto <D.24678>; else goto <D.24679>;
  <D.24678>:
  D.24680 = mono_method_get_object (domain, invoke, 0B);
  mono_message_init (domain, msg, D.24680, 0B);
  D.24681 = sig->param_count;
  D.24682 = (int) D.24681;
  count = D.24682 + -2;
  goto <D.24683>;
  <D.24679>:
  D.24684 = mono_method_get_object (domain, method, 0B);
  mono_message_init (domain, msg, D.24684, 0B);
  D.24681 = sig->param_count;
  count = (int) D.24681;
  <D.24683>:
  i = 0;
  goto <D.20296>;
  <D.20295>:
  {
    void * vpos;
    struct MonoClass * class;
    struct MonoObject * arg;

    D.24685 = sig->params[i];
    D.24686 = BIT_FIELD_REF <*D.24685, 8, 56>;
    D.24687 = D.24686 & 64;
    if (D.24687 != 0) goto <D.24688>; else goto <D.24689>;
    <D.24688>:
    i.239 = (unsigned int) i;
    D.24691 = i.239 * 4;
    D.24692 = params + D.24691;
    D.24693 = *D.24692;
    vpos = MEM[(void * *)D.24693];
    goto <D.24694>;
    <D.24689>:
    i.239 = (unsigned int) i;
    D.24691 = i.239 * 4;
    D.24692 = params + D.24691;
    vpos = *D.24692;
    <D.24694>:
    D.24685 = sig->params[i];
    D.24695 = D.24685->type;
    type = (int) D.24695;
    D.24685 = sig->params[i];
    class = mono_class_from_mono_type (D.24685);
    D.24696 = BIT_FIELD_REF <*class, 8, 160>;
    D.24697 = D.24696 & 8;
    if (D.24697 != 0) goto <D.24698>; else goto <D.24699>;
    <D.24698>:
    arg = mono_value_box (domain, class, vpos);
    goto <D.24700>;
    <D.24699>:
    arg = MEM[(struct MonoObject * *)vpos];
    <D.24700>:
    {
      void * * __p;

      i.240 = (unsigned int) i;
      D.24702 = msg->args;
      __p = mono_array_addr_with_size (D.24702, 4, i.240);
      D.24702 = msg->args;
      mono_gc_wbarrier_set_arrayref (D.24702, __p, arg);
    }
  }
  i = i + 1;
  <D.20296>:
  if (i < count) goto <D.20295>; else goto <D.20297>;
  <D.20297>:
  D.24703 = cb != 0B;
  D.24704 = state != 0B;
  D.24705 = D.24703 & D.24704;
  if (D.24705 != 0) goto <D.24706>; else goto <D.24707>;
  <D.24706>:
  i.239 = (unsigned int) i;
  D.24691 = i.239 * 4;
  D.24692 = params + D.24691;
  D.24693 = *D.24692;
  D.24708 = MEM[(struct MonoDelegate * *)D.24693];
  *cb = D.24708;
  i = i + 1;
  i.239 = (unsigned int) i;
  D.24691 = i.239 * 4;
  D.24692 = params + D.24691;
  D.24693 = *D.24692;
  D.24709 = MEM[(struct MonoObject * *)D.24693];
  *state = D.24709;
  <D.24707>:
  D.24710 = msg;
  return D.24710;
}


mono_method_return_message_restore (struct MonoMethod * method, void * * params, struct MonoArray * out_args)
{
  unsigned int D.24714;
  unsigned char D.24717;
  unsigned char D.24718;
  struct MonoException * D.24723;
  unsigned int j.241;
  char * D.24725;
  unsigned char D.24726;
  _Bool D.24727;
  long int D.24728;
  long int D.24729;
  int D.24732;
  unsigned int i.242;
  unsigned int D.24736;
  void * * D.24737;
  void * D.24738;
  struct MonoObject * * D.24739;
  struct MonoVTable * D.24743;
  unsigned char D.24744;
  unsigned char D.24745;
  void * D.24748;
  void * D.24749;
  unsigned int size.243;
  const void * D.24752;
  struct MonoClass * D.24754;
  short unsigned int D.24755;
  int D.24756;
  struct MonoMethodSignature * sig;
  int i;
  int j;
  int type;
  int size;
  int out_len;

  sig = mono_method_signature (method);
  if (out_args == 0B) goto <D.24712>; else goto <D.24713>;
  <D.24712>:
  return;
  <D.24713>:
  D.24714 = mono_array_length (out_args);
  out_len = (int) D.24714;
  if (out_len == 0) goto <D.24715>; else goto <D.24716>;
  <D.24715>:
  return;
  <D.24716>:
  i = 0;
  j = 0;
  goto <D.20313>;
  <D.20312>:
  {
    struct MonoType * pt;

    pt = sig->params[i];
    D.24717 = BIT_FIELD_REF <*pt, 8, 56>;
    D.24718 = D.24717 & 64;
    if (D.24718 != 0) goto <D.24719>; else goto <D.24720>;
    <D.24719>:
    {
      char * arg;

      if (j >= out_len) goto <D.24721>; else goto <D.24722>;
      <D.24721>:
      D.24723 = mono_get_exception_execution_engine ("The proxy call returned an incorrect number of output arguments");
      mono_raise_exception (D.24723);
      <D.24722>:
      j.241 = (unsigned int) j;
      D.24725 = mono_array_addr_with_size (out_args, 4, j.241);
      arg = MEM[(void * *)D.24725];
      D.24726 = pt->type;
      type = (int) D.24726;
      D.24727 = type == 1;
      D.24728 = (long int) D.24727;
      D.24729 = __builtin_expect (D.24728, 0);
      if (D.24729 != 0) goto <D.24730>; else goto <D.24731>;
      <D.24730>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 6283, "type != MONO_TYPE_VOID");
      <D.24731>:
      D.24732 = mono_type_is_reference (pt);
      if (D.24732 != 0) goto <D.24733>; else goto <D.24734>;
      <D.24733>:
      i.242 = (unsigned int) i;
      D.24736 = i.242 * 4;
      D.24737 = params + D.24736;
      D.24738 = *D.24737;
      D.24739 = MEM[(struct MonoObject * * *)D.24738];
      mono_gc_wbarrier_generic_store (D.24739, arg);
      goto <D.24740>;
      <D.24734>:
      if (arg != 0B) goto <D.24741>; else goto <D.24742>;
      <D.24741>:
      {
        struct MonoClass * class;

        D.24743 = MEM[(struct MonoObject *)arg].vtable;
        class = D.24743->klass;
        size = mono_class_value_size (class, 0B);
        D.24744 = BIT_FIELD_REF <*class, 8, 184>;
        D.24745 = D.24744 & 8;
        if (D.24745 != 0) goto <D.24746>; else goto <D.24747>;
        <D.24746>:
        D.24748 = arg + 8;
        i.242 = (unsigned int) i;
        D.24736 = i.242 * 4;
        D.24737 = params + D.24736;
        D.24738 = *D.24737;
        D.24749 = MEM[(void * *)D.24738];
        mono_gc_wbarrier_value_copy (D.24749, D.24748, 1, class);
        goto <D.24750>;
        <D.24747>:
        size.243 = (unsigned int) size;
        D.24752 = arg + 8;
        i.242 = (unsigned int) i;
        D.24736 = i.242 * 4;
        D.24737 = params + D.24736;
        D.24738 = *D.24737;
        D.24749 = MEM[(void * *)D.24738];
        mono_gc_memmove_atomic (D.24749, D.24752, size.243);
        <D.24750>:
      }
      goto <D.24753>;
      <D.24742>:
      D.24754 = mono_class_from_mono_type (pt);
      size = mono_class_value_size (D.24754, 0B);
      size.243 = (unsigned int) size;
      i.242 = (unsigned int) i;
      D.24736 = i.242 * 4;
      D.24737 = params + D.24736;
      D.24738 = *D.24737;
      D.24749 = MEM[(void * *)D.24738];
      mono_gc_bzero_atomic (D.24749, size.243);
      <D.24753>:
      <D.24740>:
      j = j + 1;
    }
    <D.24720>:
  }
  i = i + 1;
  <D.20313>:
  D.24755 = sig->param_count;
  D.24756 = (int) D.24755;
  if (D.24756 > i) goto <D.20312>; else goto <D.20314>;
  <D.20314>:
}


mono_load_remote_field (struct MonoObject * this, struct MonoClass * klass, struct MonoClassField * field, void * * res)
{
  struct MonoVTable * D.24758;
  struct MonoClass * D.24759;
  struct MonoClass * D.24760;
  _Bool D.24761;
  long int D.24762;
  long int D.24763;
  _Bool D.24766;
  long int D.24767;
  long int D.24768;
  struct MonoRemoteClass * D.24771;
  struct MonoClass * D.24772;
  unsigned char D.24773;
  unsigned char D.24774;
  struct MonoRealProxy * D.24777;
  struct MonoObject * D.24778;
  struct MonoAppContext * D.24779;
  struct MonoObject * D.24782;
  void * D.24783;
  struct MonoMethod * getter.244;
  struct MonoClass * D.24787;
  struct MonoMethod * getter.245;
  _Bool D.24789;
  long int D.24790;
  long int D.24791;
  struct MonoType * D.24794;
  struct MonoClass * D.24795;
  struct MonoArray * out_args.246;
  struct MonoArray * out_args.247;
  struct MonoReflectionMethod * D.24798;
  struct MonoArray * D.24799;
  struct MonoString * D.24800;
  const char * D.24801;
  struct MonoString * D.24802;
  struct MonoObject * exc.248;
  unsigned int D.24806;
  char * D.24809;
  struct MonoObject * D.24810;
  unsigned char D.24811;
  unsigned char D.24812;
  void * D.24815;
  static struct MonoMethod * getter = 0B;
  struct MonoDomain * domain;
  struct MonoTransparentProxy * tp;
  struct MonoClass * field_class;
  struct MonoMethodMessage * msg;
  struct MonoArray * out_args;
  struct MonoObject * exc;
  char * full_name;

  try
    {
      domain = mono_domain_get ();
      tp = this;
      D.24758 = this->vtable;
      D.24759 = D.24758->klass;
      D.24760 = mono_defaults.transparent_proxy_class;
      D.24761 = D.24759 != D.24760;
      D.24762 = (long int) D.24761;
      D.24763 = __builtin_expect (D.24762, 0);
      if (D.24763 != 0) goto <D.24764>; else goto <D.24765>;
      <D.24764>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 6334, "mono_object_is_transparent_proxy (this)");
      <D.24765>:
      D.24766 = res == 0B;
      D.24767 = (long int) D.24766;
      D.24768 = __builtin_expect (D.24767, 0);
      if (D.24768 != 0) goto <D.24769>; else goto <D.24770>;
      <D.24769>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 6335, "res != NULL");
      <D.24770>:
      D.24771 = tp->remote_class;
      D.24772 = D.24771->proxy_class;
      D.24773 = BIT_FIELD_REF <*D.24772, 8, 176>;
      D.24774 = D.24773 & 128;
      if (D.24774 != 0) goto <D.24775>; else goto <D.24776>;
      <D.24775>:
      D.24777 = tp->rp;
      D.24778 = D.24777->context;
      D.24779 = mono_context_get ();
      if (D.24778 == D.24779) goto <D.24780>; else goto <D.24781>;
      <D.24780>:
      D.24777 = tp->rp;
      D.24782 = D.24777->unwrapped_server;
      mono_field_get_value (D.24782, field, res);
      D.24783 = res;
      return D.24783;
      <D.24781>:
      <D.24776>:
      getter.244 = getter;
      if (getter.244 == 0B) goto <D.24785>; else goto <D.24786>;
      <D.24785>:
      D.24787 = mono_defaults.object_class;
      getter.245 = mono_class_get_method_from_name (D.24787, "FieldGetter", -1);
      getter = getter.245;
      getter.244 = getter;
      D.24789 = getter.244 == 0B;
      D.24790 = (long int) D.24789;
      D.24791 = __builtin_expect (D.24790, 0);
      if (D.24791 != 0) goto <D.24792>; else goto <D.24793>;
      <D.24792>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 6344, "getter");
      <D.24793>:
      <D.24786>:
      D.24794 = field->type;
      field_class = mono_class_from_mono_type (D.24794);
      D.24795 = mono_defaults.mono_method_message_class;
      msg = mono_object_new (domain, D.24795);
      D.24787 = mono_defaults.object_class;
      out_args.246 = mono_array_new (domain, D.24787, 1);
      out_args = out_args.246;
      out_args.247 = out_args;
      getter.244 = getter;
      D.24798 = mono_method_get_object (domain, getter.244, 0B);
      mono_message_init (domain, msg, D.24798, out_args.247);
      full_name = mono_type_get_full_name (klass);
      {
        void * * __p;

        D.24799 = msg->args;
        __p = mono_array_addr_with_size (D.24799, 4, 0);
        D.24800 = mono_string_new (domain, full_name);
        D.24799 = msg->args;
        mono_gc_wbarrier_set_arrayref (D.24799, __p, D.24800);
      }
      {
        void * * __p;

        D.24799 = msg->args;
        __p = mono_array_addr_with_size (D.24799, 4, 1);
        D.24801 = mono_field_get_name (field);
        D.24802 = mono_string_new (domain, D.24801);
        D.24799 = msg->args;
        mono_gc_wbarrier_set_arrayref (D.24799, __p, D.24802);
      }
      monoeg_g_free (full_name);
      D.24777 = tp->rp;
      mono_remoting_invoke (D.24777, msg, &exc, &out_args);
      exc.248 = exc;
      if (exc.248 != 0B) goto <D.24804>; else goto <D.24805>;
      <D.24804>:
      exc.248 = exc;
      mono_raise_exception (exc.248);
      <D.24805>:
      out_args.247 = out_args;
      D.24806 = mono_array_length (out_args.247);
      if (D.24806 == 0) goto <D.24807>; else goto <D.24808>;
      <D.24807>:
      D.24783 = 0B;
      return D.24783;
      <D.24808>:
      out_args.247 = out_args;
      D.24809 = mono_array_addr_with_size (out_args.247, 4, 0);
      D.24810 = MEM[(struct MonoObject * *)D.24809];
      *res = D.24810;
      D.24811 = BIT_FIELD_REF <*field_class, 8, 160>;
      D.24812 = D.24811 & 8;
      if (D.24812 != 0) goto <D.24813>; else goto <D.24814>;
      <D.24813>:
      D.24815 = *res;
      D.24783 = D.24815 + 8;
      return D.24783;
      <D.24814>:
      D.24783 = res;
      return D.24783;
    }
  finally
    {
      out_args = {CLOBBER};
      exc = {CLOBBER};
    }
}


mono_load_remote_field_new (struct MonoObject * this, struct MonoClass * klass, struct MonoClassField * field)
{
  struct MonoVTable * D.24818;
  struct MonoClass * D.24819;
  struct MonoClass * D.24820;
  _Bool D.24821;
  long int D.24822;
  long int D.24823;
  struct MonoType * D.24826;
  struct MonoRemoteClass * D.24827;
  struct MonoClass * D.24828;
  unsigned char D.24829;
  unsigned char D.24830;
  struct MonoRealProxy * D.24833;
  struct MonoObject * D.24834;
  struct MonoAppContext * D.24835;
  unsigned char D.24838;
  unsigned char D.24839;
  struct MonoObject * res.249;
  struct MonoObject * res.250;
  struct MonoObject * D.24845;
  struct MonoObject * D.24846;
  struct MonoMethod * getter.251;
  struct MonoClass * D.24850;
  struct MonoMethod * getter.252;
  _Bool D.24852;
  long int D.24853;
  long int D.24854;
  struct MonoClass * D.24857;
  struct MonoArray * out_args.253;
  struct MonoArray * out_args.254;
  struct MonoReflectionMethod * D.24860;
  struct MonoArray * D.24861;
  struct MonoString * D.24862;
  const char * D.24863;
  struct MonoString * D.24864;
  struct MonoObject * exc.255;
  unsigned int D.24868;
  char * D.24872;
  struct MonoObject * res.256;
  static struct MonoMethod * getter = 0B;
  struct MonoDomain * domain;
  struct MonoTransparentProxy * tp;
  struct MonoClass * field_class;
  struct MonoMethodMessage * msg;
  struct MonoArray * out_args;
  struct MonoObject * exc;
  struct MonoObject * res;
  char * full_name;

  try
    {
      domain = mono_domain_get ();
      tp = this;
      D.24818 = this->vtable;
      D.24819 = D.24818->klass;
      D.24820 = mono_defaults.transparent_proxy_class;
      D.24821 = D.24819 != D.24820;
      D.24822 = (long int) D.24821;
      D.24823 = __builtin_expect (D.24822, 0);
      if (D.24823 != 0) goto <D.24824>; else goto <D.24825>;
      <D.24824>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 6393, "mono_object_is_transparent_proxy (this)");
      <D.24825>:
      D.24826 = field->type;
      field_class = mono_class_from_mono_type (D.24826);
      D.24827 = tp->remote_class;
      D.24828 = D.24827->proxy_class;
      D.24829 = BIT_FIELD_REF <*D.24828, 8, 176>;
      D.24830 = D.24829 & 128;
      if (D.24830 != 0) goto <D.24831>; else goto <D.24832>;
      <D.24831>:
      D.24833 = tp->rp;
      D.24834 = D.24833->context;
      D.24835 = mono_context_get ();
      if (D.24834 == D.24835) goto <D.24836>; else goto <D.24837>;
      <D.24836>:
      {
        void * val;

        D.24838 = BIT_FIELD_REF <*field_class, 8, 160>;
        D.24839 = D.24838 & 8;
        if (D.24839 != 0) goto <D.24840>; else goto <D.24841>;
        <D.24840>:
        res.249 = mono_object_new (domain, field_class);
        res = res.249;
        res.250 = res;
        val = res.250 + 8;
        goto <D.24844>;
        <D.24841>:
        val = &res;
        <D.24844>:
        D.24833 = tp->rp;
        D.24845 = D.24833->unwrapped_server;
        mono_field_get_value (D.24845, field, val);
        D.24846 = res;
        return D.24846;
      }
      <D.24837>:
      <D.24832>:
      getter.251 = getter;
      if (getter.251 == 0B) goto <D.24848>; else goto <D.24849>;
      <D.24848>:
      D.24850 = mono_defaults.object_class;
      getter.252 = mono_class_get_method_from_name (D.24850, "FieldGetter", -1);
      getter = getter.252;
      getter.251 = getter;
      D.24852 = getter.251 == 0B;
      D.24853 = (long int) D.24852;
      D.24854 = __builtin_expect (D.24853, 0);
      if (D.24854 != 0) goto <D.24855>; else goto <D.24856>;
      <D.24855>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 6411, "getter");
      <D.24856>:
      <D.24849>:
      D.24857 = mono_defaults.mono_method_message_class;
      msg = mono_object_new (domain, D.24857);
      D.24850 = mono_defaults.object_class;
      out_args.253 = mono_array_new (domain, D.24850, 1);
      out_args = out_args.253;
      out_args.254 = out_args;
      getter.251 = getter;
      D.24860 = mono_method_get_object (domain, getter.251, 0B);
      mono_message_init (domain, msg, D.24860, out_args.254);
      full_name = mono_type_get_full_name (klass);
      {
        void * * __p;

        D.24861 = msg->args;
        __p = mono_array_addr_with_size (D.24861, 4, 0);
        D.24862 = mono_string_new (domain, full_name);
        D.24861 = msg->args;
        mono_gc_wbarrier_set_arrayref (D.24861, __p, D.24862);
      }
      {
        void * * __p;

        D.24861 = msg->args;
        __p = mono_array_addr_with_size (D.24861, 4, 1);
        D.24863 = mono_field_get_name (field);
        D.24864 = mono_string_new (domain, D.24863);
        D.24861 = msg->args;
        mono_gc_wbarrier_set_arrayref (D.24861, __p, D.24864);
      }
      monoeg_g_free (full_name);
      D.24833 = tp->rp;
      mono_remoting_invoke (D.24833, msg, &exc, &out_args);
      exc.255 = exc;
      if (exc.255 != 0B) goto <D.24866>; else goto <D.24867>;
      <D.24866>:
      exc.255 = exc;
      mono_raise_exception (exc.255);
      <D.24867>:
      out_args.254 = out_args;
      D.24868 = mono_array_length (out_args.254);
      if (D.24868 == 0) goto <D.24869>; else goto <D.24870>;
      <D.24869>:
      res = 0B;
      goto <D.24871>;
      <D.24870>:
      out_args.254 = out_args;
      D.24872 = mono_array_addr_with_size (out_args.254, 4, 0);
      res.256 = MEM[(struct MonoObject * *)D.24872];
      res = res.256;
      <D.24871>:
      D.24846 = res;
      return D.24846;
    }
  finally
    {
      out_args = {CLOBBER};
      exc = {CLOBBER};
      res = {CLOBBER};
    }
}


mono_store_remote_field (struct MonoObject * this, struct MonoClass * klass, struct MonoClassField * field, void * val)
{
  struct MonoVTable * D.24876;
  struct MonoClass * D.24877;
  struct MonoClass * D.24878;
  _Bool D.24879;
  long int D.24880;
  long int D.24881;
  struct MonoType * D.24884;
  struct MonoRemoteClass * D.24885;
  struct MonoClass * D.24886;
  unsigned char D.24887;
  unsigned char D.24888;
  struct MonoRealProxy * D.24891;
  struct MonoObject * D.24892;
  struct MonoAppContext * D.24893;
  unsigned char D.24896;
  unsigned char D.24897;
  struct MonoObject * D.24900;
  struct MonoObject * D.24902;
  struct MonoMethod * setter.257;
  struct MonoClass * D.24906;
  struct MonoMethod * setter.258;
  _Bool D.24908;
  long int D.24909;
  long int D.24910;
  struct MonoClass * D.24916;
  struct MonoReflectionMethod * D.24917;
  struct MonoArray * D.24918;
  struct MonoString * D.24919;
  const char * D.24920;
  struct MonoString * D.24921;
  struct MonoObject * exc.259;
  static struct MonoMethod * setter = 0B;
  struct MonoDomain * domain;
  struct MonoTransparentProxy * tp;
  struct MonoClass * field_class;
  struct MonoMethodMessage * msg;
  struct MonoArray * out_args;
  struct MonoObject * exc;
  struct MonoObject * arg;
  char * full_name;

  try
    {
      domain = mono_domain_get ();
      tp = this;
      D.24876 = this->vtable;
      D.24877 = D.24876->klass;
      D.24878 = mono_defaults.transparent_proxy_class;
      D.24879 = D.24877 != D.24878;
      D.24880 = (long int) D.24879;
      D.24881 = __builtin_expect (D.24880, 0);
      if (D.24881 != 0) goto <D.24882>; else goto <D.24883>;
      <D.24882>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 6460, "mono_object_is_transparent_proxy (this)");
      <D.24883>:
      D.24884 = field->type;
      field_class = mono_class_from_mono_type (D.24884);
      D.24885 = tp->remote_class;
      D.24886 = D.24885->proxy_class;
      D.24887 = BIT_FIELD_REF <*D.24886, 8, 176>;
      D.24888 = D.24887 & 128;
      if (D.24888 != 0) goto <D.24889>; else goto <D.24890>;
      <D.24889>:
      D.24891 = tp->rp;
      D.24892 = D.24891->context;
      D.24893 = mono_context_get ();
      if (D.24892 == D.24893) goto <D.24894>; else goto <D.24895>;
      <D.24894>:
      D.24896 = BIT_FIELD_REF <*field_class, 8, 160>;
      D.24897 = D.24896 & 8;
      if (D.24897 != 0) goto <D.24898>; else goto <D.24899>;
      <D.24898>:
      D.24891 = tp->rp;
      D.24900 = D.24891->unwrapped_server;
      mono_field_set_value (D.24900, field, val);
      goto <D.24901>;
      <D.24899>:
      D.24902 = MEM[(struct MonoObject * *)val];
      D.24891 = tp->rp;
      D.24900 = D.24891->unwrapped_server;
      mono_field_set_value (D.24900, field, D.24902);
      <D.24901>:
      return;
      <D.24895>:
      <D.24890>:
      setter.257 = setter;
      if (setter.257 == 0B) goto <D.24904>; else goto <D.24905>;
      <D.24904>:
      D.24906 = mono_defaults.object_class;
      setter.258 = mono_class_get_method_from_name (D.24906, "FieldSetter", -1);
      setter = setter.258;
      setter.257 = setter;
      D.24908 = setter.257 == 0B;
      D.24909 = (long int) D.24908;
      D.24910 = __builtin_expect (D.24909, 0);
      if (D.24910 != 0) goto <D.24911>; else goto <D.24912>;
      <D.24911>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 6472, "setter");
      <D.24912>:
      <D.24905>:
      D.24896 = BIT_FIELD_REF <*field_class, 8, 160>;
      D.24897 = D.24896 & 8;
      if (D.24897 != 0) goto <D.24913>; else goto <D.24914>;
      <D.24913>:
      arg = mono_value_box (domain, field_class, val);
      goto <D.24915>;
      <D.24914>:
      arg = MEM[(struct MonoObject * *)val];
      <D.24915>:
      D.24916 = mono_defaults.mono_method_message_class;
      msg = mono_object_new (domain, D.24916);
      setter.257 = setter;
      D.24917 = mono_method_get_object (domain, setter.257, 0B);
      mono_message_init (domain, msg, D.24917, 0B);
      full_name = mono_type_get_full_name (klass);
      {
        void * * __p;

        D.24918 = msg->args;
        __p = mono_array_addr_with_size (D.24918, 4, 0);
        D.24919 = mono_string_new (domain, full_name);
        D.24918 = msg->args;
        mono_gc_wbarrier_set_arrayref (D.24918, __p, D.24919);
      }
      {
        void * * __p;

        D.24918 = msg->args;
        __p = mono_array_addr_with_size (D.24918, 4, 1);
        D.24920 = mono_field_get_name (field);
        D.24921 = mono_string_new (domain, D.24920);
        D.24918 = msg->args;
        mono_gc_wbarrier_set_arrayref (D.24918, __p, D.24921);
      }
      {
        void * * __p;

        D.24918 = msg->args;
        __p = mono_array_addr_with_size (D.24918, 4, 2);
        D.24918 = msg->args;
        mono_gc_wbarrier_set_arrayref (D.24918, __p, arg);
      }
      monoeg_g_free (full_name);
      D.24891 = tp->rp;
      mono_remoting_invoke (D.24891, msg, &exc, &out_args);
      exc.259 = exc;
      if (exc.259 != 0B) goto <D.24923>; else goto <D.24924>;
      <D.24923>:
      exc.259 = exc;
      mono_raise_exception (exc.259);
      <D.24924>:
    }
  finally
    {
      out_args = {CLOBBER};
      exc = {CLOBBER};
    }
}


mono_store_remote_field_new (struct MonoObject * this, struct MonoClass * klass, struct MonoClassField * field, struct MonoObject * arg)
{
  struct MonoVTable * D.24928;
  struct MonoClass * D.24929;
  struct MonoClass * D.24930;
  _Bool D.24931;
  long int D.24932;
  long int D.24933;
  struct MonoType * D.24936;
  struct MonoRemoteClass * D.24937;
  struct MonoClass * D.24938;
  unsigned char D.24939;
  unsigned char D.24940;
  struct MonoRealProxy * D.24943;
  struct MonoObject * D.24944;
  struct MonoAppContext * D.24945;
  unsigned char D.24948;
  unsigned char D.24949;
  void * D.24952;
  struct MonoObject * D.24953;
  struct MonoMethod * setter.260;
  struct MonoClass * D.24958;
  struct MonoMethod * setter.261;
  _Bool D.24960;
  long int D.24961;
  long int D.24962;
  struct MonoClass * D.24965;
  struct MonoReflectionMethod * D.24966;
  struct MonoArray * D.24967;
  struct MonoString * D.24968;
  const char * D.24969;
  struct MonoString * D.24970;
  struct MonoObject * exc.262;
  static struct MonoMethod * setter = 0B;
  struct MonoDomain * domain;
  struct MonoTransparentProxy * tp;
  struct MonoClass * field_class;
  struct MonoMethodMessage * msg;
  struct MonoArray * out_args;
  struct MonoObject * exc;
  char * full_name;

  try
    {
      domain = mono_domain_get ();
      tp = this;
      D.24928 = this->vtable;
      D.24929 = D.24928->klass;
      D.24930 = mono_defaults.transparent_proxy_class;
      D.24931 = D.24929 != D.24930;
      D.24932 = (long int) D.24931;
      D.24933 = __builtin_expect (D.24932, 0);
      if (D.24933 != 0) goto <D.24934>; else goto <D.24935>;
      <D.24934>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 6516, "mono_object_is_transparent_proxy (this)");
      <D.24935>:
      D.24936 = field->type;
      field_class = mono_class_from_mono_type (D.24936);
      D.24937 = tp->remote_class;
      D.24938 = D.24937->proxy_class;
      D.24939 = BIT_FIELD_REF <*D.24938, 8, 176>;
      D.24940 = D.24939 & 128;
      if (D.24940 != 0) goto <D.24941>; else goto <D.24942>;
      <D.24941>:
      D.24943 = tp->rp;
      D.24944 = D.24943->context;
      D.24945 = mono_context_get ();
      if (D.24944 == D.24945) goto <D.24946>; else goto <D.24947>;
      <D.24946>:
      D.24948 = BIT_FIELD_REF <*field_class, 8, 160>;
      D.24949 = D.24948 & 8;
      if (D.24949 != 0) goto <D.24950>; else goto <D.24951>;
      <D.24950>:
      D.24952 = arg + 8;
      D.24943 = tp->rp;
      D.24953 = D.24943->unwrapped_server;
      mono_field_set_value (D.24953, field, D.24952);
      goto <D.24954>;
      <D.24951>:
      D.24943 = tp->rp;
      D.24953 = D.24943->unwrapped_server;
      mono_field_set_value (D.24953, field, arg);
      <D.24954>:
      return;
      <D.24947>:
      <D.24942>:
      setter.260 = setter;
      if (setter.260 == 0B) goto <D.24956>; else goto <D.24957>;
      <D.24956>:
      D.24958 = mono_defaults.object_class;
      setter.261 = mono_class_get_method_from_name (D.24958, "FieldSetter", -1);
      setter = setter.261;
      setter.260 = setter;
      D.24960 = setter.260 == 0B;
      D.24961 = (long int) D.24960;
      D.24962 = __builtin_expect (D.24961, 0);
      if (D.24962 != 0) goto <D.24963>; else goto <D.24964>;
      <D.24963>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 6528, "setter");
      <D.24964>:
      <D.24957>:
      D.24965 = mono_defaults.mono_method_message_class;
      msg = mono_object_new (domain, D.24965);
      setter.260 = setter;
      D.24966 = mono_method_get_object (domain, setter.260, 0B);
      mono_message_init (domain, msg, D.24966, 0B);
      full_name = mono_type_get_full_name (klass);
      {
        void * * __p;

        D.24967 = msg->args;
        __p = mono_array_addr_with_size (D.24967, 4, 0);
        D.24968 = mono_string_new (domain, full_name);
        D.24967 = msg->args;
        mono_gc_wbarrier_set_arrayref (D.24967, __p, D.24968);
      }
      {
        void * * __p;

        D.24967 = msg->args;
        __p = mono_array_addr_with_size (D.24967, 4, 1);
        D.24969 = mono_field_get_name (field);
        D.24970 = mono_string_new (domain, D.24969);
        D.24967 = msg->args;
        mono_gc_wbarrier_set_arrayref (D.24967, __p, D.24970);
      }
      {
        void * * __p;

        D.24967 = msg->args;
        __p = mono_array_addr_with_size (D.24967, 4, 2);
        D.24967 = msg->args;
        mono_gc_wbarrier_set_arrayref (D.24967, __p, arg);
      }
      monoeg_g_free (full_name);
      D.24943 = tp->rp;
      mono_remoting_invoke (D.24943, msg, &exc, &out_args);
      exc.262 = exc;
      if (exc.262 != 0B) goto <D.24972>; else goto <D.24973>;
      <D.24972>:
      exc.262 = exc;
      mono_raise_exception (exc.262);
      <D.24973>:
    }
  finally
    {
      out_args = {CLOBBER};
      exc = {CLOBBER};
    }
}


mono_create_ftnptr (struct MonoDomain * domain, void * addr)
{
  void * D.24977;
  void * (*<T249c>) (struct MonoDomain *, void *) D.24978;

  D.24978 = callbacks.create_ftnptr;
  D.24977 = D.24978 (domain, addr);
  return D.24977;
}


mono_get_addr_from_ftnptr (void * descr)
{
  void * D.24980;
  void * (*<T142f>) (void *) D.24981;

  D.24981 = callbacks.get_addr_from_ftnptr;
  D.24980 = D.24981 (descr);
  return D.24980;
}


mono_string_chars (struct MonoString * s)
{
  mono_unichar2 * D.24983;

  D.24983 = &s->chars;
  return D.24983;
}


mono_string_length (struct MonoString * s)
{
  int D.24985;

  D.24985 = s->length;
  return D.24985;
}


mono_array_length (struct MonoArray * array)
{
  uintptr_t D.24987;

  D.24987 = array->max_length;
  return D.24987;
}


mono_array_addr_with_size (struct MonoArray * array, int size, uintptr_t idx)
{
  char * D.24989;
  double[0:] * D.24990;
  unsigned int size.263;
  unsigned int D.24992;

  D.24990 = &array->vector;
  size.263 = (unsigned int) size;
  D.24992 = size.263 * idx;
  D.24989 = D.24990 + D.24992;
  return D.24989;
}