mono_runtime_object_init (struct MonoObject * this)
{
  struct MonoVTable * D.20377;
  char * D.20380;
  struct MonoClass * D.20381;
  unsigned int D.20382;
  unsigned int D.20383;
  struct MonoMethod * method;
  struct MonoClass * klass;

  method = 0B;
  D.20377 = this->vtable;
  klass = D.20377->klass;
  method = mono_class_get_method_from_name (klass, ".ctor", 0);
  if (method == 0B) goto <D.20378>; else goto <D.20379>;
  <D.20378>:
  D.20380 = mono_type_get_full_name (klass);
  monoeg_g_log (0B, 4, "Could not lookup zero argument constructor for class %s", D.20380);
  <D.18559>:
  goto <D.18559>;
  <D.20379>:
  D.20381 = method->klass;
  D.20382 = BIT_FIELD_REF <*D.20381, 32, 160>;
  D.20383 = D.20382 & 8;
  if (D.20383 != 0) goto <D.20384>; else goto <D.20385>;
  <D.20384>:
  this = mono_object_unbox (this);
  <D.20385>:
  mono_runtime_invoke (method, this, 0B, 0B);
}


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

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


mono_thread_get_main ()
{
  struct MonoThread * D.20392;

  D.20392 = main_thread;
  return D.20392;
}


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.20399;
  char * * D.20400;
  char * D.20401;
  int num_main_args.6;
  int i;

  i = 0;
  goto <D.19592>;
  <D.19591>:
  main_args.4 = main_args;
  i.5 = (unsigned int) i;
  D.20399 = i.5 * 4;
  D.20400 = main_args.4 + D.20399;
  D.20401 = *D.20400;
  monoeg_g_free (D.20401);
  i = i + 1;
  <D.19592>:
  num_main_args.6 = num_main_args;
  if (i < num_main_args.6) goto <D.19591>; else goto <D.19593>;
  <D.19593>:
  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 int D.20403;
  unsigned int D.20404;
  struct MonoException * D.20407;
  struct MonoImage * D.20408;
  unsigned int D.20409;
  unsigned int D.20410;
  unsigned int D.20413;
  struct MonoDomain * D.20416;
  struct MonoException * exc.7;
  struct MonoException * exc.8;
  _Bool D.20427;
  long int D.20428;
  long int D.20429;
  _Bool D.20436;
  long int D.20437;
  long int D.20438;
  unsigned int D.20441;
  _Bool D.20446;
  long int D.20447;
  long int D.20448;
  struct MonoException * D.20453;
  struct GHashTable * type_initialization_hash.9;
  struct MonoDomain * D.20457;
  int D.20460;
  _Bool D.20465;
  long int D.20466;
  long int D.20467;
  struct MonoException * D.20472;
  struct CRITICAL_SECTION * D.20473;
  union mono_mutex_t * D.20474;
  _Bool D.20477;
  long int D.20478;
  long int D.20479;
  unsigned int D.20485;
  int D.20487;
  _Bool D.20490;
  long int D.20491;
  long int D.20492;
  unsigned int D.20495;
  int D.20498;
  _Bool D.20502;
  long int D.20503;
  long int D.20504;
  struct GHashTable * blocked_thread_hash.10;
  unsigned int D.20508;
  unsigned int D.20509;
  void * tid.11;
  _Bool D.20513;
  long int D.20514;
  long int D.20515;
  struct MonoImage * D.20524;
  int D.18634;
  int iftmp.12;
  int D.18633;
  const char[7] * D.20529;
  unsigned char D.20530;
  int D.20531;
  unsigned char D.20532;
  int D.20533;
  const unsigned char * D.20538;
  unsigned char D.20539;
  int D.20540;
  const unsigned char * D.20541;
  unsigned char D.20542;
  int D.20543;
  const unsigned char * D.20548;
  unsigned char D.20549;
  int D.20550;
  const unsigned char * D.20551;
  unsigned char D.20552;
  int D.20553;
  const unsigned char * D.20558;
  unsigned char D.20559;
  int D.20560;
  const unsigned char * D.20561;
  unsigned char D.20562;
  int D.20563;
  const char * D.20565;
  int D.18643;
  int iftmp.13;
  int D.18642;
  const char[28] * D.20570;
  unsigned char D.20571;
  int D.20572;
  unsigned char D.20573;
  int D.20574;
  const unsigned char * D.20579;
  unsigned char D.20580;
  int D.20581;
  const unsigned char * D.20582;
  unsigned char D.20583;
  int D.20584;
  const unsigned char * D.20589;
  unsigned char D.20590;
  int D.20591;
  const unsigned char * D.20592;
  unsigned char D.20593;
  int D.20594;
  const unsigned char * D.20599;
  unsigned char D.20600;
  int D.20601;
  const unsigned char * D.20602;
  unsigned char D.20603;
  int D.20604;
  const char * D.20606;
  char D.20610;
  union mono_mutex_t * D.20612;
  _Bool D.20615;
  long int D.20616;
  long int D.20617;
  struct MonoGHashTable * D.20620;
  struct MonoGHashTable * D.20623;
  _Bool D.20626;
  long int D.20627;
  long int D.20628;
  _Bool D.20635;
  long int D.20636;
  long int D.20637;
  _Bool D.20643;
  long int D.20644;
  long int D.20645;
  _Bool D.20650;
  long int D.20651;
  long int D.20652;
  _Bool D.20657;
  long int D.20658;
  long int D.20659;
  const void * tid.14;
  unsigned int D.20665;
  _Bool D.20672;
  long int D.20673;
  long int D.20674;
  struct MonoException * D.20681;
  struct MonoException * exc;
  struct MonoException * exc_to_throw;
  struct MonoMethod * method;
  struct MonoClass * klass;
  gchar * full_name;

  try
    {
      method = 0B;
      D.20403 = BIT_FIELD_REF <*vtable, 32, 160>;
      D.20404 = D.20403 & 33554432;
      if (D.20404 != 0) goto <D.20405>; else goto <D.20406>;
      <D.20405>:
      D.20407 = 0B;
      return D.20407;
      <D.20406>:
      exc = 0B;
      klass = vtable->klass;
      D.20408 = klass->image;
      D.20409 = BIT_FIELD_REF <*D.20408, 32, 128>;
      D.20410 = D.20409 & 64;
      if (D.20410 == 0) goto <D.20411>; else goto <D.20412>;
      <D.20411>:
      D.20408 = klass->image;
      mono_image_check_for_module_cctor (D.20408);
      D.20408 = klass->image;
      D.20409 = BIT_FIELD_REF <*D.20408, 32, 128>;
      D.20413 = D.20409 & 128;
      if (D.20413 != 0) goto <D.20414>; else goto <D.20415>;
      <D.20414>:
      {
        struct MonoClass * module_klass;
        struct MonoVTable * module_vtable;

        D.20408 = klass->image;
        module_klass = mono_class_get (D.20408, 33554433);
        D.20416 = vtable->domain;
        module_vtable = mono_class_vtable_full (D.20416, module_klass, raise_exception);
        if (module_vtable == 0B) goto <D.20417>; else goto <D.20418>;
        <D.20417>:
        D.20407 = 0B;
        return D.20407;
        <D.20418>:
        exc.7 = mono_runtime_class_init_full (module_vtable, raise_exception);
        exc = exc.7;
        exc.8 = exc;
        if (exc.8 != 0B) goto <D.20421>; else goto <D.20422>;
        <D.20421>:
        D.20407 = exc;
        return D.20407;
        <D.20422>:
      }
      <D.20415>:
      <D.20412>:
      method = mono_class_get_cctor (klass);
      if (method != 0B) goto <D.20423>; else goto <D.20424>;
      <D.20423>:
      {
        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.20425>; else goto <D.20426>;
          <D.20425>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
          <D.20426>:
          D.20427 = ret != 0;
          D.20428 = (long int) D.20427;
          D.20429 = __builtin_expect (D.20428, 0);
          if (D.20429 != 0) goto <D.20430>; else goto <D.20431>;
          <D.20430>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 308, "ret == 0");
          <D.20431>:
        }
        D.20403 = BIT_FIELD_REF <*vtable, 32, 160>;
        D.20404 = D.20403 & 33554432;
        if (D.20404 != 0) goto <D.20432>; else goto <D.20433>;
        <D.20432>:
        {
          int ret;

          ret = pthread_mutex_unlock (&type_initialization_section.mutex);
          if (ret != 0) goto <D.20434>; else goto <D.20435>;
          <D.20434>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
          <D.20435>:
          D.20436 = ret != 0;
          D.20437 = (long int) D.20436;
          D.20438 = __builtin_expect (D.20437, 0);
          if (D.20438 != 0) goto <D.20439>; else goto <D.20440>;
          <D.20439>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 311, "ret == 0");
          <D.20440>:
        }
        D.20407 = 0B;
        return D.20407;
        <D.20433>:
        D.20403 = BIT_FIELD_REF <*vtable, 32, 160>;
        D.20441 = D.20403 & 67108864;
        if (D.20441 != 0) goto <D.20442>; else goto <D.20443>;
        <D.20442>:
        {
          int ret;

          ret = pthread_mutex_unlock (&type_initialization_section.mutex);
          if (ret != 0) goto <D.20444>; else goto <D.20445>;
          <D.20444>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
          <D.20445>:
          D.20446 = ret != 0;
          D.20447 = (long int) D.20446;
          D.20448 = __builtin_expect (D.20447, 0);
          if (D.20448 != 0) goto <D.20449>; else goto <D.20450>;
          <D.20449>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 315, "ret == 0");
          <D.20450>:
        }
        if (raise_exception != 0) goto <D.20451>; else goto <D.20452>;
        <D.20451>:
        D.20453 = get_type_init_exception_for_vtable (vtable);
        mono_raise_exception (D.20453);
        <D.20452>:
        D.20407 = get_type_init_exception_for_vtable (vtable);
        return D.20407;
        <D.20443>:
        type_initialization_hash.9 = type_initialization_hash;
        lock = monoeg_g_hash_table_lookup (type_initialization_hash.9, vtable);
        if (lock == 0B) goto <D.20455>; else goto <D.20456>;
        <D.20455>:
        D.20457 = mono_domain_get ();
        if (D.20457 != domain) goto <D.20458>; else goto <D.20459>;
        <D.20458>:
        last_domain = mono_domain_get ();
        D.20460 = mono_domain_set (domain, 0);
        if (D.20460 == 0) goto <D.20461>; else goto <D.20462>;
        <D.20461>:
        vtable->initialized = 1;
        {
          int ret;

          ret = pthread_mutex_unlock (&type_initialization_section.mutex);
          if (ret != 0) goto <D.20463>; else goto <D.20464>;
          <D.20463>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
          <D.20464>:
          D.20465 = ret != 0;
          D.20466 = (long int) D.20465;
          D.20467 = __builtin_expect (D.20466, 0);
          if (D.20467 != 0) goto <D.20468>; else goto <D.20469>;
          <D.20468>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 330, "ret == 0");
          <D.20469>:
        }
        if (raise_exception != 0) goto <D.20470>; else goto <D.20471>;
        <D.20470>:
        D.20472 = mono_get_exception_appdomain_unloaded ();
        mono_raise_exception (D.20472);
        <D.20471>:
        D.20407 = mono_get_exception_appdomain_unloaded ();
        return D.20407;
        <D.20462>:
        <D.20459>:
        lock = monoeg_malloc (40);
        D.20473 = &lock->initialization_section;
        InitializeCriticalSection (D.20473);
        lock->initializing_tid = tid;
        lock->waiting_count = 1;
        lock->done = 0;
        {
          int ret;

          D.20474 = &lock->initialization_section.mutex;
          ret = pthread_mutex_lock (D.20474);
          if (ret != 0) goto <D.20475>; else goto <D.20476>;
          <D.20475>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
          <D.20476>:
          D.20477 = ret != 0;
          D.20478 = (long int) D.20477;
          D.20479 = __builtin_expect (D.20478, 0);
          if (D.20479 != 0) goto <D.20480>; else goto <D.20481>;
          <D.20480>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 342, "ret == 0");
          <D.20481>:
        }
        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.20482>;
        <D.20456>:
        {
          void * blocked;
          struct TypeInitializationLock * pending_lock;

          D.20485 = lock->initializing_tid;
          if (D.20485 == tid) goto <D.20483>; else goto <D.20486>;
          <D.20486>:
          D.20487 = lock->done;
          if (D.20487 != 0) goto <D.20483>; else goto <D.20484>;
          <D.20483>:
          {
            int ret;

            ret = pthread_mutex_unlock (&type_initialization_section.mutex);
            if (ret != 0) goto <D.20488>; else goto <D.20489>;
            <D.20488>:
            monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
            <D.20489>:
            D.20490 = ret != 0;
            D.20491 = (long int) D.20490;
            D.20492 = __builtin_expect (D.20491, 0);
            if (D.20492 != 0) goto <D.20493>; else goto <D.20494>;
            <D.20493>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 350, "ret == 0");
            <D.20494>:
          }
          D.20407 = 0B;
          return D.20407;
          <D.20484>:
          D.20485 = lock->initializing_tid;
          blocked = (void *) D.20485;
          goto <D.18624>;
          <D.18623>:
          D.20495 = pending_lock->initializing_tid;
          if (D.20495 == tid) goto <D.20496>; else goto <D.20497>;
          <D.20496>:
          D.20498 = pending_lock->done;
          if (D.20498 == 0) goto <D.20499>; else goto <D.18622>;
          <D.20499>:
          {
            int ret;

            ret = pthread_mutex_unlock (&type_initialization_section.mutex);
            if (ret != 0) goto <D.20500>; else goto <D.20501>;
            <D.20500>:
            monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
            <D.20501>:
            D.20502 = ret != 0;
            D.20503 = (long int) D.20502;
            D.20504 = __builtin_expect (D.20503, 0);
            if (D.20504 != 0) goto <D.20505>; else goto <D.20506>;
            <D.20505>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 358, "ret == 0");
            <D.20506>:
          }
          D.20407 = 0B;
          return D.20407;
          <D.20497>:
          D.20495 = pending_lock->initializing_tid;
          blocked = (void *) D.20495;
          <D.18624>:
          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.18623>; else goto <D.18622>;
          <D.18622>:
          D.20508 = lock->waiting_count;
          D.20509 = D.20508 + 1;
          lock->waiting_count = D.20509;
          blocked_thread_hash.10 = blocked_thread_hash;
          tid.11 = (void *) tid;
          monoeg_g_hash_table_insert_replace (blocked_thread_hash.10, tid.11, lock, 0);
        }
        <D.20482>:
        {
          int ret;

          ret = pthread_mutex_unlock (&type_initialization_section.mutex);
          if (ret != 0) goto <D.20511>; else goto <D.20512>;
          <D.20511>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
          <D.20512>:
          D.20513 = ret != 0;
          D.20514 = (long int) D.20513;
          D.20515 = __builtin_expect (D.20514, 0);
          if (D.20515 != 0) goto <D.20516>; else goto <D.20517>;
          <D.20516>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 373, "ret == 0");
          <D.20517>:
        }
        if (do_initialization != 0) goto <D.20518>; else goto <D.20519>;
        <D.20518>:
        mono_runtime_invoke (method, 0B, 0B, &exc);
        exc.8 = exc;
        if (exc.8 != 0B) goto <D.20522>; else goto <D.20523>;
        <D.20522>:
        D.20408 = klass->image;
        D.20524 = mono_defaults.corlib;
        if (D.20408 != D.20524) goto <D.20520>; else goto <D.20525>;
        <D.20525>:
        {
          size_t __s1_len;
          size_t __s2_len;

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

            __s2 = klass->name_space;
            D.20529 = "System";
            D.20530 = MEM[(const unsigned char *)D.20529];
            D.20531 = (int) D.20530;
            D.20532 = *__s2;
            D.20533 = (int) D.20532;
            __result = D.20531 - D.20533;
            {
              if (__s2_len != 0) goto <D.20534>; else goto <D.20535>;
              <D.20534>:
              if (__result == 0) goto <D.20536>; else goto <D.20537>;
              <D.20536>:
              D.20538 = &MEM[(void *)"System" + 1B];
              D.20539 = *D.20538;
              D.20540 = (int) D.20539;
              D.20541 = __s2 + 1;
              D.20542 = *D.20541;
              D.20543 = (int) D.20542;
              __result = D.20540 - D.20543;
              if (__s2_len > 1) goto <D.20544>; else goto <D.20545>;
              <D.20544>:
              if (__result == 0) goto <D.20546>; else goto <D.20547>;
              <D.20546>:
              D.20548 = &MEM[(void *)"System" + 2B];
              D.20549 = *D.20548;
              D.20550 = (int) D.20549;
              D.20551 = __s2 + 2;
              D.20552 = *D.20551;
              D.20553 = (int) D.20552;
              __result = D.20550 - D.20553;
              if (__s2_len > 2) goto <D.20554>; else goto <D.20555>;
              <D.20554>:
              if (__result == 0) goto <D.20556>; else goto <D.20557>;
              <D.20556>:
              D.20558 = &MEM[(void *)"System" + 3B];
              D.20559 = *D.20558;
              D.20560 = (int) D.20559;
              D.20561 = __s2 + 3;
              D.20562 = *D.20561;
              D.20563 = (int) D.20562;
              __result = D.20560 - D.20563;
              <D.20557>:
              <D.20555>:
              <D.20547>:
              <D.20545>:
              <D.20537>:
              <D.20535>:
            }
            D.18633 = __result;
          }
          iftmp.12 = -D.18633;
          goto <D.20564>;
          <D.20528>:
          D.20565 = klass->name_space;
          iftmp.12 = __builtin_strcmp (D.20565, "System");
          <D.20564>:
          D.18634 = iftmp.12;
        }
        if (D.18634 != 0) goto <D.20520>; else goto <D.20566>;
        <D.20566>:
        {
          size_t __s1_len;
          size_t __s2_len;

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

            __s2 = klass->name;
            D.20570 = "TypeInitializationException";
            D.20571 = MEM[(const unsigned char *)D.20570];
            D.20572 = (int) D.20571;
            D.20573 = *__s2;
            D.20574 = (int) D.20573;
            __result = D.20572 - D.20574;
            {
              if (__s2_len != 0) goto <D.20575>; else goto <D.20576>;
              <D.20575>:
              if (__result == 0) goto <D.20577>; else goto <D.20578>;
              <D.20577>:
              D.20579 = &MEM[(void *)"TypeInitializationException" + 1B];
              D.20580 = *D.20579;
              D.20581 = (int) D.20580;
              D.20582 = __s2 + 1;
              D.20583 = *D.20582;
              D.20584 = (int) D.20583;
              __result = D.20581 - D.20584;
              if (__s2_len > 1) goto <D.20585>; else goto <D.20586>;
              <D.20585>:
              if (__result == 0) goto <D.20587>; else goto <D.20588>;
              <D.20587>:
              D.20589 = &MEM[(void *)"TypeInitializationException" + 2B];
              D.20590 = *D.20589;
              D.20591 = (int) D.20590;
              D.20592 = __s2 + 2;
              D.20593 = *D.20592;
              D.20594 = (int) D.20593;
              __result = D.20591 - D.20594;
              if (__s2_len > 2) goto <D.20595>; else goto <D.20596>;
              <D.20595>:
              if (__result == 0) goto <D.20597>; else goto <D.20598>;
              <D.20597>:
              D.20599 = &MEM[(void *)"TypeInitializationException" + 3B];
              D.20600 = *D.20599;
              D.20601 = (int) D.20600;
              D.20602 = __s2 + 3;
              D.20603 = *D.20602;
              D.20604 = (int) D.20603;
              __result = D.20601 - D.20604;
              <D.20598>:
              <D.20596>:
              <D.20588>:
              <D.20586>:
              <D.20578>:
              <D.20576>:
            }
            D.18642 = __result;
          }
          iftmp.13 = -D.18642;
          goto <D.20605>;
          <D.20569>:
          D.20606 = klass->name;
          iftmp.13 = __builtin_strcmp (D.20606, "TypeInitializationException");
          <D.20605>:
          D.18643 = iftmp.13;
        }
        if (D.18643 != 0) goto <D.20520>; else goto <D.20521>;
        <D.20520>:
        vtable->init_failed = 1;
        D.20565 = klass->name_space;
        if (D.20565 != 0B) goto <D.20609>; else goto <D.20607>;
        <D.20609>:
        D.20565 = klass->name_space;
        D.20610 = *D.20565;
        if (D.20610 != 0) goto <D.20611>; else goto <D.20607>;
        <D.20611>:
        D.20565 = klass->name_space;
        D.20606 = klass->name;
        full_name = monoeg_g_strdup_printf ("%s.%s", D.20565, D.20606);
        goto <D.20608>;
        <D.20607>:
        D.20606 = klass->name;
        full_name = monoeg_strdup (D.20606);
        <D.20608>:
        exc.8 = exc;
        exc_to_throw = mono_get_exception_type_initialization (full_name, exc.8);
        monoeg_g_free (full_name);
        {
          int ret;

          D.20612 = &domain->lock.mutex;
          ret = pthread_mutex_lock (D.20612);
          if (ret != 0) goto <D.20613>; else goto <D.20614>;
          <D.20613>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
          <D.20614>:
          D.20615 = ret != 0;
          D.20616 = (long int) D.20615;
          D.20617 = __builtin_expect (D.20616, 0);
          if (D.20617 != 0) goto <D.20618>; else goto <D.20619>;
          <D.20618>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 397, "ret == 0");
          <D.20619>:
        }
        D.20620 = domain->type_init_exception_hash;
        if (D.20620 == 0B) goto <D.20621>; else goto <D.20622>;
        <D.20621>:
        D.20623 = mono_g_hash_table_new_type (mono_aligned_addr_hash, 0B, 2);
        domain->type_init_exception_hash = D.20623;
        <D.20622>:
        D.20620 = domain->type_init_exception_hash;
        mono_g_hash_table_insert (D.20620, klass, exc_to_throw);
        {
          int ret;

          D.20612 = &domain->lock.mutex;
          ret = pthread_mutex_unlock (D.20612);
          if (ret != 0) goto <D.20624>; else goto <D.20625>;
          <D.20624>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
          <D.20625>:
          D.20626 = ret != 0;
          D.20627 = (long int) D.20626;
          D.20628 = __builtin_expect (D.20627, 0);
          if (D.20628 != 0) goto <D.20629>; else goto <D.20630>;
          <D.20629>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 401, "ret == 0");
          <D.20630>:
        }
        <D.20521>:
        <D.20523>:
        if (last_domain != 0B) goto <D.20631>; else goto <D.20632>;
        <D.20631>:
        mono_domain_set (last_domain, 1);
        <D.20632>:
        lock->done = 1;
        {
          int ret;

          D.20474 = &lock->initialization_section.mutex;
          ret = pthread_mutex_unlock (D.20474);
          if (ret != 0) goto <D.20633>; else goto <D.20634>;
          <D.20633>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
          <D.20634>:
          D.20635 = ret != 0;
          D.20636 = (long int) D.20635;
          D.20637 = __builtin_expect (D.20636, 0);
          if (D.20637 != 0) goto <D.20638>; else goto <D.20639>;
          <D.20638>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 407, "ret == 0");
          <D.20639>:
        }
        goto <D.20640>;
        <D.20519>:
        {
          int ret;

          D.20474 = &lock->initialization_section.mutex;
          ret = pthread_mutex_lock (D.20474);
          if (ret != 0) goto <D.20641>; else goto <D.20642>;
          <D.20641>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
          <D.20642>:
          D.20643 = ret != 0;
          D.20644 = (long int) D.20643;
          D.20645 = __builtin_expect (D.20644, 0);
          if (D.20645 != 0) goto <D.20646>; else goto <D.20647>;
          <D.20646>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 410, "ret == 0");
          <D.20647>:
        }
        {
          int ret;

          D.20474 = &lock->initialization_section.mutex;
          ret = pthread_mutex_unlock (D.20474);
          if (ret != 0) goto <D.20648>; else goto <D.20649>;
          <D.20648>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
          <D.20649>:
          D.20650 = ret != 0;
          D.20651 = (long int) D.20650;
          D.20652 = __builtin_expect (D.20651, 0);
          if (D.20652 != 0) goto <D.20653>; else goto <D.20654>;
          <D.20653>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 411, "ret == 0");
          <D.20654>:
        }
        <D.20640>:
        {
          int ret;

          ret = pthread_mutex_lock (&type_initialization_section.mutex);
          if (ret != 0) goto <D.20655>; else goto <D.20656>;
          <D.20655>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
          <D.20656>:
          D.20657 = ret != 0;
          D.20658 = (long int) D.20657;
          D.20659 = __builtin_expect (D.20658, 0);
          if (D.20659 != 0) goto <D.20660>; else goto <D.20661>;
          <D.20660>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 414, "ret == 0");
          <D.20661>:
        }
        D.20485 = lock->initializing_tid;
        if (D.20485 != tid) goto <D.20662>; else goto <D.20663>;
        <D.20662>:
        blocked_thread_hash.10 = blocked_thread_hash;
        tid.14 = (const void *) tid;
        monoeg_g_hash_table_remove (blocked_thread_hash.10, tid.14);
        <D.20663>:
        D.20508 = lock->waiting_count;
        D.20665 = D.20508 + 4294967295;
        lock->waiting_count = D.20665;
        D.20508 = lock->waiting_count;
        if (D.20508 == 0) goto <D.20666>; else goto <D.20667>;
        <D.20666>:
        D.20473 = &lock->initialization_section;
        DeleteCriticalSection (D.20473);
        type_initialization_hash.9 = type_initialization_hash;
        monoeg_g_hash_table_remove (type_initialization_hash.9, vtable);
        monoeg_g_free (lock);
        <D.20667>:
        mono_memory_barrier ();
        D.20403 = BIT_FIELD_REF <*vtable, 32, 160>;
        D.20441 = D.20403 & 67108864;
        if (D.20441 == 0) goto <D.20668>; else goto <D.20669>;
        <D.20668>:
        vtable->initialized = 1;
        <D.20669>:
        {
          int ret;

          ret = pthread_mutex_unlock (&type_initialization_section.mutex);
          if (ret != 0) goto <D.20670>; else goto <D.20671>;
          <D.20670>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
          <D.20671>:
          D.20672 = ret != 0;
          D.20673 = (long int) D.20672;
          D.20674 = __builtin_expect (D.20673, 0);
          if (D.20674 != 0) goto <D.20675>; else goto <D.20676>;
          <D.20675>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 426, "ret == 0");
          <D.20676>:
        }
        D.20403 = BIT_FIELD_REF <*vtable, 32, 160>;
        D.20441 = D.20403 & 67108864;
        if (D.20441 != 0) goto <D.20677>; else goto <D.20678>;
        <D.20677>:
        if (raise_exception != 0) goto <D.20679>; else goto <D.20680>;
        <D.20679>:
        D.20681 = get_type_init_exception_for_vtable (vtable);
        mono_raise_exception (D.20681);
        <D.20680>:
        D.20407 = get_type_init_exception_for_vtable (vtable);
        return D.20407;
        <D.20678>:
      }
      goto <D.20682>;
      <D.20424>:
      vtable->initialized = 1;
      D.20407 = 0B;
      return D.20407;
      <D.20682>:
      D.20407 = 0B;
      return D.20407;
    }
  finally
    {
      exc = {CLOBBER};
    }
}


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

  if (str != 0B) goto <D.20685>; else goto <D.20686>;
  <D.20685>:
  D.20687 = __strdup (str);
  return D.20687;
  <D.20686>:
  D.20687 = 0B;
  return D.20687;
}


mono_memory_barrier ()
{
  __sync_synchronize ();
}


get_type_init_exception_for_vtable (struct MonoVTable * vtable)
{
  unsigned int D.20689;
  unsigned int D.20690;
  char * D.20693;
  union mono_mutex_t * D.20694;
  _Bool D.20697;
  long int D.20698;
  long int D.20699;
  struct MonoGHashTable * D.20702;
  _Bool D.20707;
  long int D.20708;
  long int D.20709;
  const char * D.20716;
  char D.20718;
  const char * D.20720;
  struct MonoException * D.20721;
  struct MonoDomain * domain;
  struct MonoClass * klass;
  struct MonoException * ex;
  gchar * full_name;

  domain = vtable->domain;
  klass = vtable->klass;
  D.20689 = BIT_FIELD_REF <*vtable, 32, 160>;
  D.20690 = D.20689 & 67108864;
  if (D.20690 == 0) goto <D.20691>; else goto <D.20692>;
  <D.20691>:
  D.20693 = 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.20693);
  <D.18591>:
  goto <D.18591>;
  <D.20692>:
  ex = 0B;
  {
    int ret;

    D.20694 = &domain->lock.mutex;
    ret = pthread_mutex_lock (D.20694);
    if (ret != 0) goto <D.20695>; else goto <D.20696>;
    <D.20695>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.20696>:
    D.20697 = ret != 0;
    D.20698 = (long int) D.20697;
    D.20699 = __builtin_expect (D.20698, 0);
    if (D.20699 != 0) goto <D.20700>; else goto <D.20701>;
    <D.20700>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 236, "ret == 0");
    <D.20701>:
  }
  D.20702 = domain->type_init_exception_hash;
  if (D.20702 != 0B) goto <D.20703>; else goto <D.20704>;
  <D.20703>:
  D.20702 = domain->type_init_exception_hash;
  ex = mono_g_hash_table_lookup (D.20702, klass);
  <D.20704>:
  {
    int ret;

    D.20694 = &domain->lock.mutex;
    ret = pthread_mutex_unlock (D.20694);
    if (ret != 0) goto <D.20705>; else goto <D.20706>;
    <D.20705>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.20706>:
    D.20707 = ret != 0;
    D.20708 = (long int) D.20707;
    D.20709 = __builtin_expect (D.20708, 0);
    if (D.20709 != 0) goto <D.20710>; else goto <D.20711>;
    <D.20710>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 239, "ret == 0");
    <D.20711>:
  }
  if (ex == 0B) goto <D.20712>; else goto <D.20713>;
  <D.20712>:
  D.20716 = klass->name_space;
  if (D.20716 != 0B) goto <D.20717>; else goto <D.20714>;
  <D.20717>:
  D.20716 = klass->name_space;
  D.20718 = *D.20716;
  if (D.20718 != 0) goto <D.20719>; else goto <D.20714>;
  <D.20719>:
  D.20716 = klass->name_space;
  D.20720 = klass->name;
  full_name = monoeg_g_strdup_printf ("%s.%s", D.20716, D.20720);
  goto <D.20715>;
  <D.20714>:
  D.20720 = klass->name;
  full_name = monoeg_strdup (D.20720);
  <D.20715>:
  ex = mono_get_exception_type_initialization (full_name, 0B);
  monoeg_g_free (full_name);
  <D.20713>:
  D.20721 = ex;
  return D.20721;
}


mono_release_type_locks (struct MonoInternalThread * thread)
{
  _Bool D.20725;
  long int D.20726;
  long int D.20727;
  struct GHashTable * type_initialization_hash.15;
  long long unsigned int D.20731;
  unsigned int D.20732;
  void * D.20733;
  _Bool D.20736;
  long int D.20737;
  long int D.20738;

  {
    int ret;

    ret = pthread_mutex_lock (&type_initialization_section.mutex);
    if (ret != 0) goto <D.20723>; else goto <D.20724>;
    <D.20723>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.20724>:
    D.20725 = ret != 0;
    D.20726 = (long int) D.20725;
    D.20727 = __builtin_expect (D.20726, 0);
    if (D.20727 != 0) goto <D.20728>; else goto <D.20729>;
    <D.20728>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 469, "ret == 0");
    <D.20729>:
  }
  type_initialization_hash.15 = type_initialization_hash;
  D.20731 = thread->tid;
  D.20732 = (unsigned int) D.20731;
  D.20733 = (void *) D.20732;
  monoeg_g_hash_table_foreach_remove (type_initialization_hash.15, release_type_locks, D.20733);
  {
    int ret;

    ret = pthread_mutex_unlock (&type_initialization_section.mutex);
    if (ret != 0) goto <D.20734>; else goto <D.20735>;
    <D.20734>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.20735>:
    D.20736 = ret != 0;
    D.20737 = (long int) D.20736;
    D.20738 = __builtin_expect (D.20737, 0);
    if (D.20738 != 0) goto <D.20739>; else goto <D.20740>;
    <D.20739>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 471, "ret == 0");
    <D.20740>:
  }
}


release_type_locks (void * key, void * value, void * user)
{
  unsigned int D.20741;
  unsigned int user.16;
  int D.20745;
  union mono_mutex_t * D.20748;
  _Bool D.20751;
  long int D.20752;
  long int D.20753;
  unsigned int D.20756;
  unsigned int D.20757;
  struct CRITICAL_SECTION * D.20760;
  gboolean D.20761;
  struct MonoVTable * vtable;
  struct TypeInitializationLock * lock;

  vtable = key;
  lock = value;
  D.20741 = lock->initializing_tid;
  user.16 = (unsigned int) user;
  if (D.20741 == user.16) goto <D.20743>; else goto <D.20744>;
  <D.20743>:
  D.20745 = lock->done;
  if (D.20745 == 0) goto <D.20746>; else goto <D.20747>;
  <D.20746>:
  lock->done = 1;
  vtable->init_failed = 1;
  {
    int ret;

    D.20748 = &lock->initialization_section.mutex;
    ret = pthread_mutex_unlock (D.20748);
    if (ret != 0) goto <D.20749>; else goto <D.20750>;
    <D.20749>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.20750>:
    D.20751 = ret != 0;
    D.20752 = (long int) D.20751;
    D.20753 = __builtin_expect (D.20752, 0);
    if (D.20753 != 0) goto <D.20754>; else goto <D.20755>;
    <D.20754>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 455, "ret == 0");
    <D.20755>:
  }
  D.20756 = lock->waiting_count;
  D.20757 = D.20756 + 4294967295;
  lock->waiting_count = D.20757;
  D.20756 = lock->waiting_count;
  if (D.20756 == 0) goto <D.20758>; else goto <D.20759>;
  <D.20758>:
  D.20760 = &lock->initialization_section;
  DeleteCriticalSection (D.20760);
  monoeg_g_free (lock);
  D.20761 = 1;
  return D.20761;
  <D.20759>:
  <D.20747>:
  <D.20744>:
  D.20761 = 0;
  return D.20761;
}


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


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

  D.20764 = __builtin_object_size (__dest, 0);
  D.20763 = __builtin___memcpy_chk (__dest, __src, __len, D.20764);
  return D.20763;
}


mono_get_runtime_callbacks ()
{
  struct MonoRuntimeCallbacks * D.20766;

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


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

  if (func != 0B) goto <D.20769>; else goto <D.20770>;
  <D.20769>:
  iftmp.17 = func;
  goto <D.20771>;
  <D.20770>:
  iftmp.17 = default_trampoline;
  <D.20771>:
  arch_create_jit_trampoline = iftmp.17;
}


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

  D.20772 = method;
  return D.20772;
}


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

  if (func != 0B) goto <D.20775>; else goto <D.20776>;
  <D.20775>:
  iftmp.18 = func;
  goto <D.20777>;
  <D.20776>:
  iftmp.18 = default_jump_trampoline;
  <D.20777>:
  arch_create_jump_trampoline = iftmp.18;
}


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

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


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

  if (func != 0B) goto <D.20781>; else goto <D.20782>;
  <D.20781>:
  iftmp.19 = func;
  goto <D.20783>;
  <D.20782>:
  iftmp.19 = default_remoting_trampoline;
  <D.20783>:
  arch_create_remoting_trampoline = iftmp.19;
}


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

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


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

  if (func != 0B) goto <D.20787>; else goto <D.20788>;
  <D.20787>:
  iftmp.20 = func;
  goto <D.20789>;
  <D.20788>:
  iftmp.20 = default_delegate_trampoline;
  <D.20789>:
  arch_create_delegate_trampoline = iftmp.20;
}


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

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


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 * (*<T11b2>) (struct MonoMethod *) default_mono_compile_method.21;
  void * D.20795;

  default_mono_compile_method.21 = default_mono_compile_method;
  if (default_mono_compile_method.21 == 0B) goto <D.20793>; else goto <D.20794>;
  <D.20793>:
  monoeg_g_log (0B, 4, "compile method called on uninitialized runtime");
  <D.18715>:
  goto <D.18715>;
  D.20795 = 0B;
  return D.20795;
  <D.20794>:
  default_mono_compile_method.21 = default_mono_compile_method;
  D.20795 = default_mono_compile_method.21 (method);
  return D.20795;
}


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

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


mono_runtime_create_delegate_trampoline (struct MonoClass * klass)
{
  void * D.20800;
  void * (*<T1d25>) (struct MonoDomain *, struct MonoClass *) arch_create_delegate_trampoline.23;
  struct MonoDomain * D.20802;

  arch_create_delegate_trampoline.23 = arch_create_delegate_trampoline;
  D.20802 = mono_domain_get ();
  D.20800 = arch_create_delegate_trampoline.23 (D.20802, klass);
  return D.20800;
}


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 (*<T24e0>) (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.20805>; else goto <D.20806>;
  <D.20805>:
  default_mono_free_method.24 = default_mono_free_method;
  default_mono_free_method.24 (domain, method);
  <D.20806>:
  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.20807;

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


compute_class_bitmap (struct MonoClass * class, gsize * bitmap, int size, int offset, int * max_set, gboolean static_fields)
{
  int D.20811;
  unsigned int D.20812;
  unsigned int D.20813;
  int D.20815;
  unsigned int D.20816;
  unsigned int D.20817;
  _Bool D.20820;
  long int D.20821;
  long int D.20822;
  unsigned int max_size.25;
  unsigned int D.20826;
  unsigned int D.20827;
  unsigned int D.20828;
  struct MonoImage * D.20831;
  struct MonoImage * D.20832;
  int D.18752;
  int iftmp.26;
  int D.18748;
  const char[10] * D.20838;
  unsigned char D.20839;
  int D.20840;
  unsigned char D.20841;
  int D.20842;
  const unsigned char * D.20847;
  unsigned char D.20848;
  int D.20849;
  const unsigned char * D.20850;
  unsigned char D.20851;
  int D.20852;
  const unsigned char * D.20857;
  unsigned char D.20858;
  int D.20859;
  const unsigned char * D.20860;
  unsigned char D.20861;
  int D.20862;
  const unsigned char * D.20867;
  unsigned char D.20868;
  int D.20869;
  const unsigned char * D.20870;
  unsigned char D.20871;
  int D.20872;
  const char * D.20874;
  int D.20877;
  unsigned int D.20878;
  gsize * D.20879;
  struct MonoType * D.20882;
  short unsigned int D.20883;
  int D.20884;
  int D.20885;
  int D.20888;
  unsigned int D.20894;
  unsigned int D.20895;
  int D.20899;
  unsigned int D.20902;
  unsigned int offset.27;
  unsigned char D.20904;
  int D.20905;
  unsigned int D.20906;
  _Bool D.20907;
  long int D.20908;
  long int D.20909;
  int iftmp.28;
  unsigned int size.29;
  unsigned int max_size.30;
  _Bool D.20919;
  long int D.20920;
  long int D.20921;
  unsigned int D.20924;
  unsigned int D.20925;
  gsize * D.20926;
  unsigned int D.20927;
  int pos.31;
  int D.20929;
  unsigned int D.20930;
  unsigned int D.20931;
  int D.20932;
  unsigned int D.20933;
  unsigned int D.20934;
  int D.20935;
  int D.20936;
  unsigned int D.20941;
  unsigned int D.20942;
  gsize * D.20943;
  unsigned int D.20944;
  unsigned int D.20945;
  unsigned int D.20946;
  unsigned int D.20947;
  unsigned int D.20950;
  int D.20951;
  struct MonoClass * D.20952;
  char * D.20953;
  const char * D.20954;
  struct MonoClassField * field;
  struct MonoClass * p;
  guint32 pos;
  int max_size;

  if (static_fields != 0) goto <D.20809>; else goto <D.20810>;
  <D.20809>:
  D.20811 = mono_class_data_size (class);
  D.20812 = (unsigned int) D.20811;
  D.20813 = D.20812 / 4;
  max_size = (int) D.20813;
  goto <D.20814>;
  <D.20810>:
  D.20815 = class->instance_size;
  D.20816 = (unsigned int) D.20815;
  D.20817 = D.20816 / 4;
  max_size = (int) D.20817;
  <D.20814>:
  if (max_size > size) goto <D.20818>; else goto <D.20819>;
  <D.20818>:
  D.20820 = offset > 0;
  D.20821 = (long int) D.20820;
  D.20822 = __builtin_expect (D.20821, 0);
  if (D.20822 != 0) goto <D.20823>; else goto <D.20824>;
  <D.20823>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 664, "offset <= 0");
  <D.20824>:
  max_size.25 = (unsigned int) max_size;
  D.20826 = max_size.25 + 31;
  D.20827 = D.20826 / 32;
  D.20828 = D.20827 * 4;
  bitmap = monoeg_malloc0 (D.20828);
  size = max_size;
  <D.20819>:
  if (static_fields == 0) goto <D.20829>; else goto <D.20830>;
  <D.20829>:
  D.20831 = class->image;
  D.20832 = mono_defaults.corlib;
  if (D.20831 == D.20832) goto <D.20833>; else goto <D.20834>;
  <D.20833>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = class->name;
      D.20838 = "Ephemeron";
      D.20839 = MEM[(const unsigned char *)D.20838];
      D.20840 = (int) D.20839;
      D.20841 = *__s2;
      D.20842 = (int) D.20841;
      __result = D.20840 - D.20842;
      {
        if (__s1_len != 0) goto <D.20843>; else goto <D.20844>;
        <D.20843>:
        if (__result == 0) goto <D.20845>; else goto <D.20846>;
        <D.20845>:
        D.20847 = &MEM[(void *)"Ephemeron" + 1B];
        D.20848 = *D.20847;
        D.20849 = (int) D.20848;
        D.20850 = __s2 + 1;
        D.20851 = *D.20850;
        D.20852 = (int) D.20851;
        __result = D.20849 - D.20852;
        if (__s1_len > 1) goto <D.20853>; else goto <D.20854>;
        <D.20853>:
        if (__result == 0) goto <D.20855>; else goto <D.20856>;
        <D.20855>:
        D.20857 = &MEM[(void *)"Ephemeron" + 2B];
        D.20858 = *D.20857;
        D.20859 = (int) D.20858;
        D.20860 = __s2 + 2;
        D.20861 = *D.20860;
        D.20862 = (int) D.20861;
        __result = D.20859 - D.20862;
        if (__s1_len > 2) goto <D.20863>; else goto <D.20864>;
        <D.20863>:
        if (__result == 0) goto <D.20865>; else goto <D.20866>;
        <D.20865>:
        D.20867 = &MEM[(void *)"Ephemeron" + 3B];
        D.20868 = *D.20867;
        D.20869 = (int) D.20868;
        D.20870 = __s2 + 3;
        D.20871 = *D.20870;
        D.20872 = (int) D.20871;
        __result = D.20869 - D.20872;
        <D.20866>:
        <D.20864>:
        <D.20856>:
        <D.20854>:
        <D.20846>:
        <D.20844>:
      }
      D.18748 = __result;
    }
    iftmp.26 = D.18748;
    goto <D.20873>;
    <D.20837>:
    D.20874 = class->name;
    iftmp.26 = __builtin_strcmp ("Ephemeron", D.20874);
    <D.20873>:
    D.18752 = iftmp.26;
  }
  if (D.18752 == 0) goto <D.20875>; else goto <D.20876>;
  <D.20875>:
  *max_set = 0;
  D.20877 = size / 8;
  D.20878 = (unsigned int) D.20877;
  memset (bitmap, 0, D.20878);
  D.20879 = bitmap;
  return D.20879;
  <D.20876>:
  <D.20834>:
  <D.20830>:
  p = class;
  goto <D.18787>;
  <D.18786>:
  {
    void * iter;

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

          if (static_fields != 0) goto <D.20880>; else goto <D.20881>;
          <D.20880>:
          D.20882 = field->type;
          D.20883 = D.20882->attrs;
          D.20884 = (int) D.20883;
          D.20885 = D.20884 & 272;
          if (D.20885 == 0) goto <D.20886>; else goto <D.20887>;
          <D.20886>:
          // predicted unlikely by continue predictor.
          goto <D.18755>;
          <D.20887>:
          D.20882 = field->type;
          D.20883 = D.20882->attrs;
          D.20884 = (int) D.20883;
          D.20888 = D.20884 & 64;
          if (D.20888 != 0) goto <D.20889>; else goto <D.20890>;
          <D.20889>:
          // predicted unlikely by continue predictor.
          goto <D.18755>;
          <D.20890>:
          goto <D.20891>;
          <D.20881>:
          D.20882 = field->type;
          D.20883 = D.20882->attrs;
          D.20884 = (int) D.20883;
          D.20885 = D.20884 & 272;
          if (D.20885 != 0) goto <D.20892>; else goto <D.20893>;
          <D.20892>:
          // predicted unlikely by continue predictor.
          goto <D.18755>;
          <D.20893>:
          <D.20891>:
          D.20882 = field->type;
          D.20894 = BIT_FIELD_REF <*D.20882, 32, 32>;
          D.20895 = D.20894 & 1073741824;
          if (D.20895 != 0) goto <D.18756>; else goto <D.20896>;
          <D.20896>:
          if (static_fields != 0) goto <D.20897>; else goto <D.20898>;
          <D.20897>:
          D.20899 = field->offset;
          if (D.20899 == -1) goto <D.20900>; else goto <D.20901>;
          <D.20900>:
          // predicted unlikely by continue predictor.
          goto <D.18755>;
          <D.20901>:
          <D.20898>:
          D.20899 = field->offset;
          D.20902 = (unsigned int) D.20899;
          pos = D.20902 / 4;
          offset.27 = (unsigned int) offset;
          pos = pos + offset.27;
          D.20882 = field->type;
          type = mono_type_get_underlying_type (D.20882);
          D.20904 = type->type;
          D.20905 = (int) D.20904;
          switch (D.20905) <default: <D.18782>, case 2: <D.18780>, case 3: <D.18781>, case 4: <D.18770>, case 5: <D.18771>, case 6: <D.18772>, case 7: <D.18773>, case 8: <D.18774>, case 9: <D.18775>, case 10: <D.18776>, case 11: <D.18777>, case 12: <D.18778>, case 13: <D.18779>, case 14: <D.18762>, case 15: <D.18758>, case 17: <D.18768>, case 18: <D.18764>, case 20: <D.18766>, case 21: <D.18767>, case 24: <D.18757>, case 25: <D.18761>, case 27: <D.18759>, case 28: <D.18765>, case 29: <D.18763>>
          <D.18757>:
          <D.18758>:
          <D.18759>:
          goto <D.18760>;
          <D.18761>:
          goto <D.18760>;
          <D.18762>:
          <D.18763>:
          <D.18764>:
          <D.18765>:
          <D.18766>:
          D.20899 = field->offset;
          D.20902 = (unsigned int) D.20899;
          D.20906 = D.20902 & 3;
          D.20907 = D.20906 != 0;
          D.20908 = (long int) D.20907;
          D.20909 = __builtin_expect (D.20908, 0);
          if (D.20909 != 0) goto <D.20910>; else goto <D.20911>;
          <D.20910>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 722, "(field->offset % sizeof(gpointer)) == 0");
          <D.20911>:
          size.29 = (unsigned int) size;
          if (size.29 <= pos) goto <D.20916>; else goto <D.20913>;
          <D.20916>:
          max_size.30 = (unsigned int) max_size;
          if (max_size.30 < pos) goto <D.20918>; else goto <D.20913>;
          <D.20918>:
          iftmp.28 = 1;
          goto <D.20914>;
          <D.20913>:
          iftmp.28 = 0;
          <D.20914>:
          D.20919 = iftmp.28 != 0;
          D.20920 = (long int) D.20919;
          D.20921 = __builtin_expect (D.20920, 0);
          if (D.20921 != 0) goto <D.20922>; else goto <D.20923>;
          <D.20922>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 724, "pos < size || pos <= max_size");
          <D.20923>:
          D.20924 = pos / 32;
          D.20925 = D.20924 * 4;
          D.20926 = bitmap + D.20925;
          D.20925 = D.20924 * 4;
          D.20926 = bitmap + D.20925;
          D.20927 = *D.20926;
          pos.31 = (int) pos;
          D.20929 = pos.31 & 31;
          D.20930 = 1 << D.20929;
          D.20931 = D.20927 | D.20930;
          *D.20926 = D.20931;
          D.20932 = *max_set;
          D.20933 = (unsigned int) D.20932;
          D.20934 = MAX_EXPR <D.20933, pos>;
          D.20935 = (int) D.20934;
          *max_set = D.20935;
          goto <D.18760>;
          <D.18767>:
          D.20936 = mono_type_generic_inst_is_valuetype (type);
          if (D.20936 == 0) goto <D.20937>; else goto <D.20938>;
          <D.20937>:
          D.20899 = field->offset;
          D.20902 = (unsigned int) D.20899;
          D.20906 = D.20902 & 3;
          D.20907 = D.20906 != 0;
          D.20908 = (long int) D.20907;
          D.20909 = __builtin_expect (D.20908, 0);
          if (D.20909 != 0) goto <D.20939>; else goto <D.20940>;
          <D.20939>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 730, "(field->offset % sizeof(gpointer)) == 0");
          <D.20940>:
          D.20941 = pos / 32;
          D.20942 = D.20941 * 4;
          D.20943 = bitmap + D.20942;
          D.20942 = D.20941 * 4;
          D.20943 = bitmap + D.20942;
          D.20944 = *D.20943;
          pos.31 = (int) pos;
          D.20929 = pos.31 & 31;
          D.20930 = 1 << D.20929;
          D.20945 = D.20944 | D.20930;
          *D.20943 = D.20945;
          D.20932 = *max_set;
          D.20933 = (unsigned int) D.20932;
          D.20934 = MAX_EXPR <D.20933, pos>;
          D.20935 = (int) D.20934;
          *max_set = D.20935;
          goto <D.18760>;
          <D.20938>:
          <D.18768>:
          {
            struct MonoClass * fclass;

            D.20882 = field->type;
            fclass = mono_class_from_mono_type (D.20882);
            D.20946 = BIT_FIELD_REF <*fclass, 32, 160>;
            D.20947 = D.20946 & 134217728;
            if (D.20947 != 0) goto <D.20948>; else goto <D.20949>;
            <D.20948>:
            D.20950 = pos + 4294967294;
            D.20951 = (int) D.20950;
            compute_class_bitmap (fclass, bitmap, size, D.20951, max_set, 0);
            <D.20949>:
            goto <D.18760>;
          }
          <D.18770>:
          <D.18771>:
          <D.18772>:
          <D.18773>:
          <D.18774>:
          <D.18775>:
          <D.18776>:
          <D.18777>:
          <D.18778>:
          <D.18779>:
          <D.18780>:
          <D.18781>:
          goto <D.18760>;
          <D.18782>:
          D.20904 = type->type;
          D.20905 = (int) D.20904;
          D.20952 = field->parent;
          D.20953 = mono_type_get_full_name (D.20952);
          D.20954 = field->name;
          monoeg_g_log (0B, 4, "compute_class_bitmap: Invalid type %x for field %s:%s\n", D.20905, D.20953, D.20954);
          <D.18783>:
          goto <D.18783>;
          <D.18760>:
        }
        <D.18755>:
        field = mono_class_get_fields (p, &iter);
        if (field != 0B) goto <D.18784>; else goto <D.18756>;
        <D.18756>:
        if (static_fields != 0) goto <D.18785>; else goto <D.20955>;
        <D.20955>:
      }
    finally
      {
        iter = {CLOBBER};
      }
  }
  p = p->parent;
  <D.18787>:
  if (p != 0B) goto <D.18786>; else goto <D.18785>;
  <D.18785>:
  D.20879 = bitmap;
  return D.20879;
}


memset (void * __dest, int __ch, size_t __len)
{
  int D.20962;
  int D.20967;
  void * D.20969;
  unsigned int D.20970;

  D.20962 = __builtin_constant_p (__len);
  if (D.20962 != 0) goto <D.20963>; else goto <D.20964>;
  <D.20963>:
  if (__len == 0) goto <D.20965>; else goto <D.20966>;
  <D.20965>:
  D.20967 = __builtin_constant_p (__ch);
  if (D.20967 == 0) goto <D.20960>; else goto <D.20968>;
  <D.20968>:
  if (__ch != 0) goto <D.20960>; else goto <D.20961>;
  <D.20960>:
  __warn_memset_zero_len ();
  D.20969 = __dest;
  return D.20969;
  <D.20961>:
  <D.20966>:
  <D.20964>:
  D.20970 = __builtin_object_size (__dest, 0);
  D.20969 = __builtin___memset_chk (__dest, __ch, __len, D.20970);
  return D.20969;
}


mono_string_alloc (int length)
{
  struct MonoString * D.20972;
  struct MonoDomain * D.20973;

  D.20973 = mono_domain_get ();
  D.20972 = mono_string_new_size (D.20973, length);
  return D.20972;
}


mono_class_compute_gc_descriptor (struct MonoClass * class)
{
  int gcj_inited.32;
  struct MonoMethodSignature * D.20978;
  struct MonoMethodSignature * D.20979;
  struct MonoMethodSignature * D.20980;
  struct MonoMethodSignature * D.20981;
  unsigned int D.20982;
  unsigned int D.20983;
  unsigned int D.20986;
  struct MonoClass * D.20989;
  void * D.20992;
  unsigned char D.20994;
  struct MonoClass * D.20997;
  unsigned int D.20998;
  unsigned int D.20999;
  unsigned char D.21002;
  _Bool D.21003;
  int D.21004;
  void * D.21005;
  int D.21007;
  unsigned int D.21008;
  unsigned int D.21009;
  int D.21010;
  int D.21011;
  unsigned int D.21012;
  void * D.21013;
  int max_set.33;
  int D.21018;
  int D.21019;
  unsigned int D.21020;
  void * D.21021;
  int max_set;
  gsize * bitmap;
  gsize default_bitmap[4];
  static gboolean gcj_inited = 0;

  try
    {
      max_set = 0;
      default_bitmap = {};
      gcj_inited.32 = gcj_inited;
      if (gcj_inited.32 == 0) goto <D.20976>; else goto <D.20977>;
      <D.20976>:
      mono_loader_lock ();
      D.20978 = mono_create_icall_signature ("object ptr");
      mono_register_jit_icall (mono_object_new_ptrfree, "mono_object_new_ptrfree", D.20978, 0);
      D.20979 = mono_create_icall_signature ("object ptr");
      mono_register_jit_icall (mono_object_new_ptrfree_box, "mono_object_new_ptrfree_box", D.20979, 0);
      D.20980 = mono_create_icall_signature ("object ptr");
      mono_register_jit_icall (mono_object_new_fast, "mono_object_new_fast", D.20980, 0);
      D.20981 = mono_create_icall_signature ("object int");
      mono_register_jit_icall (mono_string_alloc, "mono_string_alloc", D.20981, 0);
      gcj_inited = 1;
      mono_loader_unlock ();
      <D.20977>:
      D.20982 = BIT_FIELD_REF <*class, 32, 160>;
      D.20983 = D.20982 & 1;
      if (D.20983 == 0) goto <D.20984>; else goto <D.20985>;
      <D.20984>:
      mono_class_init (class);
      <D.20985>:
      D.20982 = BIT_FIELD_REF <*class, 32, 160>;
      D.20986 = D.20982 & 33554432;
      if (D.20986 != 0) goto <D.20987>; else goto <D.20988>;
      <D.20987>:
      return;
      <D.20988>:
      class->gc_descr_inited = 1;
      class->gc_descr = 0B;
      bitmap = &default_bitmap;
      D.20989 = mono_defaults.string_class;
      if (D.20989 == class) goto <D.20990>; else goto <D.20991>;
      <D.20990>:
      D.20992 = mono_gc_make_descr_for_string (bitmap, 2);
      class->gc_descr = D.20992;
      goto <D.20993>;
      <D.20991>:
      D.20994 = class->rank;
      if (D.20994 != 0) goto <D.20995>; else goto <D.20996>;
      <D.20995>:
      D.20997 = class->element_class;
      mono_class_compute_gc_descriptor (D.20997);
      D.20997 = class->element_class;
      D.20998 = BIT_FIELD_REF <*D.20997, 32, 160>;
      D.20999 = D.20998 & 8;
      if (D.20999 == 0) goto <D.21000>; else goto <D.21001>;
      <D.21000>:
      {
        gsize abm;

        try
          {
            abm = 1;
            D.21002 = class->byval_arg.type;
            D.21003 = D.21002 == 29;
            D.21004 = (int) D.21003;
            D.21005 = mono_gc_make_descr_for_array (D.21004, &abm, 1, 4);
            class->gc_descr = D.21005;
          }
        finally
          {
            abm = {CLOBBER};
          }
      }
      goto <D.21006>;
      <D.21001>:
      D.20997 = class->element_class;
      bitmap = compute_class_bitmap (D.20997, &default_bitmap, 128, -2, &max_set, 0);
      D.21002 = class->byval_arg.type;
      D.21003 = D.21002 == 29;
      D.21004 = (int) D.21003;
      D.21007 = mono_array_element_size (class);
      D.21008 = (unsigned int) D.21007;
      D.21009 = D.21008 / 4;
      D.21010 = (int) D.21009;
      D.21011 = mono_array_element_size (class);
      D.21012 = (unsigned int) D.21011;
      D.21013 = mono_gc_make_descr_for_array (D.21004, bitmap, D.21010, D.21012);
      class->gc_descr = D.21013;
      if (&default_bitmap != bitmap) goto <D.21014>; else goto <D.21015>;
      <D.21014>:
      monoeg_g_free (bitmap);
      <D.21015>:
      <D.21006>:
      goto <D.21016>;
      <D.20996>:
      bitmap = compute_class_bitmap (class, &default_bitmap, 128, 0, &max_set, 0);
      max_set.33 = max_set;
      D.21018 = max_set.33 + 1;
      D.21019 = class->instance_size;
      D.21020 = (unsigned int) D.21019;
      D.21021 = mono_gc_make_descr_for_object (bitmap, D.21018, D.21020);
      class->gc_descr = D.21021;
      if (&default_bitmap != bitmap) goto <D.21022>; else goto <D.21023>;
      <D.21022>:
      monoeg_g_free (bitmap);
      <D.21023>:
      <D.21016>:
      <D.20993>:
    }
  finally
    {
      max_set = {CLOBBER};
      default_bitmap = {CLOBBER};
    }
}


mono_object_new_ptrfree_box (struct MonoVTable * vtable)
{
  struct MonoClass * D.21027;
  int D.21028;
  unsigned int D.21029;
  struct MonoObject * D.21030;
  struct MonoObject * obj;

  D.21027 = vtable->klass;
  D.21028 = D.21027->instance_size;
  D.21029 = (unsigned int) D.21028;
  obj = mono_gc_alloc_obj (vtable, D.21029);
  D.21030 = obj;
  return D.21030;
}


mono_object_new_ptrfree (struct MonoVTable * vtable)
{
  struct MonoClass * D.21032;
  int D.21033;
  unsigned int D.21034;
  struct MonoObject * D.21035;
  struct MonoObject * obj;

  D.21032 = vtable->klass;
  D.21033 = D.21032->instance_size;
  D.21034 = (unsigned int) D.21033;
  obj = mono_gc_alloc_obj (vtable, D.21034);
  D.21035 = obj;
  return D.21035;
}


mono_method_get_imt_slot (struct MonoMethod * method)
{
  unsigned int D.21037;
  unsigned int D.21038;
  short unsigned int D.21041;
  int D.21042;
  unsigned int hashes_count.34;
  unsigned int D.21044;
  struct MonoClass * D.21045;
  unsigned int D.21046;
  unsigned int D.21047;
  unsigned char D.21050;
  const char * D.21055;
  const char * D.21056;
  const char * D.21057;
  unsigned int D.21058;
  guint32 * D.21059;
  unsigned int D.21060;
  guint32 * D.21061;
  unsigned int D.21062;
  guint32 * D.21063;
  struct MonoType * D.21064;
  unsigned int D.21065;
  int D.21066;
  unsigned int D.21067;
  unsigned int D.21068;
  guint32 * D.21069;
  struct MonoType * D.21070;
  unsigned int D.21071;
  unsigned int D.21072;
  unsigned int D.21073;
  unsigned int D.21074;
  unsigned int D.21075;
  unsigned int D.21076;
  unsigned int D.21077;
  unsigned int D.21078;
  unsigned int D.21079;
  unsigned int D.21080;
  unsigned int D.21081;
  unsigned int D.21082;
  unsigned int D.21083;
  unsigned int D.21084;
  unsigned int D.21085;
  unsigned int D.21086;
  unsigned int D.21087;
  guint32 D.21089;
  struct MonoMethodSignature * sig;
  int hashes_count;
  guint32 * hashes_start;
  guint32 * hashes;
  guint32 a;
  guint32 b;
  guint32 c;
  int i;

  D.21037 = BIT_FIELD_REF <*method, 32, 160>;
  D.21038 = D.21037 & 4096;
  if (D.21038 != 0) goto <D.21039>; else goto <D.21040>;
  <D.21039>:
  method = MEM[(struct MonoMethodInflated *)method].declaring;
  <D.21040>:
  sig = mono_method_signature (method);
  D.21041 = sig->param_count;
  D.21042 = (int) D.21041;
  hashes_count = D.21042 + 4;
  hashes_count.34 = (unsigned int) hashes_count;
  D.21044 = hashes_count.34 * 4;
  hashes_start = malloc (D.21044);
  hashes = hashes_start;
  D.21045 = method->klass;
  D.21046 = D.21045->flags;
  D.21047 = D.21046 & 32;
  if (D.21047 == 0) goto <D.21048>; else goto <D.21049>;
  <D.21048>:
  D.21045 = method->klass;
  D.21050 = D.21045->byval_arg.type;
  if (D.21050 != 19) goto <D.21051>; else goto <D.21052>;
  <D.21051>:
  D.21045 = method->klass;
  D.21050 = D.21045->byval_arg.type;
  if (D.21050 != 30) goto <D.21053>; else goto <D.21054>;
  <D.21053>:
  D.21045 = method->klass;
  D.21055 = D.21045->name_space;
  D.21045 = method->klass;
  D.21056 = D.21045->name;
  D.21057 = method->name;
  monoeg_g_log (0B, 4, "mono_method_get_imt_slot: %s.%s.%s is not an interface MonoMethod", D.21055, D.21056, D.21057);
  <D.18846>:
  goto <D.18846>;
  <D.21054>:
  <D.21052>:
  <D.21049>:
  D.21045 = method->klass;
  D.21056 = D.21045->name;
  D.21058 = mono_metadata_str_hash (D.21056);
  *hashes = D.21058;
  D.21059 = hashes + 4;
  D.21045 = method->klass;
  D.21055 = D.21045->name_space;
  D.21060 = mono_metadata_str_hash (D.21055);
  *D.21059 = D.21060;
  D.21061 = hashes + 8;
  D.21057 = method->name;
  D.21062 = mono_metadata_str_hash (D.21057);
  *D.21061 = D.21062;
  D.21063 = hashes + 12;
  D.21064 = sig->ret;
  D.21065 = mono_metadata_type_hash (D.21064);
  *D.21063 = D.21065;
  i = 0;
  goto <D.18848>;
  <D.18847>:
  D.21066 = i + 4;
  D.21067 = (unsigned int) D.21066;
  D.21068 = D.21067 * 4;
  D.21069 = hashes + D.21068;
  D.21070 = sig->params[i];
  D.21071 = mono_metadata_type_hash (D.21070);
  *D.21069 = D.21071;
  i = i + 1;
  <D.18848>:
  D.21041 = sig->param_count;
  D.21042 = (int) D.21041;
  if (D.21042 > i) goto <D.18847>; else goto <D.18849>;
  <D.18849>:
  hashes_count.34 = (unsigned int) hashes_count;
  D.21072 = hashes_count.34 << 2;
  c = D.21072 + 3735928559;
  b = c;
  a = b;
  goto <D.18851>;
  <D.18850>:
  D.21073 = *hashes;
  a = D.21073 + a;
  D.21059 = hashes + 4;
  D.21074 = *D.21059;
  b = D.21074 + b;
  D.21061 = hashes + 8;
  D.21075 = *D.21061;
  c = D.21075 + c;
  a = a - c;
  D.21076 = c r>> 28;
  a = D.21076 ^ a;
  c = c + b;
  b = b - a;
  D.21077 = a r>> 26;
  b = D.21077 ^ b;
  a = a + c;
  c = c - b;
  D.21078 = b r>> 24;
  c = D.21078 ^ c;
  b = b + a;
  a = a - c;
  D.21079 = c r>> 16;
  a = D.21079 ^ a;
  c = c + b;
  b = b - a;
  D.21080 = a r>> 13;
  b = D.21080 ^ b;
  a = a + c;
  c = c - b;
  D.21081 = b r>> 28;
  c = D.21081 ^ c;
  b = b + a;
  hashes_count = hashes_count + -3;
  hashes = hashes + 12;
  <D.18851>:
  if (hashes_count > 3) goto <D.18850>; else goto <D.18852>;
  <D.18852>:
  switch (hashes_count) <default: <D.21088>, case 0: <D.18856>, case 1: <D.18855>, case 2: <D.18854>, case 3: <D.18853>>
  <D.18853>:
  D.21061 = hashes + 8;
  D.21075 = *D.21061;
  c = D.21075 + c;
  <D.18854>:
  D.21059 = hashes + 4;
  D.21074 = *D.21059;
  b = D.21074 + b;
  <D.18855>:
  D.21073 = *hashes;
  a = D.21073 + a;
  c = c ^ b;
  D.21082 = b r>> 18;
  c = c - D.21082;
  a = a ^ c;
  D.21083 = c r>> 21;
  a = a - D.21083;
  b = b ^ a;
  D.21084 = a r>> 7;
  b = b - D.21084;
  c = c ^ b;
  D.21085 = b r>> 16;
  c = c - D.21085;
  a = a ^ c;
  D.21076 = c r>> 28;
  a = a - D.21076;
  b = b ^ a;
  D.21086 = a r>> 18;
  b = b - D.21086;
  c = c ^ b;
  D.21087 = b r>> 8;
  c = c - D.21087;
  <D.18856>:
  goto <D.18857>;
  <D.21088>:
  <D.18857>:
  free (hashes_start);
  D.21089 = c % 19;
  return D.21089;
}


mono_vtable_build_imt_slot (struct MonoVTable * vtable, int imt_slot)
{
  unsigned int imt_slot.35;
  _Bool D.21092;
  long int D.21093;
  long int D.21094;
  struct MonoDomain * D.21097;
  union mono_mutex_t * D.21098;
  _Bool D.21101;
  long int D.21102;
  long int D.21103;
  unsigned int imt_slot.36;
  unsigned int D.21107;
  void * * D.21108;
  void * D.21109;
  void * (*<T24a6>) (int) D.21110;
  void * D.21111;
  struct MonoClass * D.21114;
  _Bool D.21117;
  long int D.21118;
  long int D.21119;
  void * * imt;

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

    D.21097 = vtable->domain;
    D.21098 = &D.21097->lock.mutex;
    ret = pthread_mutex_lock (D.21098);
    if (ret != 0) goto <D.21099>; else goto <D.21100>;
    <D.21099>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.21100>:
    D.21101 = ret != 0;
    D.21102 = (long int) D.21101;
    D.21103 = __builtin_expect (D.21102, 0);
    if (D.21103 != 0) goto <D.21104>; else goto <D.21105>;
    <D.21104>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 1460, "ret == 0");
    <D.21105>:
  }
  imt_slot.36 = (unsigned int) imt_slot;
  D.21107 = imt_slot.36 * 4;
  D.21108 = imt + D.21107;
  D.21109 = *D.21108;
  D.21110 = callbacks.get_imt_trampoline;
  D.21111 = D.21110 (imt_slot);
  if (D.21109 == D.21111) goto <D.21112>; else goto <D.21113>;
  <D.21112>:
  D.21114 = vtable->klass;
  D.21097 = vtable->domain;
  build_imt_slots (D.21114, vtable, D.21097, imt, 0B, imt_slot);
  <D.21113>:
  {
    int ret;

    D.21097 = vtable->domain;
    D.21098 = &D.21097->lock.mutex;
    ret = pthread_mutex_unlock (D.21098);
    if (ret != 0) goto <D.21115>; else goto <D.21116>;
    <D.21115>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.21116>:
    D.21117 = ret != 0;
    D.21118 = (long int) D.21117;
    D.21119 = __builtin_expect (D.21118, 0);
    if (D.21119 != 0) goto <D.21120>; else goto <D.21121>;
    <D.21120>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 1464, "ret == 0");
    <D.21121>:
  }
  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.21122;
  unsigned int i.37;
  unsigned int D.21124;
  struct MonoClass * * D.21125;
  guint16 * D.21126;
  unsigned int D.21127;
  guint16 * D.21128;
  short unsigned int D.21129;
  int D.21130;
  unsigned int D.21135;
  unsigned int D.21136;
  struct MonoGenericClass * D.21139;
  struct MonoClass * D.21140;
  unsigned int D.21141;
  unsigned int slot_num.38;
  unsigned int D.21145;
  unsigned int D.21146;
  short unsigned int D.21149;
  int D.21150;
  int D.21151;
  unsigned int method_slot_in_interface.39;
  unsigned int D.21155;
  short unsigned int D.21156;
  int D.21157;
  int D.21160;
  unsigned int method_slot_in_interface.40;
  unsigned int D.21162;
  unsigned int interface_offset.41;
  unsigned int D.21164;
  void * * D.21168;
  struct MonoImtBuilderEntry * * D.21171;
  struct MonoImtBuilderEntry * D.21172;
  struct _MonoImtBuilderEntry * D.21175;
  int D.21176;
  int D.21177;
  int D.21178;
  int D.21179;
  int D.21184;
  unsigned int D.21185;
  unsigned int imt_collisions_bitmap.42;
  unsigned int imt_collisions_bitmap.43;
  void * iftmp.44;
  void * (*<T24a6>) (int) D.21189;
  void * D.21193;
  void * D.21194;
  long unsigned int methods_in_slot.45;
  long unsigned int D.21198;
  long unsigned int methods_in_slot.46;
  long unsigned int D.21202;
  long unsigned int method_count.47;
  long unsigned int D.21204;
  long unsigned int method_count.48;
  unsigned int D.21208;
  unsigned int D.21209;
  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.18940>;
      <D.18939>:
      {
        struct MonoClass * iface;
        int interface_offset;
        int method_slot_in_interface;
        int vt_slot;

        D.21122 = klass->interfaces_packed;
        i.37 = (unsigned int) i;
        D.21124 = i.37 * 4;
        D.21125 = D.21122 + D.21124;
        iface = *D.21125;
        D.21126 = klass->interface_offsets_packed;
        i.37 = (unsigned int) i;
        D.21127 = i.37 * 2;
        D.21128 = D.21126 + D.21127;
        D.21129 = *D.21128;
        interface_offset = (int) D.21129;
        D.21130 = mono_class_has_variant_generic_params (iface);
        if (D.21130 != 0) goto <D.21131>; else goto <D.21132>;
        <D.21131>:
        has_variant_iface = 1;
        <D.21132>:
        mono_class_setup_methods (iface);
        vt_slot = interface_offset;
        method_slot_in_interface = 0;
        goto <D.18937>;
        <D.18936>:
        {
          struct MonoMethod * method;

          if (slot_num >= 0) goto <D.21133>; else goto <D.21134>;
          <D.21133>:
          D.21135 = BIT_FIELD_REF <*iface, 32, 192>;
          D.21136 = D.21135 & 8;
          if (D.21136 != 0) goto <D.21137>; else goto <D.21138>;
          <D.21137>:
          D.21139 = iface->generic_class;
          D.21140 = D.21139->container_class;
          method = mono_class_get_method_by_index (D.21140, method_slot_in_interface);
          D.21141 = mono_method_get_imt_slot (method);
          slot_num.38 = (unsigned int) slot_num;
          if (D.21141 != slot_num.38) goto <D.21143>; else goto <D.21144>;
          <D.21143>:
          vt_slot = vt_slot + 1;
          // predicted unlikely by continue predictor.
          goto <D.18935>;
          <D.21144>:
          <D.21138>:
          <D.21134>:
          method = mono_class_get_method_by_index (iface, method_slot_in_interface);
          D.21145 = BIT_FIELD_REF <*method, 32, 160>;
          D.21146 = D.21145 & 2048;
          if (D.21146 != 0) goto <D.21147>; else goto <D.21148>;
          <D.21147>:
          has_generic_virtual = 1;
          vt_slot = vt_slot + 1;
          // predicted unlikely by continue predictor.
          goto <D.18935>;
          <D.21148>:
          D.21149 = method->flags;
          D.21150 = (int) D.21149;
          D.21151 = D.21150 & 16;
          if (D.21151 == 0) goto <D.21152>; else goto <D.21153>;
          <D.21152>:
          add_imt_builder_entry (imt_builder, method, &imt_collisions_bitmap, vt_slot, slot_num);
          vt_slot = vt_slot + 1;
          <D.21153>:
        }
        <D.18935>:
        method_slot_in_interface = method_slot_in_interface + 1;
        <D.18937>:
        method_slot_in_interface.39 = (unsigned int) method_slot_in_interface;
        D.21155 = iface->method.count;
        if (method_slot_in_interface.39 < D.21155) goto <D.18936>; else goto <D.18938>;
        <D.18938>:
      }
      i = i + 1;
      <D.18940>:
      D.21156 = klass->interface_offsets_count;
      D.21157 = (int) D.21156;
      if (D.21157 > i) goto <D.18939>; else goto <D.18941>;
      <D.18941>:
      if (extra_interfaces != 0B) goto <D.21158>; else goto <D.21159>;
      <D.21158>:
      {
        int interface_offset;

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

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

            method = mono_class_get_method_by_index (iface, method_slot_in_interface);
            D.21160 = interface_offset + method_slot_in_interface;
            add_imt_builder_entry (imt_builder, method, &imt_collisions_bitmap, D.21160, slot_num);
          }
          method_slot_in_interface = method_slot_in_interface + 1;
          <D.18947>:
          method_slot_in_interface.40 = (unsigned int) method_slot_in_interface;
          D.21162 = iface->method.count;
          if (method_slot_in_interface.40 < D.21162) goto <D.18946>; else goto <D.18948>;
          <D.18948>:
          D.21162 = iface->method.count;
          interface_offset.41 = (unsigned int) interface_offset;
          D.21164 = D.21162 + interface_offset.41;
          interface_offset = (int) D.21164;
        }
        list_item = list_item->next;
        <D.18950>:
        if (list_item != 0B) goto <D.18949>; else goto <D.18951>;
        <D.18951>:
      }
      <D.21159>:
      i = 0;
      goto <D.18959>;
      <D.18958>:
      if (slot_num < 0) goto <D.21165>; else goto <D.21167>;
      <D.21167>:
      if (i == slot_num) goto <D.21165>; else goto <D.21166>;
      <D.21165>:
      {
        struct MonoImtBuilderEntry * entries;

        i.37 = (unsigned int) i;
        D.21124 = i.37 * 4;
        D.21168 = imt + D.21124;
        entries = get_generic_virtual_entries (domain, D.21168);
        if (entries != 0B) goto <D.21169>; else goto <D.21170>;
        <D.21169>:
        i.37 = (unsigned int) i;
        D.21124 = i.37 * 4;
        D.21171 = imt_builder + D.21124;
        D.21172 = *D.21171;
        if (D.21172 != 0B) goto <D.21173>; else goto <D.21174>;
        <D.21173>:
        {
          struct MonoImtBuilderEntry * entry;

          entry = entries;
          goto <D.18955>;
          <D.18954>:
          entry = entry->next;
          <D.18955>:
          D.21175 = entry->next;
          if (D.21175 != 0B) goto <D.18954>; else goto <D.18956>;
          <D.18956>:
          i.37 = (unsigned int) i;
          D.21124 = i.37 * 4;
          D.21171 = imt_builder + D.21124;
          D.21172 = *D.21171;
          entry->next = D.21172;
          D.21176 = entries->children;
          i.37 = (unsigned int) i;
          D.21124 = i.37 * 4;
          D.21171 = imt_builder + D.21124;
          D.21172 = *D.21171;
          D.21177 = D.21172->children;
          D.21178 = D.21177 + 1;
          D.21179 = D.21176 + D.21178;
          entries->children = D.21179;
        }
        <D.21174>:
        i.37 = (unsigned int) i;
        D.21124 = i.37 * 4;
        D.21171 = imt_builder + D.21124;
        *D.21171 = entries;
        <D.21170>:
        if (has_generic_virtual != 0) goto <D.21180>; else goto <D.21183>;
        <D.21183>:
        if (has_variant_iface != 0) goto <D.21180>; else goto <D.21181>;
        <D.21180>:
        D.21184 = 1 << i;
        D.21185 = (unsigned int) D.21184;
        imt_collisions_bitmap.42 = imt_collisions_bitmap;
        imt_collisions_bitmap.43 = D.21185 | imt_collisions_bitmap.42;
        imt_collisions_bitmap = imt_collisions_bitmap.43;
        i.37 = (unsigned int) i;
        D.21124 = i.37 * 4;
        D.21168 = imt + D.21124;
        i.37 = (unsigned int) i;
        D.21124 = i.37 * 4;
        D.21171 = imt_builder + D.21124;
        D.21172 = *D.21171;
        D.21189 = callbacks.get_imt_trampoline;
        if (D.21189 != 0B) goto <D.21190>; else goto <D.21191>;
        <D.21190>:
        D.21189 = callbacks.get_imt_trampoline;
        iftmp.44 = D.21189 (i);
        goto <D.21192>;
        <D.21191>:
        iftmp.44 = 0B;
        <D.21192>:
        D.21193 = initialize_imt_slot (vt, domain, D.21172, iftmp.44);
        *D.21168 = D.21193;
        goto <D.21182>;
        <D.21181>:
        i.37 = (unsigned int) i;
        D.21124 = i.37 * 4;
        D.21168 = imt + D.21124;
        i.37 = (unsigned int) i;
        D.21124 = i.37 * 4;
        D.21171 = imt_builder + D.21124;
        D.21172 = *D.21171;
        D.21194 = initialize_imt_slot (vt, domain, D.21172, 0B);
        *D.21168 = D.21194;
        <D.21182>:
      }
      <D.21166>:
      i.37 = (unsigned int) i;
      D.21124 = i.37 * 4;
      D.21171 = imt_builder + D.21124;
      D.21172 = *D.21171;
      if (D.21172 != 0B) goto <D.21195>; else goto <D.21196>;
      <D.21195>:
      {
        int methods_in_slot;

        i.37 = (unsigned int) i;
        D.21124 = i.37 * 4;
        D.21171 = imt_builder + D.21124;
        D.21172 = *D.21171;
        D.21177 = D.21172->children;
        methods_in_slot = D.21177 + 1;
        methods_in_slot.45 = (long unsigned int) methods_in_slot;
        D.21198 = mono_stats.imt_max_collisions_in_slot;
        if (methods_in_slot.45 > D.21198) goto <D.21199>; else goto <D.21200>;
        <D.21199>:
        methods_in_slot.46 = (long unsigned int) methods_in_slot;
        mono_stats.imt_max_collisions_in_slot = methods_in_slot.46;
        record_method_count_for_max_collisions = 1;
        <D.21200>:
        method_count = method_count + methods_in_slot;
      }
      <D.21196>:
      i = i + 1;
      <D.18959>:
      if (i <= 18) goto <D.18958>; else goto <D.18960>;
      <D.18960>:
      D.21202 = mono_stats.imt_number_of_methods;
      method_count.47 = (long unsigned int) method_count;
      D.21204 = D.21202 + method_count.47;
      mono_stats.imt_number_of_methods = D.21204;
      if (record_method_count_for_max_collisions != 0) goto <D.21205>; else goto <D.21206>;
      <D.21205>:
      method_count.48 = (long unsigned int) method_count;
      mono_stats.imt_method_count_when_max_collisions = method_count.48;
      <D.21206>:
      i = 0;
      goto <D.18967>;
      <D.18966>:
      {
        struct MonoImtBuilderEntry * entry;

        i.37 = (unsigned int) i;
        D.21124 = i.37 * 4;
        D.21171 = imt_builder + D.21124;
        entry = *D.21171;
        goto <D.18964>;
        <D.18963>:
        {
          struct MonoImtBuilderEntry * next;

          next = entry->next;
          monoeg_g_free (entry);
          entry = next;
        }
        <D.18964>:
        if (entry != 0B) goto <D.18963>; else goto <D.18965>;
        <D.18965>:
      }
      i = i + 1;
      <D.18967>:
      if (i <= 18) goto <D.18966>; else goto <D.18968>;
      <D.18968>:
      free (imt_builder);
      D.21208 = vt->imt_collisions_bitmap;
      imt_collisions_bitmap.42 = imt_collisions_bitmap;
      D.21209 = D.21208 | imt_collisions_bitmap.42;
      vt->imt_collisions_bitmap = D.21209;
    }
  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)
{
  unsigned int slot_num.49;
  unsigned int D.21215;
  struct MonoImtBuilderEntry * * D.21216;
  struct MonoImtBuilderEntry * D.21217;
  int D.21220;
  int D.21221;
  int D.21222;
  long unsigned int D.21225;
  long unsigned int D.21226;
  unsigned int D.21227;
  int imt_slot.50;
  int D.21229;
  unsigned int D.21230;
  unsigned int D.21231;
  long unsigned int D.21233;
  long unsigned int D.21234;
  guint32 imt_slot;
  struct MonoImtBuilderEntry * entry;

  imt_slot = mono_method_get_imt_slot (method);
  if (slot_num >= 0) goto <D.21210>; else goto <D.21211>;
  <D.21210>:
  slot_num.49 = (unsigned int) slot_num;
  if (slot_num.49 != imt_slot) goto <D.21213>; else goto <D.21214>;
  <D.21213>:
  return;
  <D.21214>:
  <D.21211>:
  entry = monoeg_malloc0 (20);
  entry->key = method;
  entry->value.vtable_slot = vtable_slot;
  D.21215 = imt_slot * 4;
  D.21216 = imt_builder + D.21215;
  D.21217 = *D.21216;
  entry->next = D.21217;
  D.21215 = imt_slot * 4;
  D.21216 = imt_builder + D.21215;
  D.21217 = *D.21216;
  if (D.21217 != 0B) goto <D.21218>; else goto <D.21219>;
  <D.21218>:
  D.21215 = imt_slot * 4;
  D.21216 = imt_builder + D.21215;
  D.21217 = *D.21216;
  D.21220 = D.21217->children;
  D.21221 = D.21220 + 1;
  entry->children = D.21221;
  D.21222 = entry->children;
  if (D.21222 == 1) goto <D.21223>; else goto <D.21224>;
  <D.21223>:
  D.21225 = mono_stats.imt_slots_with_collisions;
  D.21226 = D.21225 + 1;
  mono_stats.imt_slots_with_collisions = D.21226;
  D.21227 = *imt_collisions_bitmap;
  imt_slot.50 = (int) imt_slot;
  D.21229 = 1 << imt_slot.50;
  D.21230 = (unsigned int) D.21229;
  D.21231 = D.21227 | D.21230;
  *imt_collisions_bitmap = D.21231;
  <D.21224>:
  goto <D.21232>;
  <D.21219>:
  entry->children = 0;
  D.21233 = mono_stats.imt_used_slots;
  D.21234 = D.21233 + 1;
  mono_stats.imt_used_slots = D.21234;
  <D.21232>:
  D.21215 = imt_slot * 4;
  D.21216 = imt_builder + D.21215;
  *D.21216 = entry;
}


get_generic_virtual_entries (struct MonoDomain * domain, void * * vtable_slot)
{
  union mono_mutex_t * D.21236;
  _Bool D.21239;
  long int D.21240;
  long int D.21241;
  struct GHashTable * D.21244;
  struct GHashTable * D.21247;
  int D.21248;
  struct MonoMethod * D.21251;
  void * D.21252;
  void * D.21253;
  int D.21256;
  int D.21257;
  _Bool D.21260;
  long int D.21261;
  long int D.21262;
  struct MonoImtBuilderEntry * D.21265;
  struct GenericVirtualCase * list;
  struct MonoImtBuilderEntry * entries;

  {
    int ret;

    D.21236 = &domain->lock.mutex;
    ret = pthread_mutex_lock (D.21236);
    if (ret != 0) goto <D.21237>; else goto <D.21238>;
    <D.21237>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.21238>:
    D.21239 = ret != 0;
    D.21240 = (long int) D.21239;
    D.21241 = __builtin_expect (D.21240, 0);
    if (D.21241 != 0) goto <D.21242>; else goto <D.21243>;
    <D.21242>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 1645, "ret == 0");
    <D.21243>:
  }
  D.21244 = domain->generic_virtual_cases;
  if (D.21244 == 0B) goto <D.21245>; else goto <D.21246>;
  <D.21245>:
  D.21247 = monoeg_g_hash_table_new (mono_aligned_addr_hash, 0B);
  domain->generic_virtual_cases = D.21247;
  <D.21246>:
  D.21244 = domain->generic_virtual_cases;
  list = monoeg_g_hash_table_lookup (D.21244, vtable_slot);
  entries = 0B;
  goto <D.19044>;
  <D.19043>:
  {
    struct MonoImtBuilderEntry * entry;

    D.21248 = list->count;
    if (D.21248 <= 9) goto <D.21249>; else goto <D.21250>;
    <D.21249>:
    // predicted unlikely by continue predictor.
    goto <D.19042>;
    <D.21250>:
    entry = monoeg_malloc0 (20);
    D.21251 = list->method;
    entry->key = D.21251;
    D.21252 = list->code;
    D.21253 = mono_get_addr_from_ftnptr (D.21252);
    entry->value.target_code = D.21253;
    entry->has_target_code = 1;
    if (entries != 0B) goto <D.21254>; else goto <D.21255>;
    <D.21254>:
    D.21256 = entries->children;
    D.21257 = D.21256 + 1;
    entry->children = D.21257;
    <D.21255>:
    entry->next = entries;
    entries = entry;
  }
  <D.19042>:
  list = list->next;
  <D.19044>:
  if (list != 0B) goto <D.19043>; else goto <D.19045>;
  <D.19045>:
  {
    int ret;

    D.21236 = &domain->lock.mutex;
    ret = pthread_mutex_unlock (D.21236);
    if (ret != 0) goto <D.21258>; else goto <D.21259>;
    <D.21258>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.21259>:
    D.21260 = ret != 0;
    D.21261 = (long int) D.21260;
    D.21262 = __builtin_expect (D.21261, 0);
    if (D.21262 != 0) goto <D.21263>; else goto <D.21264>;
    <D.21263>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 1668, "ret == 0");
    <D.21264>:
  }
  D.21265 = entries;
  return D.21265;
}


initialize_imt_slot (struct MonoVTable * vtable, struct MonoDomain * domain, struct MonoImtBuilderEntry * imt_builder_entry, void * fail_tramp)
{
  int D.21270;
  void * D.21273;
  int D.21274;
  void * (*<T26de>) (struct MonoVTable *, struct MonoDomain *, struct MonoIMTCheckItem * *, int, void *) imt_thunk_builder.51;
  void * * D.21276;
  unsigned int D.21277;
  int D.21278;
  unsigned int i.52;
  unsigned int D.21280;
  void * * D.21281;
  void * D.21282;
  unsigned int i.53;

  if (imt_builder_entry != 0B) goto <D.21267>; else goto <D.21268>;
  <D.21267>:
  D.21270 = imt_builder_entry->children;
  if (D.21270 == 0) goto <D.21271>; else goto <D.21269>;
  <D.21271>:
  if (fail_tramp == 0B) goto <D.21272>; else goto <D.21269>;
  <D.21272>:
  D.21274 = imt_builder_entry->value.vtable_slot;
  D.21273 = vtable->vtable[D.21274];
  return D.21273;
  <D.21269>:
  {
    struct GPtrArray * imt_ir;
    void * result;
    int i;

    imt_ir = imt_sort_slot_entries (imt_builder_entry);
    imt_thunk_builder.51 = imt_thunk_builder;
    D.21276 = imt_ir->pdata;
    D.21277 = imt_ir->len;
    D.21278 = (int) D.21277;
    result = imt_thunk_builder.51 (vtable, domain, D.21276, D.21278, fail_tramp);
    i = 0;
    goto <D.18909>;
    <D.18908>:
    D.21276 = imt_ir->pdata;
    i.52 = (unsigned int) i;
    D.21280 = i.52 * 4;
    D.21281 = D.21276 + D.21280;
    D.21282 = *D.21281;
    monoeg_g_free (D.21282);
    i = i + 1;
    <D.18909>:
    i.53 = (unsigned int) i;
    D.21277 = imt_ir->len;
    if (i.53 < D.21277) goto <D.18908>; else goto <D.18910>;
    <D.18910>:
    monoeg_g_ptr_array_free (imt_ir, 1);
    D.21273 = result;
    return D.21273;
  }
  <D.21268>:
  if (fail_tramp != 0B) goto <D.21284>; else goto <D.21285>;
  <D.21284>:
  D.21273 = fail_tramp;
  return D.21273;
  <D.21285>:
  D.21273 = 0B;
  return D.21273;
}


imt_sort_slot_entries (struct MonoImtBuilderEntry * entries)
{
  int D.21287;
  unsigned int number_of_entries.54;
  unsigned int D.21289;
  unsigned int i.55;
  unsigned int D.21291;
  struct MonoImtBuilderEntry * * D.21292;
  unsigned int number_of_entries.56;
  struct GPtrArray * D.21294;
  int number_of_entries;
  struct MonoImtBuilderEntry * * sorted_array;
  struct GPtrArray * result;
  struct MonoImtBuilderEntry * current_entry;
  int i;

  D.21287 = entries->children;
  number_of_entries = D.21287 + 1;
  number_of_entries.54 = (unsigned int) number_of_entries;
  D.21289 = number_of_entries.54 * 4;
  sorted_array = malloc (D.21289);
  result = monoeg_g_ptr_array_new ();
  current_entry = entries;
  i = 0;
  goto <D.18897>;
  <D.18896>:
  i.55 = (unsigned int) i;
  D.21291 = i.55 * 4;
  D.21292 = sorted_array + D.21291;
  *D.21292 = current_entry;
  current_entry = current_entry->next;
  i = i + 1;
  <D.18897>:
  if (current_entry != 0B) goto <D.18896>; else goto <D.18898>;
  <D.18898>:
  number_of_entries.56 = (unsigned int) number_of_entries;
  qsort (sorted_array, number_of_entries.56, 4, compare_imt_builder_entries);
  imt_emit_ir (sorted_array, 0, number_of_entries, result);
  free (sorted_array);
  D.21294 = result;
  return D.21294;
}


compare_imt_builder_entries (const void * p1, const void * p2)
{
  int D.21296;
  int iftmp.57;
  void * D.21298;
  void * D.21299;
  _Bool D.21302;
  struct MonoImtBuilderEntry * e1;
  struct MonoImtBuilderEntry * e2;

  e1 = MEM[(struct MonoImtBuilderEntry * *)p1];
  e2 = MEM[(struct MonoImtBuilderEntry * *)p2];
  D.21298 = e1->key;
  D.21299 = e2->key;
  if (D.21298 >= D.21299) goto <D.21300>; else goto <D.21301>;
  <D.21300>:
  D.21298 = e1->key;
  D.21299 = e2->key;
  D.21302 = D.21298 > D.21299;
  iftmp.57 = (int) D.21302;
  goto <D.21303>;
  <D.21301>:
  iftmp.57 = -1;
  <D.21303>:
  D.21296 = iftmp.57;
  return D.21296;
}


imt_emit_ir (struct MonoImtBuilderEntry * * sorted_array, int start, int end, struct GPtrArray * out_array)
{
  unsigned int D.21305;
  unsigned int i.58;
  unsigned int D.21309;
  struct MonoImtBuilderEntry * * D.21310;
  struct MonoImtBuilderEntry * D.21311;
  void * D.21312;
  <unnamed-unsigned:1> D.21313;
  unsigned char D.21314;
  int D.21315;
  unsigned int D.21318;
  int D.21319;
  int D.21322;
  unsigned int middle.59;
  unsigned int D.21324;
  struct MonoImtBuilderEntry * * D.21325;
  struct MonoImtBuilderEntry * D.21326;
  void * D.21327;
  int D.21328;
  int D.21329;
  int count;
  int chunk_start;

  count = end - start;
  D.21305 = out_array->len;
  chunk_start = (int) D.21305;
  if (count <= 3) goto <D.21306>; else goto <D.21307>;
  <D.21306>:
  {
    int i;

    i = start;
    goto <D.18884>;
    <D.18883>:
    {
      struct MonoIMTCheckItem * item;

      item = monoeg_malloc0 (28);
      i.58 = (unsigned int) i;
      D.21309 = i.58 * 4;
      D.21310 = sorted_array + D.21309;
      D.21311 = *D.21310;
      D.21312 = D.21311->key;
      item->key = D.21312;
      i.58 = (unsigned int) i;
      D.21309 = i.58 * 4;
      D.21310 = sorted_array + D.21309;
      D.21311 = *D.21310;
      item->value = D.21311->value;
      i.58 = (unsigned int) i;
      D.21309 = i.58 * 4;
      D.21310 = sorted_array + D.21309;
      D.21311 = *D.21310;
      D.21313 = D.21311->has_target_code;
      D.21314 = (unsigned char) D.21313;
      item->has_target_code = D.21314;
      item->is_equals = 1;
      D.21315 = end + -1;
      if (D.21315 > i) goto <D.21316>; else goto <D.21317>;
      <D.21316>:
      D.21305 = out_array->len;
      D.21318 = D.21305 + 1;
      D.21319 = (int) D.21318;
      item->check_target_idx = D.21319;
      goto <D.21320>;
      <D.21317>:
      item->check_target_idx = 0;
      <D.21320>:
      monoeg_g_ptr_array_add (out_array, item);
    }
    i = i + 1;
    <D.18884>:
    if (i < end) goto <D.18883>; else goto <D.18885>;
    <D.18885>:
  }
  goto <D.21321>;
  <D.21307>:
  {
    int middle;
    struct MonoIMTCheckItem * item;

    D.21322 = count / 2;
    middle = D.21322 + start;
    item = monoeg_malloc0 (28);
    middle.59 = (unsigned int) middle;
    D.21324 = middle.59 * 4;
    D.21325 = sorted_array + D.21324;
    D.21326 = *D.21325;
    D.21327 = D.21326->key;
    item->key = D.21327;
    item->is_equals = 0;
    monoeg_g_ptr_array_add (out_array, item);
    imt_emit_ir (sorted_array, start, middle, out_array);
    D.21328 = imt_emit_ir (sorted_array, middle, end, out_array);
    item->check_target_idx = D.21328;
  }
  <D.21321>:
  D.21329 = chunk_start;
  return D.21329;
}


mono_method_alloc_generic_virtual_thunk (struct MonoDomain * domain, int size)
{
  unsigned int size.60;
  unsigned int D.21332;
  struct MonoThunkFreeList * * D.21335;
  unsigned int i.61;
  unsigned int D.21337;
  struct MonoThunkFreeList * D.21338;
  unsigned int D.21339;
  unsigned int size.62;
  struct _MonoThunkFreeList * D.21343;
  void * D.21344;
  struct MonoThunkFreeList * * D.21345;
  unsigned int D.21348;
  _Bool D.21349;
  long int D.21350;
  long int D.21351;
  struct _MonoThunkFreeList * D.21354;
  int inited.63;
  int generic_virtual_thunks_size.64;
  int generic_virtual_thunks_size.65;
  union mono_mutex_t * D.21360;
  _Bool D.21363;
  long int D.21364;
  long int D.21365;
  struct GHashTable * D.21368;
  struct GHashTable * D.21371;
  _Bool D.21374;
  long int D.21375;
  long int D.21376;
  static gboolean inited = 0;
  static int generic_virtual_thunks_size = 0;
  guint32 * p;
  int i;
  struct MonoThunkFreeList * * l;

  init_thunk_free_lists (domain);
  size.60 = (unsigned int) size;
  D.21332 = size.60 + 4;
  size = (int) D.21332;
  size.60 = (unsigned int) size;
  if (size.60 <= 11) goto <D.21333>; else goto <D.21334>;
  <D.21333>:
  size = 12;
  <D.21334>:
  i = list_index_for_size (size);
  D.21335 = domain->thunk_free_lists;
  i.61 = (unsigned int) i;
  D.21337 = i.61 * 4;
  l = D.21335 + D.21337;
  goto <D.19005>;
  <D.19004>:
  D.21338 = *l;
  D.21339 = D.21338->size;
  size.62 = (unsigned int) size;
  if (D.21339 >= size.62) goto <D.21341>; else goto <D.21342>;
  <D.21341>:
  {
    struct MonoThunkFreeList * item;

    item = *l;
    D.21343 = item->next;
    *l = D.21343;
    D.21344 = item + 4;
    return D.21344;
  }
  <D.21342>:
  D.21338 = *l;
  l = &D.21338->next;
  <D.19005>:
  D.21338 = *l;
  if (D.21338 != 0B) goto <D.19004>; else goto <D.19006>;
  <D.19006>:
  goto <D.19008>;
  <D.19009>:
  {
    struct MonoThunkFreeList * item;

    D.21335 = domain->thunk_free_lists;
    i.61 = (unsigned int) i;
    D.21337 = i.61 * 4;
    D.21345 = D.21335 + D.21337;
    item = *D.21345;
    if (item == 0B) goto <D.21346>; else goto <D.21347>;
    <D.21346>:
    // predicted unlikely by continue predictor.
    goto <D.19008>;
    <D.21347>:
    D.21348 = item->size;
    size.62 = (unsigned int) size;
    D.21349 = D.21348 <= size.62;
    D.21350 = (long int) D.21349;
    D.21351 = __builtin_expect (D.21350, 0);
    if (D.21351 != 0) goto <D.21352>; else goto <D.21353>;
    <D.21352>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 1550, "item->size > size");
    <D.21353>:
    D.21335 = domain->thunk_free_lists;
    i.61 = (unsigned int) i;
    D.21337 = i.61 * 4;
    D.21345 = D.21335 + D.21337;
    D.21354 = item->next;
    *D.21345 = D.21354;
    D.21344 = item + 4;
    return D.21344;
  }
  <D.19008>:
  i = i + 1;
  if (i <= 11) goto <D.19009>; else goto <D.19010>;
  <D.19010>:
  inited.63 = inited;
  if (inited.63 == 0) goto <D.21356>; else goto <D.21357>;
  <D.21356>:
  mono_counters_register ("Generic virtual thunk bytes", 2048, &generic_virtual_thunks_size);
  inited = 1;
  <D.21357>:
  generic_virtual_thunks_size.64 = generic_virtual_thunks_size;
  generic_virtual_thunks_size.65 = generic_virtual_thunks_size.64 + size;
  generic_virtual_thunks_size = generic_virtual_thunks_size.65;
  p = mono_domain_code_reserve (domain, size);
  size.62 = (unsigned int) size;
  *p = size.62;
  {
    int ret;

    D.21360 = &domain->lock.mutex;
    ret = pthread_mutex_lock (D.21360);
    if (ret != 0) goto <D.21361>; else goto <D.21362>;
    <D.21361>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.21362>:
    D.21363 = ret != 0;
    D.21364 = (long int) D.21363;
    D.21365 = __builtin_expect (D.21364, 0);
    if (D.21365 != 0) goto <D.21366>; else goto <D.21367>;
    <D.21366>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 1566, "ret == 0");
    <D.21367>:
  }
  D.21368 = domain->generic_virtual_thunks;
  if (D.21368 == 0B) goto <D.21369>; else goto <D.21370>;
  <D.21369>:
  D.21371 = monoeg_g_hash_table_new (0B, 0B);
  domain->generic_virtual_thunks = D.21371;
  <D.21370>:
  D.21368 = domain->generic_virtual_thunks;
  monoeg_g_hash_table_insert_replace (D.21368, p, p, 0);
  {
    int ret;

    D.21360 = &domain->lock.mutex;
    ret = pthread_mutex_unlock (D.21360);
    if (ret != 0) goto <D.21372>; else goto <D.21373>;
    <D.21372>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.21373>:
    D.21374 = ret != 0;
    D.21375 = (long int) D.21374;
    D.21376 = __builtin_expect (D.21375, 0);
    if (D.21376 != 0) goto <D.21377>; else goto <D.21378>;
    <D.21377>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 1570, "ret == 0");
    <D.21378>:
  }
  D.21344 = p + 4;
  return D.21344;
}


init_thunk_free_lists (struct MonoDomain * domain)
{
  struct MonoThunkFreeList * * D.21380;
  void * D.21383;

  D.21380 = domain->thunk_free_lists;
  if (D.21380 != 0B) goto <D.21381>; else goto <D.21382>;
  <D.21381>:
  return;
  <D.21382>:
  D.21383 = mono_domain_alloc0 (domain, 48);
  domain->thunk_free_lists = D.21383;
}


list_index_for_size (int item_size)
{
  int D.21386;
  int i;
  int size;

  i = 2;
  size = 64;
  goto <D.18992>;
  <D.18991>:
  i = i + 1;
  size = size << 1;
  <D.18992>:
  if (item_size > size) goto <D.21385>; else goto <D.18993>;
  <D.21385>:
  if (i <= 10) goto <D.18991>; else goto <D.18993>;
  <D.18993>:
  D.21386 = i;
  return D.21386;
}


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.21388;
  _Bool D.21391;
  long int D.21392;
  long int D.21393;
  struct GHashTable * D.21396;
  struct GHashTable * D.21399;
  struct MonoMethod * D.21400;
  void * D.21404;
  int inited.66;
  int num_added.67;
  int num_added.68;
  int D.21410;
  int D.21411;
  int vtable_slot.69;
  int vtable.70;
  int D.21418;
  void * (*<T24a6>) (int) D.21419;
  void * iftmp.71;
  void * (*<T24a6>) (int) D.21422;
  void *[0:] * D.21425;
  int D.21426;
  int D.21427;
  int D.21428;
  void * (*<T26de>) (struct MonoVTable *, struct MonoDomain *, struct MonoIMTCheckItem * *, int, void *) imt_thunk_builder.72;
  void * * D.21431;
  unsigned int D.21432;
  int D.21433;
  void * D.21434;
  unsigned int i.73;
  unsigned int D.21436;
  void * * D.21437;
  void * D.21438;
  unsigned int i.74;
  _Bool D.21446;
  long int D.21447;
  long int D.21448;
  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.21388 = &domain->lock.mutex;
    ret = pthread_mutex_lock (D.21388);
    if (ret != 0) goto <D.21389>; else goto <D.21390>;
    <D.21389>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.21390>:
    D.21391 = ret != 0;
    D.21392 = (long int) D.21391;
    D.21393 = __builtin_expect (D.21392, 0);
    if (D.21393 != 0) goto <D.21394>; else goto <D.21395>;
    <D.21394>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 1699, "ret == 0");
    <D.21395>:
  }
  D.21396 = domain->generic_virtual_cases;
  if (D.21396 == 0B) goto <D.21397>; else goto <D.21398>;
  <D.21397>:
  D.21399 = monoeg_g_hash_table_new (mono_aligned_addr_hash, 0B);
  domain->generic_virtual_cases = D.21399;
  <D.21398>:
  D.21396 = domain->generic_virtual_cases;
  list = monoeg_g_hash_table_lookup (D.21396, vtable_slot);
  gvc = list;
  goto <D.19064>;
  <D.19063>:
  D.21400 = gvc->method;
  if (D.21400 == method) goto <D.19062>; else goto <D.21401>;
  <D.21401>:
  gvc = gvc->next;
  <D.19064>:
  if (gvc != 0B) goto <D.19063>; else goto <D.19062>;
  <D.19062>:
  if (gvc == 0B) goto <D.21402>; else goto <D.21403>;
  <D.21402>:
  gvc = mono_domain_alloc (domain, 16);
  gvc->method = method;
  gvc->code = code;
  gvc->count = 0;
  D.21396 = domain->generic_virtual_cases;
  D.21404 = monoeg_g_hash_table_lookup (D.21396, vtable_slot);
  gvc->next = D.21404;
  D.21396 = domain->generic_virtual_cases;
  monoeg_g_hash_table_insert_replace (D.21396, vtable_slot, gvc, 0);
  inited.66 = inited;
  if (inited.66 == 0) goto <D.21406>; else goto <D.21407>;
  <D.21406>:
  mono_counters_register ("Generic virtual cases", 2048, &num_added);
  inited = 1;
  <D.21407>:
  num_added.67 = num_added;
  num_added.68 = num_added.67 + 1;
  num_added = num_added.68;
  <D.21403>:
  D.21410 = gvc->count;
  D.21411 = D.21410 + 1;
  gvc->count = D.21411;
  D.21410 = gvc->count;
  if (D.21410 == 10) goto <D.21412>; else goto <D.21413>;
  <D.21412>:
  {
    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.21414>; else goto <D.21415>;
    <D.21414>:
    {
      int displacement;
      int imt_slot;

      vtable_slot.69 = (int) vtable_slot;
      vtable.70 = (int) vtable;
      D.21418 = vtable_slot.69 - vtable.70;
      displacement = D.21418 /[ex] 4;
      imt_slot = displacement + 19;
      D.21419 = callbacks.get_imt_trampoline;
      imt_trampoline = D.21419 (imt_slot);
      *vtable_slot = imt_trampoline;
    }
    goto <D.21420>;
    <D.21415>:
    D.21422 = callbacks.get_vtable_trampoline;
    if (D.21422 != 0B) goto <D.21423>; else goto <D.21424>;
    <D.21423>:
    D.21422 = callbacks.get_vtable_trampoline;
    vtable_slot.69 = (int) vtable_slot;
    D.21425 = &vtable->vtable;
    D.21426 = (int) D.21425;
    D.21427 = vtable_slot.69 - D.21426;
    D.21428 = D.21427 /[ex] 4;
    iftmp.71 = D.21422 (D.21428);
    goto <D.21429>;
    <D.21424>:
    iftmp.71 = 0B;
    <D.21429>:
    vtable_trampoline = iftmp.71;
    entries = get_generic_virtual_entries (domain, vtable_slot);
    sorted = imt_sort_slot_entries (entries);
    imt_thunk_builder.72 = imt_thunk_builder;
    D.21431 = sorted->pdata;
    D.21432 = sorted->len;
    D.21433 = (int) D.21432;
    D.21434 = imt_thunk_builder.72 (0B, domain, D.21431, D.21433, vtable_trampoline);
    *vtable_slot = D.21434;
    goto <D.19072>;
    <D.19071>:
    {
      struct MonoImtBuilderEntry * next;

      next = entries->next;
      monoeg_g_free (entries);
      entries = next;
    }
    <D.19072>:
    if (entries != 0B) goto <D.19071>; else goto <D.19073>;
    <D.19073>:
    i = 0;
    goto <D.19075>;
    <D.19074>:
    D.21431 = sorted->pdata;
    i.73 = (unsigned int) i;
    D.21436 = i.73 * 4;
    D.21437 = D.21431 + D.21436;
    D.21438 = *D.21437;
    monoeg_g_free (D.21438);
    i = i + 1;
    <D.19075>:
    i.74 = (unsigned int) i;
    D.21432 = sorted->len;
    if (i.74 < D.21432) goto <D.19074>; else goto <D.19076>;
    <D.19076>:
    monoeg_g_ptr_array_free (sorted, 1);
    <D.21420>:
    if (old_thunk != vtable_trampoline) goto <D.21440>; else goto <D.21441>;
    <D.21440>:
    if (old_thunk != imt_trampoline) goto <D.21442>; else goto <D.21443>;
    <D.21442>:
    invalidate_generic_virtual_thunk (domain, old_thunk);
    <D.21443>:
    <D.21441>:
  }
  <D.21413>:
  {
    int ret;

    D.21388 = &domain->lock.mutex;
    ret = pthread_mutex_unlock (D.21388);
    if (ret != 0) goto <D.21444>; else goto <D.21445>;
    <D.21444>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.21445>:
    D.21446 = ret != 0;
    D.21447 = (long int) D.21446;
    D.21448 = __builtin_expect (D.21447, 0);
    if (D.21448 != 0) goto <D.21449>; else goto <D.21450>;
    <D.21449>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 1770, "ret == 0");
    <D.21450>:
  }
}


invalidate_generic_virtual_thunk (struct MonoDomain * domain, void * code)
{
  union mono_mutex_t * D.21451;
  _Bool D.21454;
  long int D.21455;
  long int D.21456;
  struct GHashTable * D.21459;
  struct GHashTable * D.21462;
  void * D.21463;
  _Bool D.21468;
  long int D.21469;
  long int D.21470;
  struct MonoThunkFreeList * * D.21475;
  struct _MonoThunkFreeList * D.21476;
  struct MonoThunkFreeList * D.21477;
  int D.21478;
  unsigned int D.21479;
  int D.21480;
  unsigned int i.75;
  unsigned int D.21482;
  struct MonoThunkFreeList * * D.21483;
  struct MonoThunkFreeList * D.21484;
  int D.21486;
  struct MonoThunkFreeList * * D.21487;
  struct MonoThunkFreeList * D.21488;
  struct _MonoThunkFreeList * D.21491;
  int D.21492;
  _Bool D.21494;
  long int D.21495;
  long int D.21496;
  guint32 * p;
  struct MonoThunkFreeList * l;
  gboolean found;

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

    D.21451 = &domain->lock.mutex;
    ret = pthread_mutex_lock (D.21451);
    if (ret != 0) goto <D.21452>; else goto <D.21453>;
    <D.21452>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.21453>:
    D.21454 = ret != 0;
    D.21455 = (long int) D.21454;
    D.21456 = __builtin_expect (D.21455, 0);
    if (D.21456 != 0) goto <D.21457>; else goto <D.21458>;
    <D.21457>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 1585, "ret == 0");
    <D.21458>:
  }
  D.21459 = domain->generic_virtual_thunks;
  if (D.21459 == 0B) goto <D.21460>; else goto <D.21461>;
  <D.21460>:
  D.21462 = monoeg_g_hash_table_new (0B, 0B);
  domain->generic_virtual_thunks = D.21462;
  <D.21461>:
  D.21459 = domain->generic_virtual_thunks;
  D.21463 = monoeg_g_hash_table_lookup (D.21459, l);
  if (D.21463 != 0B) goto <D.21464>; else goto <D.21465>;
  <D.21464>:
  found = 1;
  <D.21465>:
  {
    int ret;

    D.21451 = &domain->lock.mutex;
    ret = pthread_mutex_unlock (D.21451);
    if (ret != 0) goto <D.21466>; else goto <D.21467>;
    <D.21466>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.21467>:
    D.21468 = ret != 0;
    D.21469 = (long int) D.21468;
    D.21470 = __builtin_expect (D.21469, 0);
    if (D.21470 != 0) goto <D.21471>; else goto <D.21472>;
    <D.21471>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 1590, "ret == 0");
    <D.21472>:
  }
  if (found == 0) goto <D.21473>; else goto <D.21474>;
  <D.21473>:
  return;
  <D.21474>:
  init_thunk_free_lists (domain);
  goto <D.19026>;
  <D.19025>:
  {
    struct MonoThunkFreeList * item;
    int length;
    int i;

    D.21475 = domain->thunk_free_lists;
    item = *D.21475;
    length = item->length;
    D.21475 = domain->thunk_free_lists;
    D.21476 = item->next;
    *D.21475 = D.21476;
    D.21475 = domain->thunk_free_lists;
    D.21477 = *D.21475;
    D.21478 = length + -1;
    D.21477->length = D.21478;
    D.21479 = item->size;
    D.21480 = (int) D.21479;
    i = list_index_for_size (D.21480);
    D.21475 = domain->thunk_free_lists;
    i.75 = (unsigned int) i;
    D.21482 = i.75 * 4;
    D.21483 = D.21475 + D.21482;
    D.21484 = *D.21483;
    item->next = D.21484;
    D.21475 = domain->thunk_free_lists;
    i.75 = (unsigned int) i;
    D.21482 = i.75 * 4;
    D.21483 = D.21475 + D.21482;
    *D.21483 = item;
  }
  <D.19026>:
  D.21475 = domain->thunk_free_lists;
  D.21477 = *D.21475;
  if (D.21477 != 0B) goto <D.21485>; else goto <D.19027>;
  <D.21485>:
  D.21475 = domain->thunk_free_lists;
  D.21477 = *D.21475;
  D.21486 = D.21477->length;
  if (D.21486 > 49) goto <D.19025>; else goto <D.19027>;
  <D.19027>:
  l->next = 0B;
  D.21475 = domain->thunk_free_lists;
  D.21487 = D.21475 + 4;
  D.21488 = *D.21487;
  if (D.21488 != 0B) goto <D.21489>; else goto <D.21490>;
  <D.21489>:
  D.21475 = domain->thunk_free_lists;
  D.21487 = D.21475 + 4;
  D.21475 = domain->thunk_free_lists;
  D.21487 = D.21475 + 4;
  D.21488 = *D.21487;
  D.21488->next = l;
  D.21491 = D.21488->next;
  *D.21487 = D.21491;
  D.21475 = domain->thunk_free_lists;
  D.21477 = *D.21475;
  D.21486 = D.21477->length;
  D.21492 = D.21486 + 1;
  D.21477->length = D.21492;
  goto <D.21493>;
  <D.21490>:
  D.21475 = domain->thunk_free_lists;
  D.21477 = *D.21475;
  D.21494 = D.21477 != 0B;
  D.21495 = (long int) D.21494;
  D.21496 = __builtin_expect (D.21495, 0);
  if (D.21496 != 0) goto <D.21497>; else goto <D.21498>;
  <D.21497>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 1618, "!domain->thunk_free_lists [0]");
  <D.21498>:
  D.21475 = domain->thunk_free_lists;
  D.21475 = domain->thunk_free_lists;
  D.21487 = D.21475 + 4;
  *D.21487 = l;
  D.21488 = *D.21487;
  *D.21475 = D.21488;
  D.21475 = domain->thunk_free_lists;
  D.21477 = *D.21475;
  D.21477->length = 1;
  <D.21493>:
}


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

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


mono_class_vtable_full (struct MonoDomain * domain, struct MonoClass * class, gboolean raise_on_error)
{
  _Bool D.21502;
  long int D.21503;
  long int D.21504;
  unsigned char D.21507;
  struct MonoException * D.21512;
  struct MonoVTable * D.21513;
  short unsigned int D.21516;
  int D.21517;
  int D.21518;
  struct MonoVTable * D.21521;
  struct MonoClassRuntimeInfo * runtime_info;

  D.21502 = class == 0B;
  D.21503 = (long int) D.21502;
  D.21504 = __builtin_expect (D.21503, 0);
  if (D.21504 != 0) goto <D.21505>; else goto <D.21506>;
  <D.21505>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 1804, "class");
  <D.21506>:
  D.21507 = class->exception_type;
  if (D.21507 != 0) goto <D.21508>; else goto <D.21509>;
  <D.21508>:
  if (raise_on_error != 0) goto <D.21510>; else goto <D.21511>;
  <D.21510>:
  D.21512 = mono_class_get_exception_for_failure (class);
  mono_raise_exception (D.21512);
  <D.21511>:
  D.21513 = 0B;
  return D.21513;
  <D.21509>:
  runtime_info = class->runtime_info;
  if (runtime_info != 0B) goto <D.21514>; else goto <D.21515>;
  <D.21514>:
  D.21516 = runtime_info->max_domain;
  D.21517 = (int) D.21516;
  D.21518 = domain->domain_id;
  if (D.21517 >= D.21518) goto <D.21519>; else goto <D.21520>;
  <D.21519>:
  D.21518 = domain->domain_id;
  D.21521 = runtime_info->domain_vtables[D.21518];
  if (D.21521 != 0B) goto <D.21522>; else goto <D.21523>;
  <D.21522>:
  D.21518 = domain->domain_id;
  D.21513 = runtime_info->domain_vtables[D.21518];
  return D.21513;
  <D.21523>:
  <D.21520>:
  <D.21515>:
  D.21513 = mono_class_create_runtime_vtable (domain, class, raise_on_error);
  return D.21513;
}


mono_class_create_runtime_vtable (struct MonoDomain * domain, struct MonoClass * class, gboolean raise_on_error)
{
  union mono_mutex_t * D.21525;
  _Bool D.21528;
  long int D.21529;
  long int D.21530;
  short unsigned int D.21535;
  int D.21536;
  int D.21537;
  struct MonoVTable * D.21540;
  _Bool D.21545;
  long int D.21546;
  long int D.21547;
  struct MonoVTable * D.21550;
  unsigned int D.21553;
  unsigned int D.21554;
  unsigned char D.21556;
  int D.21559;
  _Bool D.21563;
  long int D.21564;
  long int D.21565;
  struct MonoException * D.21570;
  unsigned char D.21573;
  unsigned int D.21575;
  unsigned int D.21576;
  unsigned char D.21579;
  int D.21582;
  _Bool D.21591;
  long int D.21592;
  long int D.21593;
  struct MonoException * D.21598;
  int D.21599;
  struct MonoGenericClass * D.21602;
  struct MonoMethod * * D.21605;
  _Bool D.21612;
  long int D.21613;
  long int D.21614;
  struct MonoException * D.21619;
  int D.21620;
  void * (*<T26de>) (struct MonoVTable *, struct MonoDomain *, struct MonoIMTCheckItem * *, int, void *) imt_thunk_builder.76;
  unsigned int vtable_slots.77;
  unsigned int D.21627;
  short unsigned int D.21628;
  long unsigned int D.21631;
  long unsigned int D.21632;
  long unsigned int D.21633;
  long unsigned int D.21634;
  short unsigned int D.21636;
  unsigned int D.21637;
  unsigned int D.21638;
  unsigned int D.21639;
  long unsigned int D.21640;
  long unsigned int D.21641;
  long unsigned int D.21642;
  long unsigned int D.21643;
  sizetype imt_table_bytes.78;
  sizetype D.21648;
  sizetype D.21649;
  sizetype D.21650;
  unsigned char D.21651;
  void * D.21652;
  unsigned int D.21653;
  int D.21654;
  _Bool D.21655;
  long int D.21656;
  long int D.21657;
  unsigned char D.21660;
  <unnamed-unsigned:4> D.21661;
  unsigned int D.21664;
  int max_set.79;
  int D.21668;
  void * D.21669;
  void * D.21670;
  void * D.21674;
  long unsigned int D.21675;
  long unsigned int D.21676;
  struct MonoType * D.21677;
  short unsigned int D.21678;
  int D.21679;
  int D.21680;
  int D.21683;
  int D.19135;
  int iftmp.80;
  int D.19134;
  const char[9] * D.21689;
  unsigned char D.21690;
  int D.21691;
  unsigned char D.21692;
  int D.21693;
  const unsigned char * D.21698;
  unsigned char D.21699;
  int D.21700;
  const unsigned char * D.21701;
  unsigned char D.21702;
  int D.21703;
  const unsigned char * D.21708;
  unsigned char D.21709;
  int D.21710;
  const unsigned char * D.21711;
  unsigned char D.21712;
  int D.21713;
  const unsigned char * D.21718;
  unsigned char D.21719;
  int D.21720;
  const unsigned char * D.21721;
  unsigned char D.21722;
  int D.21723;
  const char * D.21725;
  int D.21728;
  int iftmp.81;
  unsigned int D.21732;
  int D.21738;
  int D.21742;
  int max_set.82;
  int D.21747;
  unsigned int special_static.83;
  int align.84;
  unsigned int align.85;
  struct GHashTable * D.21751;
  struct GHashTable * D.21754;
  void * offset.86;
  int D.21758;
  signed short D.21761;
  _Bool D.21762;
  long int D.21763;
  long int D.21764;
  void * D.21767;
  int D.21768;
  sizetype D.21769;
  unsigned int D.21772;
  unsigned int D.21773;
  int D.21776;
  unsigned int D.21777;
  int iftmp.87;
  unsigned char D.21782;
  _Bool D.21785;
  long int D.21786;
  long int D.21787;
  char D.21790;
  guint8 * D.21791;
  struct MonoClass * * D.21794;
  unsigned int i.88;
  unsigned int D.21796;
  struct MonoClass * * D.21797;
  struct MonoClass * D.21798;
  short unsigned int D.21799;
  guint16 * D.21800;
  unsigned int D.21801;
  guint16 * D.21802;
  short unsigned int D.21803;
  int D.21804;
  int D.21805;
  unsigned int D.21806;
  unsigned int D.21807;
  void * * D.21808;
  void * * D.21809;
  int D.21810;
  void * (*<T24a6>) (int) D.21811;
  void * D.21814;
  struct MonoMethod * * D.21816;
  void * (*<T1d17>) (struct MonoMethod *) arch_create_jit_trampoline.89;
  void * D.21820;
  void * (*<T24a6>) (int) D.21825;
  void * * D.21828;
  void * D.21829;
  struct MonoClass * D.21831;
  struct MonoType * D.21834;
  struct MonoReflectionType * D.21835;
  void * D.21836;
  struct MonoClass * D.21837;
  int D.21840;
  void * * D.21845;
  void * D.21846;
  unsigned int D.21847;
  _Bool D.21848;
  struct GPtrArray * D.21849;
  short unsigned int D.21853;
  int D.21854;
  int D.21858;
  struct MonoImage * D.21859;
  unsigned int new_size.90;
  unsigned int D.21861;
  unsigned int D.21862;
  short unsigned int D.21863;
  short unsigned int D.21864;
  struct MonoVTable *[0:] * D.21867;
  struct MonoVTable *[0:] * D.21868;
  int D.21869;
  unsigned int D.21870;
  unsigned int D.21871;
  struct MonoReflectionType * D.21874;
  struct MonoClass * D.21875;
  int D.21878;
  void * D.21883;
  _Bool D.21886;
  long int D.21887;
  long int D.21888;
  int D.21891;
  struct MonoException * D.21898;
  struct MonoClass * D.21899;
  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.21525 = &domain->lock.mutex;
        ret = pthread_mutex_lock (D.21525);
        if (ret != 0) goto <D.21526>; else goto <D.21527>;
        <D.21526>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
        <D.21527>:
        D.21528 = ret != 0;
        D.21529 = (long int) D.21528;
        D.21530 = __builtin_expect (D.21529, 0);
        if (D.21530 != 0) goto <D.21531>; else goto <D.21532>;
        <D.21531>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 1856, "ret == 0");
        <D.21532>:
      }
      runtime_info = class->runtime_info;
      if (runtime_info != 0B) goto <D.21533>; else goto <D.21534>;
      <D.21533>:
      D.21535 = runtime_info->max_domain;
      D.21536 = (int) D.21535;
      D.21537 = domain->domain_id;
      if (D.21536 >= D.21537) goto <D.21538>; else goto <D.21539>;
      <D.21538>:
      D.21537 = domain->domain_id;
      D.21540 = runtime_info->domain_vtables[D.21537];
      if (D.21540 != 0B) goto <D.21541>; else goto <D.21542>;
      <D.21541>:
      {
        int ret;

        D.21525 = &domain->lock.mutex;
        ret = pthread_mutex_unlock (D.21525);
        if (ret != 0) goto <D.21543>; else goto <D.21544>;
        <D.21543>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.21544>:
        D.21545 = ret != 0;
        D.21546 = (long int) D.21545;
        D.21547 = __builtin_expect (D.21546, 0);
        if (D.21547 != 0) goto <D.21548>; else goto <D.21549>;
        <D.21548>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 1859, "ret == 0");
        <D.21549>:
      }
      mono_loader_unlock ();
      D.21537 = domain->domain_id;
      D.21550 = runtime_info->domain_vtables[D.21537];
      return D.21550;
      <D.21542>:
      <D.21539>:
      <D.21534>:
      D.21553 = BIT_FIELD_REF <*class, 32, 160>;
      D.21554 = D.21553 & 1;
      if (D.21554 == 0) goto <D.21551>; else goto <D.21555>;
      <D.21555>:
      D.21556 = class->exception_type;
      if (D.21556 != 0) goto <D.21551>; else goto <D.21552>;
      <D.21551>:
      D.21559 = mono_class_init (class);
      if (D.21559 == 0) goto <D.21557>; else goto <D.21560>;
      <D.21560>:
      D.21556 = class->exception_type;
      if (D.21556 != 0) goto <D.21557>; else goto <D.21558>;
      <D.21557>:
      {
        int ret;

        D.21525 = &domain->lock.mutex;
        ret = pthread_mutex_unlock (D.21525);
        if (ret != 0) goto <D.21561>; else goto <D.21562>;
        <D.21561>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.21562>:
        D.21563 = ret != 0;
        D.21564 = (long int) D.21563;
        D.21565 = __builtin_expect (D.21564, 0);
        if (D.21565 != 0) goto <D.21566>; else goto <D.21567>;
        <D.21566>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 1865, "ret == 0");
        <D.21567>:
      }
      mono_loader_unlock ();
      if (raise_on_error != 0) goto <D.21568>; else goto <D.21569>;
      <D.21568>:
      D.21570 = mono_class_get_exception_for_failure (class);
      mono_raise_exception (D.21570);
      <D.21569>:
      D.21550 = 0B;
      return D.21550;
      <D.21558>:
      <D.21552>:
      D.21573 = class->byval_arg.type;
      if (D.21573 == 20) goto <D.21571>; else goto <D.21574>;
      <D.21574>:
      D.21573 = class->byval_arg.type;
      if (D.21573 == 29) goto <D.21571>; else goto <D.21572>;
      <D.21571>:
      {
        struct MonoClass * element_class;

        element_class = class->element_class;
        D.21575 = BIT_FIELD_REF <*element_class, 32, 160>;
        D.21576 = D.21575 & 1;
        if (D.21576 == 0) goto <D.21577>; else goto <D.21578>;
        <D.21577>:
        mono_class_init (element_class);
        <D.21578>:
        D.21579 = element_class->exception_type;
        if (D.21579 == 0) goto <D.21580>; else goto <D.21581>;
        <D.21580>:
        D.21582 = element_class->vtable_size;
        if (D.21582 == 0) goto <D.21583>; else goto <D.21584>;
        <D.21583>:
        mono_class_setup_vtable (element_class);
        <D.21584>:
        <D.21581>:
        D.21579 = element_class->exception_type;
        if (D.21579 != 0) goto <D.21585>; else goto <D.21586>;
        <D.21585>:
        D.21556 = class->exception_type;
        if (D.21556 == 0) goto <D.21587>; else goto <D.21588>;
        <D.21587>:
        mono_class_set_failure (class, 7, 0B);
        <D.21588>:
        {
          int ret;

          D.21525 = &domain->lock.mutex;
          ret = pthread_mutex_unlock (D.21525);
          if (ret != 0) goto <D.21589>; else goto <D.21590>;
          <D.21589>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
          <D.21590>:
          D.21591 = ret != 0;
          D.21592 = (long int) D.21591;
          D.21593 = __builtin_expect (D.21592, 0);
          if (D.21593 != 0) goto <D.21594>; else goto <D.21595>;
          <D.21594>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 1887, "ret == 0");
          <D.21595>:
        }
        mono_loader_unlock ();
        if (raise_on_error != 0) goto <D.21596>; else goto <D.21597>;
        <D.21596>:
        D.21598 = mono_class_get_exception_for_failure (class);
        mono_raise_exception (D.21598);
        <D.21597>:
        D.21550 = 0B;
        return D.21550;
        <D.21586>:
      }
      <D.21572>:
      D.21599 = class->vtable_size;
      if (D.21599 == 0) goto <D.21600>; else goto <D.21601>;
      <D.21600>:
      mono_class_setup_vtable (class);
      <D.21601>:
      D.21602 = class->generic_class;
      if (D.21602 != 0B) goto <D.21603>; else goto <D.21604>;
      <D.21603>:
      D.21605 = class->vtable;
      if (D.21605 == 0B) goto <D.21606>; else goto <D.21607>;
      <D.21606>:
      mono_class_check_vtable_constraints (class, 0B);
      <D.21607>:
      <D.21604>:
      mono_class_has_finalizer (class);
      D.21556 = class->exception_type;
      if (D.21556 != 0) goto <D.21608>; else goto <D.21609>;
      <D.21608>:
      {
        int ret;

        D.21525 = &domain->lock.mutex;
        ret = pthread_mutex_unlock (D.21525);
        if (ret != 0) goto <D.21610>; else goto <D.21611>;
        <D.21610>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.21611>:
        D.21612 = ret != 0;
        D.21613 = (long int) D.21612;
        D.21614 = __builtin_expect (D.21613, 0);
        if (D.21614 != 0) goto <D.21615>; else goto <D.21616>;
        <D.21615>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 1909, "ret == 0");
        <D.21616>:
      }
      mono_loader_unlock ();
      if (raise_on_error != 0) goto <D.21617>; else goto <D.21618>;
      <D.21617>:
      D.21619 = mono_class_get_exception_for_failure (class);
      mono_raise_exception (D.21619);
      <D.21618>:
      D.21550 = 0B;
      return D.21550;
      <D.21609>:
      vtable_slots = class->vtable_size;
      D.21620 = mono_class_data_size (class);
      class_size = (guint32) D.21620;
      if (class_size != 0) goto <D.21621>; else goto <D.21622>;
      <D.21621>:
      vtable_slots = vtable_slots + 1;
      <D.21622>:
      imt_thunk_builder.76 = imt_thunk_builder;
      if (imt_thunk_builder.76 != 0B) goto <D.21624>; else goto <D.21625>;
      <D.21624>:
      vtable_slots.77 = (unsigned int) vtable_slots;
      D.21627 = vtable_slots.77 + 8;
      vtable_size = D.21627 * 4;
      D.21628 = class->interface_offsets_count;
      if (D.21628 != 0) goto <D.21629>; else goto <D.21630>;
      <D.21629>:
      imt_table_bytes = 76;
      vtable_size = vtable_size + 76;
      D.21631 = mono_stats.imt_number_of_tables;
      D.21632 = D.21631 + 1;
      mono_stats.imt_number_of_tables = D.21632;
      D.21633 = mono_stats.imt_tables_size;
      D.21634 = D.21633 + 76;
      mono_stats.imt_tables_size = D.21634;
      <D.21630>:
      goto <D.21635>;
      <D.21625>:
      D.21636 = class->max_interface_id;
      D.21637 = (unsigned int) D.21636;
      vtable_slots.77 = (unsigned int) vtable_slots;
      D.21638 = D.21637 + vtable_slots.77;
      D.21639 = D.21638 + 9;
      vtable_size = D.21639 * 4;
      <D.21635>:
      D.21640 = mono_stats.used_class_count;
      D.21641 = D.21640 + 1;
      mono_stats.used_class_count = D.21641;
      D.21642 = mono_stats.class_vtable_size;
      D.21643 = D.21642 + vtable_size;
      mono_stats.class_vtable_size = D.21643;
      interface_offsets = mono_domain_alloc0 (domain, vtable_size);
      imt_thunk_builder.76 = imt_thunk_builder;
      if (imt_thunk_builder.76 != 0B) goto <D.21644>; else goto <D.21645>;
      <D.21644>:
      imt_table_bytes.78 = (sizetype) imt_table_bytes;
      vt = interface_offsets + imt_table_bytes.78;
      goto <D.21647>;
      <D.21645>:
      D.21636 = class->max_interface_id;
      D.21648 = (sizetype) D.21636;
      D.21649 = D.21648 + 1;
      D.21650 = D.21649 * 4;
      vt = interface_offsets + D.21650;
      <D.21647>:
      vt->klass = class;
      D.21651 = class->rank;
      vt->rank = D.21651;
      vt->domain = domain;
      mono_class_compute_gc_descriptor (class);
      D.21652 = class->gc_descr;
      vt->gc_descr = D.21652;
      D.21653 = mono_gc_get_vtable_bits (class);
      gc_bits = (int) D.21653;
      D.21654 = gc_bits & -16;
      D.21655 = D.21654 != 0;
      D.21656 = (long int) D.21655;
      D.21657 = __builtin_expect (D.21656, 0);
      if (D.21657 != 0) goto <D.21658>; else goto <D.21659>;
      <D.21658>:
      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.21659>:
      D.21660 = (unsigned char) gc_bits;
      D.21661 = (<unnamed-unsigned:4>) D.21660;
      vt->gc_bits = D.21661;
      if (class_size != 0) goto <D.21662>; else goto <D.21663>;
      <D.21662>:
      D.21553 = BIT_FIELD_REF <*class, 32, 160>;
      D.21664 = D.21553 & 268435456;
      if (D.21664 != 0) goto <D.21665>; else goto <D.21666>;
      <D.21665>:
      {
        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.79 = max_set;
            D.21668 = max_set.79 + 1;
            statics_gc_descr = mono_gc_make_descr_from_bitmap (bitmap, D.21668);
            D.21599 = class->vtable_size;
            D.21669 = mono_gc_alloc_fixed (class_size, statics_gc_descr);
            vt->vtable[D.21599] = D.21669;
            D.21599 = class->vtable_size;
            D.21670 = vt->vtable[D.21599];
            mono_domain_add_class_static_data (domain, class, D.21670, 0B);
            if (&default_bitmap != bitmap) goto <D.21671>; else goto <D.21672>;
            <D.21671>:
            monoeg_g_free (bitmap);
            <D.21672>:
          }
        finally
          {
            max_set = {CLOBBER};
            default_bitmap = {CLOBBER};
          }
      }
      goto <D.21673>;
      <D.21666>:
      D.21599 = class->vtable_size;
      D.21674 = mono_domain_alloc0 (domain, class_size);
      vt->vtable[D.21599] = D.21674;
      <D.21673>:
      vt->has_static_fields = 1;
      D.21675 = mono_stats.class_static_data_size;
      D.21676 = D.21675 + class_size;
      mono_stats.class_static_data_size = D.21676;
      <D.21663>:
      cindex = 4294967295;
      iter = 0B;
      goto <D.19126>;
      <D.19147>:
      D.21677 = field->type;
      D.21678 = D.21677->attrs;
      D.21679 = (int) D.21678;
      D.21680 = D.21679 & 16;
      if (D.21680 == 0) goto <D.21681>; else goto <D.21682>;
      <D.21681>:
      // predicted unlikely by continue predictor.
      goto <D.19126>;
      <D.21682>:
      D.21677 = field->type;
      D.21678 = D.21677->attrs;
      D.21679 = (int) D.21678;
      D.21683 = D.21679 & 1536;
      if (D.21683 != 0) goto <D.21684>; else goto <D.21685>;
      <D.21684>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          __s2 = mono_field_get_name (field);
          D.21689 = "_Deleted";
          D.21690 = MEM[(const unsigned char *)D.21689];
          D.21691 = (int) D.21690;
          D.21692 = *__s2;
          D.21693 = (int) D.21692;
          __result = D.21691 - D.21693;
          {
            if (__s2_len != 0) goto <D.21694>; else goto <D.21695>;
            <D.21694>:
            if (__result == 0) goto <D.21696>; else goto <D.21697>;
            <D.21696>:
            D.21698 = &MEM[(void *)"_Deleted" + 1B];
            D.21699 = *D.21698;
            D.21700 = (int) D.21699;
            D.21701 = __s2 + 1;
            D.21702 = *D.21701;
            D.21703 = (int) D.21702;
            __result = D.21700 - D.21703;
            if (__s2_len > 1) goto <D.21704>; else goto <D.21705>;
            <D.21704>:
            if (__result == 0) goto <D.21706>; else goto <D.21707>;
            <D.21706>:
            D.21708 = &MEM[(void *)"_Deleted" + 2B];
            D.21709 = *D.21708;
            D.21710 = (int) D.21709;
            D.21711 = __s2 + 2;
            D.21712 = *D.21711;
            D.21713 = (int) D.21712;
            __result = D.21710 - D.21713;
            if (__s2_len > 2) goto <D.21714>; else goto <D.21715>;
            <D.21714>:
            if (__result == 0) goto <D.21716>; else goto <D.21717>;
            <D.21716>:
            D.21718 = &MEM[(void *)"_Deleted" + 3B];
            D.21719 = *D.21718;
            D.21720 = (int) D.21719;
            D.21721 = __s2 + 3;
            D.21722 = *D.21721;
            D.21723 = (int) D.21722;
            __result = D.21720 - D.21723;
            <D.21717>:
            <D.21715>:
            <D.21707>:
            <D.21705>:
            <D.21697>:
            <D.21695>:
          }
          D.19134 = __result;
        }
        iftmp.80 = -D.19134;
        goto <D.21724>;
        <D.21688>:
        D.21725 = mono_field_get_name (field);
        iftmp.80 = __builtin_strcmp (D.21725, "_Deleted");
        <D.21724>:
        D.19135 = iftmp.80;
      }
      if (D.19135 == 0) goto <D.21726>; else goto <D.21727>;
      <D.21726>:
      // predicted unlikely by continue predictor.
      goto <D.19126>;
      <D.21727>:
      <D.21685>:
      D.21677 = field->type;
      D.21678 = D.21677->attrs;
      D.21679 = (int) D.21678;
      D.21728 = D.21679 & 64;
      if (D.21728 == 0) goto <D.21729>; else goto <D.21730>;
      <D.21729>:
      {
        gint32 special_static;

        D.21553 = BIT_FIELD_REF <*class, 32, 160>;
        D.21732 = D.21553 & 536870912;
        if (D.21732 == 0) goto <D.21733>; else goto <D.21734>;
        <D.21733>:
        iftmp.81 = field_is_special_static (class, field);
        goto <D.21735>;
        <D.21734>:
        iftmp.81 = 0;
        <D.21735>:
        special_static = iftmp.81;
        if (special_static != 0) goto <D.21736>; else goto <D.21737>;
        <D.21736>:
        {
          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.21677 = field->type;
              D.21738 = mono_type_is_reference (D.21677);
              if (D.21738 != 0) goto <D.21739>; else goto <D.21740>;
              <D.21739>:
              default_bitmap[0] = 1;
              numbits = 1;
              bitmap = &default_bitmap;
              goto <D.21741>;
              <D.21740>:
              D.21677 = field->type;
              D.21742 = mono_type_is_struct (D.21677);
              if (D.21742 != 0) goto <D.21743>; else goto <D.21744>;
              <D.21743>:
              D.21677 = field->type;
              fclass = mono_class_from_mono_type (D.21677);
              bitmap = compute_class_bitmap (fclass, &default_bitmap, 128, -2, &max_set, 0);
              max_set.82 = max_set;
              numbits = max_set.82 + 1;
              goto <D.21746>;
              <D.21744>:
              default_bitmap[0] = 0;
              numbits = 0;
              bitmap = &default_bitmap;
              <D.21746>:
              <D.21741>:
              D.21677 = field->type;
              D.21747 = mono_type_size (D.21677, &align);
              size = (guint32) D.21747;
              special_static.83 = (unsigned int) special_static;
              align.84 = align;
              align.85 = (unsigned int) align.84;
              offset = mono_alloc_special_static_data (special_static.83, size, align.85, bitmap, numbits);
              D.21751 = domain->special_static_fields;
              if (D.21751 == 0B) goto <D.21752>; else goto <D.21753>;
              <D.21752>:
              D.21754 = monoeg_g_hash_table_new (0B, 0B);
              domain->special_static_fields = D.21754;
              <D.21753>:
              D.21751 = domain->special_static_fields;
              offset.86 = (void *) offset;
              monoeg_g_hash_table_insert_replace (D.21751, field, offset.86, 0);
              if (&default_bitmap != bitmap) goto <D.21756>; else goto <D.21757>;
              <D.21756>:
              monoeg_g_free (bitmap);
              <D.21757>:
              field->offset = -1;
              // predicted unlikely by continue predictor.
              goto <D.19126>;
            }
          finally
            {
              align = {CLOBBER};
              default_bitmap = {CLOBBER};
              max_set = {CLOBBER};
            }
        }
        <D.21737>:
      }
      <D.21730>:
      D.21677 = field->type;
      D.21678 = D.21677->attrs;
      D.21679 = (int) D.21678;
      D.21758 = D.21679 & 256;
      if (D.21758 != 0) goto <D.21759>; else goto <D.21760>;
      <D.21759>:
      {
        struct MonoClass * fklass;
        const char * data;

        D.21677 = field->type;
        fklass = mono_class_from_mono_type (D.21677);
        data = mono_field_get_data (field);
        D.21677 = field->type;
        D.21678 = D.21677->attrs;
        D.21761 = (signed short) D.21678;
        D.21762 = D.21761 < 0;
        D.21763 = (long int) D.21762;
        D.21764 = __builtin_expect (D.21763, 0);
        if (D.21764 != 0) goto <D.21765>; else goto <D.21766>;
        <D.21765>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 2043, "!(field->type->attrs & FIELD_ATTRIBUTE_HAS_DEFAULT)");
        <D.21766>:
        D.21767 = mono_vtable_get_static_field_data (vt);
        D.21768 = field->offset;
        D.21769 = (sizetype) D.21768;
        t = D.21767 + D.21769;
        if (data == 0B) goto <D.21770>; else goto <D.21771>;
        <D.21770>:
        // predicted unlikely by continue predictor.
        goto <D.19126>;
        <D.21771>:
        D.21772 = BIT_FIELD_REF <*fklass, 32, 160>;
        D.21773 = D.21772 & 8;
        if (D.21773 != 0) goto <D.21774>; else goto <D.21775>;
        <D.21774>:
        D.21776 = mono_class_value_size (fklass, 0B);
        D.21777 = (unsigned int) D.21776;
        memcpy (t, data, D.21777);
        goto <D.21778>;
        <D.21775>:
        D.21782 = fklass->byval_arg.type;
        if (D.21782 != 15) goto <D.21783>; else goto <D.21780>;
        <D.21783>:
        D.21782 = fklass->byval_arg.type;
        if (D.21782 != 27) goto <D.21784>; else goto <D.21780>;
        <D.21784>:
        iftmp.87 = 1;
        goto <D.21781>;
        <D.21780>:
        iftmp.87 = 0;
        <D.21781>:
        D.21785 = iftmp.87 != 0;
        D.21786 = (long int) D.21785;
        D.21787 = __builtin_expect (D.21786, 0);
        if (D.21787 != 0) goto <D.21788>; else goto <D.21789>;
        <D.21788>:
        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.21789>:
        D.21790 = MEM[(char *)data];
        *t = D.21790;
        <D.21778>:
        // predicted unlikely by continue predictor.
        goto <D.19126>;
      }
      <D.21760>:
      <D.19126>:
      field = mono_class_get_fields (class, &iter);
      if (field != 0B) goto <D.19147>; else goto <D.19148>;
      <D.19148>:
      D.21636 = class->max_interface_id;
      vt->max_interface_id = D.21636;
      D.21791 = class->interface_bitmap;
      vt->interface_bitmap = D.21791;
      imt_thunk_builder.76 = imt_thunk_builder;
      if (imt_thunk_builder.76 == 0B) goto <D.21792>; else goto <D.21793>;
      <D.21792>:
      i = 0;
      goto <D.19152>;
      <D.19151>:
      {
        int interface_id;
        int slot;

        D.21794 = class->interfaces_packed;
        i.88 = (unsigned int) i;
        D.21796 = i.88 * 4;
        D.21797 = D.21794 + D.21796;
        D.21798 = *D.21797;
        D.21799 = D.21798->interface_id;
        interface_id = (int) D.21799;
        D.21800 = class->interface_offsets_packed;
        i.88 = (unsigned int) i;
        D.21801 = i.88 * 2;
        D.21802 = D.21800 + D.21801;
        D.21803 = *D.21802;
        slot = (int) D.21803;
        D.21636 = class->max_interface_id;
        D.21804 = (int) D.21636;
        D.21805 = D.21804 - interface_id;
        D.21806 = (unsigned int) D.21805;
        D.21807 = D.21806 * 4;
        D.21808 = interface_offsets + D.21807;
        D.21809 = &vt->vtable[slot];
        *D.21808 = D.21809;
      }
      i = i + 1;
      <D.19152>:
      D.21628 = class->interface_offsets_count;
      D.21810 = (int) D.21628;
      if (D.21810 > i) goto <D.19151>; else goto <D.19153>;
      <D.19153>:
      <D.21793>:
      D.21811 = callbacks.get_vtable_trampoline;
      if (D.21811 != 0B) goto <D.21812>; else goto <D.21813>;
      <D.21812>:
      i = 0;
      goto <D.19155>;
      <D.19154>:
      D.21811 = callbacks.get_vtable_trampoline;
      D.21814 = D.21811 (i);
      vt->vtable[i] = D.21814;
      i = i + 1;
      <D.19155>:
      D.21599 = class->vtable_size;
      if (D.21599 > i) goto <D.19154>; else goto <D.19156>;
      <D.19156>:
      goto <D.21815>;
      <D.21813>:
      mono_class_setup_vtable (class);
      i = 0;
      goto <D.19159>;
      <D.19158>:
      {
        struct MonoMethod * cm;

        D.21605 = class->vtable;
        i.88 = (unsigned int) i;
        D.21796 = i.88 * 4;
        D.21816 = D.21605 + D.21796;
        cm = *D.21816;
        if (cm != 0B) goto <D.21817>; else goto <D.21818>;
        <D.21817>:
        arch_create_jit_trampoline.89 = arch_create_jit_trampoline;
        D.21820 = arch_create_jit_trampoline.89 (cm);
        vt->vtable[i] = D.21820;
        <D.21818>:
      }
      i = i + 1;
      <D.19159>:
      D.21599 = class->vtable_size;
      if (D.21599 > i) goto <D.19158>; else goto <D.19160>;
      <D.19160>:
      <D.21815>:
      imt_thunk_builder.76 = imt_thunk_builder;
      if (imt_thunk_builder.76 != 0B) goto <D.21821>; else goto <D.21822>;
      <D.21821>:
      if (imt_table_bytes != 0) goto <D.21823>; else goto <D.21824>;
      <D.21823>:
      D.21825 = callbacks.get_imt_trampoline;
      if (D.21825 != 0B) goto <D.21826>; else goto <D.21827>;
      <D.21826>:
      i = 0;
      goto <D.19162>;
      <D.19161>:
      i.88 = (unsigned int) i;
      D.21796 = i.88 * 4;
      D.21828 = interface_offsets + D.21796;
      D.21825 = callbacks.get_imt_trampoline;
      D.21829 = D.21825 (i);
      *D.21828 = D.21829;
      i = i + 1;
      <D.19162>:
      if (i <= 18) goto <D.19161>; else goto <D.19163>;
      <D.19163>:
      goto <D.21830>;
      <D.21827>:
      build_imt (class, vt, domain, interface_offsets, 0B);
      <D.21830>:
      <D.21824>:
      <D.21822>:
      D.21831 = mono_defaults.monotype_class;
      if (D.21831 != class) goto <D.21832>; else goto <D.21833>;
      <D.21832>:
      D.21834 = &class->byval_arg;
      D.21835 = mono_type_get_object (domain, D.21834);
      vt->type = D.21835;
      D.21836 = vt->type;
      D.21837 = mono_object_get_class (D.21836);
      D.21831 = mono_defaults.monotype_class;
      if (D.21837 != D.21831) goto <D.21838>; else goto <D.21839>;
      <D.21838>:
      D.21840 = mono_gc_is_moving ();
      if (D.21840 != 0) goto <D.21841>; else goto <D.21842>;
      <D.21841>:
      if (0 != 0) goto <D.21843>; else goto <D.21844>;
      <D.21843>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 2114, "sizeof (vt->type) == sizeof (MonoObject*)");
      <D.21844>:
      D.21845 = &vt->type;
      D.21846 = mono_gc_make_root_descr_all_refs (1);
      mono_gc_register_root (D.21845, 4, D.21846);
      <D.21842>:
      <D.21839>:
      <D.21833>:
      D.21553 = BIT_FIELD_REF <*class, 32, 160>;
      D.21847 = D.21553 & 8388608;
      D.21848 = D.21847 != 0;
      vt->remote = D.21848;
      D.21849 = domain->class_vtable_array;
      monoeg_g_ptr_array_add (D.21849, vt);
      mono_memory_barrier ();
      old_info = class->runtime_info;
      if (old_info != 0B) goto <D.21852>; else goto <D.21850>;
      <D.21852>:
      D.21853 = old_info->max_domain;
      D.21854 = (int) D.21853;
      D.21537 = domain->domain_id;
      if (D.21854 >= D.21537) goto <D.21855>; else goto <D.21850>;
      <D.21855>:
      D.21537 = domain->domain_id;
      old_info->domain_vtables[D.21537] = vt;
      goto <D.21851>;
      <D.21850>:
      {
        int new_size;

        new_size = domain->domain_id;
        if (old_info != 0B) goto <D.21856>; else goto <D.21857>;
        <D.21856>:
        D.21853 = old_info->max_domain;
        D.21858 = (int) D.21853;
        new_size = MAX_EXPR <D.21858, new_size>;
        <D.21857>:
        new_size = new_size + 1;
        i = 2;
        goto <D.19166>;
        <D.19165>:
        i = i << 1;
        <D.19166>:
        if (new_size > i) goto <D.19165>; else goto <D.19167>;
        <D.19167>:
        new_size = i;
        D.21859 = class->image;
        new_size.90 = (unsigned int) new_size;
        D.21861 = new_size.90 + 1;
        D.21862 = D.21861 * 4;
        runtime_info = mono_image_alloc0 (D.21859, D.21862);
        D.21863 = (short unsigned int) new_size;
        D.21864 = D.21863 + 65535;
        runtime_info->max_domain = D.21864;
        if (old_info != 0B) goto <D.21865>; else goto <D.21866>;
        <D.21865>:
        D.21867 = &runtime_info->domain_vtables;
        D.21868 = &old_info->domain_vtables;
        D.21853 = old_info->max_domain;
        D.21858 = (int) D.21853;
        D.21869 = D.21858 + 1;
        D.21870 = (unsigned int) D.21869;
        D.21871 = D.21870 * 4;
        memcpy (D.21867, D.21868, D.21871);
        <D.21866>:
        D.21537 = domain->domain_id;
        runtime_info->domain_vtables[D.21537] = vt;
        mono_memory_barrier ();
        class->runtime_info = runtime_info;
      }
      <D.21851>:
      D.21831 = mono_defaults.monotype_class;
      if (D.21831 == class) goto <D.21872>; else goto <D.21873>;
      <D.21872>:
      D.21834 = &class->byval_arg;
      D.21874 = mono_type_get_object (domain, D.21834);
      vt->type = D.21874;
      D.21836 = vt->type;
      D.21875 = mono_object_get_class (D.21836);
      D.21831 = mono_defaults.monotype_class;
      if (D.21875 != D.21831) goto <D.21876>; else goto <D.21877>;
      <D.21876>:
      D.21878 = mono_gc_is_moving ();
      if (D.21878 != 0) goto <D.21879>; else goto <D.21880>;
      <D.21879>:
      if (0 != 0) goto <D.21881>; else goto <D.21882>;
      <D.21881>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 2168, "sizeof (vt->type) == sizeof (MonoObject*)");
      <D.21882>:
      D.21845 = &vt->type;
      D.21883 = mono_gc_make_root_descr_all_refs (1);
      mono_gc_register_root (D.21845, 4, D.21883);
      <D.21880>:
      <D.21877>:
      <D.21873>:
      {
        int ret;

        D.21525 = &domain->lock.mutex;
        ret = pthread_mutex_unlock (D.21525);
        if (ret != 0) goto <D.21884>; else goto <D.21885>;
        <D.21884>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.21885>:
        D.21886 = ret != 0;
        D.21887 = (long int) D.21886;
        D.21888 = __builtin_expect (D.21887, 0);
        if (D.21888 != 0) goto <D.21889>; else goto <D.21890>;
        <D.21889>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 2171, "ret == 0");
        <D.21890>:
      }
      mono_loader_unlock ();
      D.21891 = mono_is_security_manager_active ();
      if (D.21891 != 0) goto <D.21892>; else goto <D.21893>;
      <D.21892>:
      D.21556 = class->exception_type;
      if (D.21556 == 2) goto <D.21894>; else goto <D.21895>;
      <D.21894>:
      if (raise_on_error != 0) goto <D.21896>; else goto <D.21897>;
      <D.21896>:
      D.21898 = mono_class_get_exception_for_failure (class);
      mono_raise_exception (D.21898);
      <D.21897>:
      <D.21895>:
      <D.21893>:
      D.21899 = class->parent;
      if (D.21899 != 0B) goto <D.21900>; else goto <D.21901>;
      <D.21900>:
      D.21899 = class->parent;
      mono_class_vtable_full (domain, D.21899, raise_on_error);
      <D.21901>:
      D.21550 = vt;
      return D.21550;
    }
  finally
    {
      iter = {CLOBBER};
    }
}


field_is_special_static (struct MonoClass * fklass, struct MonoClassField * field)
{
  gint32 D.21907;
  struct MonoMethod * D.21908;
  struct MonoImage * D.21909;
  struct MonoImage * D.21910;
  int D.18822;
  int iftmp.91;
  int D.18821;
  const char[22] * D.21916;
  unsigned char D.21917;
  int D.21918;
  unsigned char D.21919;
  int D.21920;
  const unsigned char * D.21925;
  unsigned char D.21926;
  int D.21927;
  const unsigned char * D.21928;
  unsigned char D.21929;
  int D.21930;
  const unsigned char * D.21935;
  unsigned char D.21936;
  int D.21937;
  const unsigned char * D.21938;
  unsigned char D.21939;
  int D.21940;
  const unsigned char * D.21945;
  unsigned char D.21946;
  int D.21947;
  const unsigned char * D.21948;
  unsigned char D.21949;
  int D.21950;
  const char * D.21952;
  int D.18831;
  int iftmp.92;
  int D.18830;
  const char[23] * D.21958;
  unsigned char D.21959;
  int D.21960;
  unsigned char D.21961;
  int D.21962;
  const unsigned char * D.21967;
  unsigned char D.21968;
  int D.21969;
  const unsigned char * D.21970;
  unsigned char D.21971;
  int D.21972;
  const unsigned char * D.21977;
  unsigned char D.21978;
  int D.21979;
  const unsigned char * D.21980;
  unsigned char D.21981;
  int D.21982;
  const unsigned char * D.21987;
  unsigned char D.21988;
  int D.21989;
  const unsigned char * D.21990;
  unsigned char D.21991;
  int D.21992;
  int D.21996;
  struct MonoCustomAttrInfo * ainfo;
  int i;

  ainfo = mono_custom_attrs_from_field (fklass, field);
  if (ainfo == 0B) goto <D.21905>; else goto <D.21906>;
  <D.21905>:
  D.21907 = 0;
  return D.21907;
  <D.21906>:
  i = 0;
  goto <D.18833>;
  <D.18832>:
  {
    struct MonoClass * klass;

    D.21908 = ainfo->attrs[i].ctor;
    klass = D.21908->klass;
    D.21909 = klass->image;
    D.21910 = mono_defaults.corlib;
    if (D.21909 == D.21910) goto <D.21911>; else goto <D.21912>;
    <D.21911>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = klass->name;
        D.21916 = "ThreadStaticAttribute";
        D.21917 = MEM[(const unsigned char *)D.21916];
        D.21918 = (int) D.21917;
        D.21919 = *__s2;
        D.21920 = (int) D.21919;
        __result = D.21918 - D.21920;
        {
          if (__s2_len != 0) goto <D.21921>; else goto <D.21922>;
          <D.21921>:
          if (__result == 0) goto <D.21923>; else goto <D.21924>;
          <D.21923>:
          D.21925 = &MEM[(void *)"ThreadStaticAttribute" + 1B];
          D.21926 = *D.21925;
          D.21927 = (int) D.21926;
          D.21928 = __s2 + 1;
          D.21929 = *D.21928;
          D.21930 = (int) D.21929;
          __result = D.21927 - D.21930;
          if (__s2_len > 1) goto <D.21931>; else goto <D.21932>;
          <D.21931>:
          if (__result == 0) goto <D.21933>; else goto <D.21934>;
          <D.21933>:
          D.21935 = &MEM[(void *)"ThreadStaticAttribute" + 2B];
          D.21936 = *D.21935;
          D.21937 = (int) D.21936;
          D.21938 = __s2 + 2;
          D.21939 = *D.21938;
          D.21940 = (int) D.21939;
          __result = D.21937 - D.21940;
          if (__s2_len > 2) goto <D.21941>; else goto <D.21942>;
          <D.21941>:
          if (__result == 0) goto <D.21943>; else goto <D.21944>;
          <D.21943>:
          D.21945 = &MEM[(void *)"ThreadStaticAttribute" + 3B];
          D.21946 = *D.21945;
          D.21947 = (int) D.21946;
          D.21948 = __s2 + 3;
          D.21949 = *D.21948;
          D.21950 = (int) D.21949;
          __result = D.21947 - D.21950;
          <D.21944>:
          <D.21942>:
          <D.21934>:
          <D.21932>:
          <D.21924>:
          <D.21922>:
        }
        D.18821 = __result;
      }
      iftmp.91 = -D.18821;
      goto <D.21951>;
      <D.21915>:
      D.21952 = klass->name;
      iftmp.91 = __builtin_strcmp (D.21952, "ThreadStaticAttribute");
      <D.21951>:
      D.18822 = iftmp.91;
    }
    if (D.18822 == 0) goto <D.21953>; else goto <D.21954>;
    <D.21953>:
    mono_custom_attrs_free (ainfo);
    D.21907 = 1;
    return D.21907;
    <D.21954>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = klass->name;
        D.21958 = "ContextStaticAttribute";
        D.21959 = MEM[(const unsigned char *)D.21958];
        D.21960 = (int) D.21959;
        D.21961 = *__s2;
        D.21962 = (int) D.21961;
        __result = D.21960 - D.21962;
        {
          if (__s2_len != 0) goto <D.21963>; else goto <D.21964>;
          <D.21963>:
          if (__result == 0) goto <D.21965>; else goto <D.21966>;
          <D.21965>:
          D.21967 = &MEM[(void *)"ContextStaticAttribute" + 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;
          if (__s2_len > 1) goto <D.21973>; else goto <D.21974>;
          <D.21973>:
          if (__result == 0) goto <D.21975>; else goto <D.21976>;
          <D.21975>:
          D.21977 = &MEM[(void *)"ContextStaticAttribute" + 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;
          if (__s2_len > 2) goto <D.21983>; else goto <D.21984>;
          <D.21983>:
          if (__result == 0) goto <D.21985>; else goto <D.21986>;
          <D.21985>:
          D.21987 = &MEM[(void *)"ContextStaticAttribute" + 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.21984>:
          <D.21976>:
          <D.21974>:
          <D.21966>:
          <D.21964>:
        }
        D.18830 = __result;
      }
      iftmp.92 = -D.18830;
      goto <D.21993>;
      <D.21957>:
      D.21952 = klass->name;
      iftmp.92 = __builtin_strcmp (D.21952, "ContextStaticAttribute");
      <D.21993>:
      D.18831 = iftmp.92;
    }
    if (D.18831 == 0) goto <D.21994>; else goto <D.21995>;
    <D.21994>:
    mono_custom_attrs_free (ainfo);
    D.21907 = 2;
    return D.21907;
    <D.21995>:
    <D.21912>:
  }
  i = i + 1;
  <D.18833>:
  D.21996 = ainfo->num_attrs;
  if (D.21996 > i) goto <D.18832>; else goto <D.18834>;
  <D.18834>:
  mono_custom_attrs_free (ainfo);
  D.21907 = 0;
  return D.21907;
}


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.21998;
  long int D.21999;
  long int D.22000;
  short unsigned int D.22005;
  int D.22006;
  int D.22007;
  struct MonoVTable * D.22010;
  struct MonoVTable * D.22013;
  struct MonoClassRuntimeInfo * runtime_info;

  D.21998 = class == 0B;
  D.21999 = (long int) D.21998;
  D.22000 = __builtin_expect (D.21999, 0);
  if (D.22000 != 0) goto <D.22001>; else goto <D.22002>;
  <D.22001>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 1832, "class");
  <D.22002>:
  runtime_info = class->runtime_info;
  if (runtime_info != 0B) goto <D.22003>; else goto <D.22004>;
  <D.22003>:
  D.22005 = runtime_info->max_domain;
  D.22006 = (int) D.22005;
  D.22007 = domain->domain_id;
  if (D.22006 >= D.22007) goto <D.22008>; else goto <D.22009>;
  <D.22008>:
  D.22007 = domain->domain_id;
  D.22010 = runtime_info->domain_vtables[D.22007];
  if (D.22010 != 0B) goto <D.22011>; else goto <D.22012>;
  <D.22011>:
  D.22007 = domain->domain_id;
  D.22013 = runtime_info->domain_vtables[D.22007];
  return D.22013;
  <D.22012>:
  <D.22009>:
  <D.22004>:
  D.22013 = 0B;
  return D.22013;
}


mono_class_field_is_special_static (struct MonoClassField * field)
{
  struct MonoType * D.22015;
  short unsigned int D.22016;
  int D.22017;
  int D.22018;
  gboolean D.22021;
  int D.22022;
  int D.19243;
  int iftmp.93;
  int D.19242;
  const char[9] * D.22028;
  unsigned char D.22029;
  int D.22030;
  unsigned char D.22031;
  int D.22032;
  const unsigned char * D.22037;
  unsigned char D.22038;
  int D.22039;
  const unsigned char * D.22040;
  unsigned char D.22041;
  int D.22042;
  const unsigned char * D.22047;
  unsigned char D.22048;
  int D.22049;
  const unsigned char * D.22050;
  unsigned char D.22051;
  int D.22052;
  const unsigned char * D.22057;
  unsigned char D.22058;
  int D.22059;
  const unsigned char * D.22060;
  unsigned char D.22061;
  int D.22062;
  const char * D.22064;
  int D.22067;
  struct MonoClass * D.22070;
  int D.22071;

  D.22015 = field->type;
  D.22016 = D.22015->attrs;
  D.22017 = (int) D.22016;
  D.22018 = D.22017 & 16;
  if (D.22018 == 0) goto <D.22019>; else goto <D.22020>;
  <D.22019>:
  D.22021 = 0;
  return D.22021;
  <D.22020>:
  D.22015 = field->type;
  D.22016 = D.22015->attrs;
  D.22017 = (int) D.22016;
  D.22022 = D.22017 & 1536;
  if (D.22022 != 0) goto <D.22023>; else goto <D.22024>;
  <D.22023>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = mono_field_get_name (field);
      D.22028 = "_Deleted";
      D.22029 = MEM[(const unsigned char *)D.22028];
      D.22030 = (int) D.22029;
      D.22031 = *__s2;
      D.22032 = (int) D.22031;
      __result = D.22030 - D.22032;
      {
        if (__s2_len != 0) goto <D.22033>; else goto <D.22034>;
        <D.22033>:
        if (__result == 0) goto <D.22035>; else goto <D.22036>;
        <D.22035>:
        D.22037 = &MEM[(void *)"_Deleted" + 1B];
        D.22038 = *D.22037;
        D.22039 = (int) D.22038;
        D.22040 = __s2 + 1;
        D.22041 = *D.22040;
        D.22042 = (int) D.22041;
        __result = D.22039 - D.22042;
        if (__s2_len > 1) goto <D.22043>; else goto <D.22044>;
        <D.22043>:
        if (__result == 0) goto <D.22045>; else goto <D.22046>;
        <D.22045>:
        D.22047 = &MEM[(void *)"_Deleted" + 2B];
        D.22048 = *D.22047;
        D.22049 = (int) D.22048;
        D.22050 = __s2 + 2;
        D.22051 = *D.22050;
        D.22052 = (int) D.22051;
        __result = D.22049 - D.22052;
        if (__s2_len > 2) goto <D.22053>; else goto <D.22054>;
        <D.22053>:
        if (__result == 0) goto <D.22055>; else goto <D.22056>;
        <D.22055>:
        D.22057 = &MEM[(void *)"_Deleted" + 3B];
        D.22058 = *D.22057;
        D.22059 = (int) D.22058;
        D.22060 = __s2 + 3;
        D.22061 = *D.22060;
        D.22062 = (int) D.22061;
        __result = D.22059 - D.22062;
        <D.22056>:
        <D.22054>:
        <D.22046>:
        <D.22044>:
        <D.22036>:
        <D.22034>:
      }
      D.19242 = __result;
    }
    iftmp.93 = -D.19242;
    goto <D.22063>;
    <D.22027>:
    D.22064 = mono_field_get_name (field);
    iftmp.93 = __builtin_strcmp (D.22064, "_Deleted");
    <D.22063>:
    D.19243 = iftmp.93;
  }
  if (D.19243 == 0) goto <D.22065>; else goto <D.22066>;
  <D.22065>:
  D.22021 = 0;
  return D.22021;
  <D.22066>:
  <D.22024>:
  D.22015 = field->type;
  D.22016 = D.22015->attrs;
  D.22017 = (int) D.22016;
  D.22067 = D.22017 & 64;
  if (D.22067 == 0) goto <D.22068>; else goto <D.22069>;
  <D.22068>:
  D.22070 = field->parent;
  D.22071 = field_is_special_static (D.22070, field);
  if (D.22071 != 0) goto <D.22072>; else goto <D.22073>;
  <D.22072>:
  D.22021 = 1;
  return D.22021;
  <D.22073>:
  <D.22069>:
  D.22021 = 0;
  return D.22021;
}


mono_class_field_get_special_static_type (struct MonoClassField * field)
{
  struct MonoType * D.22075;
  short unsigned int D.22076;
  int D.22077;
  int D.22078;
  guint32 D.22081;
  int D.22082;
  int D.19255;
  int iftmp.94;
  int D.19254;
  const char[9] * D.22088;
  unsigned char D.22089;
  int D.22090;
  unsigned char D.22091;
  int D.22092;
  const unsigned char * D.22097;
  unsigned char D.22098;
  int D.22099;
  const unsigned char * D.22100;
  unsigned char D.22101;
  int D.22102;
  const unsigned char * D.22107;
  unsigned char D.22108;
  int D.22109;
  const unsigned char * D.22110;
  unsigned char D.22111;
  int D.22112;
  const unsigned char * D.22117;
  unsigned char D.22118;
  int D.22119;
  const unsigned char * D.22120;
  unsigned char D.22121;
  int D.22122;
  const char * D.22124;
  int D.22127;
  struct MonoClass * D.22130;
  int D.22131;

  D.22075 = field->type;
  D.22076 = D.22075->attrs;
  D.22077 = (int) D.22076;
  D.22078 = D.22077 & 16;
  if (D.22078 == 0) goto <D.22079>; else goto <D.22080>;
  <D.22079>:
  D.22081 = 0;
  return D.22081;
  <D.22080>:
  D.22075 = field->type;
  D.22076 = D.22075->attrs;
  D.22077 = (int) D.22076;
  D.22082 = D.22077 & 1536;
  if (D.22082 != 0) goto <D.22083>; else goto <D.22084>;
  <D.22083>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = mono_field_get_name (field);
      D.22088 = "_Deleted";
      D.22089 = MEM[(const unsigned char *)D.22088];
      D.22090 = (int) D.22089;
      D.22091 = *__s2;
      D.22092 = (int) D.22091;
      __result = D.22090 - D.22092;
      {
        if (__s2_len != 0) goto <D.22093>; else goto <D.22094>;
        <D.22093>:
        if (__result == 0) goto <D.22095>; else goto <D.22096>;
        <D.22095>:
        D.22097 = &MEM[(void *)"_Deleted" + 1B];
        D.22098 = *D.22097;
        D.22099 = (int) D.22098;
        D.22100 = __s2 + 1;
        D.22101 = *D.22100;
        D.22102 = (int) D.22101;
        __result = D.22099 - D.22102;
        if (__s2_len > 1) goto <D.22103>; else goto <D.22104>;
        <D.22103>:
        if (__result == 0) goto <D.22105>; else goto <D.22106>;
        <D.22105>:
        D.22107 = &MEM[(void *)"_Deleted" + 2B];
        D.22108 = *D.22107;
        D.22109 = (int) D.22108;
        D.22110 = __s2 + 2;
        D.22111 = *D.22110;
        D.22112 = (int) D.22111;
        __result = D.22109 - D.22112;
        if (__s2_len > 2) goto <D.22113>; else goto <D.22114>;
        <D.22113>:
        if (__result == 0) goto <D.22115>; else goto <D.22116>;
        <D.22115>:
        D.22117 = &MEM[(void *)"_Deleted" + 3B];
        D.22118 = *D.22117;
        D.22119 = (int) D.22118;
        D.22120 = __s2 + 3;
        D.22121 = *D.22120;
        D.22122 = (int) D.22121;
        __result = D.22119 - D.22122;
        <D.22116>:
        <D.22114>:
        <D.22106>:
        <D.22104>:
        <D.22096>:
        <D.22094>:
      }
      D.19254 = __result;
    }
    iftmp.94 = -D.19254;
    goto <D.22123>;
    <D.22087>:
    D.22124 = mono_field_get_name (field);
    iftmp.94 = __builtin_strcmp (D.22124, "_Deleted");
    <D.22123>:
    D.19255 = iftmp.94;
  }
  if (D.19255 == 0) goto <D.22125>; else goto <D.22126>;
  <D.22125>:
  D.22081 = 0;
  return D.22081;
  <D.22126>:
  <D.22084>:
  D.22075 = field->type;
  D.22076 = D.22075->attrs;
  D.22077 = (int) D.22076;
  D.22127 = D.22077 & 64;
  if (D.22127 == 0) goto <D.22128>; else goto <D.22129>;
  <D.22128>:
  D.22130 = field->parent;
  D.22131 = field_is_special_static (D.22130, field);
  D.22081 = (guint32) D.22131;
  return D.22081;
  <D.22129>:
  D.22081 = 0;
  return D.22081;
}


mono_class_has_special_static_fields (struct MonoClass * klass)
{
  struct MonoClass * D.22133;
  _Bool D.22134;
  long int D.22135;
  long int D.22136;
  int D.22139;
  gboolean D.22142;
  struct MonoClassField * field;
  void * iter;

  try
    {
      iter = 0B;
      goto <D.19262>;
      <D.19261>:
      D.22133 = field->parent;
      D.22134 = D.22133 != klass;
      D.22135 = (long int) D.22134;
      D.22136 = __builtin_expect (D.22135, 0);
      if (D.22136 != 0) goto <D.22137>; else goto <D.22138>;
      <D.22137>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 2420, "field->parent == klass");
      <D.22138>:
      D.22139 = mono_class_field_is_special_static (field);
      if (D.22139 != 0) goto <D.22140>; else goto <D.22141>;
      <D.22140>:
      D.22142 = 1;
      return D.22142;
      <D.22141>:
      <D.19262>:
      field = mono_class_get_fields (klass, &iter);
      if (field != 0B) goto <D.19261>; else goto <D.19263>;
      <D.19263>:
      D.22142 = 0;
      return D.22142;
    }
  finally
    {
      iter = {CLOBBER};
    }
}


mono_remote_class (struct MonoDomain * domain, struct MonoString * class_name, struct MonoClass * proxy_class)
{
  union mono_mutex_t * D.22145;
  _Bool D.22148;
  long int D.22149;
  long int D.22150;
  struct GHashTable * D.22153;
  _Bool D.22158;
  long int D.22159;
  long int D.22160;
  struct MonoRemoteClass * D.22163;
  struct MonoMemPool * D.22164;
  int D.22165;
  _Bool D.22170;
  long int D.22171;
  long int D.22172;
  unsigned int D.22175;
  unsigned int D.22176;
  struct MonoClass * D.22179;
  int D.22181;
  int D.22182;
  struct MonoPerfCounters * mono_perfcounters.95;
  unsigned int D.22184;
  unsigned int D.22185;
  unsigned int D.22186;
  _Bool D.22189;
  long int D.22190;
  long int D.22191;
  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.22145 = &domain->lock.mutex;
        ret = pthread_mutex_lock (D.22145);
        if (ret != 0) goto <D.22146>; else goto <D.22147>;
        <D.22146>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
        <D.22147>:
        D.22148 = ret != 0;
        D.22149 = (long int) D.22148;
        D.22150 = __builtin_expect (D.22149, 0);
        if (D.22150 != 0) goto <D.22151>; else goto <D.22152>;
        <D.22151>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 2515, "ret == 0");
        <D.22152>:
      }
      D.22153 = domain->proxy_vtable_hash;
      rc = monoeg_g_hash_table_lookup (D.22153, key);
      if (rc != 0B) goto <D.22154>; else goto <D.22155>;
      <D.22154>:
      monoeg_g_free (key);
      {
        int ret;

        D.22145 = &domain->lock.mutex;
        ret = pthread_mutex_unlock (D.22145);
        if (ret != 0) goto <D.22156>; else goto <D.22157>;
        <D.22156>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.22157>:
        D.22158 = ret != 0;
        D.22159 = (long int) D.22158;
        D.22160 = __builtin_expect (D.22159, 0);
        if (D.22160 != 0) goto <D.22161>; else goto <D.22162>;
        <D.22161>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 2520, "ret == 0");
        <D.22162>:
      }
      D.22163 = rc;
      return D.22163;
      <D.22155>:
      D.22164 = domain->mp;
      name = mono_string_to_utf8_mp (D.22164, class_name, &error);
      D.22165 = mono_error_ok (&error);
      if (D.22165 == 0) goto <D.22166>; else goto <D.22167>;
      <D.22166>:
      monoeg_g_free (key);
      {
        int ret;

        D.22145 = &domain->lock.mutex;
        ret = pthread_mutex_unlock (D.22145);
        if (ret != 0) goto <D.22168>; else goto <D.22169>;
        <D.22168>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.22169>:
        D.22170 = ret != 0;
        D.22171 = (long int) D.22170;
        D.22172 = __builtin_expect (D.22171, 0);
        if (D.22172 != 0) goto <D.22173>; else goto <D.22174>;
        <D.22173>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 2527, "ret == 0");
        <D.22174>:
      }
      mono_error_raise_exception (&error);
      <D.22167>:
      mp_key = copy_remote_class_key (domain, key);
      monoeg_g_free (key);
      key = mp_key;
      D.22175 = proxy_class->flags;
      D.22176 = D.22175 & 32;
      if (D.22176 != 0) goto <D.22177>; else goto <D.22178>;
      <D.22177>:
      rc = mono_domain_alloc (domain, 24);
      rc->interface_count = 1;
      rc->interfaces[0] = proxy_class;
      D.22179 = mono_defaults.marshalbyrefobject_class;
      rc->proxy_class = D.22179;
      goto <D.22180>;
      <D.22178>:
      rc = mono_domain_alloc (domain, 20);
      rc->interface_count = 0;
      rc->proxy_class = proxy_class;
      <D.22180>:
      rc->default_vtable = 0B;
      rc->xdomain_vtable = 0B;
      rc->proxy_class_name = name;
      D.22181 = mono_string_length (class_name);
      D.22182 = D.22181 + 1;
      mono_perfcounters.95 = mono_perfcounters;
      mono_perfcounters.95 = mono_perfcounters;
      D.22184 = mono_perfcounters.95->loader_bytes;
      D.22185 = (unsigned int) D.22182;
      D.22186 = D.22184 + D.22185;
      mono_perfcounters.95->loader_bytes = D.22186;
      D.22153 = domain->proxy_vtable_hash;
      monoeg_g_hash_table_insert_replace (D.22153, key, rc, 0);
      {
        int ret;

        D.22145 = &domain->lock.mutex;
        ret = pthread_mutex_unlock (D.22145);
        if (ret != 0) goto <D.22187>; else goto <D.22188>;
        <D.22187>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.22188>:
        D.22189 = ret != 0;
        D.22190 = (long int) D.22189;
        D.22191 = __builtin_expect (D.22190, 0);
        if (D.22191 != 0) goto <D.22192>; else goto <D.22193>;
        <D.22192>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 2555, "ret == 0");
        <D.22193>:
      }
      D.22163 = rc;
      return D.22163;
    }
  finally
    {
      error = {CLOBBER};
    }
}


create_remote_class_key (struct MonoRemoteClass * remote_class, struct MonoClass * extra_class)
{
  unsigned int D.22198;
  unsigned int D.22199;
  void * * D.22202;
  struct MonoClass * D.22203;
  void * * D.22204;
  unsigned int D.22210;
  unsigned int D.22211;
  unsigned int D.22212;
  unsigned int D.22213;
  void * D.22214;
  struct MonoClass * D.22215;
  struct MonoClass * D.22218;
  int j.96;
  unsigned int j.97;
  unsigned int D.22223;
  void * * D.22224;
  unsigned int j.98;
  unsigned int D.22226;
  void * * D.22227;
  unsigned int i.99;
  unsigned int D.22231;
  unsigned int D.22232;
  void * D.22233;
  struct MonoClass * iftmp.100;
  int D.22238;
  unsigned int D.22239;
  unsigned int D.22240;
  void * * D.22241;
  void * * D.22242;
  void * * key;
  int i;
  int j;

  if (remote_class == 0B) goto <D.22196>; else goto <D.22197>;
  <D.22196>:
  D.22198 = extra_class->flags;
  D.22199 = D.22198 & 32;
  if (D.22199 != 0) goto <D.22200>; else goto <D.22201>;
  <D.22200>:
  key = monoeg_malloc (12);
  *key = 2B;
  D.22202 = key + 4;
  D.22203 = mono_defaults.marshalbyrefobject_class;
  *D.22202 = D.22203;
  D.22204 = key + 8;
  *D.22204 = extra_class;
  goto <D.22205>;
  <D.22201>:
  key = monoeg_malloc (8);
  *key = 1B;
  D.22202 = key + 4;
  *D.22202 = extra_class;
  <D.22205>:
  goto <D.22206>;
  <D.22197>:
  if (extra_class != 0B) goto <D.22208>; else goto <D.22207>;
  <D.22208>:
  D.22198 = extra_class->flags;
  D.22199 = D.22198 & 32;
  if (D.22199 != 0) goto <D.22209>; else goto <D.22207>;
  <D.22209>:
  D.22210 = remote_class->interface_count;
  D.22211 = D.22210 + 3;
  D.22212 = D.22211 * 4;
  key = monoeg_malloc (D.22212);
  D.22210 = remote_class->interface_count;
  D.22213 = D.22210 + 2;
  D.22214 = (void *) D.22213;
  *key = D.22214;
  D.22202 = key + 4;
  D.22215 = remote_class->proxy_class;
  *D.22202 = D.22215;
  i = 0;
  j = 2;
  goto <D.19272>;
  <D.19271>:
  if (extra_class != 0B) goto <D.22216>; else goto <D.22217>;
  <D.22216>:
  D.22218 = remote_class->interfaces[i];
  if (D.22218 > extra_class) goto <D.22219>; else goto <D.22220>;
  <D.22219>:
  j.96 = j;
  j = j.96 + 1;
  j.97 = (unsigned int) j.96;
  D.22223 = j.97 * 4;
  D.22224 = key + D.22223;
  *D.22224 = extra_class;
  extra_class = 0B;
  <D.22220>:
  <D.22217>:
  j.98 = (unsigned int) j;
  D.22226 = j.98 * 4;
  D.22227 = key + D.22226;
  D.22218 = remote_class->interfaces[i];
  *D.22227 = D.22218;
  i = i + 1;
  j = j + 1;
  <D.19272>:
  i.99 = (unsigned int) i;
  D.22210 = remote_class->interface_count;
  if (i.99 < D.22210) goto <D.19271>; else goto <D.19273>;
  <D.19273>:
  if (extra_class != 0B) goto <D.22229>; else goto <D.22230>;
  <D.22229>:
  j.98 = (unsigned int) j;
  D.22226 = j.98 * 4;
  D.22227 = key + D.22226;
  *D.22227 = extra_class;
  <D.22230>:
  goto <D.19276>;
  <D.22207>:
  D.22210 = remote_class->interface_count;
  D.22213 = D.22210 + 2;
  D.22231 = D.22213 * 4;
  key = monoeg_malloc (D.22231);
  D.22210 = remote_class->interface_count;
  D.22232 = D.22210 + 1;
  D.22233 = (void *) D.22232;
  *key = D.22233;
  D.22202 = key + 4;
  if (extra_class == 0B) goto <D.22235>; else goto <D.22236>;
  <D.22235>:
  iftmp.100 = remote_class->proxy_class;
  goto <D.22237>;
  <D.22236>:
  iftmp.100 = extra_class;
  <D.22237>:
  *D.22202 = iftmp.100;
  i = 0;
  goto <D.19275>;
  <D.19274>:
  D.22238 = i + 2;
  D.22239 = (unsigned int) D.22238;
  D.22240 = D.22239 * 4;
  D.22241 = key + D.22240;
  D.22218 = remote_class->interfaces[i];
  *D.22241 = D.22218;
  i = i + 1;
  <D.19275>:
  i.99 = (unsigned int) i;
  D.22210 = remote_class->interface_count;
  if (i.99 < D.22210) goto <D.19274>; else goto <D.19276>;
  <D.19276>:
  <D.22206>:
  D.22242 = key;
  return D.22242;
}


copy_remote_class_key (struct MonoDomain * domain, void * * key)
{
  void * D.22244;
  unsigned int D.22245;
  unsigned int D.22246;
  unsigned int D.22247;
  unsigned int key_size.101;
  unsigned int key_size.102;
  void * * D.22250;
  int key_size;
  void * * mp_key;

  D.22244 = *key;
  D.22245 = (unsigned int) D.22244;
  D.22246 = D.22245 + 1;
  D.22247 = D.22246 * 4;
  key_size = (int) D.22247;
  key_size.101 = (unsigned int) key_size;
  mp_key = mono_domain_alloc (domain, key_size.101);
  key_size.102 = (unsigned int) key_size;
  memcpy (mp_key, key, key_size.102);
  D.22250 = mp_key;
  return D.22250;
}


mono_remote_class_vtable (struct MonoDomain * domain, struct MonoRemoteClass * remote_class, struct MonoRealProxy * rp)
{
  union mono_mutex_t * D.22252;
  _Bool D.22255;
  long int D.22256;
  long int D.22257;
  int D.22260;
  struct MonoVTable * D.22263;
  struct MonoVTable * D.22266;
  _Bool D.22269;
  long int D.22270;
  long int D.22271;
  void * D.22274;
  struct MonoVTable * D.22275;
  struct MonoReflectionType * D.22278;
  unsigned int D.22282;
  unsigned int D.22283;
  struct MonoClass * D.22285;
  struct MonoClass * D.22287;
  struct MonoDomain * D.22288;
  struct MonoVTable * D.22289;
  unsigned int D.22290;
  unsigned int D.22291;
  struct MonoVTable * D.22293;
  struct MonoVTable * D.22294;
  _Bool D.22297;
  long int D.22298;
  long int D.22299;

  mono_loader_lock ();
  {
    int ret;

    D.22252 = &domain->lock.mutex;
    ret = pthread_mutex_lock (D.22252);
    if (ret != 0) goto <D.22253>; else goto <D.22254>;
    <D.22253>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.22254>:
    D.22255 = ret != 0;
    D.22256 = (long int) D.22255;
    D.22257 = __builtin_expect (D.22256, 0);
    if (D.22257 != 0) goto <D.22258>; else goto <D.22259>;
    <D.22258>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 2617, "ret == 0");
    <D.22259>:
  }
  D.22260 = rp->target_domain_id;
  if (D.22260 != -1) goto <D.22261>; else goto <D.22262>;
  <D.22261>:
  D.22263 = remote_class->xdomain_vtable;
  if (D.22263 == 0B) goto <D.22264>; else goto <D.22265>;
  <D.22264>:
  D.22266 = mono_class_proxy_vtable (domain, remote_class, 1);
  remote_class->xdomain_vtable = D.22266;
  <D.22265>:
  {
    int ret;

    D.22252 = &domain->lock.mutex;
    ret = pthread_mutex_unlock (D.22252);
    if (ret != 0) goto <D.22267>; else goto <D.22268>;
    <D.22267>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.22268>:
    D.22269 = ret != 0;
    D.22270 = (long int) D.22269;
    D.22271 = __builtin_expect (D.22270, 0);
    if (D.22271 != 0) goto <D.22272>; else goto <D.22273>;
    <D.22272>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 2621, "ret == 0");
    <D.22273>:
  }
  mono_loader_unlock ();
  D.22274 = remote_class->xdomain_vtable;
  return D.22274;
  <D.22262>:
  D.22275 = remote_class->default_vtable;
  if (D.22275 == 0B) goto <D.22276>; else goto <D.22277>;
  <D.22276>:
  {
    struct MonoType * type;
    struct MonoClass * klass;

    D.22278 = rp->class_to_proxy;
    type = D.22278->type;
    klass = mono_class_from_mono_type (type);
    D.22282 = BIT_FIELD_REF <*klass, 32, 160>;
    D.22283 = D.22282 & 1073741824;
    if (D.22283 != 0) goto <D.22279>; else goto <D.22284>;
    <D.22284>:
    D.22285 = mono_class_get_com_object_class ();
    if (D.22285 != 0B) goto <D.22286>; else goto <D.22280>;
    <D.22286>:
    D.22287 = mono_class_get_com_object_class ();
    if (D.22287 == klass) goto <D.22279>; else goto <D.22280>;
    <D.22279>:
    D.22288 = mono_domain_get ();
    D.22289 = mono_class_vtable (D.22288, klass);
    D.22290 = BIT_FIELD_REF <*D.22289, 32, 160>;
    D.22291 = D.22290 & 16777216;
    if (D.22291 == 0) goto <D.22292>; else goto <D.22280>;
    <D.22292>:
    D.22293 = mono_class_proxy_vtable (domain, remote_class, 2);
    remote_class->default_vtable = D.22293;
    goto <D.22281>;
    <D.22280>:
    D.22294 = mono_class_proxy_vtable (domain, remote_class, 0);
    remote_class->default_vtable = D.22294;
    <D.22281>:
  }
  <D.22277>:
  {
    int ret;

    D.22252 = &domain->lock.mutex;
    ret = pthread_mutex_unlock (D.22252);
    if (ret != 0) goto <D.22295>; else goto <D.22296>;
    <D.22295>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.22296>:
    D.22297 = ret != 0;
    D.22298 = (long int) D.22297;
    D.22299 = __builtin_expect (D.22298, 0);
    if (D.22299 != 0) goto <D.22300>; else goto <D.22301>;
    <D.22300>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 2638, "ret == 0");
    <D.22301>:
  }
  mono_loader_unlock ();
  D.22274 = remote_class->default_vtable;
  return D.22274;
}


mono_class_proxy_vtable (struct MonoDomain * domain, struct MonoRemoteClass * remote_class, MonoRemotingTarget target_type)
{
  _Bool D.22303;
  long int D.22304;
  long int D.22305;
  short unsigned int D.22308;
  short unsigned int D.22309;
  short unsigned int D.22310;
  guint8 * D.22313;
  short unsigned int D.22314;
  sizetype D.22315;
  guint8 * D.22316;
  unsigned char D.22317;
  int D.22318;
  int D.22319;
  int D.22320;
  int D.22321;
  int D.22322;
  struct GSList * D.22325;
  int D.22328;
  _Bool D.22329;
  long int D.22330;
  long int D.22331;
  void * * D.22336;
  unsigned int i.103;
  unsigned int D.22338;
  void * * D.22339;
  short unsigned int D.22340;
  short unsigned int D.22343;
  sizetype D.22344;
  guint8 * D.22345;
  unsigned char D.22346;
  int D.22347;
  int D.22348;
  int D.22349;
  int D.22350;
  int D.22351;
  struct GSList * D.22354;
  int D.22357;
  unsigned int i.104;
  unsigned int D.22359;
  unsigned int method_count.105;
  unsigned int D.22361;
  unsigned int extra_interface_vtsize.106;
  unsigned int D.22363;
  short unsigned int D.22364;
  int D.22365;
  unsigned int j.107;
  unsigned int D.22369;
  void * (*<T26de>) (struct MonoVTable *, struct MonoDomain *, struct MonoIMTCheckItem * *, int, void *) imt_thunk_builder.108;
  long unsigned int D.22373;
  long unsigned int D.22374;
  long unsigned int D.22375;
  long unsigned int D.22376;
  int D.22377;
  unsigned int D.22378;
  unsigned int D.22379;
  unsigned int D.22380;
  unsigned int max_interface_id.109;
  unsigned int D.22383;
  unsigned int D.22384;
  unsigned int D.22385;
  long unsigned int D.22386;
  int D.22387;
  long unsigned int D.22388;
  long unsigned int D.22389;
  unsigned int D.22390;
  sizetype max_interface_id.110;
  sizetype D.22395;
  sizetype D.22396;
  unsigned int D.22397;
  unsigned int D.22398;
  struct MonoClass * D.22399;
  void * D.22400;
  struct MonoMethod * * D.22401;
  struct MonoMethod * * D.22402;
  void * (*<T1d20>) (struct MonoDomain *, struct MonoMethod *, MonoRemotingTarget) arch_create_remoting_trampoline.111;
  void * D.22406;
  unsigned int D.22408;
  unsigned int D.22409;
  short int D.22412;
  int D.22413;
  void * D.22414;
  void * D.22417;
  short unsigned int D.22418;
  int D.22419;
  unsigned int bsize.112;
  struct MonoClass * * D.22423;
  struct MonoClass * * D.22424;
  struct MonoClass * D.22425;
  short unsigned int D.22426;
  guint16 * D.22427;
  unsigned int D.22428;
  guint16 * D.22429;
  short unsigned int D.22430;
  int D.22431;
  int D.22432;
  unsigned int D.22433;
  unsigned int D.22434;
  void * * D.22435;
  void * * D.22436;
  short unsigned int D.22437;
  int D.22438;
  int D.22439;
  sizetype D.22440;
  uint8_t * D.22441;
  unsigned char D.22442;
  signed char D.22443;
  int D.22444;
  int D.22445;
  signed char D.22446;
  signed char D.22447;
  unsigned char D.22448;
  short unsigned int D.22453;
  int D.22454;
  int D.22455;
  unsigned int D.22456;
  unsigned int D.22457;
  void * * D.22458;
  void * * D.22459;
  short unsigned int D.22460;
  sizetype D.22461;
  uint8_t * D.22462;
  unsigned char D.22463;
  signed char D.22464;
  int D.22465;
  int D.22466;
  signed char D.22467;
  signed char D.22468;
  unsigned char D.22469;
  int j.113;
  int D.22471;
  void * D.22472;
  int D.22473;
  struct MonoVTable * D.22480;
  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.22303 = vt == 0B;
      D.22304 = (long int) D.22303;
      D.22305 = __builtin_expect (D.22304, 0);
      if (D.22305 != 0) goto <D.22306>; else goto <D.22307>;
      <D.22306>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 2215, "vt");
      <D.22307>:
      D.22308 = vt->max_interface_id;
      max_interface_id = (int) D.22308;
      j = 0;
      goto <D.19198>;
      <D.19197>:
      {
        struct MonoClass * iclass;
        struct GPtrArray * ifaces;
        int method_count;

        iclass = remote_class->interfaces[j];
        D.22309 = iclass->interface_id;
        D.22310 = class->max_interface_id;
        if (D.22309 <= D.22310) goto <D.22311>; else goto <D.22312>;
        <D.22311>:
        D.22313 = class->interface_bitmap;
        D.22309 = iclass->interface_id;
        D.22314 = D.22309 >> 3;
        D.22315 = (sizetype) D.22314;
        D.22316 = D.22313 + D.22315;
        D.22317 = *D.22316;
        D.22318 = (int) D.22317;
        D.22309 = iclass->interface_id;
        D.22319 = (int) D.22309;
        D.22320 = D.22319 & 7;
        D.22321 = D.22318 >> D.22320;
        D.22322 = D.22321 & 1;
        if (D.22322 != 0) goto <D.22323>; else goto <D.22324>;
        <D.22323>:
        // predicted unlikely by continue predictor.
        goto <D.19191>;
        <D.22324>:
        <D.22312>:
        D.22325 = monoeg_g_slist_find (extra_interfaces, iclass);
        if (D.22325 != 0B) goto <D.22326>; else goto <D.22327>;
        <D.22326>:
        // predicted unlikely by continue predictor.
        goto <D.19191>;
        <D.22327>:
        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.22328 = mono_error_ok (&error);
        D.22329 = D.22328 == 0;
        D.22330 = (long int) D.22329;
        D.22331 = __builtin_expect (D.22330, 0);
        if (D.22331 != 0) goto <D.22332>; else goto <D.22333>;
        <D.22332>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 2235, "mono_error_ok (&error)");
        <D.22333>:
        if (ifaces != 0B) goto <D.22334>; else goto <D.22335>;
        <D.22334>:
        i = 0;
        goto <D.19195>;
        <D.19194>:
        {
          struct MonoClass * ic;

          D.22336 = ifaces->pdata;
          i.103 = (unsigned int) i;
          D.22338 = i.103 * 4;
          D.22339 = D.22336 + D.22338;
          ic = *D.22339;
          D.22340 = ic->interface_id;
          D.22310 = class->max_interface_id;
          if (D.22340 <= D.22310) goto <D.22341>; else goto <D.22342>;
          <D.22341>:
          D.22313 = class->interface_bitmap;
          D.22340 = ic->interface_id;
          D.22343 = D.22340 >> 3;
          D.22344 = (sizetype) D.22343;
          D.22345 = D.22313 + D.22344;
          D.22346 = *D.22345;
          D.22347 = (int) D.22346;
          D.22340 = ic->interface_id;
          D.22348 = (int) D.22340;
          D.22349 = D.22348 & 7;
          D.22350 = D.22347 >> D.22349;
          D.22351 = D.22350 & 1;
          if (D.22351 != 0) goto <D.22352>; else goto <D.22353>;
          <D.22352>:
          // predicted unlikely by continue predictor.
          goto <D.19193>;
          <D.22353>:
          <D.22342>:
          D.22354 = monoeg_g_slist_find (extra_interfaces, ic);
          if (D.22354 != 0B) goto <D.22355>; else goto <D.22356>;
          <D.22355>:
          // predicted unlikely by continue predictor.
          goto <D.19193>;
          <D.22356>:
          extra_interfaces = monoeg_g_slist_prepend (extra_interfaces, ic);
          D.22357 = mono_class_num_methods (ic);
          method_count = D.22357 + method_count;
        }
        <D.19193>:
        i = i + 1;
        <D.19195>:
        i.104 = (unsigned int) i;
        D.22359 = ifaces->len;
        if (i.104 < D.22359) goto <D.19194>; else goto <D.19196>;
        <D.19196>:
        monoeg_g_ptr_array_free (ifaces, 1);
        <D.22335>:
        method_count.105 = (unsigned int) method_count;
        D.22361 = method_count.105 * 4;
        extra_interface_vtsize.106 = (unsigned int) extra_interface_vtsize;
        D.22363 = D.22361 + extra_interface_vtsize.106;
        extra_interface_vtsize = (int) D.22363;
        D.22364 = iclass->max_interface_id;
        D.22365 = (int) D.22364;
        if (D.22365 > max_interface_id) goto <D.22366>; else goto <D.22367>;
        <D.22366>:
        D.22364 = iclass->max_interface_id;
        max_interface_id = (int) D.22364;
        <D.22367>:
      }
      <D.19191>:
      j = j + 1;
      <D.19198>:
      j.107 = (unsigned int) j;
      D.22369 = remote_class->interface_count;
      if (j.107 < D.22369) goto <D.19197>; else goto <D.19199>;
      <D.19199>:
      imt_thunk_builder.108 = imt_thunk_builder;
      if (imt_thunk_builder.108 != 0B) goto <D.22371>; else goto <D.22372>;
      <D.22371>:
      D.22373 = mono_stats.imt_number_of_tables;
      D.22374 = D.22373 + 1;
      mono_stats.imt_number_of_tables = D.22374;
      D.22375 = mono_stats.imt_tables_size;
      D.22376 = D.22375 + 76;
      mono_stats.imt_tables_size = D.22376;
      D.22377 = class->vtable_size;
      D.22378 = (unsigned int) D.22377;
      D.22379 = D.22378 + 27;
      D.22380 = D.22379 * 4;
      vtsize = (int) D.22380;
      goto <D.22381>;
      <D.22372>:
      D.22377 = class->vtable_size;
      D.22378 = (unsigned int) D.22377;
      max_interface_id.109 = (unsigned int) max_interface_id;
      D.22383 = D.22378 + max_interface_id.109;
      D.22384 = D.22383 + 9;
      D.22385 = D.22384 * 4;
      vtsize = (int) D.22385;
      <D.22381>:
      D.22386 = mono_stats.class_vtable_size;
      D.22387 = vtsize + extra_interface_vtsize;
      D.22388 = (long unsigned int) D.22387;
      D.22389 = D.22386 + D.22388;
      mono_stats.class_vtable_size = D.22389;
      D.22387 = vtsize + extra_interface_vtsize;
      D.22390 = (unsigned int) D.22387;
      interface_offsets = mono_domain_alloc0 (domain, D.22390);
      imt_thunk_builder.108 = imt_thunk_builder;
      if (imt_thunk_builder.108 != 0B) goto <D.22391>; else goto <D.22392>;
      <D.22391>:
      pvt = interface_offsets + 76;
      goto <D.22393>;
      <D.22392>:
      max_interface_id.110 = (sizetype) max_interface_id;
      D.22395 = max_interface_id.110 + 1;
      D.22396 = D.22395 * 4;
      pvt = interface_offsets + D.22396;
      <D.22393>:
      D.22377 = class->vtable_size;
      D.22378 = (unsigned int) D.22377;
      D.22397 = D.22378 + 8;
      D.22398 = D.22397 * 4;
      memcpy (pvt, vt, D.22398);
      D.22399 = mono_defaults.transparent_proxy_class;
      pvt->klass = D.22399;
      D.22399 = mono_defaults.transparent_proxy_class;
      D.22400 = D.22399->gc_descr;
      pvt->gc_descr = D.22400;
      mono_class_setup_vtable (class);
      i = 0;
      goto <D.19202>;
      <D.19201>:
      {
        struct MonoMethod * cm;

        D.22401 = class->vtable;
        i.103 = (unsigned int) i;
        D.22338 = i.103 * 4;
        D.22402 = D.22401 + D.22338;
        cm = *D.22402;
        if (cm != 0B) goto <D.22403>; else goto <D.22404>;
        <D.22403>:
        arch_create_remoting_trampoline.111 = arch_create_remoting_trampoline;
        D.22406 = arch_create_remoting_trampoline.111 (domain, cm, target_type);
        pvt->vtable[i] = D.22406;
        goto <D.22407>;
        <D.22404>:
        pvt->vtable[i] = 0B;
        <D.22407>:
      }
      i = i + 1;
      <D.19202>:
      D.22377 = class->vtable_size;
      if (D.22377 > i) goto <D.19201>; else goto <D.19203>;
      <D.19203>:
      D.22408 = class->flags;
      D.22409 = D.22408 & 128;
      if (D.22409 != 0) goto <D.22410>; else goto <D.22411>;
      <D.22410>:
      k = class;
      goto <D.19210>;
      <D.19209>:
      {
        struct MonoMethod * m;
        void * iter;

        try
          {
            iter = 0B;
            goto <D.19207>;
            <D.19206>:
            D.22412 = m->slot;
            D.22413 = (int) D.22412;
            D.22414 = pvt->vtable[D.22413];
            if (D.22414 == 0B) goto <D.22415>; else goto <D.22416>;
            <D.22415>:
            D.22412 = m->slot;
            D.22413 = (int) D.22412;
            arch_create_remoting_trampoline.111 = arch_create_remoting_trampoline;
            D.22417 = arch_create_remoting_trampoline.111 (domain, m, target_type);
            pvt->vtable[D.22413] = D.22417;
            <D.22416>:
            <D.19207>:
            m = mono_class_get_methods (k, &iter);
            if (m != 0B) goto <D.19206>; else goto <D.19208>;
            <D.19208>:
          }
        finally
          {
            iter = {CLOBBER};
          }
      }
      k = k->parent;
      <D.19210>:
      if (k != 0B) goto <D.19209>; else goto <D.19211>;
      <D.19211>:
      <D.22411>:
      D.22418 = (short unsigned int) max_interface_id;
      pvt->max_interface_id = D.22418;
      D.22419 = max_interface_id / 8;
      bsize = D.22419 + 1;
      bsize.112 = (unsigned int) bsize;
      bitmap = mono_domain_alloc0 (domain, bsize.112);
      imt_thunk_builder.108 = imt_thunk_builder;
      if (imt_thunk_builder.108 == 0B) goto <D.22421>; else goto <D.22422>;
      <D.22421>:
      i = 0;
      goto <D.19215>;
      <D.19214>:
      {
        int interface_id;
        int slot;

        D.22423 = class->interfaces_packed;
        i.103 = (unsigned int) i;
        D.22338 = i.103 * 4;
        D.22424 = D.22423 + D.22338;
        D.22425 = *D.22424;
        D.22426 = D.22425->interface_id;
        interface_id = (int) D.22426;
        D.22427 = class->interface_offsets_packed;
        i.103 = (unsigned int) i;
        D.22428 = i.103 * 2;
        D.22429 = D.22427 + D.22428;
        D.22430 = *D.22429;
        slot = (int) D.22430;
        D.22310 = class->max_interface_id;
        D.22431 = (int) D.22310;
        D.22432 = D.22431 - interface_id;
        D.22433 = (unsigned int) D.22432;
        D.22434 = D.22433 * 4;
        D.22435 = interface_offsets + D.22434;
        D.22436 = &pvt->vtable[slot];
        *D.22435 = D.22436;
      }
      i = i + 1;
      <D.19215>:
      D.22437 = class->interface_offsets_count;
      D.22438 = (int) D.22437;
      if (D.22438 > i) goto <D.19214>; else goto <D.19216>;
      <D.19216>:
      <D.22422>:
      i = 0;
      goto <D.19219>;
      <D.19218>:
      {
        int interface_id;

        D.22423 = class->interfaces_packed;
        i.103 = (unsigned int) i;
        D.22338 = i.103 * 4;
        D.22424 = D.22423 + D.22338;
        D.22425 = *D.22424;
        D.22426 = D.22425->interface_id;
        interface_id = (int) D.22426;
        D.22439 = interface_id >> 3;
        D.22440 = (sizetype) D.22439;
        D.22441 = bitmap + D.22440;
        D.22439 = interface_id >> 3;
        D.22440 = (sizetype) D.22439;
        D.22441 = bitmap + D.22440;
        D.22442 = *D.22441;
        D.22443 = (signed char) D.22442;
        D.22444 = interface_id & 7;
        D.22445 = 1 << D.22444;
        D.22446 = (signed char) D.22445;
        D.22447 = D.22443 | D.22446;
        D.22448 = (unsigned char) D.22447;
        *D.22441 = D.22448;
      }
      i = i + 1;
      <D.19219>:
      D.22437 = class->interface_offsets_count;
      D.22438 = (int) D.22437;
      if (D.22438 > i) goto <D.19218>; else goto <D.19220>;
      <D.19220>:
      if (extra_interfaces != 0B) goto <D.22449>; else goto <D.22450>;
      <D.22449>:
      {
        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.19230>;
            <D.19229>:
            interf = list_item->data;
            imt_thunk_builder.108 = imt_thunk_builder;
            if (imt_thunk_builder.108 == 0B) goto <D.22451>; else goto <D.22452>;
            <D.22451>:
            D.22453 = interf->interface_id;
            D.22454 = (int) D.22453;
            D.22455 = max_interface_id - D.22454;
            D.22456 = (unsigned int) D.22455;
            D.22457 = D.22456 * 4;
            D.22458 = interface_offsets + D.22457;
            D.22459 = &pvt->vtable[slot];
            *D.22458 = D.22459;
            <D.22452>:
            D.22453 = interf->interface_id;
            D.22460 = D.22453 >> 3;
            D.22461 = (sizetype) D.22460;
            D.22462 = bitmap + D.22461;
            D.22453 = interf->interface_id;
            D.22460 = D.22453 >> 3;
            D.22461 = (sizetype) D.22460;
            D.22462 = bitmap + D.22461;
            D.22463 = *D.22462;
            D.22464 = (signed char) D.22463;
            D.22453 = interf->interface_id;
            D.22454 = (int) D.22453;
            D.22465 = D.22454 & 7;
            D.22466 = 1 << D.22465;
            D.22467 = (signed char) D.22466;
            D.22468 = D.22464 | D.22467;
            D.22469 = (unsigned char) D.22468;
            *D.22462 = D.22469;
            iter = 0B;
            j = 0;
            goto <D.19227>;
            <D.19226>:
            j.113 = j;
            j = j.113 + 1;
            D.22471 = j.113 + slot;
            arch_create_remoting_trampoline.111 = arch_create_remoting_trampoline;
            D.22472 = arch_create_remoting_trampoline.111 (domain, cm, target_type);
            pvt->vtable[D.22471] = D.22472;
            <D.19227>:
            cm = mono_class_get_methods (interf, &iter);
            if (cm != 0B) goto <D.19226>; else goto <D.19228>;
            <D.19228>:
            D.22473 = mono_class_num_methods (interf);
            slot = D.22473 + slot;
            list_item = list_item->next;
            <D.19230>:
            if (list_item != 0B) goto <D.19229>; else goto <D.19231>;
            <D.19231>:
            imt_thunk_builder.108 = imt_thunk_builder;
            if (imt_thunk_builder.108 == 0B) goto <D.22474>; else goto <D.22475>;
            <D.22474>:
            monoeg_g_slist_free (extra_interfaces);
            <D.22475>:
          }
        finally
          {
            iter = {CLOBBER};
          }
      }
      <D.22450>:
      imt_thunk_builder.108 = imt_thunk_builder;
      if (imt_thunk_builder.108 != 0B) goto <D.22476>; else goto <D.22477>;
      <D.22476>:
      build_imt (class, pvt, domain, interface_offsets, extra_interfaces);
      if (extra_interfaces != 0B) goto <D.22478>; else goto <D.22479>;
      <D.22478>:
      monoeg_g_slist_free (extra_interfaces);
      <D.22479>:
      <D.22477>:
      pvt->interface_bitmap = bitmap;
      D.22480 = pvt;
      return D.22480;
    }
  finally
    {
      error = {CLOBBER};
    }
}


mono_upgrade_remote_class (struct MonoDomain * domain, struct MonoObject * proxy_object, struct MonoClass * klass)
{
  union mono_mutex_t * D.22483;
  _Bool D.22486;
  long int D.22487;
  long int D.22488;
  unsigned int D.22491;
  unsigned int D.22492;
  struct MonoClass * D.22495;
  unsigned int i.114;
  unsigned int D.22499;
  struct MonoClass * D.22502;
  _Bool D.22503;
  struct MonoRemoteClass * D.22506;
  struct MonoRemoteClass * D.22507;
  struct MonoRealProxy * D.22508;
  void * D.22509;
  _Bool D.22512;
  long int D.22513;
  long int D.22514;
  struct MonoTransparentProxy * tproxy;
  struct MonoRemoteClass * remote_class;
  gboolean redo_vtable;

  mono_loader_lock ();
  {
    int ret;

    D.22483 = &domain->lock.mutex;
    ret = pthread_mutex_lock (D.22483);
    if (ret != 0) goto <D.22484>; else goto <D.22485>;
    <D.22484>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.22485>:
    D.22486 = ret != 0;
    D.22487 = (long int) D.22486;
    D.22488 = __builtin_expect (D.22487, 0);
    if (D.22488 != 0) goto <D.22489>; else goto <D.22490>;
    <D.22489>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 2661, "ret == 0");
    <D.22490>:
  }
  tproxy = proxy_object;
  remote_class = tproxy->remote_class;
  D.22491 = klass->flags;
  D.22492 = D.22491 & 32;
  if (D.22492 != 0) goto <D.22493>; else goto <D.22494>;
  <D.22493>:
  {
    int i;

    redo_vtable = 1;
    i = 0;
    goto <D.19331>;
    <D.19330>:
    D.22495 = remote_class->interfaces[i];
    if (D.22495 == klass) goto <D.22496>; else goto <D.22497>;
    <D.22496>:
    redo_vtable = 0;
    <D.22497>:
    i = i + 1;
    <D.19331>:
    i.114 = (unsigned int) i;
    D.22499 = remote_class->interface_count;
    if (i.114 < D.22499) goto <D.22500>; else goto <D.19332>;
    <D.22500>:
    if (redo_vtable != 0) goto <D.19330>; else goto <D.19332>;
    <D.19332>:
  }
  goto <D.22501>;
  <D.22494>:
  D.22502 = remote_class->proxy_class;
  D.22503 = D.22502 != klass;
  redo_vtable = (gboolean) D.22503;
  <D.22501>:
  if (redo_vtable != 0) goto <D.22504>; else goto <D.22505>;
  <D.22504>:
  D.22506 = clone_remote_class (domain, remote_class, klass);
  tproxy->remote_class = D.22506;
  D.22507 = tproxy->remote_class;
  D.22508 = tproxy->rp;
  D.22509 = mono_remote_class_vtable (domain, D.22507, D.22508);
  proxy_object->vtable = D.22509;
  <D.22505>:
  {
    int ret;

    D.22483 = &domain->lock.mutex;
    ret = pthread_mutex_unlock (D.22483);
    if (ret != 0) goto <D.22510>; else goto <D.22511>;
    <D.22510>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.22511>:
    D.22512 = ret != 0;
    D.22513 = (long int) D.22512;
    D.22514 = __builtin_expect (D.22513, 0);
    if (D.22514 != 0) goto <D.22515>; else goto <D.22516>;
    <D.22515>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 2682, "ret == 0");
    <D.22516>:
  }
  mono_loader_unlock ();
}


clone_remote_class (struct MonoDomain * domain, struct MonoRemoteClass * remote_class, struct MonoClass * extra_class)
{
  struct GHashTable * D.22517;
  struct MonoRemoteClass * D.22520;
  unsigned int D.22521;
  unsigned int D.22522;
  unsigned int D.22525;
  unsigned int D.22526;
  unsigned int D.22527;
  struct MonoClass * D.22528;
  unsigned int D.22529;
  struct MonoClass * D.22530;
  int j.115;
  unsigned int i.116;
  unsigned int D.22540;
  unsigned int D.22541;
  unsigned int D.22542;
  struct MonoClass *[0:] * D.22545;
  struct MonoClass *[0:] * D.22546;
  unsigned int D.22547;
  char * D.22548;
  struct MonoRemoteClass * rc;
  void * * key;
  void * * mp_key;

  key = create_remote_class_key (remote_class, extra_class);
  D.22517 = domain->proxy_vtable_hash;
  rc = monoeg_g_hash_table_lookup (D.22517, key);
  if (rc != 0B) goto <D.22518>; else goto <D.22519>;
  <D.22518>:
  monoeg_g_free (key);
  D.22520 = rc;
  return D.22520;
  <D.22519>:
  mp_key = copy_remote_class_key (domain, key);
  monoeg_g_free (key);
  key = mp_key;
  D.22521 = extra_class->flags;
  D.22522 = D.22521 & 32;
  if (D.22522 != 0) goto <D.22523>; else goto <D.22524>;
  <D.22523>:
  {
    int i;
    int j;

    D.22525 = remote_class->interface_count;
    D.22526 = D.22525 + 6;
    D.22527 = D.22526 * 4;
    rc = mono_domain_alloc (domain, D.22527);
    D.22528 = remote_class->proxy_class;
    rc->proxy_class = D.22528;
    D.22525 = remote_class->interface_count;
    D.22529 = D.22525 + 1;
    rc->interface_count = D.22529;
    i = 0;
    j = 0;
    goto <D.19308>;
    <D.19307>:
    D.22530 = remote_class->interfaces[i];
    if (D.22530 > extra_class) goto <D.22531>; else goto <D.22532>;
    <D.22531>:
    if (i == j) goto <D.22533>; else goto <D.22534>;
    <D.22533>:
    j.115 = j;
    j = j.115 + 1;
    rc->interfaces[j.115] = extra_class;
    <D.22534>:
    <D.22532>:
    D.22530 = remote_class->interfaces[i];
    rc->interfaces[j] = D.22530;
    i = i + 1;
    j = j + 1;
    <D.19308>:
    i.116 = (unsigned int) i;
    D.22525 = remote_class->interface_count;
    if (i.116 < D.22525) goto <D.19307>; else goto <D.19309>;
    <D.19309>:
    if (i == j) goto <D.22537>; else goto <D.22538>;
    <D.22537>:
    rc->interfaces[j] = extra_class;
    <D.22538>:
  }
  goto <D.22539>;
  <D.22524>:
  D.22525 = remote_class->interface_count;
  D.22540 = D.22525 + 5;
  D.22541 = D.22540 * 4;
  rc = mono_domain_alloc (domain, D.22541);
  rc->proxy_class = extra_class;
  D.22525 = remote_class->interface_count;
  rc->interface_count = D.22525;
  D.22542 = rc->interface_count;
  if (D.22542 != 0) goto <D.22543>; else goto <D.22544>;
  <D.22543>:
  D.22545 = &rc->interfaces;
  D.22546 = &remote_class->interfaces;
  D.22542 = rc->interface_count;
  D.22547 = D.22542 * 4;
  memcpy (D.22545, D.22546, D.22547);
  <D.22544>:
  <D.22539>:
  rc->default_vtable = 0B;
  rc->xdomain_vtable = 0B;
  D.22548 = remote_class->proxy_class_name;
  rc->proxy_class_name = D.22548;
  D.22517 = domain->proxy_vtable_hash;
  monoeg_g_hash_table_insert_replace (D.22517, key, rc, 0);
  D.22520 = rc;
  return D.22520;
}


mono_object_get_virtual_method (struct MonoObject * obj, struct MonoMethod * method)
{
  struct MonoVTable * D.22550;
  struct MonoClass * D.22551;
  struct MonoRemoteClass * D.22554;
  short unsigned int D.22557;
  unsigned int D.22558;
  unsigned int D.22559;
  struct MonoMethod * D.22562;
  short int D.22563;
  unsigned int D.22566;
  unsigned int D.22567;
  struct MonoMethod * D.22570;
  short int D.22571;
  _Bool D.22572;
  long int D.22573;
  long int D.22574;
  struct MonoClass * D.22582;
  unsigned int D.22583;
  unsigned int D.22584;
  _Bool D.22589;
  long int D.22590;
  long int D.22591;
  int D.22594;
  int D.22595;
  unsigned int D.22596;
  unsigned int D.22597;
  struct MonoMethod * * D.22598;
  unsigned int D.22600;
  unsigned int D.22601;
  struct MonoMethod * * D.22602;
  struct MonoMethodSignature * D.22608;
  short unsigned int D.22609;
  struct MonoMethodSignature * D.22610;
  short unsigned int D.22611;
  struct MonoClass * D.22618;
  unsigned int D.22620;
  unsigned int D.22621;
  struct MonoGenericContext * D.22625;
  _Bool D.22626;
  long int D.22627;
  long int D.22628;
  struct MonoClass * klass;
  struct MonoMethod * * vtable;
  gboolean is_proxy;
  struct MonoMethod * res;

  is_proxy = 0;
  res = 0B;
  D.22550 = obj->vtable;
  klass = D.22550->klass;
  D.22551 = mono_defaults.transparent_proxy_class;
  if (D.22551 == klass) goto <D.22552>; else goto <D.22553>;
  <D.22552>:
  D.22554 = MEM[(struct MonoTransparentProxy *)obj].remote_class;
  klass = D.22554->proxy_class;
  is_proxy = 1;
  <D.22553>:
  if (is_proxy == 0) goto <D.22555>; else goto <D.22556>;
  <D.22555>:
  D.22557 = method->flags;
  D.22558 = (unsigned int) D.22557;
  D.22559 = D.22558 & 96;
  if (D.22559 != 64) goto <D.22560>; else goto <D.22561>;
  <D.22560>:
  D.22562 = method;
  return D.22562;
  <D.22561>:
  <D.22556>:
  mono_class_setup_vtable (klass);
  vtable = klass->vtable;
  D.22563 = method->slot;
  if (D.22563 == -1) goto <D.22564>; else goto <D.22565>;
  <D.22564>:
  D.22566 = BIT_FIELD_REF <*method, 32, 160>;
  D.22567 = D.22566 & 4096;
  if (D.22567 != 0) goto <D.22568>; else goto <D.22569>;
  <D.22568>:
  D.22570 = MEM[(struct MonoMethodInflated *)method].declaring;
  D.22571 = D.22570->slot;
  D.22572 = D.22571 == -1;
  D.22573 = (long int) D.22572;
  D.22574 = __builtin_expect (D.22573, 0);
  if (D.22574 != 0) goto <D.22575>; else goto <D.22576>;
  <D.22575>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 2721, "((MonoMethodInflated*)method)->declaring->slot != -1");
  <D.22576>:
  D.22570 = MEM[(struct MonoMethodInflated *)method].declaring;
  D.22571 = D.22570->slot;
  method->slot = D.22571;
  goto <D.22577>;
  <D.22569>:
  if (is_proxy == 0) goto <D.22578>; else goto <D.22579>;
  <D.22578>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "object.c", 2725);
  <D.22579>:
  <D.22577>:
  <D.22565>:
  D.22563 = method->slot;
  if (D.22563 != -1) goto <D.22580>; else goto <D.22581>;
  <D.22580>:
  D.22582 = method->klass;
  D.22583 = D.22582->flags;
  D.22584 = D.22583 & 32;
  if (D.22584 != 0) goto <D.22585>; else goto <D.22586>;
  <D.22585>:
  if (is_proxy == 0) goto <D.22587>; else goto <D.22588>;
  <D.22587>:
  {
    gboolean variance_used;
    int iface_offset;

    try
      {
        variance_used = 0;
        D.22582 = method->klass;
        iface_offset = mono_class_interface_offset_with_variance (klass, D.22582, &variance_used);
        D.22589 = iface_offset <= 0;
        D.22590 = (long int) D.22589;
        D.22591 = __builtin_expect (D.22590, 0);
        if (D.22591 != 0) goto <D.22592>; else goto <D.22593>;
        <D.22592>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 2735, "iface_offset > 0");
        <D.22593>:
        D.22563 = method->slot;
        D.22594 = (int) D.22563;
        D.22595 = D.22594 + iface_offset;
        D.22596 = (unsigned int) D.22595;
        D.22597 = D.22596 * 4;
        D.22598 = vtable + D.22597;
        res = *D.22598;
      }
    finally
      {
        variance_used = {CLOBBER};
      }
  }
  <D.22588>:
  goto <D.22599>;
  <D.22586>:
  D.22563 = method->slot;
  D.22600 = (unsigned int) D.22563;
  D.22601 = D.22600 * 4;
  D.22602 = vtable + D.22601;
  res = *D.22602;
  <D.22599>:
  <D.22581>:
  if (is_proxy != 0) goto <D.22603>; else goto <D.22604>;
  <D.22603>:
  if (res == 0B) goto <D.22605>; else goto <D.22607>;
  <D.22607>:
  D.22608 = mono_method_signature (res);
  D.22609 = D.22608->generic_param_count;
  if (D.22609 != 0) goto <D.22605>; else goto <D.22606>;
  <D.22605>:
  res = method;
  <D.22606>:
  D.22610 = mono_method_signature (res);
  D.22611 = D.22610->generic_param_count;
  if (D.22611 != 0) goto <D.22612>; else goto <D.22613>;
  <D.22612>:
  res = mono_marshal_get_remoting_invoke_with_check (res);
  goto <D.22614>;
  <D.22613>:
  D.22618 = mono_class_get_com_object_class ();
  if (D.22618 == klass) goto <D.22615>; else goto <D.22619>;
  <D.22619>:
  D.22620 = BIT_FIELD_REF <*klass, 32, 160>;
  D.22621 = D.22620 & 1073741824;
  if (D.22621 != 0) goto <D.22615>; else goto <D.22616>;
  <D.22615>:
  res = mono_cominterop_get_invoke (res);
  goto <D.22617>;
  <D.22616>:
  res = mono_marshal_get_remoting_invoke (res);
  <D.22617>:
  <D.22614>:
  goto <D.22622>;
  <D.22604>:
  D.22566 = BIT_FIELD_REF <*method, 32, 160>;
  D.22567 = D.22566 & 4096;
  if (D.22567 != 0) goto <D.22623>; else goto <D.22624>;
  <D.22623>:
  D.22625 = &MEM[(struct MonoMethodInflated *)method].context;
  res = mono_class_inflate_generic_method (res, D.22625);
  <D.22624>:
  <D.22622>:
  D.22626 = res == 0B;
  D.22627 = (long int) D.22626;
  D.22628 = __builtin_expect (D.22627, 0);
  if (D.22628 != 0) goto <D.22629>; else goto <D.22630>;
  <D.22629>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 2769, "res");
  <D.22630>:
  D.22562 = res;
  return D.22562;
}


mono_runtime_invoke (struct MonoMethod * method, void * obj, void * * params, struct MonoObject * * exc)
{
  int D.22632;
  char * D.22635;
  <unnamed type> D.22636;
  unsigned int D.22637;
  struct MonoObject * (*<T11ad>) (struct MonoMethod *, void *, void * *, struct MonoObject * *) default_mono_runtime_invoke.117;
  <unnamed type> D.22641;
  unsigned int D.22642;
  struct MonoObject * D.22645;
  struct MonoObject * result;

  D.22632 = mono_runtime_get_no_exec ();
  if (D.22632 != 0) goto <D.22633>; else goto <D.22634>;
  <D.22633>:
  D.22635 = mono_method_full_name (method, 1);
  monoeg_g_log (0B, 16, "Invoking method \'%s\' when running in no-exec mode.\n", D.22635);
  <D.22634>:
  D.22636 = mono_profiler_get_events ();
  D.22637 = D.22636 & 65536;
  if (D.22637 != 0) goto <D.22638>; else goto <D.22639>;
  <D.22638>:
  mono_profiler_method_start_invoke (method);
  <D.22639>:
  default_mono_runtime_invoke.117 = default_mono_runtime_invoke;
  result = default_mono_runtime_invoke.117 (method, obj, params, exc);
  D.22641 = mono_profiler_get_events ();
  D.22642 = D.22641 & 65536;
  if (D.22642 != 0) goto <D.22643>; else goto <D.22644>;
  <D.22643>:
  mono_profiler_method_end_invoke (method);
  <D.22644>:
  D.22645 = result;
  return D.22645;
}


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

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


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

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


mono_field_set_value (struct MonoObject * obj, struct MonoClassField * field, void * value)
{
  struct MonoType * D.22651;
  short unsigned int D.22652;
  int D.22653;
  int D.22654;
  int D.22657;
  sizetype D.22658;
  void * dest;

  D.22651 = field->type;
  D.22652 = D.22651->attrs;
  D.22653 = (int) D.22652;
  D.22654 = D.22653 & 16;
  if (D.22654 != 0) goto <D.22655>; else goto <D.22656>;
  <D.22655>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "object.c", 3003, "!(field->type->attrs & FIELD_ATTRIBUTE_STATIC)");
  return;
  <D.22656>:
  D.22657 = field->offset;
  D.22658 = (sizetype) D.22657;
  dest = obj + D.22658;
  D.22651 = field->type;
  set_value (D.22651, dest, value, 0);
}


set_value (struct MonoType * type, void * dest, void * value, int deref_pointer)
{
  unsigned int D.22660;
  unsigned int D.22661;
  unsigned char D.22664;
  guint8 iftmp.118;
  guint16 iftmp.119;
  int iftmp.120;
  gint64 iftmp.121;
  float iftmp.122;
  double iftmp.123;
  struct MonoObject * iftmp.124;
  void * iftmp.125;
  struct MonoClass * D.22699;
  unsigned int D.22700;
  unsigned int D.22701;
  struct MonoType * D.22703;
  unsigned char D.22704;
  unsigned int size.126;
  struct MonoGenericClass * D.22709;
  struct MonoClass * D.22710;
  unsigned char D.22711;
  int D.22712;
  int t;
  void handle_enum = <<< error >>>;

  D.22660 = BIT_FIELD_REF <*type, 32, 32>;
  D.22661 = D.22660 & 1073741824;
  if (D.22661 != 0) goto <D.22662>; else goto <D.22663>;
  <D.22662>:
  {
    void * * p;

    p = dest;
    *p = value;
    return;
  }
  <D.22663>:
  D.22664 = type->type;
  t = (int) D.22664;
  handle_enum:
  switch (t) <default: <D.19403>, case 2: <D.19371>, case 3: <D.19377>, case 4: <D.19372>, case 5: <D.19373>, case 6: <D.19375>, case 7: <D.19376>, case 8: <D.19381>, case 9: <D.19382>, case 10: <D.19384>, case 11: <D.19385>, case 12: <D.19387>, case 13: <D.19389>, case 14: <D.19391>, case 15: <D.19397>, case 17: <D.19399>, case 18: <D.19393>, case 20: <D.19395>, case 21: <D.19402>, case 24: <D.19379>, case 25: <D.19380>, case 27: <D.19396>, case 28: <D.19394>, case 29: <D.19392>>
  <D.19371>:
  <D.19372>:
  <D.19373>:
  {
    guint8 * p;

    p = dest;
    if (value != 0B) goto <D.22666>; else goto <D.22667>;
    <D.22666>:
    iftmp.118 = MEM[(guint8 *)value];
    goto <D.22668>;
    <D.22667>:
    iftmp.118 = 0;
    <D.22668>:
    *p = iftmp.118;
    return;
  }
  <D.19375>:
  <D.19376>:
  <D.19377>:
  {
    guint16 * p;

    p = dest;
    if (value != 0B) goto <D.22670>; else goto <D.22671>;
    <D.22670>:
    iftmp.119 = MEM[(guint16 *)value];
    goto <D.22672>;
    <D.22671>:
    iftmp.119 = 0;
    <D.22672>:
    *p = iftmp.119;
    return;
  }
  <D.19379>:
  <D.19380>:
  <D.19381>:
  <D.19382>:
  {
    gint32 * p;

    p = dest;
    if (value != 0B) goto <D.22674>; else goto <D.22675>;
    <D.22674>:
    iftmp.120 = MEM[(gint32 *)value];
    goto <D.22676>;
    <D.22675>:
    iftmp.120 = 0;
    <D.22676>:
    *p = iftmp.120;
    return;
  }
  <D.19384>:
  <D.19385>:
  {
    gint64 * p;

    p = dest;
    if (value != 0B) goto <D.22678>; else goto <D.22679>;
    <D.22678>:
    iftmp.121 = MEM[(gint64 *)value];
    goto <D.22680>;
    <D.22679>:
    iftmp.121 = 0;
    <D.22680>:
    *p = iftmp.121;
    return;
  }
  <D.19387>:
  {
    float * p;

    p = dest;
    if (value != 0B) goto <D.22682>; else goto <D.22683>;
    <D.22682>:
    iftmp.122 = MEM[(float *)value];
    goto <D.22684>;
    <D.22683>:
    iftmp.122 = 0.0;
    <D.22684>:
    *p = iftmp.122;
    return;
  }
  <D.19389>:
  {
    double * p;

    p = dest;
    if (value != 0B) goto <D.22686>; else goto <D.22687>;
    <D.22686>:
    iftmp.123 = MEM[(double *)value];
    goto <D.22688>;
    <D.22687>:
    iftmp.123 = 0.0;
    <D.22688>:
    *p = iftmp.123;
    return;
  }
  <D.19391>:
  <D.19392>:
  <D.19393>:
  <D.19394>:
  <D.19395>:
  if (deref_pointer != 0) goto <D.22690>; else goto <D.22691>;
  <D.22690>:
  iftmp.124 = MEM[(void * *)value];
  goto <D.22692>;
  <D.22691>:
  iftmp.124 = value;
  <D.22692>:
  mono_gc_wbarrier_generic_store (dest, iftmp.124);
  return;
  <D.19396>:
  <D.19397>:
  {
    void * * p;

    p = dest;
    if (deref_pointer != 0) goto <D.22694>; else goto <D.22695>;
    <D.22694>:
    iftmp.125 = MEM[(void * *)value];
    goto <D.22696>;
    <D.22695>:
    iftmp.125 = value;
    <D.22696>:
    *p = iftmp.125;
    return;
  }
  <D.19399>:
  D.22664 = type->type;
  if (D.22664 == 17) goto <D.22698>; else goto <D.22697>;
  <D.22698>:
  D.22699 = type->data.klass;
  D.22700 = BIT_FIELD_REF <*D.22699, 32, 160>;
  D.22701 = D.22700 & 16;
  if (D.22701 != 0) goto <D.22702>; else goto <D.22697>;
  <D.22702>:
  D.22699 = type->data.klass;
  D.22703 = mono_class_enum_basetype (D.22699);
  D.22704 = D.22703->type;
  t = (int) D.22704;
  goto handle_enum;
  <D.22697>:
  {
    struct MonoClass * class;
    int size;

    class = mono_class_from_mono_type (type);
    size = mono_class_value_size (class, 0B);
    if (value == 0B) goto <D.22705>; else goto <D.22706>;
    <D.22705>:
    size.126 = (unsigned int) size;
    mono_gc_bzero_atomic (dest, size.126);
    goto <D.22708>;
    <D.22706>:
    mono_gc_wbarrier_value_copy (dest, value, 1, class);
    <D.22708>:
  }
  return;
  <D.19402>:
  D.22709 = type->data.generic_class;
  D.22710 = D.22709->container_class;
  D.22711 = D.22710->byval_arg.type;
  t = (int) D.22711;
  goto handle_enum;
  <D.19403>:
  D.22664 = type->type;
  D.22712 = (int) D.22664;
  monoeg_g_log (0B, 4, "got type %x", D.22712);
  <D.19404>:
  goto <D.19404>;
}


mono_field_static_set_value (struct MonoVTable * vt, struct MonoClassField * field, void * value)
{
  struct MonoType * D.22714;
  short unsigned int D.22715;
  int D.22716;
  int D.22717;
  int D.22720;
  int D.22723;
  struct MonoDomain * D.22726;
  union mono_mutex_t * D.22727;
  _Bool D.22730;
  long int D.22731;
  long int D.22732;
  struct GHashTable * D.22735;
  _Bool D.22738;
  long int D.22739;
  long int D.22740;
  unsigned int addr.127;
  void * D.22745;
  sizetype D.22746;
  void * dest;

  D.22714 = field->type;
  D.22715 = D.22714->attrs;
  D.22716 = (int) D.22715;
  D.22717 = D.22716 & 16;
  if (D.22717 == 0) goto <D.22718>; else goto <D.22719>;
  <D.22718>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "object.c", 3024, "field->type->attrs & FIELD_ATTRIBUTE_STATIC");
  return;
  <D.22719>:
  D.22714 = field->type;
  D.22715 = D.22714->attrs;
  D.22716 = (int) D.22715;
  D.22720 = D.22716 & 64;
  if (D.22720 != 0) goto <D.22721>; else goto <D.22722>;
  <D.22721>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "object.c", 3026, "!(field->type->attrs & FIELD_ATTRIBUTE_LITERAL)");
  return;
  <D.22722>:
  D.22723 = field->offset;
  if (D.22723 == -1) goto <D.22724>; else goto <D.22725>;
  <D.22724>:
  {
    void * addr;

    {
      int ret;

      D.22726 = vt->domain;
      D.22727 = &D.22726->lock.mutex;
      ret = pthread_mutex_lock (D.22727);
      if (ret != 0) goto <D.22728>; else goto <D.22729>;
      <D.22728>:
      monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
      <D.22729>:
      D.22730 = ret != 0;
      D.22731 = (long int) D.22730;
      D.22732 = __builtin_expect (D.22731, 0);
      if (D.22732 != 0) goto <D.22733>; else goto <D.22734>;
      <D.22733>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 3032, "ret == 0");
      <D.22734>:
    }
    D.22726 = vt->domain;
    D.22735 = D.22726->special_static_fields;
    addr = monoeg_g_hash_table_lookup (D.22735, field);
    {
      int ret;

      D.22726 = vt->domain;
      D.22727 = &D.22726->lock.mutex;
      ret = pthread_mutex_unlock (D.22727);
      if (ret != 0) goto <D.22736>; else goto <D.22737>;
      <D.22736>:
      monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
      <D.22737>:
      D.22738 = ret != 0;
      D.22739 = (long int) D.22738;
      D.22740 = __builtin_expect (D.22739, 0);
      if (D.22740 != 0) goto <D.22741>; else goto <D.22742>;
      <D.22741>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 3034, "ret == 0");
      <D.22742>:
    }
    addr.127 = (unsigned int) addr;
    dest = mono_get_special_static_data (addr.127);
  }
  goto <D.22744>;
  <D.22725>:
  D.22745 = mono_vtable_get_static_field_data (vt);
  D.22723 = field->offset;
  D.22746 = (sizetype) D.22723;
  dest = D.22745 + D.22746;
  <D.22744>:
  D.22714 = field->type;
  set_value (D.22714, dest, value, 0);
}


mono_vtable_get_static_field_data (struct MonoVTable * vt)
{
  unsigned int D.22748;
  unsigned int D.22749;
  void * D.22752;
  struct MonoClass * D.22753;
  int D.22754;

  D.22748 = BIT_FIELD_REF <*vt, 32, 160>;
  D.22749 = D.22748 & 134217728;
  if (D.22749 == 0) goto <D.22750>; else goto <D.22751>;
  <D.22750>:
  D.22752 = 0B;
  return D.22752;
  <D.22751>:
  D.22753 = vt->klass;
  D.22754 = D.22753->vtable_size;
  D.22752 = vt->vtable[D.22754];
  return D.22752;
}


mono_field_get_value (struct MonoObject * obj, struct MonoClassField * field, void * value)
{
  _Bool D.22756;
  long int D.22757;
  long int D.22758;
  struct MonoType * D.22761;
  short unsigned int D.22762;
  int D.22763;
  int D.22764;
  int D.22767;
  sizetype D.22768;
  void * src;

  D.22756 = obj == 0B;
  D.22757 = (long int) D.22756;
  D.22758 = __builtin_expect (D.22757, 0);
  if (D.22758 != 0) goto <D.22759>; else goto <D.22760>;
  <D.22759>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 3103, "obj");
  <D.22760>:
  D.22761 = field->type;
  D.22762 = D.22761->attrs;
  D.22763 = (int) D.22762;
  D.22764 = D.22763 & 16;
  if (D.22764 != 0) goto <D.22765>; else goto <D.22766>;
  <D.22765>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "object.c", 3105, "!(field->type->attrs & FIELD_ATTRIBUTE_STATIC)");
  return;
  <D.22766>:
  D.22767 = field->offset;
  D.22768 = (sizetype) D.22767;
  src = obj + D.22768;
  D.22761 = field->type;
  set_value (D.22761, value, src, 1);
}


mono_field_get_value_object (struct MonoDomain * domain, struct MonoClassField * field, struct MonoObject * obj)
{
  int D.22770;
  unsigned char D.22773;
  int D.22774;
  <unnamed-unsigned:1> D.22775;
  int D.22776;
  _Bool D.22777;
  struct MonoObject * D.22778;
  short unsigned int D.22779;
  int D.22780;
  int D.22781;
  int D.22784;
  struct MonoClass * D.22789;
  unsigned int D.22790;
  unsigned int D.22791;
  _Bool D.22795;
  long int D.22796;
  long int D.22797;
  struct MonoMethod * m.128;
  struct MonoClass * ptr_klass.131;
  struct MonoClass * tmp_klass.129;
  struct MonoImage * D.22818;
  struct MonoClass * tmp_klass.130;
  _Bool D.22820;
  long int D.22821;
  long int D.22822;
  struct MonoMethod * m.132;
  _Bool D.22826;
  long int D.22827;
  long int D.22828;
  void * * ptr.133;
  void * D.22838;
  struct MonoDomain * D.22839;
  struct MonoReflectionType * D.22840;
  int D.22841;
  guint8 * D.22844;
  struct MonoObject * o.134;
  struct MonoObject * o.135;
  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.22770 = mono_error_ok (&error);
      if (D.22770 == 0) goto <D.22771>; else goto <D.22772>;
      <D.22771>:
      mono_error_raise_exception (&error);
      <D.22772>:
      D.22773 = type->type;
      D.22774 = (int) D.22773;
      switch (D.22774) <default: <D.19476>, case 2: <D.19461>, case 3: <D.19464>, case 4: <D.19460>, case 5: <D.19459>, case 6: <D.19463>, case 7: <D.19462>, case 8: <D.19468>, case 9: <D.19467>, case 10: <D.19471>, case 11: <D.19470>, case 12: <D.19469>, case 13: <D.19472>, case 14: <D.19453>, case 15: <D.19475>, case 17: <D.19473>, case 18: <D.19455>, case 20: <D.19456>, case 21: <D.19474>, case 24: <D.19466>, case 25: <D.19465>, case 28: <D.19454>, case 29: <D.19457>>
      <D.19453>:
      <D.19454>:
      <D.19455>:
      <D.19456>:
      <D.19457>:
      is_ref = 1;
      goto <D.19458>;
      <D.19459>:
      <D.19460>:
      <D.19461>:
      <D.19462>:
      <D.19463>:
      <D.19464>:
      <D.19465>:
      <D.19466>:
      <D.19467>:
      <D.19468>:
      <D.19469>:
      <D.19470>:
      <D.19471>:
      <D.19472>:
      <D.19473>:
      D.22775 = type->byref;
      is_ref = (gboolean) D.22775;
      goto <D.19458>;
      <D.19474>:
      D.22776 = mono_type_generic_inst_is_valuetype (type);
      D.22777 = D.22776 == 0;
      is_ref = (gboolean) D.22777;
      goto <D.19458>;
      <D.19475>:
      is_ptr = 1;
      goto <D.19458>;
      <D.19476>:
      D.22773 = type->type;
      D.22774 = (int) D.22773;
      monoeg_g_log (0B, 4, "type 0x%x not handled in mono_field_get_value_object", D.22774);
      <D.19477>:
      goto <D.19477>;
      D.22778 = 0B;
      return D.22778;
      <D.19458>:
      D.22779 = type->attrs;
      D.22780 = (int) D.22779;
      D.22781 = D.22780 & 64;
      if (D.22781 != 0) goto <D.22782>; else goto <D.22783>;
      <D.22782>:
      is_literal = 1;
      <D.22783>:
      D.22779 = type->attrs;
      D.22780 = (int) D.22779;
      D.22784 = D.22780 & 16;
      if (D.22784 != 0) goto <D.22785>; else goto <D.22786>;
      <D.22785>:
      is_static = 1;
      if (is_literal == 0) goto <D.22787>; else goto <D.22788>;
      <D.22787>:
      D.22789 = field->parent;
      vtable = mono_class_vtable_full (domain, D.22789, 1);
      D.22790 = BIT_FIELD_REF <*vtable, 32, 160>;
      D.22791 = D.22790 & 33554432;
      if (D.22791 == 0) goto <D.22792>; else goto <D.22793>;
      <D.22792>:
      mono_runtime_class_init (vtable);
      <D.22793>:
      <D.22788>:
      goto <D.22794>;
      <D.22786>:
      D.22795 = obj == 0B;
      D.22796 = (long int) D.22795;
      D.22797 = __builtin_expect (D.22796, 0);
      if (D.22797 != 0) goto <D.22798>; else goto <D.22799>;
      <D.22798>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 3187, "obj");
      <D.22799>:
      <D.22794>:
      if (is_ref != 0) goto <D.22800>; else goto <D.22801>;
      <D.22800>:
      if (is_literal != 0) goto <D.22802>; else goto <D.22803>;
      <D.22802>:
      get_default_field_value (domain, field, &o);
      goto <D.22804>;
      <D.22803>:
      if (is_static != 0) goto <D.22805>; else goto <D.22806>;
      <D.22805>:
      mono_field_static_get_value (vtable, field, &o);
      goto <D.22807>;
      <D.22806>:
      mono_field_get_value (obj, field, &o);
      <D.22807>:
      <D.22804>:
      D.22778 = o;
      return D.22778;
      <D.22801>:
      if (is_ptr != 0) goto <D.22808>; else goto <D.22809>;
      <D.22808>:
      {
        static struct MonoMethod * m;
        void * args[2];
        void * * ptr;
        void * v;

        try
          {
            m.128 = m;
            if (m.128 == 0B) goto <D.22811>; else goto <D.22812>;
            <D.22811>:
            {
              struct MonoClass * ptr_klass;

              {
                static struct MonoClass * tmp_klass;

                {
                  tmp_klass.129 = tmp_klass;
                  if (tmp_klass.129 == 0B) goto <D.22814>; else goto <D.22815>;
                  <D.22814>:
                  if (0 != 0) goto <D.22816>; else goto <D.22817>;
                  <D.22816>:
                  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 3208, "mono_defaults.corlib == mono_defaults.corlib");
                  <D.22817>:
                  D.22818 = mono_defaults.corlib;
                  tmp_klass.130 = mono_class_from_name (D.22818, "System.Reflection", "Pointer");
                  tmp_klass = tmp_klass.130;
                  tmp_klass.129 = tmp_klass;
                  D.22820 = tmp_klass.129 == 0B;
                  D.22821 = (long int) D.22820;
                  D.22822 = __builtin_expect (D.22821, 0);
                  if (D.22822 != 0) goto <D.22823>; else goto <D.22824>;
                  <D.22823>:
                  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 3208, "tmp_klass");
                  <D.22824>:
                  <D.22815>:
                }
                ptr_klass.131 = tmp_klass;
              }
              ptr_klass = ptr_klass.131;
              m.132 = mono_class_get_method_from_name_flags (ptr_klass, "Box", 2, 16);
              m = m.132;
              m.128 = m;
              D.22826 = m.128 == 0B;
              D.22827 = (long int) D.22826;
              D.22828 = __builtin_expect (D.22827, 0);
              if (D.22828 != 0) goto <D.22829>; else goto <D.22830>;
              <D.22829>:
              monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 3210, "m");
              <D.22830>:
            }
            <D.22812>:
            v = &ptr;
            if (is_literal != 0) goto <D.22831>; else goto <D.22832>;
            <D.22831>:
            get_default_field_value (domain, field, v);
            goto <D.22833>;
            <D.22832>:
            if (is_static != 0) goto <D.22834>; else goto <D.22835>;
            <D.22834>:
            mono_field_static_get_value (vtable, field, v);
            goto <D.22836>;
            <D.22835>:
            mono_field_get_value (obj, field, v);
            <D.22836>:
            <D.22833>:
            ptr.133 = ptr;
            D.22838 = *ptr.133;
            args[0] = D.22838;
            D.22839 = mono_domain_get ();
            D.22840 = mono_type_get_object (D.22839, type);
            args[1] = D.22840;
            m.128 = m;
            D.22778 = mono_runtime_invoke (m.128, 0B, &args, 0B);
            return D.22778;
          }
        finally
          {
            args = {CLOBBER};
            ptr = {CLOBBER};
          }
      }
      <D.22809>:
      klass = mono_class_from_mono_type (type);
      D.22841 = mono_class_is_nullable (klass);
      if (D.22841 != 0) goto <D.22842>; else goto <D.22843>;
      <D.22842>:
      D.22844 = mono_field_get_addr (obj, vtable, field);
      D.22778 = mono_nullable_box (D.22844, klass);
      return D.22778;
      <D.22843>:
      o.134 = mono_object_new (domain, klass);
      o = o.134;
      o.135 = o;
      v = o.135 + 8;
      if (is_literal != 0) goto <D.22847>; else goto <D.22848>;
      <D.22847>:
      get_default_field_value (domain, field, v);
      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, v);
      goto <D.22852>;
      <D.22851>:
      mono_field_get_value (obj, field, v);
      <D.22852>:
      <D.22849>:
      D.22778 = o;
      return D.22778;
    }
  finally
    {
      o = {CLOBBER};
      error = {CLOBBER};
    }
}


mono_field_get_addr (struct MonoObject * obj, struct MonoVTable * vt, struct MonoClassField * field)
{
  struct MonoType * D.22856;
  short unsigned int D.22857;
  int D.22858;
  int D.22859;
  int D.22862;
  struct MonoDomain * D.22865;
  union mono_mutex_t * D.22866;
  _Bool D.22869;
  long int D.22870;
  long int D.22871;
  struct GHashTable * D.22874;
  _Bool D.22877;
  long int D.22878;
  long int D.22879;
  unsigned int addr.136;
  void * D.22884;
  sizetype D.22885;
  guint8 * D.22887;
  guint8 * src;

  D.22856 = field->type;
  D.22857 = D.22856->attrs;
  D.22858 = (int) D.22857;
  D.22859 = D.22858 & 16;
  if (D.22859 != 0) goto <D.22860>; else goto <D.22861>;
  <D.22860>:
  D.22862 = field->offset;
  if (D.22862 == -1) goto <D.22863>; else goto <D.22864>;
  <D.22863>:
  {
    void * addr;

    {
      int ret;

      D.22865 = vt->domain;
      D.22866 = &D.22865->lock.mutex;
      ret = pthread_mutex_lock (D.22866);
      if (ret != 0) goto <D.22867>; else goto <D.22868>;
      <D.22867>:
      monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
      <D.22868>:
      D.22869 = ret != 0;
      D.22870 = (long int) D.22869;
      D.22871 = __builtin_expect (D.22870, 0);
      if (D.22871 != 0) goto <D.22872>; else goto <D.22873>;
      <D.22872>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 3067, "ret == 0");
      <D.22873>:
    }
    D.22865 = vt->domain;
    D.22874 = D.22865->special_static_fields;
    addr = monoeg_g_hash_table_lookup (D.22874, field);
    {
      int ret;

      D.22865 = vt->domain;
      D.22866 = &D.22865->lock.mutex;
      ret = pthread_mutex_unlock (D.22866);
      if (ret != 0) goto <D.22875>; else goto <D.22876>;
      <D.22875>:
      monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
      <D.22876>:
      D.22877 = ret != 0;
      D.22878 = (long int) D.22877;
      D.22879 = __builtin_expect (D.22878, 0);
      if (D.22879 != 0) goto <D.22880>; else goto <D.22881>;
      <D.22880>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 3069, "ret == 0");
      <D.22881>:
    }
    addr.136 = (unsigned int) addr;
    src = mono_get_special_static_data (addr.136);
  }
  goto <D.22883>;
  <D.22864>:
  D.22884 = mono_vtable_get_static_field_data (vt);
  D.22862 = field->offset;
  D.22885 = (sizetype) D.22862;
  src = D.22884 + D.22885;
  <D.22883>:
  goto <D.22886>;
  <D.22861>:
  D.22862 = field->offset;
  D.22885 = (sizetype) D.22862;
  src = obj + D.22885;
  <D.22886>:
  D.22887 = src;
  return D.22887;
}


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

  try
    {
      data = mono_class_get_field_default_value (field, &def_type);
      def_type.137 = def_type;
      mono_get_constant_value_from_blob (domain, def_type.137, 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.138;
  char D.22891;
  unsigned char D.22892;
  short unsigned int D.22893;
  unsigned int D.22894;
  long long unsigned int D.22895;
  unsigned int D.22896;
  float D.22897;
  long long unsigned int D.22898;
  double D.22899;
  struct MonoString * D.22900;
  int D.22901;
  int retval;
  const char * p;

  try
    {
      retval = 0;
      p = blob;
      p.138 = p;
      mono_metadata_decode_blob_size (p.138, &p);
      switch (type) <default: <D.19510>, case 2: <D.19493>, case 3: <D.19497>, case 4: <D.19495>, case 5: <D.19494>, case 6: <D.19499>, case 7: <D.19498>, case 8: <D.19501>, case 9: <D.19500>, case 10: <D.19503>, case 11: <D.19502>, case 12: <D.19504>, case 13: <D.19506>, case 14: <D.19508>, case 18: <D.19509>>
      <D.19493>:
      <D.19494>:
      <D.19495>:
      p.138 = p;
      D.22891 = *p.138;
      D.22892 = (unsigned char) D.22891;
      MEM[(guint8 *)value] = D.22892;
      goto <D.19496>;
      <D.19497>:
      <D.19498>:
      <D.19499>:
      p.138 = p;
      D.22893 = mono_read16 (p.138);
      MEM[(guint16 *)value] = D.22893;
      goto <D.19496>;
      <D.19500>:
      <D.19501>:
      p.138 = p;
      D.22894 = mono_read32 (p.138);
      MEM[(guint32 *)value] = D.22894;
      goto <D.19496>;
      <D.19502>:
      <D.19503>:
      p.138 = p;
      D.22895 = mono_read64 (p.138);
      MEM[(guint64 *)value] = D.22895;
      goto <D.19496>;
      <D.19504>:
      {
        union mono_rfloat mf;

        try
          {
            p.138 = p;
            D.22896 = mono_read32 (p.138);
            mf.ival = D.22896;
            D.22897 = mf.fval;
            MEM[(float *)value] = D.22897;
          }
        finally
          {
            mf = {CLOBBER};
          }
      }
      goto <D.19496>;
      <D.19506>:
      {
        union mono_rdouble mf;

        try
          {
            p.138 = p;
            D.22898 = mono_read64 (p.138);
            mf.ival = D.22898;
            D.22899 = mf.fval;
            MEM[(double *)value] = D.22899;
          }
        finally
          {
            mf = {CLOBBER};
          }
      }
      goto <D.19496>;
      <D.19508>:
      D.22900 = mono_ldstr_metadata_sig (domain, blob);
      MEM[(void * *)value] = D.22900;
      goto <D.19496>;
      <D.19509>:
      MEM[(void * *)value] = 0B;
      goto <D.19496>;
      <D.19510>:
      retval = -1;
      monoeg_g_log (0B, 16, "type 0x%02x should not be in constant table", type);
      <D.19496>:
      D.22901 = retval;
      return D.22901;
    }
  finally
    {
      p = {CLOBBER};
    }
}


mono_ldstr_metadata_sig (struct MonoDomain * domain, const char * sig)
{
  const char * str.139;
  int len2.140;
  _Bool D.22908;
  long int D.22909;
  long int D.22910;
  struct MonoGHashTable * D.22913;
  _Bool D.22918;
  long int D.22919;
  long int D.22920;
  struct MonoString * D.22923;
  _Bool D.22928;
  long int D.22929;
  long int D.22930;
  const char * str;
  struct MonoString * o;
  struct MonoString * interned;
  size_t len2;

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

        ret = pthread_mutex_lock (&ldstr_section.mutex);
        if (ret != 0) goto <D.22906>; else goto <D.22907>;
        <D.22906>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
        <D.22907>:
        D.22908 = ret != 0;
        D.22909 = (long int) D.22908;
        D.22910 = __builtin_expect (D.22909, 0);
        if (D.22910 != 0) goto <D.22911>; else goto <D.22912>;
        <D.22911>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 5487, "ret == 0");
        <D.22912>:
      }
      D.22913 = domain->ldstr_table;
      interned = mono_g_hash_table_lookup (D.22913, o);
      if (interned != 0B) goto <D.22914>; else goto <D.22915>;
      <D.22914>:
      {
        int ret;

        ret = pthread_mutex_unlock (&ldstr_section.mutex);
        if (ret != 0) goto <D.22916>; else goto <D.22917>;
        <D.22916>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.22917>:
        D.22918 = ret != 0;
        D.22919 = (long int) D.22918;
        D.22920 = __builtin_expect (D.22919, 0);
        if (D.22920 != 0) goto <D.22921>; else goto <D.22922>;
        <D.22921>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 5489, "ret == 0");
        <D.22922>:
      }
      D.22923 = interned;
      return D.22923;
      <D.22915>:
      o = mono_string_get_pinned (o);
      if (o != 0B) goto <D.22924>; else goto <D.22925>;
      <D.22924>:
      D.22913 = domain->ldstr_table;
      mono_g_hash_table_insert (D.22913, o, o);
      <D.22925>:
      {
        int ret;

        ret = pthread_mutex_unlock (&ldstr_section.mutex);
        if (ret != 0) goto <D.22926>; else goto <D.22927>;
        <D.22926>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.22927>:
        D.22928 = ret != 0;
        D.22929 = (long int) D.22928;
        D.22930 = __builtin_expect (D.22929, 0);
        if (D.22930 != 0) goto <D.22931>; else goto <D.22932>;
        <D.22931>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 5497, "ret == 0");
        <D.22932>:
      }
      D.22923 = o;
      return D.22923;
    }
  finally
    {
      str = {CLOBBER};
    }
}


mono_string_get_pinned (struct MonoString * str)
{
  int D.22935;
  int D.22936;
  int D.22937;
  unsigned int D.22938;
  unsigned int D.22939;
  struct MonoVTable * D.22940;
  unsigned int size.141;
  mono_unichar2 * D.22944;
  mono_unichar2 * D.22945;
  int D.22946;
  int D.22947;
  unsigned int D.22948;
  int D.22949;
  struct MonoString * D.22950;
  int size;
  struct MonoString * news;

  D.22935 = mono_string_length (str);
  D.22936 = D.22935 + 1;
  D.22937 = D.22936 * 2;
  D.22938 = (unsigned int) D.22937;
  D.22939 = D.22938 + 12;
  size = (int) D.22939;
  D.22940 = MEM[(struct MonoObject *)str].vtable;
  size.141 = (unsigned int) size;
  news = mono_gc_alloc_pinned_obj (D.22940, size.141);
  if (news != 0B) goto <D.22942>; else goto <D.22943>;
  <D.22942>:
  D.22944 = mono_string_chars (news);
  D.22945 = mono_string_chars (str);
  D.22946 = mono_string_length (str);
  D.22947 = D.22946 * 2;
  D.22948 = (unsigned int) D.22947;
  memcpy (D.22944, D.22945, D.22948);
  D.22949 = mono_string_length (str);
  news->length = D.22949;
  <D.22943>:
  D.22950 = news;
  return D.22950;
}


mono_field_static_get_value_for_thread (struct MonoInternalThread * thread, struct MonoVTable * vt, struct MonoClassField * field, void * value)
{
  struct MonoType * D.22952;
  short unsigned int D.22953;
  int D.22954;
  int D.22955;
  int D.22958;
  struct MonoDomain * D.22961;
  int D.22962;
  struct GHashTable * D.22965;
  unsigned int addr.142;
  void * D.22968;
  sizetype D.22969;
  void * src;

  D.22952 = field->type;
  D.22953 = D.22952->attrs;
  D.22954 = (int) D.22953;
  D.22955 = D.22954 & 16;
  if (D.22955 == 0) goto <D.22956>; else goto <D.22957>;
  <D.22956>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "object.c", 3309, "field->type->attrs & FIELD_ATTRIBUTE_STATIC");
  return;
  <D.22957>:
  D.22952 = field->type;
  D.22953 = D.22952->attrs;
  D.22954 = (int) D.22953;
  D.22958 = D.22954 & 64;
  if (D.22958 != 0) goto <D.22959>; else goto <D.22960>;
  <D.22959>:
  D.22961 = vt->domain;
  get_default_field_value (D.22961, field, value);
  return;
  <D.22960>:
  D.22962 = field->offset;
  if (D.22962 == -1) goto <D.22963>; else goto <D.22964>;
  <D.22963>:
  {
    void * addr;

    D.22961 = vt->domain;
    D.22965 = D.22961->special_static_fields;
    addr = monoeg_g_hash_table_lookup (D.22965, field);
    addr.142 = (unsigned int) addr;
    src = mono_get_special_static_data_for_thread (thread, addr.142);
  }
  goto <D.22967>;
  <D.22964>:
  D.22968 = mono_vtable_get_static_field_data (vt);
  D.22962 = field->offset;
  D.22969 = (sizetype) D.22962;
  src = D.22968 + D.22969;
  <D.22967>:
  D.22952 = field->type;
  set_value (D.22952, value, src, 1);
}


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

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


mono_property_set_value (struct MonoProperty * prop, void * obj, void * * params, struct MonoObject * * exc)
{
  struct MonoObject * (*<T11ad>) (struct MonoMethod *, void *, void * *, struct MonoObject * *) default_mono_runtime_invoke.143;
  struct MonoMethod * D.22974;

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


mono_property_get_value (struct MonoProperty * prop, void * obj, void * * params, struct MonoObject * * exc)
{
  struct MonoObject * D.22975;
  struct MonoObject * (*<T11ad>) (struct MonoMethod *, void *, void * *, struct MonoObject * *) default_mono_runtime_invoke.144;
  struct MonoMethod * D.22977;

  default_mono_runtime_invoke.144 = default_mono_runtime_invoke;
  D.22977 = prop->get;
  D.22975 = default_mono_runtime_invoke.144 (D.22977, obj, params, exc);
  return D.22975;
}


mono_nullable_init (guint8 * buf, struct MonoObject * value, struct MonoClass * klass)
{
  unsigned int D.22979;
  unsigned int D.22980;
  _Bool D.22981;
  long int D.22982;
  long int D.22983;
  struct MonoClassField * D.22986;
  struct MonoType * D.22987;
  struct MonoClass * D.22988;
  _Bool D.22989;
  long int D.22990;
  long int D.22991;
  struct MonoClassField * D.22994;
  struct MonoType * D.22995;
  struct MonoClass * D.22996;
  struct MonoClass * D.22997;
  _Bool D.22998;
  long int D.22999;
  long int D.23000;
  int D.23003;
  sizetype D.23004;
  sizetype D.23005;
  guint8 * D.23006;
  _Bool D.23007;
  unsigned char D.23008;
  unsigned int D.23011;
  unsigned int D.23012;
  int D.23015;
  sizetype D.23016;
  sizetype D.23017;
  guint8 * D.23018;
  void * D.23019;
  void * D.23021;
  int D.23022;
  unsigned int D.23023;
  int D.23025;
  unsigned int D.23026;
  struct MonoClass * param_class;

  param_class = klass->cast_class;
  mono_class_setup_fields_locking (klass);
  D.22979 = BIT_FIELD_REF <*klass, 32, 192>;
  D.22980 = D.22979 & 32;
  D.22981 = D.22980 == 0;
  D.22982 = (long int) D.22981;
  D.22983 = __builtin_expect (D.22982, 0);
  if (D.22983 != 0) goto <D.22984>; else goto <D.22985>;
  <D.22984>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 3412, "klass->fields_inited");
  <D.22985>:
  D.22986 = klass->fields;
  D.22987 = D.22986->type;
  D.22988 = mono_class_from_mono_type (D.22987);
  D.22989 = D.22988 != param_class;
  D.22990 = (long int) D.22989;
  D.22991 = __builtin_expect (D.22990, 0);
  if (D.22991 != 0) goto <D.22992>; else goto <D.22993>;
  <D.22992>:
  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.22993>:
  D.22986 = klass->fields;
  D.22994 = D.22986 + 16;
  D.22995 = D.22994->type;
  D.22996 = mono_class_from_mono_type (D.22995);
  D.22997 = mono_defaults.boolean_class;
  D.22998 = D.22996 != D.22997;
  D.22999 = (long int) D.22998;
  D.23000 = __builtin_expect (D.22999, 0);
  if (D.23000 != 0) goto <D.23001>; else goto <D.23002>;
  <D.23001>:
  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.23002>:
  D.22986 = klass->fields;
  D.22994 = D.22986 + 16;
  D.23003 = D.22994->offset;
  D.23004 = (sizetype) D.23003;
  D.23005 = D.23004 + 4294967288;
  D.23006 = buf + D.23005;
  D.23007 = value != 0B;
  D.23008 = (unsigned char) D.23007;
  *D.23006 = D.23008;
  if (value != 0B) goto <D.23009>; else goto <D.23010>;
  <D.23009>:
  D.23011 = BIT_FIELD_REF <*param_class, 32, 160>;
  D.23012 = D.23011 & 134217728;
  if (D.23012 != 0) goto <D.23013>; else goto <D.23014>;
  <D.23013>:
  D.22986 = klass->fields;
  D.23015 = D.22986->offset;
  D.23016 = (sizetype) D.23015;
  D.23017 = D.23016 + 4294967288;
  D.23018 = buf + D.23017;
  D.23019 = mono_object_unbox (value);
  mono_gc_wbarrier_value_copy (D.23018, D.23019, 1, param_class);
  goto <D.23020>;
  <D.23014>:
  D.22986 = klass->fields;
  D.23015 = D.22986->offset;
  D.23016 = (sizetype) D.23015;
  D.23017 = D.23016 + 4294967288;
  D.23018 = buf + D.23017;
  D.23021 = mono_object_unbox (value);
  D.23022 = mono_class_value_size (param_class, 0B);
  D.23023 = (unsigned int) D.23022;
  mono_gc_memmove_atomic (D.23018, D.23021, D.23023);
  <D.23020>:
  goto <D.23024>;
  <D.23010>:
  D.22986 = klass->fields;
  D.23015 = D.22986->offset;
  D.23016 = (sizetype) D.23015;
  D.23017 = D.23016 + 4294967288;
  D.23018 = buf + D.23017;
  D.23025 = mono_class_value_size (param_class, 0B);
  D.23026 = (unsigned int) D.23025;
  mono_gc_bzero_atomic (D.23018, D.23026);
  <D.23024>:
}


mono_nullable_box (guint8 * buf, struct MonoClass * klass)
{
  unsigned int D.23027;
  unsigned int D.23028;
  _Bool D.23029;
  long int D.23030;
  long int D.23031;
  struct MonoClassField * D.23034;
  struct MonoType * D.23035;
  struct MonoClass * D.23036;
  _Bool D.23037;
  long int D.23038;
  long int D.23039;
  struct MonoClassField * D.23042;
  struct MonoType * D.23043;
  struct MonoClass * D.23044;
  struct MonoClass * D.23045;
  _Bool D.23046;
  long int D.23047;
  long int D.23048;
  int D.23051;
  sizetype D.23052;
  sizetype D.23053;
  guint8 * D.23054;
  unsigned char D.23055;
  struct MonoDomain * D.23058;
  unsigned int D.23059;
  unsigned int D.23060;
  void * D.23063;
  int D.23064;
  sizetype D.23065;
  sizetype D.23066;
  guint8 * D.23067;
  void * D.23069;
  int D.23070;
  unsigned int D.23071;
  struct MonoObject * D.23072;
  struct MonoClass * param_class;

  param_class = klass->cast_class;
  mono_class_setup_fields_locking (klass);
  D.23027 = BIT_FIELD_REF <*klass, 32, 192>;
  D.23028 = D.23027 & 32;
  D.23029 = D.23028 == 0;
  D.23030 = (long int) D.23029;
  D.23031 = __builtin_expect (D.23030, 0);
  if (D.23031 != 0) goto <D.23032>; else goto <D.23033>;
  <D.23032>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 3442, "klass->fields_inited");
  <D.23033>:
  D.23034 = klass->fields;
  D.23035 = D.23034->type;
  D.23036 = mono_class_from_mono_type (D.23035);
  D.23037 = D.23036 != param_class;
  D.23038 = (long int) D.23037;
  D.23039 = __builtin_expect (D.23038, 0);
  if (D.23039 != 0) goto <D.23040>; else goto <D.23041>;
  <D.23040>:
  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.23041>:
  D.23034 = klass->fields;
  D.23042 = D.23034 + 16;
  D.23043 = D.23042->type;
  D.23044 = mono_class_from_mono_type (D.23043);
  D.23045 = mono_defaults.boolean_class;
  D.23046 = D.23044 != D.23045;
  D.23047 = (long int) D.23046;
  D.23048 = __builtin_expect (D.23047, 0);
  if (D.23048 != 0) goto <D.23049>; else goto <D.23050>;
  <D.23049>:
  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.23050>:
  D.23034 = klass->fields;
  D.23042 = D.23034 + 16;
  D.23051 = D.23042->offset;
  D.23052 = (sizetype) D.23051;
  D.23053 = D.23052 + 4294967288;
  D.23054 = buf + D.23053;
  D.23055 = *D.23054;
  if (D.23055 != 0) goto <D.23056>; else goto <D.23057>;
  <D.23056>:
  {
    struct MonoObject * o;

    D.23058 = mono_domain_get ();
    o = mono_object_new (D.23058, param_class);
    D.23059 = BIT_FIELD_REF <*param_class, 32, 160>;
    D.23060 = D.23059 & 134217728;
    if (D.23060 != 0) goto <D.23061>; else goto <D.23062>;
    <D.23061>:
    D.23063 = mono_object_unbox (o);
    D.23034 = klass->fields;
    D.23064 = D.23034->offset;
    D.23065 = (sizetype) D.23064;
    D.23066 = D.23065 + 4294967288;
    D.23067 = buf + D.23066;
    mono_gc_wbarrier_value_copy (D.23063, D.23067, 1, param_class);
    goto <D.23068>;
    <D.23062>:
    D.23069 = mono_object_unbox (o);
    D.23034 = klass->fields;
    D.23064 = D.23034->offset;
    D.23065 = (sizetype) D.23064;
    D.23066 = D.23065 + 4294967288;
    D.23067 = buf + D.23066;
    D.23070 = mono_class_value_size (param_class, 0B);
    D.23071 = (unsigned int) D.23070;
    mono_gc_memmove_atomic (D.23069, D.23067, D.23071);
    <D.23068>:
    D.23072 = o;
    return D.23072;
  }
  <D.23057>:
  D.23072 = 0B;
  return D.23072;
}


mono_get_delegate_invoke (struct MonoClass * klass)
{
  unsigned char D.23074;
  struct MonoMethod * D.23077;
  struct MonoMethod * im;

  mono_class_setup_methods (klass);
  D.23074 = klass->exception_type;
  if (D.23074 != 0) goto <D.23075>; else goto <D.23076>;
  <D.23075>:
  D.23077 = 0B;
  return D.23077;
  <D.23076>:
  im = mono_class_get_method_from_name (klass, "Invoke", -1);
  D.23077 = im;
  return D.23077;
}


mono_get_delegate_begin_invoke (struct MonoClass * klass)
{
  unsigned char D.23079;
  struct MonoMethod * D.23082;
  struct MonoMethod * im;

  mono_class_setup_methods (klass);
  D.23079 = klass->exception_type;
  if (D.23079 != 0) goto <D.23080>; else goto <D.23081>;
  <D.23080>:
  D.23082 = 0B;
  return D.23082;
  <D.23081>:
  im = mono_class_get_method_from_name (klass, "BeginInvoke", -1);
  D.23082 = im;
  return D.23082;
}


mono_get_delegate_end_invoke (struct MonoClass * klass)
{
  unsigned char D.23084;
  struct MonoMethod * D.23087;
  struct MonoMethod * im;

  mono_class_setup_methods (klass);
  D.23084 = klass->exception_type;
  if (D.23084 != 0) goto <D.23085>; else goto <D.23086>;
  <D.23085>:
  D.23087 = 0B;
  return D.23087;
  <D.23086>:
  im = mono_class_get_method_from_name (klass, "EndInvoke", -1);
  D.23087 = im;
  return D.23087;
}


mono_runtime_delegate_invoke (struct MonoObject * delegate, void * * params, struct MonoObject * * exc)
{
  struct MonoVTable * D.23089;
  char * D.23092;
  struct MonoObject * D.23093;
  struct MonoMethod * im;
  struct MonoClass * klass;

  D.23089 = delegate->vtable;
  klass = D.23089->klass;
  im = mono_get_delegate_invoke (klass);
  if (im == 0B) goto <D.23090>; else goto <D.23091>;
  <D.23090>:
  D.23092 = mono_type_get_full_name (klass);
  monoeg_g_log (0B, 4, "Could not lookup delegate invoke method for delegate %s", D.23092);
  <D.19574>:
  goto <D.19574>;
  <D.23091>:
  D.23093 = mono_runtime_invoke (im, delegate, params, exc);
  return D.23093;
}


mono_runtime_get_main_args ()
{
  char * * main_args.145;
  struct MonoArray * D.23098;
  struct MonoClass * D.23099;
  int num_main_args.146;
  unsigned int num_main_args.147;
  unsigned int i.148;
  unsigned int i.149;
  unsigned int D.23104;
  char * * D.23105;
  char * D.23106;
  struct MonoString * D.23107;
  struct MonoArray * res;
  int i;
  struct MonoDomain * domain;

  domain = mono_domain_get ();
  main_args.145 = main_args;
  if (main_args.145 == 0B) goto <D.23096>; else goto <D.23097>;
  <D.23096>:
  D.23098 = 0B;
  return D.23098;
  <D.23097>:
  D.23099 = mono_defaults.string_class;
  num_main_args.146 = num_main_args;
  num_main_args.147 = (unsigned int) num_main_args.146;
  res = mono_array_new (domain, D.23099, num_main_args.147);
  i = 0;
  goto <D.19585>;
  <D.19584>:
  {
    void * * __p;

    i.148 = (unsigned int) i;
    __p = mono_array_addr_with_size (res, 4, i.148);
    main_args.145 = main_args;
    i.149 = (unsigned int) i;
    D.23104 = i.149 * 4;
    D.23105 = main_args.145 + D.23104;
    D.23106 = *D.23105;
    D.23107 = mono_string_new (domain, D.23106);
    mono_gc_wbarrier_set_arrayref (res, __p, D.23107);
  }
  i = i + 1;
  <D.19585>:
  num_main_args.146 = num_main_args;
  if (i < num_main_args.146) goto <D.19584>; else goto <D.19586>;
  <D.19586>:
  D.23098 = res;
  return D.23098;
}


mono_runtime_run_main (struct MonoMethod * method, int argc, char * * argv, struct MonoObject * * exc)
{
  _Bool D.23109;
  long int D.23110;
  long int D.23111;
  struct MonoThread * D.23114;
  unsigned int argc.150;
  unsigned int D.23116;
  void * main_args.151;
  char * D.23118;
  int D.23119;
  struct MonoClass * D.23122;
  struct MonoImage * D.23123;
  struct MonoAssembly * D.23124;
  char * D.23125;
  char * * main_args.152;
  unsigned int i.153;
  unsigned int D.23133;
  char * * D.23134;
  char * D.23135;
  char * * D.23138;
  short unsigned int D.23141;
  struct MonoClass * D.23144;
  unsigned int argc.154;
  unsigned int i.155;
  int D.23148;
  int i;
  struct MonoArray * args;
  struct MonoDomain * domain;
  gchar * utf8_fullpath;
  struct MonoMethodSignature * sig;

  args = 0B;
  domain = mono_domain_get ();
  D.23109 = method == 0B;
  D.23110 = (long int) D.23109;
  D.23111 = __builtin_expect (D.23110, 0);
  if (D.23111 != 0) goto <D.23112>; else goto <D.23113>;
  <D.23112>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 3601, "method != NULL");
  <D.23113>:
  D.23114 = mono_thread_current ();
  mono_thread_set_main (D.23114);
  argc.150 = (unsigned int) argc;
  D.23116 = argc.150 * 4;
  main_args.151 = monoeg_malloc0 (D.23116);
  main_args = main_args.151;
  num_main_args = argc;
  D.23118 = *argv;
  D.23119 = monoeg_g_path_is_absolute (D.23118);
  if (D.23119 == 0) goto <D.23120>; else goto <D.23121>;
  <D.23120>:
  {
    gchar * basename;
    gchar * fullpath;

    D.23118 = *argv;
    basename = monoeg_g_path_get_basename (D.23118);
    D.23122 = method->klass;
    D.23123 = D.23122->image;
    D.23124 = D.23123->assembly;
    D.23125 = D.23124->basedir;
    fullpath = monoeg_g_build_path ("/", D.23125, basename, 0B);
    utf8_fullpath = mono_utf8_from_external (fullpath);
    if (utf8_fullpath == 0B) goto <D.23126>; else goto <D.23127>;
    <D.23126>:
    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.23127>:
    monoeg_g_free (fullpath);
    monoeg_g_free (basename);
  }
  goto <D.23128>;
  <D.23121>:
  D.23118 = *argv;
  utf8_fullpath = mono_utf8_from_external (D.23118);
  if (utf8_fullpath == 0B) goto <D.23129>; else goto <D.23130>;
  <D.23129>:
  D.23118 = *argv;
  monoeg_g_print ("\nCannot determine the text encoding for the assembly location: %s\n", D.23118);
  monoeg_g_print ("Please add the correct encoding to MONO_EXTERNAL_ENCODINGS and try again.\n");
  exit (-1);
  <D.23130>:
  <D.23128>:
  main_args.152 = main_args;
  *main_args.152 = utf8_fullpath;
  i = 1;
  goto <D.19609>;
  <D.19608>:
  {
    gchar * utf8_arg;

    i.153 = (unsigned int) i;
    D.23133 = i.153 * 4;
    D.23134 = argv + D.23133;
    D.23135 = *D.23134;
    utf8_arg = mono_utf8_from_external (D.23135);
    if (utf8_arg == 0B) goto <D.23136>; else goto <D.23137>;
    <D.23136>:
    i.153 = (unsigned int) i;
    D.23133 = i.153 * 4;
    D.23134 = argv + D.23133;
    D.23135 = *D.23134;
    monoeg_g_print ("\nCannot determine the text encoding for argument %d (%s).\n", i, D.23135);
    monoeg_g_print ("Please add the correct encoding to MONO_EXTERNAL_ENCODINGS and try again.\n");
    exit (-1);
    <D.23137>:
    main_args.152 = main_args;
    i.153 = (unsigned int) i;
    D.23133 = i.153 * 4;
    D.23138 = main_args.152 + D.23133;
    *D.23138 = utf8_arg;
  }
  i = i + 1;
  <D.19609>:
  if (i < argc) goto <D.19608>; else goto <D.19610>;
  <D.19610>:
  argc = argc + -1;
  argv = argv + 4;
  sig = mono_method_signature (method);
  if (sig == 0B) goto <D.23139>; else goto <D.23140>;
  <D.23139>:
  monoeg_g_print ("Unable to load Main method.\n");
  exit (-1);
  <D.23140>:
  D.23141 = sig->param_count;
  if (D.23141 != 0) goto <D.23142>; else goto <D.23143>;
  <D.23142>:
  D.23144 = mono_defaults.string_class;
  argc.154 = (unsigned int) argc;
  args = mono_array_new (domain, D.23144, argc.154);
  i = 0;
  goto <D.19615>;
  <D.19614>:
  {
    gchar * str;
    struct MonoString * arg;

    i.153 = (unsigned int) i;
    D.23133 = i.153 * 4;
    D.23134 = argv + D.23133;
    D.23135 = *D.23134;
    str = mono_utf8_from_external (D.23135);
    arg = mono_string_new (domain, str);
    {
      void * * __p;

      i.155 = (unsigned int) i;
      __p = mono_array_addr_with_size (args, 4, i.155);
      mono_gc_wbarrier_set_arrayref (args, __p, arg);
    }
    monoeg_g_free (str);
  }
  i = i + 1;
  <D.19615>:
  if (i < argc) goto <D.19614>; else goto <D.19616>;
  <D.19616>:
  goto <D.23147>;
  <D.23143>:
  D.23144 = mono_defaults.string_class;
  args = mono_array_new (domain, D.23144, 0);
  <D.23147>:
  D.23122 = method->klass;
  D.23123 = D.23122->image;
  D.23124 = D.23123->assembly;
  mono_assembly_set_main (D.23124);
  D.23148 = mono_runtime_exec_main (method, args, exc);
  return D.23148;
}


mono_object_xdomain_representation (struct MonoObject * obj, struct MonoDomain * target_domain, struct MonoObject * * exc)
{
  struct MonoVTable * D.23150;
  struct MonoClass * D.23151;
  unsigned int D.23152;
  unsigned int D.23153;
  struct MonoDomain * D.23157;
  int failure.156;
  struct MonoObject * D.23163;
  struct MonoObject * deserialized;
  gboolean failure;

  try
    {
      deserialized = 0B;
      failure = 0;
      *exc = 0B;
      D.23150 = obj->vtable;
      D.23151 = D.23150->klass;
      D.23152 = BIT_FIELD_REF <*D.23151, 32, 160>;
      D.23153 = D.23152 & 4194304;
      if (D.23153 != 0) goto <D.23154>; else goto <D.23155>;
      <D.23154>:
      deserialized = make_transparent_proxy (obj, &failure, exc);
      goto <D.23156>;
      <D.23155>:
      {
        struct MonoDomain * domain;
        struct MonoObject * serialized;

        domain = mono_domain_get ();
        D.23150 = obj->vtable;
        D.23157 = D.23150->domain;
        mono_domain_set_internal_with_options (D.23157, 0);
        serialized = serialize_object (obj, &failure, exc);
        mono_domain_set_internal_with_options (target_domain, 0);
        failure.156 = failure;
        if (failure.156 == 0) goto <D.23159>; else goto <D.23160>;
        <D.23159>:
        deserialized = deserialize_object (serialized, &failure, exc);
        <D.23160>:
        if (domain != target_domain) goto <D.23161>; else goto <D.23162>;
        <D.23161>:
        mono_domain_set_internal_with_options (domain, 0);
        <D.23162>:
      }
      <D.23156>:
      D.23163 = deserialized;
      return D.23163;
    }
  finally
    {
      failure = {CLOBBER};
    }
}


make_transparent_proxy (struct MonoObject * obj, gboolean * failure, struct MonoObject * * exc)
{
  struct MonoMethod * get_proxy_method.157;
  struct MonoClass * D.23169;
  struct MonoMethod * get_proxy_method.158;
  struct MonoVTable * D.23171;
  struct MonoClass * D.23172;
  unsigned int D.23173;
  unsigned int D.23174;
  _Bool D.23175;
  long int D.23176;
  long int D.23177;
  struct MonoType * D.23180;
  struct MonoReflectionType * * D.23181;
  struct MonoObject * * D.23182;
  struct MonoObject * D.23183;
  struct MonoObject * D.23186;
  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.157 = get_proxy_method;
  if (get_proxy_method.157 == 0B) goto <D.23167>; else goto <D.23168>;
  <D.23167>:
  D.23169 = mono_defaults.real_proxy_class;
  get_proxy_method.158 = mono_class_get_method_from_name (D.23169, "GetTransparentProxy", 0);
  get_proxy_method = get_proxy_method.158;
  <D.23168>:
  D.23171 = obj->vtable;
  D.23172 = D.23171->klass;
  D.23173 = BIT_FIELD_REF <*D.23172, 32, 160>;
  D.23174 = D.23173 & 4194304;
  D.23175 = D.23174 == 0;
  D.23176 = (long int) D.23175;
  D.23177 = __builtin_expect (D.23176, 0);
  if (D.23177 != 0) goto <D.23178>; else goto <D.23179>;
  <D.23178>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 3751, "mono_class_is_marshalbyref (obj->vtable->klass)");
  <D.23179>:
  D.23169 = mono_defaults.real_proxy_class;
  real_proxy = mono_object_new (domain, D.23169);
  D.23171 = obj->vtable;
  D.23172 = D.23171->klass;
  D.23180 = &D.23172->byval_arg;
  reflection_type = mono_type_get_object (domain, D.23180);
  D.23181 = &real_proxy->class_to_proxy;
  mono_gc_wbarrier_set_field (real_proxy, D.23181, reflection_type);
  D.23182 = &real_proxy->unwrapped_server;
  mono_gc_wbarrier_set_field (real_proxy, D.23182, obj);
  *exc = 0B;
  get_proxy_method.157 = get_proxy_method;
  transparent_proxy = mono_runtime_invoke (get_proxy_method.157, real_proxy, 0B, exc);
  D.23183 = *exc;
  if (D.23183 != 0B) goto <D.23184>; else goto <D.23185>;
  <D.23184>:
  *failure = 1;
  <D.23185>:
  D.23186 = transparent_proxy;
  return D.23186;
}


serialize_object (struct MonoObject * obj, gboolean * failure, struct MonoObject * * exc)
{
  struct MonoMethod * serialize_method.159;
  struct MonoImage * D.23191;
  struct MonoMethod * serialize_method.160;
  struct MonoObject * D.23195;
  struct MonoVTable * D.23196;
  struct MonoClass * D.23197;
  unsigned int D.23198;
  unsigned int D.23199;
  _Bool D.23200;
  long int D.23201;
  long int D.23202;
  struct MonoObject * D.23205;
  static struct MonoMethod * serialize_method;
  void * params[1];
  struct MonoObject * array;

  try
    {
      serialize_method.159 = serialize_method;
      if (serialize_method.159 == 0B) goto <D.23189>; else goto <D.23190>;
      <D.23189>:
      {
        struct MonoClass * klass;

        D.23191 = mono_defaults.corlib;
        klass = mono_class_from_name (D.23191, "System.Runtime.Remoting", "RemotingServices");
        serialize_method.160 = mono_class_get_method_from_name (klass, "SerializeCallData", -1);
        serialize_method = serialize_method.160;
      }
      <D.23190>:
      serialize_method.159 = serialize_method;
      if (serialize_method.159 == 0B) goto <D.23193>; else goto <D.23194>;
      <D.23193>:
      *failure = 1;
      D.23195 = 0B;
      return D.23195;
      <D.23194>:
      D.23196 = obj->vtable;
      D.23197 = D.23196->klass;
      D.23198 = BIT_FIELD_REF <*D.23197, 32, 160>;
      D.23199 = D.23198 & 4194304;
      D.23200 = D.23199 != 0;
      D.23201 = (long int) D.23200;
      D.23202 = __builtin_expect (D.23201, 0);
      if (D.23202 != 0) goto <D.23203>; else goto <D.23204>;
      <D.23203>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 3700, "!mono_class_is_marshalbyref (mono_object_class (obj))");
      <D.23204>:
      params[0] = obj;
      *exc = 0B;
      serialize_method.159 = serialize_method;
      array = mono_runtime_invoke (serialize_method.159, 0B, &params, exc);
      D.23205 = *exc;
      if (D.23205 != 0B) goto <D.23206>; else goto <D.23207>;
      <D.23206>:
      *failure = 1;
      <D.23207>:
      D.23195 = array;
      return D.23195;
    }
  finally
    {
      params = {CLOBBER};
    }
}


deserialize_object (struct MonoObject * obj, gboolean * failure, struct MonoObject * * exc)
{
  struct MonoMethod * deserialize_method.161;
  struct MonoImage * D.23213;
  struct MonoMethod * deserialize_method.162;
  struct MonoObject * D.23217;
  struct MonoObject * D.23218;
  static struct MonoMethod * deserialize_method;
  void * params[1];
  struct MonoObject * result;

  try
    {
      deserialize_method.161 = deserialize_method;
      if (deserialize_method.161 == 0B) goto <D.23211>; else goto <D.23212>;
      <D.23211>:
      {
        struct MonoClass * klass;

        D.23213 = mono_defaults.corlib;
        klass = mono_class_from_name (D.23213, "System.Runtime.Remoting", "RemotingServices");
        deserialize_method.162 = mono_class_get_method_from_name (klass, "DeserializeCallData", -1);
        deserialize_method = deserialize_method.162;
      }
      <D.23212>:
      deserialize_method.161 = deserialize_method;
      if (deserialize_method.161 == 0B) goto <D.23215>; else goto <D.23216>;
      <D.23215>:
      *failure = 1;
      D.23217 = 0B;
      return D.23217;
      <D.23216>:
      params[0] = obj;
      *exc = 0B;
      deserialize_method.161 = deserialize_method;
      result = mono_runtime_invoke (deserialize_method.161, 0B, &params, exc);
      D.23218 = *exc;
      if (D.23218 != 0B) goto <D.23219>; else goto <D.23220>;
      <D.23219>:
      *failure = 1;
      <D.23220>:
      D.23217 = result;
      return D.23217;
    }
  finally
    {
      params = {CLOBBER};
    }
}


mono_runtime_unhandled_exception_policy_set (MonoRuntimeUnhandledExceptionPolicy policy)
{
  runtime_unhandled_exception_policy = policy;
}


mono_runtime_unhandled_exception_policy_get ()
{
  MonoRuntimeUnhandledExceptionPolicy D.23223;

  D.23223 = runtime_unhandled_exception_policy;
  return D.23223;
}


mono_unhandled_exception (struct MonoObject * exc)
{
  struct MonoClass * D.23225;
  _Bool D.23226;
  long int D.23227;
  long int D.23228;
  struct MonoVTable * D.23231;
  struct MonoClass * D.23232;
  struct MonoClass * D.23233;
  int iftmp.163;
  struct MonoThread * main_thread.164;
  struct MonoInternalThread * D.23243;
  struct _MonoInternalThread * D.23244;
  <unnamed type> D.23245;
  struct MonoAppDomain * D.23246;
  int D.23247;
  sizetype D.23248;
  struct MonoObject * * D.23249;
  struct MonoAppDomain * D.23252;
  struct MonoObject * * D.23253;
  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.23225 = mono_defaults.appdomain_class;
  field = mono_class_get_field_from_name (D.23225, "UnhandledException");
  D.23226 = field == 0B;
  D.23227 = (long int) D.23226;
  D.23228 = __builtin_expect (D.23227, 0);
  if (D.23228 != 0) goto <D.23229>; else goto <D.23230>;
  <D.23229>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 3940, "field");
  <D.23230>:
  D.23231 = exc->vtable;
  D.23232 = D.23231->klass;
  D.23233 = mono_defaults.threadabortexception_class;
  if (D.23232 != D.23233) goto <D.23234>; else goto <D.23235>;
  <D.23234>:
  {
    gboolean abort_process;

    main_thread.164 = main_thread;
    if (main_thread.164 != 0B) goto <D.23242>; else goto <D.23237>;
    <D.23242>:
    D.23243 = mono_thread_internal_current ();
    main_thread.164 = main_thread;
    D.23244 = main_thread.164->internal_thread;
    if (D.23243 == D.23244) goto <D.23238>; else goto <D.23237>;
    <D.23237>:
    D.23245 = mono_runtime_unhandled_exception_policy_get ();
    if (D.23245 == 1) goto <D.23238>; else goto <D.23239>;
    <D.23238>:
    iftmp.163 = 1;
    goto <D.23240>;
    <D.23239>:
    iftmp.163 = 0;
    <D.23240>:
    abort_process = iftmp.163;
    D.23246 = root_domain->domain;
    D.23247 = field->offset;
    D.23248 = (sizetype) D.23247;
    D.23249 = D.23246 + D.23248;
    root_appdomain_delegate = *D.23249;
    if (current_domain != root_domain) goto <D.23250>; else goto <D.23251>;
    <D.23250>:
    D.23252 = current_domain->domain;
    D.23247 = field->offset;
    D.23248 = (sizetype) D.23247;
    D.23253 = D.23252 + D.23248;
    current_appdomain_delegate = *D.23253;
    goto <D.23254>;
    <D.23251>:
    current_appdomain_delegate = 0B;
    <D.23254>:
    if (current_appdomain_delegate == 0B) goto <D.23257>; else goto <D.23255>;
    <D.23257>:
    if (root_appdomain_delegate == 0B) goto <D.23258>; else goto <D.23255>;
    <D.23258>:
    if (abort_process != 0) goto <D.23259>; else goto <D.23260>;
    <D.23259>:
    mono_environment_exitcode_set (1);
    <D.23260>:
    mono_print_unhandled_exception (exc);
    goto <D.23256>;
    <D.23255>:
    if (root_appdomain_delegate != 0B) goto <D.23261>; else goto <D.23262>;
    <D.23261>:
    call_unhandled_exception_delegate (root_domain, root_appdomain_delegate, exc);
    <D.23262>:
    if (current_appdomain_delegate != 0B) goto <D.23263>; else goto <D.23264>;
    <D.23263>:
    call_unhandled_exception_delegate (current_domain, current_appdomain_delegate, exc);
    <D.23264>:
    <D.23256>:
  }
  <D.23235>:
}


call_unhandled_exception_delegate (struct MonoDomain * domain, struct MonoObject * delegate, struct MonoObject * exc)
{
  struct MonoAppDomain * D.23267;
  struct MonoVTable * D.23268;
  struct MonoDomain * D.23269;
  _Bool D.23270;
  long int D.23271;
  long int D.23272;
  struct MonoVTable * D.23275;
  struct MonoDomain * D.23276;
  struct MonoObject * serialization_exc.165;
  _Bool D.23284;
  long int D.23285;
  long int D.23286;
  struct MonoImage * D.23290;
  _Bool D.23291;
  long int D.23292;
  long int D.23293;
  struct MonoObject * D.23296;
  struct MonoObject * e.166;
  struct MonoString * D.23302;
  int D.23303;
  struct MonoObject * e;
  void * pa[2];
  struct MonoDomain * current_domain;

  try
    {
      e = 0B;
      current_domain = mono_domain_get ();
      if (domain != current_domain) goto <D.23265>; else goto <D.23266>;
      <D.23265>:
      mono_domain_set_internal_with_options (domain, 0);
      <D.23266>:
      D.23267 = domain->domain;
      D.23268 = MEM[(struct MonoObject *)D.23267].vtable;
      D.23269 = D.23268->domain;
      D.23270 = D.23269 != domain;
      D.23271 = (long int) D.23270;
      D.23272 = __builtin_expect (D.23271, 0);
      if (D.23272 != 0) goto <D.23273>; else goto <D.23274>;
      <D.23273>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 3850, "domain == mono_object_domain (domain->domain)");
      <D.23274>:
      D.23275 = exc->vtable;
      D.23276 = D.23275->domain;
      if (D.23276 != domain) goto <D.23277>; else goto <D.23278>;
      <D.23277>:
      {
        struct MonoObject * serialization_exc;

        try
          {
            exc = mono_object_xdomain_representation (exc, domain, &serialization_exc);
            if (exc == 0B) goto <D.23279>; else goto <D.23280>;
            <D.23279>:
            serialization_exc.165 = serialization_exc;
            if (serialization_exc.165 != 0B) goto <D.23282>; else goto <D.23283>;
            <D.23282>:
            {
              struct MonoObject * dummy;

              try
                {
                  serialization_exc.165 = serialization_exc;
                  exc = mono_object_xdomain_representation (serialization_exc.165, domain, &dummy);
                  D.23284 = exc == 0B;
                  D.23285 = (long int) D.23284;
                  D.23286 = __builtin_expect (D.23285, 0);
                  if (D.23286 != 0) goto <D.23287>; else goto <D.23288>;
                  <D.23287>:
                  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 3860, "exc");
                  <D.23288>:
                }
              finally
                {
                  dummy = {CLOBBER};
                }
            }
            goto <D.23289>;
            <D.23283>:
            D.23290 = mono_get_corlib ();
            exc = mono_exception_from_name_msg (D.23290, "System.Runtime.Serialization", "SerializationException", "Could not serialize unhandled exception.");
            <D.23289>:
            <D.23280>:
          }
        finally
          {
            serialization_exc = {CLOBBER};
          }
      }
      <D.23278>:
      D.23275 = exc->vtable;
      D.23276 = D.23275->domain;
      D.23291 = D.23276 != domain;
      D.23292 = (long int) D.23291;
      D.23293 = __builtin_expect (D.23292, 0);
      if (D.23293 != 0) goto <D.23294>; else goto <D.23295>;
      <D.23294>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 3868, "mono_object_domain (exc) == domain");
      <D.23295>:
      D.23267 = domain->domain;
      pa[0] = D.23267;
      D.23296 = create_unhandled_exception_eventargs (exc);
      pa[1] = D.23296;
      mono_runtime_delegate_invoke (delegate, &pa, &e);
      if (domain != current_domain) goto <D.23297>; else goto <D.23298>;
      <D.23297>:
      mono_domain_set_internal_with_options (current_domain, 0);
      <D.23298>:
      e.166 = e;
      if (e.166 != 0B) goto <D.23300>; else goto <D.23301>;
      <D.23300>:
      {
        struct MonoError error;
        gchar * msg;

        try
          {
            e.166 = e;
            D.23302 = MEM[(struct MonoException *)e.166].message;
            msg = mono_string_to_utf8_checked (D.23302, &error);
            D.23303 = mono_error_ok (&error);
            if (D.23303 == 0) goto <D.23304>; else goto <D.23305>;
            <D.23304>:
            monoeg_g_log (0B, 16, "Exception inside UnhandledException handler with invalid message (Invalid characters)\n");
            mono_error_cleanup (&error);
            goto <D.23306>;
            <D.23305>:
            monoeg_g_log (0B, 16, "exception inside UnhandledException handler: %s\n", msg);
            monoeg_g_free (msg);
            <D.23306>:
          }
        finally
          {
            error = {CLOBBER};
          }
      }
      <D.23301>:
    }
  finally
    {
      e = {CLOBBER};
      pa = {CLOBBER};
    }
}


create_unhandled_exception_eventargs (struct MonoObject * exc)
{
  struct MonoImage * D.23307;
  _Bool D.23308;
  long int D.23309;
  long int D.23310;
  _Bool D.23313;
  long int D.23314;
  long int D.23315;
  struct MonoDomain * D.23318;
  struct MonoObject * D.23319;
  struct MonoClass * klass;
  void * args[2];
  struct MonoMethod * method;
  MonoBoolean is_terminating;
  struct MonoObject * obj;

  try
    {
      method = 0B;
      is_terminating = 1;
      D.23307 = mono_defaults.corlib;
      klass = mono_class_from_name (D.23307, "System", "UnhandledExceptionEventArgs");
      D.23308 = klass == 0B;
      D.23309 = (long int) D.23308;
      D.23310 = __builtin_expect (D.23309, 0);
      if (D.23310 != 0) goto <D.23311>; else goto <D.23312>;
      <D.23311>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 3823, "klass");
      <D.23312>:
      mono_class_init (klass);
      method = mono_class_get_method_from_name_flags (klass, ".ctor", 2, 6);
      D.23313 = method == 0B;
      D.23314 = (long int) D.23313;
      D.23315 = __builtin_expect (D.23314, 0);
      if (D.23315 != 0) goto <D.23316>; else goto <D.23317>;
      <D.23316>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 3829, "method");
      <D.23317>:
      args[0] = exc;
      args[1] = &is_terminating;
      D.23318 = mono_domain_get ();
      obj = mono_object_new (D.23318, klass);
      mono_runtime_invoke (method, obj, &args, 0B);
      D.23319 = obj;
      return D.23319;
    }
  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.23322;
  long int D.23323;
  long int D.23324;
  struct MonoVTable * D.23327;
  struct MonoAssembly * D.23328;
  struct MonoClass * D.23331;
  struct MonoImage * D.23332;
  struct MonoAppDomainSetup * D.23333;
  struct MonoString * D.23334;
  struct MonoString * * D.23337;
  char * D.23338;
  struct MonoString * D.23339;
  struct MonoString * D.23340;
  struct MonoImage * D.23343;
  char * D.23344;
  struct MonoString * * D.23345;
  struct MonoString * D.23346;
  struct MonoClass * stathread_attribute.167;
  struct MonoImage * D.23352;
  struct MonoClass * stathread_attribute.168;
  int D.23354;
  struct MonoMethodSignature * D.23361;
  struct MonoType * D.23362;
  unsigned char D.23363;
  struct MonoObject * D.23370;
  guint32 * D.23371;
  unsigned int D.23372;
  int D.23378;
  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.23322 = args == 0B;
      D.23323 = (long int) D.23322;
      D.23324 = __builtin_expect (D.23323, 0);
      if (D.23324 != 0) goto <D.23325>; else goto <D.23326>;
      <D.23325>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 4008, "args");
      <D.23326>:
      pa[0] = args;
      D.23327 = MEM[(struct MonoObject *)args].vtable;
      domain = D.23327->domain;
      D.23328 = domain->entry_assembly;
      if (D.23328 == 0B) goto <D.23329>; else goto <D.23330>;
      <D.23329>:
      {
        gchar * str;
        struct MonoAssembly * assembly;

        D.23331 = method->klass;
        D.23332 = D.23331->image;
        assembly = D.23332->assembly;
        domain->entry_assembly = assembly;
        D.23333 = domain->setup;
        D.23334 = D.23333->application_base;
        if (D.23334 == 0B) goto <D.23335>; else goto <D.23336>;
        <D.23335>:
        D.23333 = domain->setup;
        D.23333 = domain->setup;
        D.23337 = &D.23333->application_base;
        D.23338 = assembly->basedir;
        D.23339 = mono_string_new (domain, D.23338);
        mono_gc_wbarrier_set_field (D.23333, D.23337, D.23339);
        <D.23336>:
        D.23333 = domain->setup;
        D.23340 = D.23333->configuration_file;
        if (D.23340 == 0B) goto <D.23341>; else goto <D.23342>;
        <D.23341>:
        D.23343 = assembly->image;
        D.23344 = D.23343->name;
        str = monoeg_g_strconcat (D.23344, ".config", 0B);
        D.23333 = domain->setup;
        D.23333 = domain->setup;
        D.23345 = &D.23333->configuration_file;
        D.23346 = mono_string_new (domain, str);
        mono_gc_wbarrier_set_field (D.23333, D.23345, D.23346);
        monoeg_g_free (str);
        mono_set_private_bin_path_from_config (domain);
        <D.23342>:
      }
      <D.23330>:
      cinfo = mono_custom_attrs_from_method (method);
      if (cinfo != 0B) goto <D.23347>; else goto <D.23348>;
      <D.23347>:
      {
        static struct MonoClass * stathread_attribute = 0B;

        stathread_attribute.167 = stathread_attribute;
        if (stathread_attribute.167 == 0B) goto <D.23350>; else goto <D.23351>;
        <D.23350>:
        D.23352 = mono_defaults.corlib;
        stathread_attribute.168 = mono_class_from_name (D.23352, "System", "STAThreadAttribute");
        stathread_attribute = stathread_attribute.168;
        <D.23351>:
        stathread_attribute.167 = stathread_attribute;
        has_stathread_attribute = mono_custom_attrs_has_attr (cinfo, stathread_attribute.167);
        D.23354 = cinfo->cached;
        if (D.23354 == 0) goto <D.23355>; else goto <D.23356>;
        <D.23355>:
        mono_custom_attrs_free (cinfo);
        <D.23356>:
      }
      goto <D.23357>;
      <D.23348>:
      has_stathread_attribute = 0;
      <D.23357>:
      if (has_stathread_attribute != 0) goto <D.23358>; else goto <D.23359>;
      <D.23358>:
      thread->apartment_state = 0;
      goto <D.23360>;
      <D.23359>:
      thread->apartment_state = 1;
      <D.23360>:
      mono_thread_init_apartment_state ();
      D.23361 = mono_method_signature (method);
      D.23362 = D.23361->ret;
      D.23363 = D.23362->type;
      if (D.23363 == 8) goto <D.23364>; else goto <D.23365>;
      <D.23364>:
      {
        struct MonoObject * res;

        res = mono_runtime_invoke (method, 0B, &pa, exc);
        if (exc == 0B) goto <D.23366>; else goto <D.23369>;
        <D.23369>:
        D.23370 = *exc;
        if (D.23370 == 0B) goto <D.23366>; else goto <D.23367>;
        <D.23366>:
        D.23371 = res + 8;
        D.23372 = *D.23371;
        rval = (int) D.23372;
        goto <D.23368>;
        <D.23367>:
        rval = -1;
        <D.23368>:
        mono_environment_exitcode_set (rval);
      }
      goto <D.23373>;
      <D.23365>:
      mono_runtime_invoke (method, 0B, &pa, exc);
      if (exc == 0B) goto <D.23374>; else goto <D.23377>;
      <D.23377>:
      D.23370 = *exc;
      if (D.23370 == 0B) goto <D.23374>; else goto <D.23375>;
      <D.23374>:
      rval = 0;
      goto <D.23376>;
      <D.23375>:
      rval = -1;
      mono_environment_exitcode_set (rval);
      <D.23376>:
      <D.23373>:
      D.23378 = rval;
      return D.23378;
    }
  finally
    {
      pa = {CLOBBER};
    }
}


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

  if (func != 0B) goto <D.23382>; else goto <D.23383>;
  <D.23382>:
  iftmp.169 = func;
  goto <D.23384>;
  <D.23383>:
  iftmp.169 = dummy_mono_runtime_invoke;
  <D.23384>:
  default_mono_runtime_invoke = iftmp.169;
}


mono_runtime_invoke_array (struct MonoMethod * method, void * obj, struct MonoArray * params, struct MonoObject * * exc)
{
  unsigned int D.23387;
  unsigned int D.23388;
  unsigned char D.23389;
  int D.23390;
  struct MonoType * D.23394;
  struct MonoClass * D.23395;
  int D.23396;
  unsigned int i.170;
  unsigned int D.23399;
  void * * D.23400;
  unsigned int i.171;
  char * D.23402;
  struct MonoObject * D.23403;
  unsigned int D.23404;
  unsigned int D.23405;
  char * D.23408;
  struct MonoObject * D.23409;
  struct MonoDomain * D.23412;
  struct MonoClass * D.23413;
  struct MonoObject * D.23414;
  char * D.23417;
  struct MonoDomain * D.23418;
  struct MonoVTable * D.23419;
  struct MonoClass * D.23420;
  void * D.23421;
  char * D.23422;
  struct MonoObject * D.23423;
  void * D.23424;
  char * D.23427;
  char * D.23429;
  struct MonoObject * D.23430;
  struct MonoGenericClass * D.23433;
  struct MonoClass * D.23434;
  char * D.23436;
  struct MonoVTable * D.23440;
  struct MonoClass * D.23441;
  struct MonoClass * D.23442;
  _Bool D.23443;
  long int D.23444;
  long int D.23445;
  void * D.23448;
  unsigned char D.23449;
  int D.23450;
  unsigned int D.23451;
  int D.19767;
  int iftmp.172;
  int D.19766;
  const char[6] * D.23456;
  unsigned char D.23457;
  int D.23458;
  unsigned char D.23459;
  int D.23460;
  const unsigned char * D.23465;
  unsigned char D.23466;
  int D.23467;
  const unsigned char * D.23468;
  unsigned char D.23469;
  int D.23470;
  const unsigned char * D.23475;
  unsigned char D.23476;
  int D.23477;
  const unsigned char * D.23478;
  unsigned char D.23479;
  int D.23480;
  const unsigned char * D.23485;
  unsigned char D.23486;
  int D.23487;
  const unsigned char * D.23488;
  unsigned char D.23489;
  int D.23490;
  const char * D.23492;
  struct MonoClass * D.23494;
  struct MonoClass * D.23495;
  int D.23497;
  _Bool D.23500;
  long int D.23501;
  long int D.23502;
  struct MonoObject * D.23507;
  struct MonoDomain * D.23508;
  struct MonoClass * D.23509;
  void * D.23510;
  struct MonoDomain * D.23513;
  _Bool D.23514;
  long int D.23515;
  long int D.23516;
  struct MonoVTable * D.23519;
  struct MonoClass * D.23520;
  struct MonoClass * D.23521;
  struct MonoMethod * iftmp.173;
  short int D.23525;
  struct MonoMethod * * D.23528;
  unsigned int D.23529;
  unsigned int D.23530;
  struct MonoMethod * * D.23531;
  unsigned int D.23533;
  unsigned int D.23534;
  struct MonoDomain * D.23541;
  int D.23542;
  struct MonoDomain * D.23545;
  void * D.23546;
  struct MonoDomain * D.23547;
  struct MonoObject * D.23548;
  struct MonoType * D.23549;
  unsigned char D.23550;
  struct MonoClass * pointer_class.176;
  struct MonoClass * tmp_klass.174;
  struct MonoImage * D.23558;
  struct MonoClass * tmp_klass.175;
  _Bool D.23560;
  long int D.23561;
  long int D.23562;
  struct MonoMethod * box_method.177;
  struct MonoMethod * box_method.178;
  struct MonoVTable * D.23569;
  struct MonoClass * D.23570;
  _Bool D.23571;
  long int D.23572;
  long int D.23573;
  void * D.23576;
  struct MonoDomain * D.23577;
  struct MonoReflectionType * D.23578;
  struct MonoObject * box_exc.179;
  _Bool D.23580;
  long int D.23581;
  long int D.23582;
  unsigned int D.23587;
  unsigned int D.23588;
  struct MonoClass * D.23591;
  int D.23592;
  void * D.23595;
  unsigned int D.23596;
  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.23385>; else goto <D.23386>;
  <D.23385>:
  D.23387 = mono_array_length (params);
  D.23388 = D.23387 * 4;
  pa = __builtin_alloca (D.23388);
  i = 0;
  goto <D.19757>;
  <D.19756>:
  {
    struct MonoType * t;

    t = sig->params[i];
    again:
    D.23389 = t->type;
    D.23390 = (int) D.23389;
    switch (D.23390) <default: <D.19754>, case 2: <D.19728>, case 3: <D.19731>, case 4: <D.19727>, case 5: <D.19726>, case 6: <D.19730>, case 7: <D.19729>, case 8: <D.19735>, case 9: <D.19734>, case 10: <D.19737>, case 11: <D.19736>, case 12: <D.19738>, case 13: <D.19739>, case 14: <D.19746>, case 15: <D.19752>, case 17: <D.19740>, case 18: <D.19748>, case 20: <D.19749>, case 21: <D.19751>, case 24: <D.19733>, case 25: <D.19732>, case 28: <D.19747>, case 29: <D.19750>>
    <D.19726>:
    <D.19727>:
    <D.19728>:
    <D.19729>:
    <D.19730>:
    <D.19731>:
    <D.19732>:
    <D.19733>:
    <D.19734>:
    <D.19735>:
    <D.19736>:
    <D.19737>:
    <D.19738>:
    <D.19739>:
    <D.19740>:
    D.23389 = t->type;
    if (D.23389 == 17) goto <D.23393>; else goto <D.23391>;
    <D.23393>:
    D.23394 = sig->params[i];
    D.23395 = mono_class_from_mono_type (D.23394);
    D.23396 = mono_class_is_nullable (D.23395);
    if (D.23396 != 0) goto <D.23397>; else goto <D.23391>;
    <D.23397>:
    i.170 = (unsigned int) i;
    D.23399 = i.170 * 4;
    D.23400 = pa + D.23399;
    i.171 = (unsigned int) i;
    D.23402 = mono_array_addr_with_size (params, 4, i.171);
    D.23403 = MEM[(struct MonoObject * *)D.23402];
    *D.23400 = D.23403;
    D.23404 = BIT_FIELD_REF <*t, 32, 32>;
    D.23405 = D.23404 & 1073741824;
    if (D.23405 != 0) goto <D.23406>; else goto <D.23407>;
    <D.23406>:
    has_byref_nullables = 1;
    <D.23407>:
    goto <D.23392>;
    <D.23391>:
    i.171 = (unsigned int) i;
    D.23408 = mono_array_addr_with_size (params, 4, i.171);
    D.23409 = MEM[(struct MonoObject * *)D.23408];
    if (D.23409 == 0B) goto <D.23410>; else goto <D.23411>;
    <D.23410>:
    {
      void * * __p;

      i.171 = (unsigned int) i;
      __p = mono_array_addr_with_size (params, 4, i.171);
      D.23412 = mono_domain_get ();
      D.23394 = sig->params[i];
      D.23413 = mono_class_from_mono_type (D.23394);
      D.23414 = mono_object_new (D.23412, D.23413);
      mono_gc_wbarrier_set_arrayref (params, __p, D.23414);
    }
    <D.23411>:
    D.23404 = BIT_FIELD_REF <*t, 32, 32>;
    D.23405 = D.23404 & 1073741824;
    if (D.23405 != 0) goto <D.23415>; else goto <D.23416>;
    <D.23415>:
    {
      struct MonoObject * orig;
      struct MonoObject * copy;

      i.171 = (unsigned int) i;
      D.23417 = mono_array_addr_with_size (params, 4, i.171);
      orig = MEM[(struct MonoObject * *)D.23417];
      D.23418 = mono_domain_get ();
      D.23419 = orig->vtable;
      D.23420 = D.23419->klass;
      D.23421 = mono_object_unbox (orig);
      copy = mono_value_box (D.23418, D.23420, D.23421);
      {
        void * * __p;

        i.171 = (unsigned int) i;
        __p = mono_array_addr_with_size (params, 4, i.171);
        mono_gc_wbarrier_set_arrayref (params, __p, copy);
      }
    }
    <D.23416>:
    i.170 = (unsigned int) i;
    D.23399 = i.170 * 4;
    D.23400 = pa + D.23399;
    i.171 = (unsigned int) i;
    D.23422 = mono_array_addr_with_size (params, 4, i.171);
    D.23423 = MEM[(struct MonoObject * *)D.23422];
    D.23424 = mono_object_unbox (D.23423);
    *D.23400 = D.23424;
    <D.23392>:
    goto <D.19745>;
    <D.19746>:
    <D.19747>:
    <D.19748>:
    <D.19749>:
    <D.19750>:
    D.23404 = BIT_FIELD_REF <*t, 32, 32>;
    D.23405 = D.23404 & 1073741824;
    if (D.23405 != 0) goto <D.23425>; else goto <D.23426>;
    <D.23425>:
    i.170 = (unsigned int) i;
    D.23399 = i.170 * 4;
    D.23400 = pa + D.23399;
    i.171 = (unsigned int) i;
    D.23427 = mono_array_addr_with_size (params, 4, i.171);
    *D.23400 = D.23427;
    goto <D.23428>;
    <D.23426>:
    i.170 = (unsigned int) i;
    D.23399 = i.170 * 4;
    D.23400 = pa + D.23399;
    i.171 = (unsigned int) i;
    D.23429 = mono_array_addr_with_size (params, 4, i.171);
    D.23430 = MEM[(struct MonoObject * *)D.23429];
    *D.23400 = D.23430;
    <D.23428>:
    goto <D.19745>;
    <D.19751>:
    D.23404 = BIT_FIELD_REF <*t, 32, 32>;
    D.23405 = D.23404 & 1073741824;
    if (D.23405 != 0) goto <D.23431>; else goto <D.23432>;
    <D.23431>:
    D.23433 = t->data.generic_class;
    D.23434 = D.23433->container_class;
    t = &D.23434->this_arg;
    goto <D.23435>;
    <D.23432>:
    D.23433 = t->data.generic_class;
    D.23434 = D.23433->container_class;
    t = &D.23434->byval_arg;
    <D.23435>:
    goto again;
    <D.19752>:
    {
      struct MonoObject * arg;

      i.171 = (unsigned int) i;
      D.23436 = mono_array_addr_with_size (params, 4, i.171);
      arg = MEM[(struct MonoObject * *)D.23436];
      if (arg == 0B) goto <D.23437>; else goto <D.23438>;
      <D.23437>:
      i.170 = (unsigned int) i;
      D.23399 = i.170 * 4;
      D.23400 = pa + D.23399;
      *D.23400 = 0B;
      goto <D.23439>;
      <D.23438>:
      D.23440 = arg->vtable;
      D.23441 = D.23440->klass;
      D.23442 = mono_defaults.int_class;
      D.23443 = D.23441 != D.23442;
      D.23444 = (long int) D.23443;
      D.23445 = __builtin_expect (D.23444, 0);
      if (D.23445 != 0) goto <D.23446>; else goto <D.23447>;
      <D.23446>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 4211, "arg->vtable->klass == mono_defaults.int_class");
      <D.23447>:
      i.170 = (unsigned int) i;
      D.23399 = i.170 * 4;
      D.23400 = pa + D.23399;
      D.23448 = MEM[(struct MonoIntPtr *)arg].m_value;
      *D.23400 = D.23448;
      <D.23439>:
      goto <D.19745>;
    }
    <D.19754>:
    D.23394 = sig->params[i];
    D.23449 = D.23394->type;
    D.23450 = (int) D.23449;
    monoeg_g_log (0B, 4, "type 0x%x not handled in mono_runtime_invoke_array", D.23450);
    <D.19755>:
    goto <D.19755>;
    <D.19745>:
  }
  i = i + 1;
  <D.19757>:
  i.171 = (unsigned int) i;
  D.23451 = mono_array_length (params);
  if (i.171 < D.23451) goto <D.19756>; else goto <D.19758>;
  <D.19758>:
  <D.23386>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = method->name;
      D.23456 = ".ctor";
      D.23457 = MEM[(const unsigned char *)D.23456];
      D.23458 = (int) D.23457;
      D.23459 = *__s2;
      D.23460 = (int) D.23459;
      __result = D.23458 - D.23460;
      {
        if (__s2_len != 0) goto <D.23461>; else goto <D.23462>;
        <D.23461>:
        if (__result == 0) goto <D.23463>; else goto <D.23464>;
        <D.23463>:
        D.23465 = &MEM[(void *)".ctor" + 1B];
        D.23466 = *D.23465;
        D.23467 = (int) D.23466;
        D.23468 = __s2 + 1;
        D.23469 = *D.23468;
        D.23470 = (int) D.23469;
        __result = D.23467 - D.23470;
        if (__s2_len > 1) goto <D.23471>; else goto <D.23472>;
        <D.23471>:
        if (__result == 0) goto <D.23473>; else goto <D.23474>;
        <D.23473>:
        D.23475 = &MEM[(void *)".ctor" + 2B];
        D.23476 = *D.23475;
        D.23477 = (int) D.23476;
        D.23478 = __s2 + 2;
        D.23479 = *D.23478;
        D.23480 = (int) D.23479;
        __result = D.23477 - D.23480;
        if (__s2_len > 2) goto <D.23481>; else goto <D.23482>;
        <D.23481>:
        if (__result == 0) goto <D.23483>; else goto <D.23484>;
        <D.23483>:
        D.23485 = &MEM[(void *)".ctor" + 3B];
        D.23486 = *D.23485;
        D.23487 = (int) D.23486;
        D.23488 = __s2 + 3;
        D.23489 = *D.23488;
        D.23490 = (int) D.23489;
        __result = D.23487 - D.23490;
        <D.23484>:
        <D.23482>:
        <D.23474>:
        <D.23472>:
        <D.23464>:
        <D.23462>:
      }
      D.19766 = __result;
    }
    iftmp.172 = -D.19766;
    goto <D.23491>;
    <D.23455>:
    D.23492 = method->name;
    iftmp.172 = __builtin_strcmp (D.23492, ".ctor");
    <D.23491>:
    D.19767 = iftmp.172;
  }
  if (D.19767 == 0) goto <D.23493>; else goto <D.23452>;
  <D.23493>:
  D.23494 = method->klass;
  D.23495 = mono_defaults.string_class;
  if (D.23494 != D.23495) goto <D.23496>; else goto <D.23452>;
  <D.23496>:
  {
    void * o;

    o = obj;
    D.23494 = method->klass;
    D.23497 = mono_class_is_nullable (D.23494);
    if (D.23497 != 0) goto <D.23498>; else goto <D.23499>;
    <D.23498>:
    D.23500 = obj != 0B;
    D.23501 = (long int) D.23500;
    D.23502 = __builtin_expect (D.23501, 0);
    if (D.23502 != 0) goto <D.23503>; else goto <D.23504>;
    <D.23503>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 4227, "!obj");
    <D.23504>:
    if (params == 0B) goto <D.23505>; else goto <D.23506>;
    <D.23505>:
    D.23507 = 0B;
    return D.23507;
    <D.23506>:
    D.23508 = mono_domain_get ();
    D.23494 = method->klass;
    D.23509 = D.23494->cast_class;
    D.23510 = *pa;
    D.23507 = mono_value_box (D.23508, D.23509, D.23510);
    return D.23507;
    <D.23499>:
    if (obj == 0B) goto <D.23511>; else goto <D.23512>;
    <D.23511>:
    D.23513 = mono_domain_get ();
    D.23494 = method->klass;
    obj = mono_object_new (D.23513, D.23494);
    D.23514 = obj == 0B;
    D.23515 = (long int) D.23514;
    D.23516 = __builtin_expect (D.23515, 0);
    if (D.23516 != 0) goto <D.23517>; else goto <D.23518>;
    <D.23517>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 4237, "obj");
    <D.23518>:
    D.23519 = MEM[(struct MonoObject *)obj].vtable;
    D.23520 = D.23519->klass;
    D.23521 = mono_defaults.transparent_proxy_class;
    if (D.23520 == D.23521) goto <D.23522>; else goto <D.23523>;
    <D.23522>:
    D.23525 = method->slot;
    if (D.23525 != -1) goto <D.23526>; else goto <D.23527>;
    <D.23526>:
    D.23494 = method->klass;
    D.23528 = D.23494->vtable;
    D.23525 = method->slot;
    D.23529 = (unsigned int) D.23525;
    D.23530 = D.23529 * 4;
    D.23531 = D.23528 + D.23530;
    iftmp.173 = *D.23531;
    goto <D.23532>;
    <D.23527>:
    iftmp.173 = method;
    <D.23532>:
    method = mono_marshal_get_remoting_invoke (iftmp.173);
    <D.23523>:
    D.23494 = method->klass;
    D.23533 = BIT_FIELD_REF <*D.23494, 32, 160>;
    D.23534 = D.23533 & 8;
    if (D.23534 != 0) goto <D.23535>; else goto <D.23536>;
    <D.23535>:
    o = mono_object_unbox (obj);
    goto <D.23537>;
    <D.23536>:
    o = obj;
    <D.23537>:
    goto <D.23538>;
    <D.23512>:
    D.23494 = method->klass;
    D.23533 = BIT_FIELD_REF <*D.23494, 32, 160>;
    D.23534 = D.23533 & 8;
    if (D.23534 != 0) goto <D.23539>; else goto <D.23540>;
    <D.23539>:
    D.23541 = mono_domain_get ();
    D.23494 = method->klass;
    obj = mono_value_box (D.23541, D.23494, obj);
    <D.23540>:
    <D.23538>:
    mono_runtime_invoke (method, o, pa, exc);
    D.23507 = obj;
    return D.23507;
  }
  <D.23452>:
  D.23494 = method->klass;
  D.23542 = mono_class_is_nullable (D.23494);
  if (D.23542 != 0) goto <D.23543>; else goto <D.23544>;
  <D.23543>:
  {
    struct MonoObject * nullable;

    D.23545 = mono_domain_get ();
    D.23494 = method->klass;
    nullable = mono_object_new (D.23545, D.23494);
    D.23546 = mono_object_unbox (nullable);
    D.23547 = mono_domain_get ();
    D.23494 = method->klass;
    D.23509 = D.23494->cast_class;
    D.23548 = mono_value_box (D.23547, D.23509, obj);
    D.23494 = method->klass;
    mono_nullable_init (D.23546, D.23548, D.23494);
    obj = mono_object_unbox (nullable);
  }
  <D.23544>:
  res = mono_runtime_invoke (method, obj, pa, exc);
  D.23549 = sig->ret;
  D.23550 = D.23549->type;
  if (D.23550 == 15) goto <D.23551>; else goto <D.23552>;
  <D.23551>:
  {
    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.174 = tmp_klass;
            if (tmp_klass.174 == 0B) goto <D.23554>; else goto <D.23555>;
            <D.23554>:
            if (0 != 0) goto <D.23556>; else goto <D.23557>;
            <D.23556>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 4277, "mono_defaults.corlib == mono_defaults.corlib");
            <D.23557>:
            D.23558 = mono_defaults.corlib;
            tmp_klass.175 = mono_class_from_name (D.23558, "System.Reflection", "Pointer");
            tmp_klass = tmp_klass.175;
            tmp_klass.174 = tmp_klass;
            D.23560 = tmp_klass.174 == 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", 4277, "tmp_klass");
            <D.23564>:
            <D.23555>:
          }
          pointer_class.176 = tmp_klass;
        }
        pointer_class = pointer_class.176;
        box_method.177 = box_method;
        if (box_method.177 == 0B) goto <D.23566>; else goto <D.23567>;
        <D.23566>:
        box_method.178 = mono_class_get_method_from_name (pointer_class, "Box", -1);
        box_method = box_method.178;
        <D.23567>:
        D.23569 = res->vtable;
        D.23570 = D.23569->klass;
        D.23442 = mono_defaults.int_class;
        D.23571 = D.23570 != D.23442;
        D.23572 = (long int) D.23571;
        D.23573 = __builtin_expect (D.23572, 0);
        if (D.23573 != 0) goto <D.23574>; else goto <D.23575>;
        <D.23574>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 4281, "res->vtable->klass == mono_defaults.int_class");
        <D.23575>:
        D.23576 = MEM[(struct MonoIntPtr *)res].m_value;
        box_args[0] = D.23576;
        D.23577 = mono_domain_get ();
        D.23549 = sig->ret;
        D.23578 = mono_type_get_object (D.23577, D.23549);
        box_args[1] = D.23578;
        box_method.177 = box_method;
        res = mono_runtime_invoke (box_method.177, 0B, &box_args, &box_exc);
        box_exc.179 = box_exc;
        D.23580 = box_exc.179 != 0B;
        D.23581 = (long int) D.23580;
        D.23582 = __builtin_expect (D.23581, 0);
        if (D.23582 != 0) goto <D.23583>; else goto <D.23584>;
        <D.23583>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 4285, "!box_exc");
        <D.23584>:
      }
    finally
      {
        box_args = {CLOBBER};
        box_exc = {CLOBBER};
      }
  }
  <D.23552>:
  if (has_byref_nullables != 0) goto <D.23585>; else goto <D.23586>;
  <D.23585>:
  i = 0;
  goto <D.19779>;
  <D.19778>:
  {
    struct MonoType * t;

    t = sig->params[i];
    D.23587 = BIT_FIELD_REF <*t, 32, 32>;
    D.23588 = D.23587 & 1090453504;
    if (D.23588 == 1075118080) goto <D.23589>; else goto <D.23590>;
    <D.23589>:
    D.23591 = mono_class_from_mono_type (t);
    D.23592 = mono_class_is_nullable (D.23591);
    if (D.23592 != 0) goto <D.23593>; else goto <D.23594>;
    <D.23593>:
    {
      void * * __p;

      i.171 = (unsigned int) i;
      __p = mono_array_addr_with_size (params, 4, i.171);
      i.170 = (unsigned int) i;
      D.23399 = i.170 * 4;
      D.23400 = pa + D.23399;
      D.23595 = *D.23400;
      mono_gc_wbarrier_set_arrayref (params, __p, D.23595);
    }
    <D.23594>:
    <D.23590>:
  }
  i = i + 1;
  <D.19779>:
  i.171 = (unsigned int) i;
  D.23596 = mono_array_length (params);
  if (i.171 < D.23596) goto <D.19778>; else goto <D.19780>;
  <D.19780>:
  <D.23586>:
  D.23507 = res;
  return D.23507;
}


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

  vtable = mono_class_vtable (domain, klass);
  if (vtable == 0B) goto <D.23598>; else goto <D.23599>;
  <D.23598>:
  D.23600 = 0B;
  return D.23600;
  <D.23599>:
  D.23600 = mono_object_new_specific (vtable);
  return D.23600;
}


mono_object_new_pinned (struct MonoDomain * domain, struct MonoClass * klass)
{
  struct MonoObject * D.23604;
  int D.23605;
  unsigned int D.23606;
  struct MonoVTable * vtable;

  vtable = mono_class_vtable (domain, klass);
  if (vtable == 0B) goto <D.23602>; else goto <D.23603>;
  <D.23602>:
  D.23604 = 0B;
  return D.23604;
  <D.23603>:
  D.23605 = mono_class_instance_size (klass);
  D.23606 = (unsigned int) D.23605;
  D.23604 = mono_gc_alloc_pinned_obj (vtable, D.23606);
  return D.23604;
}


mono_object_new_specific (struct MonoVTable * vtable)
{
  unsigned int D.23610;
  unsigned int D.23611;
  struct MonoClass * D.23613;
  unsigned int D.23614;
  unsigned int D.23615;
  struct MonoDomain * D.23616;
  struct MonoImage * D.23619;
  unsigned int D.23620;
  unsigned int D.23621;
  _Bool D.23624;
  long int D.23625;
  long int D.23626;
  struct MonoDomain * D.23629;
  struct MonoType * D.23630;
  struct MonoReflectionType * D.23631;
  struct MonoObject * D.23634;
  struct MonoObject * o;

  D.23610 = BIT_FIELD_REF <*vtable, 32, 160>;
  D.23611 = D.23610 & 16777216;
  if (D.23611 != 0) goto <D.23608>; else goto <D.23612>;
  <D.23612>:
  D.23613 = vtable->klass;
  D.23614 = BIT_FIELD_REF <*D.23613, 32, 160>;
  D.23615 = D.23614 & 1073741824;
  if (D.23615 != 0) goto <D.23608>; else goto <D.23609>;
  <D.23608>:
  {
    void * pa[1];
    struct MonoMethod * im;

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

          D.23619 = mono_defaults.corlib;
          klass = mono_class_from_name (D.23619, "System.Runtime.Remoting.Activation", "ActivationServices");
          D.23620 = BIT_FIELD_REF <*klass, 32, 160>;
          D.23621 = D.23620 & 1;
          if (D.23621 == 0) goto <D.23622>; else goto <D.23623>;
          <D.23622>:
          mono_class_init (klass);
          <D.23623>:
          im = mono_class_get_method_from_name (klass, "CreateProxyForType", 1);
          D.23624 = im == 0B;
          D.23625 = (long int) D.23624;
          D.23626 = __builtin_expect (D.23625, 0);
          if (D.23626 != 0) goto <D.23627>; else goto <D.23628>;
          <D.23627>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 4430, "im");
          <D.23628>:
          D.23616 = vtable->domain;
          D.23616->create_proxy_for_type_method = im;
        }
        <D.23618>:
        D.23629 = mono_domain_get ();
        D.23613 = vtable->klass;
        D.23630 = &D.23613->byval_arg;
        D.23631 = mono_type_get_object (D.23629, D.23630);
        pa[0] = D.23631;
        o = mono_runtime_invoke (im, 0B, &pa, 0B);
        if (o != 0B) goto <D.23632>; else goto <D.23633>;
        <D.23632>:
        D.23634 = o;
        return D.23634;
        <D.23633>:
      }
    finally
      {
        pa = {CLOBBER};
      }
  }
  <D.23609>:
  D.23634 = mono_object_new_alloc_specific (vtable);
  return D.23634;
}


mono_object_new_alloc_specific (struct MonoVTable * vtable)
{
  struct MonoClass * D.23638;
  unsigned int D.23639;
  unsigned int D.23640;
  void * D.23644;
  int D.23647;
  unsigned int D.23648;
  unsigned int D.23650;
  _Bool D.23651;
  long int D.23652;
  long int D.23653;
  int profile_allocs.180;
  _Bool D.23657;
  long int D.23658;
  long int D.23659;
  struct MonoObject * D.23662;
  struct MonoObject * o;

  D.23638 = vtable->klass;
  D.23639 = BIT_FIELD_REF <*D.23638, 32, 160>;
  D.23640 = D.23639 & 134217728;
  if (D.23640 == 0) goto <D.23641>; else goto <D.23642>;
  <D.23641>:
  o = mono_object_new_ptrfree (vtable);
  goto <D.23643>;
  <D.23642>:
  D.23644 = vtable->gc_descr;
  if (D.23644 != 0B) goto <D.23645>; else goto <D.23646>;
  <D.23645>:
  D.23638 = vtable->klass;
  D.23647 = D.23638->instance_size;
  D.23648 = (unsigned int) D.23647;
  o = mono_object_allocate_spec (D.23648, vtable);
  goto <D.23649>;
  <D.23646>:
  D.23638 = vtable->klass;
  D.23647 = D.23638->instance_size;
  D.23648 = (unsigned int) D.23647;
  o = mono_object_allocate (D.23648, vtable);
  <D.23649>:
  <D.23643>:
  D.23638 = vtable->klass;
  D.23639 = BIT_FIELD_REF <*D.23638, 32, 160>;
  D.23650 = D.23639 & 2097152;
  D.23651 = D.23650 != 0;
  D.23652 = (long int) D.23651;
  D.23653 = __builtin_expect (D.23652, 0);
  if (D.23653 != 0) goto <D.23654>; else goto <D.23655>;
  <D.23654>:
  mono_object_register_finalizer (o);
  <D.23655>:
  profile_allocs.180 = profile_allocs;
  D.23657 = profile_allocs.180 != 0;
  D.23658 = (long int) D.23657;
  D.23659 = __builtin_expect (D.23658, 0);
  if (D.23659 != 0) goto <D.23660>; else goto <D.23661>;
  <D.23660>:
  D.23638 = vtable->klass;
  mono_profiler_allocation (o, D.23638);
  <D.23661>:
  D.23662 = o;
  return D.23662;
}


mono_object_allocate_spec (size_t size, struct MonoVTable * vtable)
{
  long long unsigned int D.23664;
  long long unsigned int D.23665;
  void * D.23666;
  void * o;

  o = mono_gc_alloc_obj (vtable, size);
  D.23664 = mono_stats.new_object_count;
  D.23665 = D.23664 + 1;
  mono_stats.new_object_count = D.23665;
  D.23666 = o;
  return D.23666;
}


mono_object_allocate (size_t size, struct MonoVTable * vtable)
{
  long long unsigned int D.23668;
  long long unsigned int D.23669;
  void * D.23670;
  struct MonoObject * o;

  D.23668 = mono_stats.new_object_count;
  D.23669 = D.23668 + 1;
  mono_stats.new_object_count = D.23669;
  o = mono_gc_alloc_obj (vtable, size);
  D.23670 = o;
  return D.23670;
}


mono_object_new_fast (struct MonoVTable * vtable)
{
  struct MonoClass * D.23672;
  int D.23673;
  unsigned int D.23674;
  struct MonoObject * D.23675;
  struct MonoObject * o;

  D.23672 = vtable->klass;
  D.23673 = D.23672->instance_size;
  D.23674 = (unsigned int) D.23673;
  o = mono_gc_alloc_obj (vtable, D.23674);
  D.23675 = o;
  return D.23675;
}


mono_class_get_allocation_ftn (struct MonoVTable * vtable, gboolean for_box, gboolean * pass_size_in_words)
{
  <unnamed type> D.23677;
  unsigned int D.23678;
  struct MonoClass * D.23683;
  int D.23684;
  unsigned int D.23686;
  unsigned int D.23687;
  <unnamed type> D.23689;
  unsigned int D.23690;
  void * D.23691;
  unsigned int D.23692;
  void * D.23697;

  *pass_size_in_words = 0;
  D.23677 = mono_profiler_get_events ();
  D.23678 = D.23677 & 128;
  if (D.23678 == 0) goto <D.23679>; else goto <D.23680>;
  <D.23679>:
  profile_allocs = 0;
  <D.23680>:
  D.23683 = vtable->klass;
  D.23684 = mono_class_has_finalizer (D.23683);
  if (D.23684 != 0) goto <D.23681>; else goto <D.23685>;
  <D.23685>:
  D.23683 = vtable->klass;
  D.23686 = BIT_FIELD_REF <*D.23683, 32, 160>;
  D.23687 = D.23686 & 4194304;
  if (D.23687 != 0) goto <D.23681>; else goto <D.23688>;
  <D.23688>:
  D.23689 = mono_profiler_get_events ();
  D.23690 = D.23689 & 128;
  if (D.23690 != 0) goto <D.23681>; else goto <D.23682>;
  <D.23681>:
  D.23691 = mono_object_new_specific;
  return D.23691;
  <D.23682>:
  D.23683 = vtable->klass;
  D.23686 = BIT_FIELD_REF <*D.23683, 32, 160>;
  D.23692 = D.23686 & 134217728;
  if (D.23692 == 0) goto <D.23693>; else goto <D.23694>;
  <D.23693>:
  if (for_box != 0) goto <D.23695>; else goto <D.23696>;
  <D.23695>:
  D.23691 = mono_object_new_ptrfree_box;
  return D.23691;
  <D.23696>:
  D.23691 = mono_object_new_ptrfree;
  return D.23691;
  <D.23694>:
  D.23697 = vtable->gc_descr;
  if (D.23697 != 0B) goto <D.23698>; else goto <D.23699>;
  <D.23698>:
  D.23691 = mono_object_new_fast;
  return D.23691;
  <D.23699>:
  D.23691 = mono_object_new_specific;
  return D.23691;
}


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

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


mono_object_clone (struct MonoObject * obj)
{
  struct MonoVTable * D.23703;
  struct MonoClass * D.23704;
  unsigned char D.23705;
  struct MonoObject * D.23708;
  unsigned int size.181;
  unsigned int D.23710;
  unsigned int D.23711;
  void * D.23715;
  const void * D.23716;
  unsigned int size.182;
  unsigned int D.23718;
  int profile_allocs.183;
  _Bool D.23720;
  long int D.23721;
  long int D.23722;
  unsigned int D.23725;
  struct MonoObject * o;
  int size;

  D.23703 = obj->vtable;
  D.23704 = D.23703->klass;
  size = D.23704->instance_size;
  D.23703 = obj->vtable;
  D.23704 = D.23703->klass;
  D.23705 = D.23704->rank;
  if (D.23705 != 0) goto <D.23706>; else goto <D.23707>;
  <D.23706>:
  D.23708 = mono_array_clone (obj);
  return D.23708;
  <D.23707>:
  size.181 = (unsigned int) size;
  D.23703 = obj->vtable;
  o = mono_object_allocate (size.181, D.23703);
  D.23703 = obj->vtable;
  D.23704 = D.23703->klass;
  D.23710 = BIT_FIELD_REF <*D.23704, 32, 160>;
  D.23711 = D.23710 & 134217728;
  if (D.23711 != 0) goto <D.23712>; else goto <D.23713>;
  <D.23712>:
  mono_gc_wbarrier_object_copy (o, obj);
  goto <D.23714>;
  <D.23713>:
  {
    int size;

    D.23703 = obj->vtable;
    D.23704 = D.23703->klass;
    size = D.23704->instance_size;
    D.23715 = o + 8;
    D.23716 = obj + 8;
    size.182 = (unsigned int) size;
    D.23718 = size.182 + 4294967288;
    mono_gc_memmove_atomic (D.23715, D.23716, D.23718);
  }
  <D.23714>:
  profile_allocs.183 = profile_allocs;
  D.23720 = profile_allocs.183 != 0;
  D.23721 = (long int) D.23720;
  D.23722 = __builtin_expect (D.23721, 0);
  if (D.23722 != 0) goto <D.23723>; else goto <D.23724>;
  <D.23723>:
  D.23703 = obj->vtable;
  D.23704 = D.23703->klass;
  mono_profiler_allocation (o, D.23704);
  <D.23724>:
  D.23703 = obj->vtable;
  D.23704 = D.23703->klass;
  D.23710 = BIT_FIELD_REF <*D.23704, 32, 160>;
  D.23725 = D.23710 & 2097152;
  if (D.23725 != 0) goto <D.23726>; else goto <D.23727>;
  <D.23726>:
  mono_object_register_finalizer (o);
  <D.23727>:
  D.23708 = o;
  return D.23708;
}


mono_array_full_copy (struct MonoArray * src, struct MonoArray * dest)
{
  struct MonoVTable * D.23729;
  struct MonoVTable * D.23730;
  struct MonoClass * D.23731;
  _Bool D.23732;
  long int D.23733;
  long int D.23734;
  unsigned int D.23737;
  _Bool D.23738;
  long int D.23739;
  long int D.23740;
  int D.23743;
  unsigned int D.23744;
  struct MonoClass * D.23745;
  unsigned int D.23746;
  unsigned int D.23747;
  unsigned int D.23750;
  double[0:] * D.23753;
  unsigned int D.23754;
  int D.23755;
  double[0:] * D.23757;
  unsigned int D.23759;
  int D.23760;
  uintptr_t size;
  struct MonoClass * klass;

  D.23729 = src->obj.vtable;
  klass = D.23729->klass;
  D.23730 = dest->obj.vtable;
  D.23731 = D.23730->klass;
  D.23732 = D.23731 != klass;
  D.23733 = (long int) D.23732;
  D.23734 = __builtin_expect (D.23733, 0);
  if (D.23734 != 0) goto <D.23735>; else goto <D.23736>;
  <D.23735>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 4619, "klass == dest->obj.vtable->klass");
  <D.23736>:
  size = mono_array_length (src);
  D.23737 = mono_array_length (dest);
  D.23738 = D.23737 != size;
  D.23739 = (long int) D.23738;
  D.23740 = __builtin_expect (D.23739, 0);
  if (D.23740 != 0) goto <D.23741>; else goto <D.23742>;
  <D.23741>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 4622, "size == mono_array_length (dest)");
  <D.23742>:
  D.23743 = mono_array_element_size (klass);
  D.23744 = (unsigned int) D.23743;
  size = D.23744 * size;
  D.23745 = klass->element_class;
  D.23746 = BIT_FIELD_REF <*D.23745, 32, 160>;
  D.23747 = D.23746 & 8;
  if (D.23747 != 0) goto <D.23748>; else goto <D.23749>;
  <D.23748>:
  D.23745 = klass->element_class;
  D.23746 = BIT_FIELD_REF <*D.23745, 32, 160>;
  D.23750 = D.23746 & 134217728;
  if (D.23750 != 0) goto <D.23751>; else goto <D.23752>;
  <D.23751>:
  D.23753 = &src->vector;
  D.23754 = mono_array_length (src);
  D.23755 = (int) D.23754;
  mono_value_copy_array (dest, 0, D.23753, D.23755);
  goto <D.23756>;
  <D.23752>:
  D.23757 = &dest->vector;
  D.23753 = &src->vector;
  mono_gc_memmove_atomic (D.23757, D.23753, size);
  <D.23756>:
  goto <D.23758>;
  <D.23749>:
  {
    void * * __p;
    void * * __s;

    __p = mono_array_addr_with_size (dest, 4, 0);
    __s = mono_array_addr_with_size (src, 4, 0);
    D.23759 = mono_array_length (src);
    D.23760 = (int) D.23759;
    mono_gc_wbarrier_arrayref_copy (__p, __s, D.23760);
  }
  <D.23758>:
}


mono_array_clone_in_domain (struct MonoDomain * domain, struct MonoArray * array)
{
  struct MonoVTable * D.23761;
  struct MonoArrayBounds * D.23762;
  unsigned int size.184;
  int D.23766;
  unsigned int D.23767;
  unsigned int size.185;
  unsigned int size.186;
  struct MonoClass * D.23770;
  unsigned int D.23771;
  unsigned int D.23772;
  unsigned int D.23775;
  double[0:] * D.23778;
  unsigned int D.23779;
  int D.23780;
  double[0:] * D.23782;
  unsigned int D.23784;
  int D.23785;
  struct MonoArray * D.23786;
  unsigned char D.23787;
  unsigned int D.23788;
  unsigned int D.23789;
  int D.23790;
  unsigned int size.187;
  unsigned int D.23792;
  uintptr_t * D.23793;
  unsigned int D.23794;
  struct MonoArrayBounds * D.23795;
  unsigned int D.23796;
  unsigned int size.188;
  unsigned int D.23798;
  unsigned int D.23799;
  unsigned int D.23800;
  uintptr_t * D.23801;
  int D.23802;
  unsigned int D.23803;
  unsigned int D.23804;
  intptr_t * D.23805;
  unsigned int D.23810;
  int D.23811;
  unsigned int D.23814;
  int D.23815;
  struct MonoArray * o;
  uintptr_t size;
  uintptr_t i;
  uintptr_t * sizes;
  struct MonoClass * klass;

  try
    {
      D.23761 = array->obj.vtable;
      klass = D.23761->klass;
      D.23762 = array->bounds;
      if (D.23762 == 0B) goto <D.23763>; else goto <D.23764>;
      <D.23763>:
      size.184 = mono_array_length (array);
      size = size.184;
      o = mono_array_new_full (domain, klass, &size, 0B);
      D.23766 = mono_array_element_size (klass);
      D.23767 = (unsigned int) D.23766;
      size.185 = size;
      size.186 = D.23767 * size.185;
      size = size.186;
      D.23770 = klass->element_class;
      D.23771 = BIT_FIELD_REF <*D.23770, 32, 160>;
      D.23772 = D.23771 & 8;
      if (D.23772 != 0) goto <D.23773>; else goto <D.23774>;
      <D.23773>:
      D.23770 = klass->element_class;
      D.23771 = BIT_FIELD_REF <*D.23770, 32, 160>;
      D.23775 = D.23771 & 134217728;
      if (D.23775 != 0) goto <D.23776>; else goto <D.23777>;
      <D.23776>:
      D.23778 = &array->vector;
      D.23779 = mono_array_length (array);
      D.23780 = (int) D.23779;
      mono_value_copy_array (o, 0, D.23778, D.23780);
      goto <D.23781>;
      <D.23777>:
      D.23782 = &o->vector;
      D.23778 = &array->vector;
      size.185 = size;
      mono_gc_memmove_atomic (D.23782, D.23778, size.185);
      <D.23781>:
      goto <D.23783>;
      <D.23774>:
      {
        void * * __p;
        void * * __s;

        __p = mono_array_addr_with_size (o, 4, 0);
        __s = mono_array_addr_with_size (array, 4, 0);
        D.23784 = mono_array_length (array);
        D.23785 = (int) D.23784;
        mono_gc_wbarrier_arrayref_copy (__p, __s, D.23785);
      }
      <D.23783>:
      D.23786 = o;
      return D.23786;
      <D.23764>:
      D.23787 = klass->rank;
      D.23788 = (unsigned int) D.23787;
      D.23789 = D.23788 * 8;
      sizes = __builtin_alloca (D.23789);
      D.23790 = mono_array_element_size (klass);
      size.187 = (unsigned int) D.23790;
      size = size.187;
      i = 0;
      goto <D.19869>;
      <D.19868>:
      D.23792 = i * 4;
      D.23793 = sizes + D.23792;
      D.23762 = array->bounds;
      D.23794 = i * 8;
      D.23795 = D.23762 + D.23794;
      D.23796 = D.23795->length;
      *D.23793 = D.23796;
      D.23762 = array->bounds;
      D.23794 = i * 8;
      D.23795 = D.23762 + D.23794;
      D.23796 = D.23795->length;
      size.185 = size;
      size.188 = D.23796 * size.185;
      size = size.188;
      D.23787 = klass->rank;
      D.23798 = (unsigned int) D.23787;
      D.23799 = D.23798 + i;
      D.23800 = D.23799 * 4;
      D.23801 = sizes + D.23800;
      D.23762 = array->bounds;
      D.23794 = i * 8;
      D.23795 = D.23762 + D.23794;
      D.23802 = D.23795->lower_bound;
      D.23803 = (unsigned int) D.23802;
      *D.23801 = D.23803;
      i = i + 1;
      <D.19869>:
      D.23787 = klass->rank;
      D.23798 = (unsigned int) D.23787;
      if (D.23798 > i) goto <D.19868>; else goto <D.19870>;
      <D.19870>:
      D.23787 = klass->rank;
      D.23788 = (unsigned int) D.23787;
      D.23804 = D.23788 * 4;
      D.23805 = sizes + D.23804;
      o = mono_array_new_full (domain, klass, sizes, D.23805);
      D.23770 = klass->element_class;
      D.23771 = BIT_FIELD_REF <*D.23770, 32, 160>;
      D.23772 = D.23771 & 8;
      if (D.23772 != 0) goto <D.23806>; else goto <D.23807>;
      <D.23806>:
      D.23770 = klass->element_class;
      D.23771 = BIT_FIELD_REF <*D.23770, 32, 160>;
      D.23775 = D.23771 & 134217728;
      if (D.23775 != 0) goto <D.23808>; else goto <D.23809>;
      <D.23808>:
      D.23778 = &array->vector;
      D.23810 = mono_array_length (array);
      D.23811 = (int) D.23810;
      mono_value_copy_array (o, 0, D.23778, D.23811);
      goto <D.23812>;
      <D.23809>:
      D.23782 = &o->vector;
      D.23778 = &array->vector;
      size.185 = size;
      mono_gc_memmove_atomic (D.23782, D.23778, size.185);
      <D.23812>:
      goto <D.23813>;
      <D.23807>:
      {
        void * * __p;
        void * * __s;

        __p = mono_array_addr_with_size (o, 4, 0);
        __s = mono_array_addr_with_size (array, 4, 0);
        D.23814 = mono_array_length (array);
        D.23815 = (int) D.23814;
        mono_gc_wbarrier_arrayref_copy (__p, __s, D.23815);
      }
      <D.23813>:
      D.23786 = o;
      return D.23786;
    }
  finally
    {
      size = {CLOBBER};
    }
}


mono_array_clone (struct MonoArray * array)
{
  struct MonoArray * D.23818;
  struct MonoVTable * D.23819;
  struct MonoDomain * D.23820;

  D.23819 = MEM[(struct MonoObject *)array].vtable;
  D.23820 = D.23819->domain;
  D.23818 = mono_array_clone_in_domain (D.23820, array);
  return D.23818;
}


mono_array_calc_byte_len (struct MonoClass * class, uintptr_t len, uintptr_t * res)
{
  int D.23822;
  int iftmp.189;
  unsigned int D.23828;
  _Bool D.23830;
  long int D.23831;
  long int D.23832;
  gboolean D.23835;
  _Bool D.23836;
  long int D.23837;
  long int D.23838;
  uintptr_t byte_len;

  D.23822 = mono_array_element_size (class);
  byte_len = (uintptr_t) D.23822;
  if (byte_len != 0) goto <D.23826>; else goto <D.23824>;
  <D.23826>:
  if (len != 0) goto <D.23827>; else goto <D.23824>;
  <D.23827>:
  D.23828 = 4294967295 / byte_len;
  if (D.23828 < len) goto <D.23829>; else goto <D.23824>;
  <D.23829>:
  iftmp.189 = 1;
  goto <D.23825>;
  <D.23824>:
  iftmp.189 = 0;
  <D.23825>:
  D.23830 = iftmp.189 != 0;
  D.23831 = (long int) D.23830;
  D.23832 = __builtin_expect (D.23831, 0);
  if (D.23832 != 0) goto <D.23833>; else goto <D.23834>;
  <D.23833>:
  D.23835 = 0;
  return D.23835;
  <D.23834>:
  byte_len = byte_len * len;
  D.23836 = byte_len > 4294967279;
  D.23837 = (long int) D.23836;
  D.23838 = __builtin_expect (D.23837, 0);
  if (D.23838 != 0) goto <D.23839>; else goto <D.23840>;
  <D.23839>:
  D.23835 = 0;
  return D.23835;
  <D.23840>:
  byte_len = byte_len + 16;
  *res = byte_len;
  D.23835 = 1;
  return D.23835;
}


mono_array_new_full (struct MonoDomain * domain, struct MonoClass * array_class, uintptr_t * lengths, intptr_t * lower_bounds)
{
  unsigned int D.23842;
  unsigned int D.23843;
  unsigned char D.23848;
  unsigned char D.23850;
  int D.23853;
  signed int len.190;
  unsigned int D.23857;
  unsigned int i.191;
  unsigned int D.23859;
  uintptr_t * D.23860;
  unsigned int D.23861;
  signed int D.23862;
  int iftmp.192;
  unsigned int D.23870;
  _Bool D.23872;
  long int D.23873;
  long int D.23874;
  int D.23877;
  int D.23878;
  unsigned int byte_len.193;
  _Bool D.23884;
  long int D.23885;
  long int D.23886;
  unsigned int D.23889;
  unsigned int byte_len.194;
  unsigned int D.23891;
  _Bool D.23892;
  long int D.23893;
  long int D.23894;
  unsigned int byte_len.195;
  long long unsigned int D.23901;
  long long unsigned int D.23902;
  unsigned int D.23905;
  struct MonoArrayBounds * D.23906;
  intptr_t * D.23909;
  int D.23910;
  int profile_allocs.196;
  _Bool D.23912;
  long int D.23913;
  long int D.23914;
  struct MonoArray * D.23917;
  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.23842 = BIT_FIELD_REF <*array_class, 32, 160>;
      D.23843 = D.23842 & 1;
      if (D.23843 == 0) goto <D.23844>; else goto <D.23845>;
      <D.23844>:
      mono_class_init (array_class);
      <D.23845>:
      len = 1;
      D.23848 = array_class->rank;
      if (D.23848 == 1) goto <D.23849>; else goto <D.23846>;
      <D.23849>:
      D.23850 = array_class->byval_arg.type;
      if (D.23850 == 29) goto <D.23847>; else goto <D.23851>;
      <D.23851>:
      if (lower_bounds != 0B) goto <D.23852>; else goto <D.23846>;
      <D.23852>:
      D.23853 = *lower_bounds;
      if (D.23853 == 0) goto <D.23847>; else goto <D.23846>;
      <D.23847>:
      len = *lengths;
      len.190 = (signed int) len;
      if (len.190 < 0) goto <D.23855>; else goto <D.23856>;
      <D.23855>:
      arith_overflow ();
      <D.23856>:
      bounds_size = 0;
      goto <D.19898>;
      <D.23846>:
      D.23848 = array_class->rank;
      D.23857 = (unsigned int) D.23848;
      bounds_size = D.23857 * 8;
      i = 0;
      goto <D.19897>;
      <D.19896>:
      i.191 = (unsigned int) i;
      D.23859 = i.191 * 4;
      D.23860 = lengths + D.23859;
      D.23861 = *D.23860;
      D.23862 = (signed int) D.23861;
      if (D.23862 < 0) goto <D.23863>; else goto <D.23864>;
      <D.23863>:
      arith_overflow ();
      <D.23864>:
      if (len != 0) goto <D.23868>; else goto <D.23866>;
      <D.23868>:
      i.191 = (unsigned int) i;
      D.23859 = i.191 * 4;
      D.23860 = lengths + D.23859;
      D.23861 = *D.23860;
      if (D.23861 != 0) goto <D.23869>; else goto <D.23866>;
      <D.23869>:
      i.191 = (unsigned int) i;
      D.23859 = i.191 * 4;
      D.23860 = lengths + D.23859;
      D.23861 = *D.23860;
      D.23870 = 4294967295 / len;
      if (D.23861 > D.23870) goto <D.23871>; else goto <D.23866>;
      <D.23871>:
      iftmp.192 = 1;
      goto <D.23867>;
      <D.23866>:
      iftmp.192 = 0;
      <D.23867>:
      D.23872 = iftmp.192 != 0;
      D.23873 = (long int) D.23872;
      D.23874 = __builtin_expect (D.23873, 0);
      if (D.23874 != 0) goto <D.23875>; else goto <D.23876>;
      <D.23875>:
      mono_gc_out_of_memory (4294967295);
      <D.23876>:
      i.191 = (unsigned int) i;
      D.23859 = i.191 * 4;
      D.23860 = lengths + D.23859;
      D.23861 = *D.23860;
      len = D.23861 * len;
      i = i + 1;
      <D.19897>:
      D.23848 = array_class->rank;
      D.23877 = (int) D.23848;
      if (D.23877 > i) goto <D.19896>; else goto <D.19898>;
      <D.19898>:
      D.23878 = mono_array_calc_byte_len (array_class, len, &byte_len);
      if (D.23878 == 0) goto <D.23879>; else goto <D.23880>;
      <D.23879>:
      mono_gc_out_of_memory (4294967295);
      <D.23880>:
      if (bounds_size != 0) goto <D.23881>; else goto <D.23882>;
      <D.23881>:
      byte_len.193 = byte_len;
      D.23884 = byte_len.193 > 4294967292;
      D.23885 = (long int) D.23884;
      D.23886 = __builtin_expect (D.23885, 0);
      if (D.23886 != 0) goto <D.23887>; else goto <D.23888>;
      <D.23887>:
      mono_gc_out_of_memory (4294967295);
      <D.23888>:
      byte_len.193 = byte_len;
      D.23889 = byte_len.193 + 3;
      byte_len.194 = D.23889 & 4294967292;
      byte_len = byte_len.194;
      D.23891 = ~bounds_size;
      byte_len.193 = byte_len;
      D.23892 = D.23891 < byte_len.193;
      D.23893 = (long int) D.23892;
      D.23894 = __builtin_expect (D.23893, 0);
      if (D.23894 != 0) goto <D.23895>; else goto <D.23896>;
      <D.23895>:
      mono_gc_out_of_memory (4294967295);
      <D.23896>:
      byte_len.193 = byte_len;
      byte_len.195 = byte_len.193 + bounds_size;
      byte_len = byte_len.195;
      <D.23882>:
      vtable = mono_class_vtable_full (domain, array_class, 1);
      if (bounds_size != 0) goto <D.23898>; else goto <D.23899>;
      <D.23898>:
      byte_len.193 = byte_len;
      o = mono_gc_alloc_array (vtable, byte_len.193, len, bounds_size);
      goto <D.23900>;
      <D.23899>:
      byte_len.193 = byte_len;
      o = mono_gc_alloc_vector (vtable, byte_len.193, len);
      <D.23900>:
      array = o;
      D.23901 = mono_stats.new_object_count;
      D.23902 = D.23901 + 1;
      mono_stats.new_object_count = D.23902;
      bounds = array->bounds;
      if (bounds_size != 0) goto <D.23903>; else goto <D.23904>;
      <D.23903>:
      i = 0;
      goto <D.19900>;
      <D.19899>:
      i.191 = (unsigned int) i;
      D.23905 = i.191 * 8;
      D.23906 = bounds + D.23905;
      i.191 = (unsigned int) i;
      D.23859 = i.191 * 4;
      D.23860 = lengths + D.23859;
      D.23861 = *D.23860;
      D.23906->length = D.23861;
      if (lower_bounds != 0B) goto <D.23907>; else goto <D.23908>;
      <D.23907>:
      i.191 = (unsigned int) i;
      D.23905 = i.191 * 8;
      D.23906 = bounds + D.23905;
      i.191 = (unsigned int) i;
      D.23859 = i.191 * 4;
      D.23909 = lower_bounds + D.23859;
      D.23910 = *D.23909;
      D.23906->lower_bound = D.23910;
      <D.23908>:
      i = i + 1;
      <D.19900>:
      D.23848 = array_class->rank;
      D.23877 = (int) D.23848;
      if (D.23877 > i) goto <D.19899>; else goto <D.19901>;
      <D.19901>:
      <D.23904>:
      profile_allocs.196 = profile_allocs;
      D.23912 = profile_allocs.196 != 0;
      D.23913 = (long int) D.23912;
      D.23914 = __builtin_expect (D.23913, 0);
      if (D.23914 != 0) goto <D.23915>; else goto <D.23916>;
      <D.23915>:
      mono_profiler_allocation (o, array_class);
      <D.23916>:
      D.23917 = array;
      return D.23917;
    }
  finally
    {
      byte_len = {CLOBBER};
    }
}


arith_overflow ()
{
  struct MonoException * D.23920;

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


mono_array_new (struct MonoDomain * domain, struct MonoClass * eclass, uintptr_t n)
{
  _Bool D.23921;
  long int D.23922;
  long int D.23923;
  struct MonoArray * D.23926;
  struct MonoVTable * D.23927;
  struct MonoClass * ac;

  ac = mono_array_class_get (eclass, 1);
  D.23921 = ac == 0B;
  D.23922 = (long int) D.23921;
  D.23923 = __builtin_expect (D.23922, 0);
  if (D.23923 != 0) goto <D.23924>; else goto <D.23925>;
  <D.23924>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 4869, "ac");
  <D.23925>:
  D.23927 = mono_class_vtable_full (domain, ac, 1);
  D.23926 = mono_array_new_specific (D.23927, n);
  return D.23926;
}


mono_array_new_specific (struct MonoVTable * vtable, uintptr_t n)
{
  signed int n.197;
  _Bool D.23930;
  long int D.23931;
  long int D.23932;
  struct MonoArray * D.23935;
  struct MonoClass * D.23936;
  int D.23937;
  unsigned int byte_len.198;
  long long unsigned int D.23941;
  long long unsigned int D.23942;
  int profile_allocs.199;
  _Bool D.23944;
  long int D.23945;
  long int D.23946;
  struct MonoObject * o;
  struct MonoArray * ao;
  uintptr_t byte_len;

  try
    {
      n.197 = (signed int) n;
      D.23930 = n.197 < 0;
      D.23931 = (long int) D.23930;
      D.23932 = __builtin_expect (D.23931, 0);
      if (D.23932 != 0) goto <D.23933>; else goto <D.23934>;
      <D.23933>:
      arith_overflow ();
      D.23935 = 0B;
      return D.23935;
      <D.23934>:
      D.23936 = vtable->klass;
      D.23937 = mono_array_calc_byte_len (D.23936, n, &byte_len);
      if (D.23937 == 0) goto <D.23938>; else goto <D.23939>;
      <D.23938>:
      mono_gc_out_of_memory (4294967295);
      D.23935 = 0B;
      return D.23935;
      <D.23939>:
      byte_len.198 = byte_len;
      o = mono_gc_alloc_vector (vtable, byte_len.198, n);
      ao = o;
      D.23941 = mono_stats.new_object_count;
      D.23942 = D.23941 + 1;
      mono_stats.new_object_count = D.23942;
      profile_allocs.199 = profile_allocs;
      D.23944 = profile_allocs.199 != 0;
      D.23945 = (long int) D.23944;
      D.23946 = __builtin_expect (D.23945, 0);
      if (D.23946 != 0) goto <D.23947>; else goto <D.23948>;
      <D.23947>:
      D.23936 = vtable->klass;
      mono_profiler_allocation (o, D.23936);
      <D.23948>:
      D.23935 = ao;
      return D.23935;
    }
  finally
    {
      byte_len = {CLOBBER};
    }
}


mono_string_new_utf16 (struct MonoDomain * domain, const guint16 * text, gint32 len)
{
  _Bool D.23951;
  long int D.23952;
  long int D.23953;
  mono_unichar2 * D.23956;
  int D.23957;
  unsigned int D.23958;
  struct MonoString * D.23959;
  struct MonoString * s;

  s = mono_string_new_size (domain, len);
  D.23951 = s == 0B;
  D.23952 = (long int) D.23951;
  D.23953 = __builtin_expect (D.23952, 0);
  if (D.23953 != 0) goto <D.23954>; else goto <D.23955>;
  <D.23954>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 4941, "s != NULL");
  <D.23955>:
  D.23956 = mono_string_chars (s);
  D.23957 = len * 2;
  D.23958 = (unsigned int) D.23957;
  memcpy (D.23956, text, D.23958);
  D.23959 = s;
  return D.23959;
}


mono_string_new_size (struct MonoDomain * domain, gint32 len)
{
  int D.23961;
  int D.23962;
  unsigned int D.23963;
  unsigned int len.200;
  struct MonoClass * D.23967;
  _Bool D.23968;
  long int D.23969;
  long int D.23970;
  int profile_allocs.201;
  _Bool D.23974;
  long int D.23975;
  long int D.23976;
  struct MonoString * D.23979;
  struct MonoString * s;
  struct MonoVTable * vtable;
  size_t size;

  D.23961 = len + 1;
  D.23962 = D.23961 * 2;
  D.23963 = (unsigned int) D.23962;
  size = D.23963 + 12;
  len.200 = (unsigned int) len;
  if (len.200 > size) goto <D.23965>; else goto <D.23966>;
  <D.23965>:
  mono_gc_out_of_memory (4294967295);
  <D.23966>:
  D.23967 = mono_defaults.string_class;
  vtable = mono_class_vtable (domain, D.23967);
  D.23968 = vtable == 0B;
  D.23969 = (long int) D.23968;
  D.23970 = __builtin_expect (D.23969, 0);
  if (D.23970 != 0) goto <D.23971>; else goto <D.23972>;
  <D.23971>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 4967, "vtable");
  <D.23972>:
  s = mono_gc_alloc_string (vtable, size, len);
  profile_allocs.201 = profile_allocs;
  D.23974 = profile_allocs.201 != 0;
  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>:
  D.23967 = mono_defaults.string_class;
  mono_profiler_allocation (s, D.23967);
  <D.23978>:
  D.23979 = s;
  return D.23979;
}


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

  try
    {
      error = 0B;
      o = 0B;
      length.202 = (long int) length;
      ut = eg_utf8_to_utf16_with_nuls (text, length.202, 0B, &items_written, &error);
      error.203 = error;
      if (error.203 == 0B) goto <D.23983>; else goto <D.23984>;
      <D.23983>:
      items_written.204 = items_written;
      o = mono_string_new_utf16 (domain, ut, items_written.204);
      goto <D.23986>;
      <D.23984>:
      error.203 = error;
      monoeg_g_error_free (error.203);
      <D.23986>:
      monoeg_g_free (ut);
      D.23987 = o;
      return D.23987;
    }
  finally
    {
      error = {CLOBBER};
      items_written = {CLOBBER};
    }
}


mono_string_new (struct MonoDomain * domain, const char * text)
{
  unsigned int D.23990;
  struct GError * error.205;
  long int items_written.206;
  struct MonoString * D.23996;
  struct GError * error;
  struct MonoString * o;
  guint16 * ut;
  glong items_written;
  int l;

  try
    {
      error = 0B;
      o = 0B;
      D.23990 = strlen (text);
      l = (int) D.23990;
      ut = monoeg_g_utf8_to_utf16 (text, l, 0B, &items_written, &error);
      error.205 = error;
      if (error.205 == 0B) goto <D.23992>; else goto <D.23993>;
      <D.23992>:
      items_written.206 = items_written;
      o = mono_string_new_utf16 (domain, ut, items_written.206);
      goto <D.23995>;
      <D.23993>:
      error.205 = error;
      monoeg_g_error_free (error.205);
      <D.23995>:
      monoeg_g_free (ut);
      D.23996 = o;
      return D.23996;
    }
  finally
    {
      error = {CLOBBER};
      items_written = {CLOBBER};
    }
}


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

  domain = mono_domain_get ();
  if (text != 0B) goto <D.23999>; else goto <D.24000>;
  <D.23999>:
  D.24001 = mono_string_new (domain, text);
  return D.24001;
  <D.24000>:
  D.24001 = 0B;
  return D.24001;
}


mono_value_box (struct MonoDomain * domain, struct MonoClass * class, void * value)
{
  unsigned int D.24003;
  unsigned int D.24004;
  _Bool D.24005;
  long int D.24006;
  long int D.24007;
  int D.24010;
  struct MonoObject * D.24013;
  int profile_allocs.207;
  _Bool D.24017;
  long int D.24018;
  long int D.24019;
  unsigned int size.208;
  unsigned int D.24023;
  int D.24024;
  _Bool D.24025;
  long int D.24026;
  long int D.24027;
  void * D.24030;
  unsigned int D.24031;
  struct MonoObject * res;
  int size;
  struct MonoVTable * vtable;

  D.24003 = BIT_FIELD_REF <*class, 32, 160>;
  D.24004 = D.24003 & 8;
  D.24005 = D.24004 == 0;
  D.24006 = (long int) D.24005;
  D.24007 = __builtin_expect (D.24006, 0);
  if (D.24007 != 0) goto <D.24008>; else goto <D.24009>;
  <D.24008>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 5092, "class->valuetype");
  <D.24009>:
  D.24010 = mono_class_is_nullable (class);
  if (D.24010 != 0) goto <D.24011>; else goto <D.24012>;
  <D.24011>:
  D.24013 = mono_nullable_box (value, class);
  return D.24013;
  <D.24012>:
  vtable = mono_class_vtable (domain, class);
  if (vtable == 0B) goto <D.24014>; else goto <D.24015>;
  <D.24014>:
  D.24013 = 0B;
  return D.24013;
  <D.24015>:
  size = mono_class_instance_size (class);
  res = mono_object_new_alloc_specific (vtable);
  profile_allocs.207 = profile_allocs;
  D.24017 = profile_allocs.207 != 0;
  D.24018 = (long int) D.24017;
  D.24019 = __builtin_expect (D.24018, 0);
  if (D.24019 != 0) goto <D.24020>; else goto <D.24021>;
  <D.24020>:
  mono_profiler_allocation (res, class);
  <D.24021>:
  size.208 = (unsigned int) size;
  D.24023 = size.208 + 4294967288;
  size = (int) D.24023;
  D.24024 = mono_class_value_size (class, 0B);
  D.24025 = D.24024 != size;
  D.24026 = (long int) D.24025;
  D.24027 = __builtin_expect (D.24026, 0);
  if (D.24027 != 0) goto <D.24028>; else goto <D.24029>;
  <D.24028>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 5107, "size == mono_class_value_size (class, NULL)");
  <D.24029>:
  D.24030 = res + 8;
  mono_gc_wbarrier_value_copy (D.24030, value, 1, class);
  D.24003 = BIT_FIELD_REF <*class, 32, 160>;
  D.24031 = D.24003 & 2097152;
  if (D.24031 != 0) goto <D.24032>; else goto <D.24033>;
  <D.24032>:
  mono_object_register_finalizer (res);
  <D.24033>:
  D.24013 = res;
  return D.24013;
}


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.24035;
  struct MonoClass * D.24036;
  double[0:] * D.24037;
  int D.24038;
  sizetype D.24039;
  struct MonoVTable * D.24040;
  struct MonoClass * D.24041;
  struct MonoClass * D.24042;
  int D.24043;
  _Bool D.24044;
  long int D.24045;
  long int D.24046;
  int size;
  char * d;

  D.24035 = dest->obj.vtable;
  D.24036 = D.24035->klass;
  size = mono_array_element_size (D.24036);
  D.24037 = &dest->vector;
  D.24038 = size * dest_idx;
  D.24039 = (sizetype) D.24038;
  d = D.24037 + D.24039;
  D.24040 = MEM[(struct MonoObject *)dest].vtable;
  D.24041 = D.24040->klass;
  D.24042 = D.24041->element_class;
  D.24043 = mono_class_value_size (D.24042, 0B);
  D.24044 = D.24043 != size;
  D.24045 = (long int) D.24044;
  D.24046 = __builtin_expect (D.24045, 0);
  if (D.24046 != 0) goto <D.24047>; else goto <D.24048>;
  <D.24047>:
  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.24048>:
  D.24040 = MEM[(struct MonoObject *)dest].vtable;
  D.24041 = D.24040->klass;
  D.24042 = D.24041->element_class;
  mono_gc_wbarrier_value_copy (d, src, count, D.24042);
}


mono_object_get_domain (struct MonoObject * obj)
{
  struct MonoDomain * D.24049;
  struct MonoVTable * D.24050;

  D.24050 = obj->vtable;
  D.24049 = D.24050->domain;
  return D.24049;
}


mono_object_get_class (struct MonoObject * obj)
{
  struct MonoClass * D.24052;
  struct MonoVTable * D.24053;

  D.24053 = obj->vtable;
  D.24052 = D.24053->klass;
  return D.24052;
}


mono_object_get_size (struct MonoObject * o)
{
  struct MonoVTable * D.24055;
  struct MonoClass * D.24056;
  unsigned int D.24059;
  int D.24060;
  int D.24061;
  unsigned int D.24062;
  unsigned char D.24063;
  int D.24066;
  unsigned int D.24067;
  unsigned int D.24068;
  unsigned int D.24069;
  struct MonoArrayBounds * D.24070;
  unsigned int D.24073;
  unsigned int D.24074;
  int D.24075;
  struct MonoClass * klass;

  D.24055 = o->vtable;
  klass = D.24055->klass;
  D.24056 = mono_defaults.string_class;
  if (D.24056 == klass) goto <D.24057>; else goto <D.24058>;
  <D.24057>:
  D.24060 = mono_string_length (o);
  D.24061 = D.24060 * 2;
  D.24062 = (unsigned int) D.24061;
  D.24059 = D.24062 + 14;
  return D.24059;
  <D.24058>:
  D.24055 = o->vtable;
  D.24063 = D.24055->rank;
  if (D.24063 != 0) goto <D.24064>; else goto <D.24065>;
  <D.24064>:
  {
    struct MonoArray * array;
    size_t size;

    array = o;
    D.24066 = mono_array_element_size (klass);
    D.24067 = (unsigned int) D.24066;
    D.24068 = mono_array_length (array);
    D.24069 = D.24067 * D.24068;
    size = D.24069 + 16;
    D.24070 = array->bounds;
    if (D.24070 != 0B) goto <D.24071>; else goto <D.24072>;
    <D.24071>:
    size = size + 3;
    size = size & 4294967292;
    D.24055 = o->vtable;
    D.24063 = D.24055->rank;
    D.24073 = (unsigned int) D.24063;
    D.24074 = D.24073 * 8;
    size = D.24074 + size;
    <D.24072>:
    D.24059 = size;
    return D.24059;
  }
  <D.24065>:
  D.24075 = mono_class_instance_size (klass);
  D.24059 = (unsigned int) D.24075;
  return D.24059;
}


mono_object_unbox (struct MonoObject * obj)
{
  struct MonoVTable * D.24077;
  struct MonoClass * D.24078;
  unsigned int D.24079;
  unsigned int D.24080;
  _Bool D.24081;
  long int D.24082;
  long int D.24083;
  void * D.24086;

  D.24077 = obj->vtable;
  D.24078 = D.24077->klass;
  D.24079 = BIT_FIELD_REF <*D.24078, 32, 160>;
  D.24080 = D.24079 & 8;
  D.24081 = D.24080 == 0;
  D.24082 = (long int) D.24081;
  D.24083 = __builtin_expect (D.24082, 0);
  if (D.24083 != 0) goto <D.24084>; else goto <D.24085>;
  <D.24084>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 5233, "obj->vtable->klass->valuetype");
  <D.24085>:
  D.24086 = obj + 8;
  return D.24086;
}


mono_object_isinst (struct MonoObject * obj, struct MonoClass * klass)
{
  unsigned int D.24088;
  unsigned int D.24089;
  unsigned int D.24094;
  unsigned int D.24096;
  unsigned int D.24097;
  struct MonoObject * D.24098;
  struct MonoObject * iftmp.209;
  struct MonoVTable * D.24102;
  struct MonoClass * D.24103;
  int D.24104;

  D.24088 = BIT_FIELD_REF <*klass, 32, 160>;
  D.24089 = D.24088 & 1;
  if (D.24089 == 0) goto <D.24090>; else goto <D.24091>;
  <D.24090>:
  mono_class_init (klass);
  <D.24091>:
  D.24088 = BIT_FIELD_REF <*klass, 32, 160>;
  D.24094 = D.24088 & 4194304;
  if (D.24094 != 0) goto <D.24092>; else goto <D.24095>;
  <D.24095>:
  D.24096 = klass->flags;
  D.24097 = D.24096 & 32;
  if (D.24097 != 0) goto <D.24092>; else goto <D.24093>;
  <D.24092>:
  D.24098 = mono_object_isinst_mbyref (obj, klass);
  return D.24098;
  <D.24093>:
  if (obj == 0B) goto <D.24099>; else goto <D.24100>;
  <D.24099>:
  D.24098 = 0B;
  return D.24098;
  <D.24100>:
  D.24102 = obj->vtable;
  D.24103 = D.24102->klass;
  D.24104 = mono_class_is_assignable_from (klass, D.24103);
  if (D.24104 != 0) goto <D.24105>; else goto <D.24106>;
  <D.24105>:
  iftmp.209 = obj;
  goto <D.24107>;
  <D.24106>:
  iftmp.209 = 0B;
  <D.24107>:
  D.24098 = iftmp.209;
  return D.24098;
}


mono_object_isinst_mbyref (struct MonoObject * obj, struct MonoClass * klass)
{
  struct MonoObject * D.24111;
  unsigned int D.24112;
  unsigned int D.24113;
  short unsigned int D.24116;
  short unsigned int D.24117;
  guint8 * D.24120;
  short unsigned int D.24121;
  sizetype D.24122;
  guint8 * D.24123;
  unsigned char D.24124;
  int D.24125;
  int D.24126;
  int D.24127;
  int D.24128;
  int D.24129;
  int D.24132;
  struct MonoVTable * D.24135;
  struct MonoClass * D.24136;
  int D.24137;
  struct MonoClass * D.24141;
  struct MonoRemoteClass * D.24144;
  short unsigned int D.24145;
  short unsigned int D.24146;
  struct MonoClass * * D.24149;
  sizetype D.24150;
  sizetype D.24151;
  sizetype D.24152;
  struct MonoClass * * D.24153;
  struct MonoClass * D.24154;
  struct MonoClass * D.24157;
  unsigned char D.24160;
  _Bool D.24163;
  long int D.24164;
  long int D.24165;
  struct MonoType * D.24168;
  struct MonoReflectionType * D.24169;
  void * D.24170;
  unsigned char D.24171;
  struct MonoVTable * vt;

  if (obj == 0B) goto <D.24109>; else goto <D.24110>;
  <D.24109>:
  D.24111 = 0B;
  return D.24111;
  <D.24110>:
  vt = obj->vtable;
  D.24112 = klass->flags;
  D.24113 = D.24112 & 32;
  if (D.24113 != 0) goto <D.24114>; else goto <D.24115>;
  <D.24114>:
  D.24116 = klass->interface_id;
  D.24117 = vt->max_interface_id;
  if (D.24116 <= D.24117) goto <D.24118>; else goto <D.24119>;
  <D.24118>:
  D.24120 = vt->interface_bitmap;
  D.24116 = klass->interface_id;
  D.24121 = D.24116 >> 3;
  D.24122 = (sizetype) D.24121;
  D.24123 = D.24120 + D.24122;
  D.24124 = *D.24123;
  D.24125 = (int) D.24124;
  D.24116 = klass->interface_id;
  D.24126 = (int) D.24116;
  D.24127 = D.24126 & 7;
  D.24128 = D.24125 >> D.24127;
  D.24129 = D.24128 & 1;
  if (D.24129 != 0) goto <D.24130>; else goto <D.24131>;
  <D.24130>:
  D.24111 = obj;
  return D.24111;
  <D.24131>:
  <D.24119>:
  D.24132 = mono_class_has_variant_generic_params (klass);
  if (D.24132 != 0) goto <D.24133>; else goto <D.24134>;
  <D.24133>:
  D.24135 = obj->vtable;
  D.24136 = D.24135->klass;
  D.24137 = mono_class_is_assignable_from (klass, D.24136);
  if (D.24137 != 0) goto <D.24138>; else goto <D.24139>;
  <D.24138>:
  D.24111 = obj;
  return D.24111;
  <D.24139>:
  <D.24134>:
  goto <D.24140>;
  <D.24115>:
  {
    struct MonoClass * oklass;

    oklass = vt->klass;
    D.24141 = mono_defaults.transparent_proxy_class;
    if (D.24141 == oklass) goto <D.24142>; else goto <D.24143>;
    <D.24142>:
    D.24144 = MEM[(struct MonoTransparentProxy *)obj].remote_class;
    oklass = D.24144->proxy_class;
    <D.24143>:
    mono_class_setup_supertypes (klass);
    D.24145 = oklass->idepth;
    D.24146 = klass->idepth;
    if (D.24145 >= D.24146) goto <D.24147>; else goto <D.24148>;
    <D.24147>:
    D.24149 = oklass->supertypes;
    D.24146 = klass->idepth;
    D.24150 = (sizetype) D.24146;
    D.24151 = D.24150 + 1073741823;
    D.24152 = D.24151 * 4;
    D.24153 = D.24149 + D.24152;
    D.24154 = *D.24153;
    if (D.24154 == klass) goto <D.24155>; else goto <D.24156>;
    <D.24155>:
    D.24111 = obj;
    return D.24111;
    <D.24156>:
    <D.24148>:
  }
  <D.24140>:
  D.24157 = vt->klass;
  D.24141 = mono_defaults.transparent_proxy_class;
  if (D.24157 == D.24141) goto <D.24158>; else goto <D.24159>;
  <D.24158>:
  D.24160 = MEM[(struct MonoTransparentProxy *)obj].custom_type_info;
  if (D.24160 != 0) goto <D.24161>; else goto <D.24162>;
  <D.24161>:
  {
    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.24163 = im == 0B;
        D.24164 = (long int) D.24163;
        D.24165 = __builtin_expect (D.24164, 0);
        if (D.24165 != 0) goto <D.24166>; else goto <D.24167>;
        <D.24166>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 5298, "im");
        <D.24167>:
        D.24168 = &klass->byval_arg;
        D.24169 = mono_type_get_object (domain, D.24168);
        pa[0] = D.24169;
        pa[1] = obj;
        res = mono_runtime_invoke (im, rp, &pa, 0B);
        D.24170 = mono_object_unbox (res);
        D.24171 = MEM[(MonoBoolean *)D.24170];
        if (D.24171 != 0) goto <D.24172>; else goto <D.24173>;
        <D.24172>:
        mono_upgrade_remote_class (domain, obj, klass);
        D.24111 = obj;
        return D.24111;
        <D.24173>:
      }
    finally
      {
        pa = {CLOBBER};
      }
  }
  <D.24162>:
  <D.24159>:
  D.24111 = 0B;
  return D.24111;
}


mono_object_castclass_mbyref (struct MonoObject * obj, struct MonoClass * klass)
{
  struct MonoObject * D.24179;
  struct MonoObject * D.24180;
  struct MonoImage * D.24183;
  struct MonoException * D.24184;

  if (obj == 0B) goto <D.24177>; else goto <D.24178>;
  <D.24177>:
  D.24179 = 0B;
  return D.24179;
  <D.24178>:
  D.24180 = mono_object_isinst_mbyref (obj, klass);
  if (D.24180 != 0B) goto <D.24181>; else goto <D.24182>;
  <D.24181>:
  D.24179 = obj;
  return D.24179;
  <D.24182>:
  D.24183 = mono_defaults.corlib;
  D.24184 = mono_exception_from_name (D.24183, "System", "InvalidCastException");
  mono_raise_exception (D.24184);
  D.24179 = 0B;
  return D.24179;
}


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

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


mono_string_is_interned_lookup (struct MonoString * str, int insert)
{
  struct MonoVTable * D.24188;
  _Bool D.24191;
  long int D.24192;
  long int D.24193;
  _Bool D.24200;
  long int D.24201;
  long int D.24202;
  struct MonoString * D.24205;
  _Bool D.24212;
  long int D.24213;
  long int D.24214;
  struct MonoString * D.24217;
  _Bool D.24222;
  long int D.24223;
  long int D.24224;
  _Bool D.24229;
  long int D.24230;
  long int D.24231;
  struct MonoGHashTable * ldstr_table;
  struct MonoString * res;
  struct MonoDomain * domain;

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

    ret = pthread_mutex_lock (&ldstr_section.mutex);
    if (ret != 0) goto <D.24189>; else goto <D.24190>;
    <D.24189>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.24190>:
    D.24191 = ret != 0;
    D.24192 = (long int) D.24191;
    D.24193 = __builtin_expect (D.24192, 0);
    if (D.24193 != 0) goto <D.24194>; else goto <D.24195>;
    <D.24194>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 5378, "ret == 0");
    <D.24195>:
  }
  res = mono_g_hash_table_lookup (ldstr_table, str);
  if (res != 0B) goto <D.24196>; else goto <D.24197>;
  <D.24196>:
  {
    int ret;

    ret = pthread_mutex_unlock (&ldstr_section.mutex);
    if (ret != 0) goto <D.24198>; else goto <D.24199>;
    <D.24198>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.24199>:
    D.24200 = ret != 0;
    D.24201 = (long int) D.24200;
    D.24202 = __builtin_expect (D.24201, 0);
    if (D.24202 != 0) goto <D.24203>; else goto <D.24204>;
    <D.24203>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 5380, "ret == 0");
    <D.24204>:
  }
  D.24205 = res;
  return D.24205;
  <D.24197>:
  if (insert != 0) goto <D.24206>; else goto <D.24207>;
  <D.24206>:
  str = mono_string_get_pinned (str);
  if (str != 0B) goto <D.24208>; else goto <D.24209>;
  <D.24208>:
  mono_g_hash_table_insert (ldstr_table, str, str);
  <D.24209>:
  {
    int ret;

    ret = pthread_mutex_unlock (&ldstr_section.mutex);
    if (ret != 0) goto <D.24210>; else goto <D.24211>;
    <D.24210>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.24211>:
    D.24212 = ret != 0;
    D.24213 = (long int) D.24212;
    D.24214 = __builtin_expect (D.24213, 0);
    if (D.24214 != 0) goto <D.24215>; else goto <D.24216>;
    <D.24215>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 5387, "ret == 0");
    <D.24216>:
  }
  D.24205 = str;
  return D.24205;
  <D.24207>:
  {
    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.24217 = ldstr_info.res;
        if (D.24217 != 0B) goto <D.24218>; else goto <D.24219>;
        <D.24218>:
        mono_g_hash_table_insert (ldstr_table, str, str);
        {
          int ret;

          ret = pthread_mutex_unlock (&ldstr_section.mutex);
          if (ret != 0) goto <D.24220>; else goto <D.24221>;
          <D.24220>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
          <D.24221>:
          D.24222 = ret != 0;
          D.24223 = (long int) D.24222;
          D.24224 = __builtin_expect (D.24223, 0);
          if (D.24224 != 0) goto <D.24225>; else goto <D.24226>;
          <D.24225>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 5402, "ret == 0");
          <D.24226>:
        }
        D.24205 = str;
        return D.24205;
        <D.24219>:
      }
    finally
      {
        ldstr_info = {CLOBBER};
      }
  }
  {
    int ret;

    ret = pthread_mutex_unlock (&ldstr_section.mutex);
    if (ret != 0) goto <D.24227>; else goto <D.24228>;
    <D.24227>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.24228>:
    D.24229 = ret != 0;
    D.24230 = (long int) D.24229;
    D.24231 = __builtin_expect (D.24230, 0);
    if (D.24231 != 0) goto <D.24232>; else goto <D.24233>;
    <D.24232>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 5406, "ret == 0");
    <D.24233>:
  }
  D.24205 = 0B;
  return D.24205;
}


str_lookup (struct MonoDomain * domain, void * user_data)
{
  struct MonoString * D.24239;
  struct MonoDomain * D.24241;
  struct MonoGHashTable * D.24242;
  struct MonoString * D.24243;
  void * D.24244;
  struct LDStrInfo * info;

  info = user_data;
  D.24239 = info->res;
  if (D.24239 != 0B) goto <D.24237>; else goto <D.24240>;
  <D.24240>:
  D.24241 = info->orig_domain;
  if (D.24241 == domain) goto <D.24237>; else goto <D.24238>;
  <D.24237>:
  return;
  <D.24238>:
  D.24242 = domain->ldstr_table;
  D.24243 = info->ins;
  D.24244 = mono_g_hash_table_lookup (D.24242, D.24243);
  info->res = D.24244;
}


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

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


mono_ldstr (struct MonoDomain * domain, struct MonoImage * image, guint32 idx)
{
  unsigned int D.24248;
  unsigned int D.24249;
  unsigned int D.24252;
  struct MonoString * D.24253;
  int D.24254;
  const char * D.24257;

  D.24248 = BIT_FIELD_REF <*image, 32, 128>;
  D.24249 = D.24248 & 8;
  if (D.24249 != 0) goto <D.24250>; else goto <D.24251>;
  <D.24250>:
  {
    struct MonoString * str;

    D.24252 = idx | 1879048192;
    str = mono_lookup_dynamic_token (image, D.24252, 0B);
    D.24253 = str;
    return D.24253;
  }
  <D.24251>:
  D.24254 = mono_verifier_verify_string_signature (image, idx, 0B);
  if (D.24254 == 0) goto <D.24255>; else goto <D.24256>;
  <D.24255>:
  D.24253 = 0B;
  return D.24253;
  <D.24256>:
  D.24257 = mono_metadata_user_string (image, idx);
  D.24253 = mono_ldstr_metadata_sig (domain, D.24257);
  return D.24253;
}


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

  try
    {
      result = mono_string_to_utf8_checked (s, &error);
      D.24259 = mono_error_ok (&error);
      if (D.24259 == 0) goto <D.24260>; else goto <D.24261>;
      <D.24260>:
      mono_error_raise_exception (&error);
      <D.24261>:
      D.24262 = result;
      return D.24262;
    }
  finally
    {
      error = {CLOBBER};
    }
}


mono_string_to_utf8_checked (struct MonoString * s, struct MonoError * error)
{
  char * D.24267;
  int D.24268;
  mono_unichar2 * D.24271;
  struct GError * gerror.210;
  gchar * D.24275;
  long int written.211;
  unsigned int D.24279;
  unsigned int written.212;
  long int written;
  char * as;
  struct GError * gerror;

  try
    {
      written = 0;
      gerror = 0B;
      mono_error_init (error);
      if (s == 0B) goto <D.24265>; else goto <D.24266>;
      <D.24265>:
      D.24267 = 0B;
      return D.24267;
      <D.24266>:
      D.24268 = s->length;
      if (D.24268 == 0) goto <D.24269>; else goto <D.24270>;
      <D.24269>:
      D.24267 = monoeg_strdup ("");
      return D.24267;
      <D.24270>:
      D.24271 = mono_string_chars (s);
      D.24268 = s->length;
      as = monoeg_g_utf16_to_utf8 (D.24271, D.24268, 0B, &written, &gerror);
      gerror.210 = gerror;
      if (gerror.210 != 0B) goto <D.24273>; else goto <D.24274>;
      <D.24273>:
      gerror.210 = gerror;
      D.24275 = gerror.210->message;
      mono_error_set_argument (error, "string", "%s", D.24275);
      gerror.210 = gerror;
      monoeg_g_error_free (gerror.210);
      D.24267 = 0B;
      return D.24267;
      <D.24274>:
      D.24268 = s->length;
      written.211 = written;
      if (D.24268 > written.211) goto <D.24277>; else goto <D.24278>;
      <D.24277>:
      {
        char * as2;

        D.24268 = s->length;
        D.24279 = (unsigned int) D.24268;
        as2 = monoeg_malloc0 (D.24279);
        written.211 = written;
        written.212 = (unsigned int) written.211;
        memcpy (as2, as, written.212);
        monoeg_g_free (as);
        as = as2;
      }
      <D.24278>:
      D.24267 = as;
      return D.24267;
    }
  finally
    {
      written = {CLOBBER};
      gerror = {CLOBBER};
    }
}


mono_string_to_utf8_ignore (struct MonoString * s)
{
  char * D.24285;
  int D.24286;
  mono_unichar2 * D.24289;
  long int written.213;
  unsigned int D.24293;
  unsigned int written.214;
  long int written;
  char * as;

  try
    {
      written = 0;
      if (s == 0B) goto <D.24283>; else goto <D.24284>;
      <D.24283>:
      D.24285 = 0B;
      return D.24285;
      <D.24284>:
      D.24286 = s->length;
      if (D.24286 == 0) goto <D.24287>; else goto <D.24288>;
      <D.24287>:
      D.24285 = monoeg_strdup ("");
      return D.24285;
      <D.24288>:
      D.24289 = mono_string_chars (s);
      D.24286 = s->length;
      as = monoeg_g_utf16_to_utf8 (D.24289, D.24286, 0B, &written, 0B);
      D.24286 = s->length;
      written.213 = written;
      if (D.24286 > written.213) goto <D.24291>; else goto <D.24292>;
      <D.24291>:
      {
        char * as2;

        D.24286 = s->length;
        D.24293 = (unsigned int) D.24286;
        as2 = monoeg_malloc0 (D.24293);
        written.213 = written;
        written.214 = (unsigned int) written.213;
        memcpy (as2, as, written.214);
        monoeg_g_free (as);
        as = as2;
      }
      <D.24292>:
      D.24285 = as;
      return D.24285;
    }
  finally
    {
      written = {CLOBBER};
    }
}


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

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


mono_string_to_utf8_internal (struct MonoMemPool * mp, struct MonoImage * image, struct MonoString * s, gboolean ignore_error, struct MonoError * error)
{
  int D.24302;
  char * D.24305;
  unsigned int D.24310;
  unsigned int D.24311;
  unsigned int len.215;
  unsigned int len.216;
  unsigned int len.217;
  char * r;
  char * mp_s;
  int len;

  if (ignore_error != 0) goto <D.24299>; else goto <D.24300>;
  <D.24299>:
  r = mono_string_to_utf8_ignore (s);
  goto <D.24301>;
  <D.24300>:
  r = mono_string_to_utf8_checked (s, error);
  D.24302 = mono_error_ok (error);
  if (D.24302 == 0) goto <D.24303>; else goto <D.24304>;
  <D.24303>:
  D.24305 = 0B;
  return D.24305;
  <D.24304>:
  <D.24301>:
  if (mp == 0B) goto <D.24306>; else goto <D.24307>;
  <D.24306>:
  if (image == 0B) goto <D.24308>; else goto <D.24309>;
  <D.24308>:
  D.24305 = r;
  return D.24305;
  <D.24309>:
  <D.24307>:
  D.24310 = strlen (r);
  D.24311 = D.24310 + 1;
  len = (int) D.24311;
  if (mp != 0B) goto <D.24312>; else goto <D.24313>;
  <D.24312>:
  len.215 = (unsigned int) len;
  mp_s = mono_mempool_alloc (mp, len.215);
  goto <D.24315>;
  <D.24313>:
  len.216 = (unsigned int) len;
  mp_s = mono_image_alloc (image, len.216);
  <D.24315>:
  len.217 = (unsigned int) len;
  memcpy (mp_s, r, len.217);
  monoeg_g_free (r);
  D.24305 = mp_s;
  return D.24305;
}


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

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


mono_string_to_utf16 (struct MonoString * s)
{
  mono_unichar2 * D.24323;
  int D.24324;
  int D.24325;
  int D.24326;
  unsigned int D.24327;
  int D.24328;
  sizetype D.24329;
  char * D.24330;
  sizetype D.24331;
  char * D.24332;
  mono_unichar2 * D.24335;
  unsigned int D.24336;
  char * as;

  if (s == 0B) goto <D.24321>; else goto <D.24322>;
  <D.24321>:
  D.24323 = 0B;
  return D.24323;
  <D.24322>:
  D.24324 = s->length;
  D.24325 = D.24324 + 1;
  D.24326 = D.24325 * 2;
  D.24327 = (unsigned int) D.24326;
  as = monoeg_malloc (D.24327);
  D.24324 = s->length;
  D.24328 = D.24324 * 2;
  D.24329 = (sizetype) D.24328;
  D.24330 = as + D.24329;
  *D.24330 = 0;
  D.24324 = s->length;
  D.24328 = D.24324 * 2;
  D.24329 = (sizetype) D.24328;
  D.24331 = D.24329 + 1;
  D.24332 = as + D.24331;
  *D.24332 = 0;
  D.24324 = s->length;
  if (D.24324 == 0) goto <D.24333>; else goto <D.24334>;
  <D.24333>:
  D.24323 = as;
  return D.24323;
  <D.24334>:
  D.24335 = mono_string_chars (s);
  D.24324 = s->length;
  D.24328 = D.24324 * 2;
  D.24336 = (unsigned int) D.24328;
  memcpy (as, D.24335, D.24336);
  D.24323 = as;
  return D.24323;
}


mono_string_from_utf16 (gunichar2 * data)
{
  struct MonoString * D.24340;
  unsigned int len.218;
  unsigned int D.24342;
  gunichar2 * D.24343;
  short unsigned int D.24344;
  struct MonoDomain * domain;
  int len;

  domain = mono_domain_get ();
  len = 0;
  if (data == 0B) goto <D.24338>; else goto <D.24339>;
  <D.24338>:
  D.24340 = 0B;
  return D.24340;
  <D.24339>:
  goto <D.20094>;
  <D.20093>:
  len = len + 1;
  <D.20094>:
  len.218 = (unsigned int) len;
  D.24342 = len.218 * 2;
  D.24343 = data + D.24342;
  D.24344 = *D.24343;
  if (D.24344 != 0) goto <D.20093>; else goto <D.20095>;
  <D.20095>:
  D.24340 = mono_string_new_utf16 (domain, data, len);
  return D.24340;
}


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

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


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

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


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


mono_get_eh_callbacks ()
{
  struct MonoRuntimeExceptionHandlingCallbacks * D.24350;

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


mono_raise_exception (struct MonoException * ex)
{
  void (*<T24cf>) (struct MonoException *) D.24352;

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


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

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


mono_wait_handle_new (struct MonoDomain * domain, void * handle)
{
  struct MonoClass * D.24354;
  struct MonoMethod * handle_set.219;
  struct MonoProperty * D.24358;
  struct MonoMethod * handle_set.220;
  struct MonoWaitHandle * D.24360;
  struct MonoWaitHandle * res;
  void * params[1];
  static struct MonoMethod * handle_set;

  try
    {
      D.24354 = mono_defaults.manualresetevent_class;
      res = mono_object_new (domain, D.24354);
      handle_set.219 = handle_set;
      if (handle_set.219 == 0B) goto <D.24356>; else goto <D.24357>;
      <D.24356>:
      D.24354 = mono_defaults.manualresetevent_class;
      D.24358 = mono_class_get_property_from_name (D.24354, "Handle");
      handle_set.220 = D.24358->set;
      handle_set = handle_set.220;
      <D.24357>:
      params[0] = &handle;
      handle_set.219 = handle_set;
      mono_runtime_invoke (handle_set.219, res, &params, 0B);
      D.24360 = res;
      return D.24360;
    }
  finally
    {
      params = {CLOBBER};
    }
}


mono_wait_handle_get_handle (struct MonoWaitHandle * handle)
{
  struct MonoClassField * f_os_handle.221;
  struct MonoClassField * f_safe_handle.222;
  struct MonoClass * D.24369;
  struct MonoClassField * f_os_handle.223;
  struct MonoClassField * f_safe_handle.224;
  void * D.24374;
  struct MonoSafeHandle * sh.225;
  static struct MonoClassField * f_os_handle;
  static struct MonoClassField * f_safe_handle;

  f_os_handle.221 = f_os_handle;
  if (f_os_handle.221 == 0B) goto <D.24364>; else goto <D.24365>;
  <D.24364>:
  f_safe_handle.222 = f_safe_handle;
  if (f_safe_handle.222 == 0B) goto <D.24367>; else goto <D.24368>;
  <D.24367>:
  D.24369 = mono_defaults.manualresetevent_class;
  f_os_handle.223 = mono_class_get_field_from_name (D.24369, "os_handle");
  f_os_handle = f_os_handle.223;
  D.24369 = mono_defaults.manualresetevent_class;
  f_safe_handle.224 = mono_class_get_field_from_name (D.24369, "safe_wait_handle");
  f_safe_handle = f_safe_handle.224;
  <D.24368>:
  <D.24365>:
  f_os_handle.221 = f_os_handle;
  if (f_os_handle.221 != 0B) goto <D.24372>; else goto <D.24373>;
  <D.24372>:
  {
    void * retval;

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

    try
      {
        f_safe_handle.222 = f_safe_handle;
        mono_field_get_value (handle, f_safe_handle.222, &sh);
        sh.225 = sh;
        D.24374 = sh.225->handle;
        return D.24374;
      }
    finally
      {
        sh = {CLOBBER};
      }
  }
}


mono_async_result_new (struct MonoDomain * domain, void * handle, struct MonoObject * state, void * data, struct MonoObject * object_data)
{
  struct MonoClass * D.24379;
  struct MonoObject * * D.24382;
  struct MonoObject * * D.24383;
  struct MonoObject * * D.24384;
  struct MonoObject * * D.24387;
  struct MonoWaitHandle * D.24388;
  struct MonoAsyncResult * D.24389;
  struct MonoAsyncResult * res;
  struct MonoObject * context;

  D.24379 = mono_defaults.asyncresult_class;
  res = mono_object_new (domain, D.24379);
  context = mono_runtime_capture_context (domain);
  if (context != 0B) goto <D.24380>; else goto <D.24381>;
  <D.24380>:
  D.24382 = &res->execution_context;
  mono_gc_wbarrier_set_field (res, D.24382, context);
  <D.24381>:
  res->data = data;
  D.24383 = &res->object_data;
  mono_gc_wbarrier_set_field (res, D.24383, object_data);
  D.24384 = &res->async_state;
  mono_gc_wbarrier_set_field (res, D.24384, state);
  if (handle != 0B) goto <D.24385>; else goto <D.24386>;
  <D.24385>:
  D.24387 = &res->handle;
  D.24388 = mono_wait_handle_new (domain, handle);
  mono_gc_wbarrier_set_field (res, D.24387, D.24388);
  <D.24386>:
  res->sync_completed = 0;
  res->completed = 0;
  D.24389 = res;
  return D.24389;
}


mono_runtime_capture_context (struct MonoDomain * domain)
{
  void * D.24393;
  void * D.24395;
  struct MonoObject * D.24398;
  void * D.24399;
  void * D.24400;
  struct MonoObject * (*RuntimeInvokeFunction) (struct MonoObject *, void * *, struct MonoObject * *, void *) runtime_invoke;

  D.24393 = domain->capture_context_runtime_invoke;
  if (D.24393 == 0B) goto <D.24391>; else goto <D.24394>;
  <D.24394>:
  D.24395 = domain->capture_context_method;
  if (D.24395 == 0B) goto <D.24391>; else goto <D.24392>;
  <D.24391>:
  {
    struct MonoMethod * method;
    struct MonoMethod * wrapper;

    method = mono_get_context_capture_method ();
    if (method == 0B) goto <D.24396>; else goto <D.24397>;
    <D.24396>:
    D.24398 = 0B;
    return D.24398;
    <D.24397>:
    wrapper = mono_marshal_get_runtime_invoke (method, 0);
    D.24399 = mono_compile_method (wrapper);
    domain->capture_context_runtime_invoke = D.24399;
    D.24400 = mono_compile_method (method);
    domain->capture_context_method = D.24400;
  }
  <D.24392>:
  D.24393 = domain->capture_context_runtime_invoke;
  runtime_invoke = (struct MonoObject * (*RuntimeInvokeFunction) (struct MonoObject *, void * *, struct MonoObject * *, void *)) D.24393;
  D.24395 = domain->capture_context_method;
  D.24398 = runtime_invoke (0B, 0B, 0B, D.24395);
  return D.24398;
}


mono_message_init (struct MonoDomain * domain, struct MonoMethodMessage * this, struct MonoReflectionMethod * method, struct MonoArray * out_args)
{
  struct MonoMethod * D.24402;
  struct MonoClass * object_array_klass.226;
  struct MonoClass * D.24406;
  _Bool D.24407;
  long int D.24408;
  long int D.24409;
  struct MonoClass * D.24412;
  struct MonoClass * D.24415;
  struct MonoReflectionMethod * * D.24418;
  struct MonoArray * * D.24419;
  struct MonoVTable * D.24420;
  short unsigned int D.24421;
  unsigned int D.24422;
  struct MonoArray * D.24423;
  struct MonoArray * * D.24424;
  struct MonoClass * byte_array_klass.227;
  struct MonoVTable * D.24426;
  struct MonoArray * D.24427;
  unsigned int D.24428;
  unsigned int D.24429;
  struct MonoArray * * D.24430;
  struct MonoClass * string_array_klass.228;
  struct MonoVTable * D.24432;
  struct MonoArray * D.24433;
  unsigned int i.229;
  unsigned int D.24435;
  char * * D.24436;
  char * D.24437;
  struct MonoArray * D.24438;
  unsigned int i.230;
  int D.24440;
  struct MonoType * D.24441;
  unsigned int D.24442;
  unsigned int D.24443;
  unsigned int j.231;
  char * D.24449;
  struct MonoArray * D.24450;
  short unsigned int D.24451;
  int D.24452;
  int D.24453;
  struct MonoArray * D.24459;
  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.24402 = method->method;
  sig = mono_method_signature (D.24402);
  object_array_klass.226 = object_array_klass;
  if (object_array_klass.226 == 0B) goto <D.24404>; else goto <D.24405>;
  <D.24404>:
  {
    struct MonoClass * klass;

    D.24406 = mono_defaults.byte_class;
    klass = mono_array_class_get (D.24406, 1);
    D.24407 = klass == 0B;
    D.24408 = (long int) D.24407;
    D.24409 = __builtin_expect (D.24408, 0);
    if (D.24409 != 0) goto <D.24410>; else goto <D.24411>;
    <D.24410>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 5891, "klass");
    <D.24411>:
    byte_array_klass = klass;
    D.24412 = mono_defaults.string_class;
    klass = mono_array_class_get (D.24412, 1);
    D.24407 = klass == 0B;
    D.24408 = (long int) D.24407;
    D.24409 = __builtin_expect (D.24408, 0);
    if (D.24409 != 0) goto <D.24413>; else goto <D.24414>;
    <D.24413>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 5895, "klass");
    <D.24414>:
    string_array_klass = klass;
    D.24415 = mono_defaults.object_class;
    klass = mono_array_class_get (D.24415, 1);
    D.24407 = klass == 0B;
    D.24408 = (long int) D.24407;
    D.24409 = __builtin_expect (D.24408, 0);
    if (D.24409 != 0) goto <D.24416>; else goto <D.24417>;
    <D.24416>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 5899, "klass");
    <D.24417>:
    mono_memory_barrier ();
    object_array_klass = klass;
  }
  <D.24405>:
  D.24418 = &this->method;
  mono_gc_wbarrier_set_field (this, D.24418, method);
  D.24419 = &this->args;
  object_array_klass.226 = object_array_klass;
  D.24420 = mono_class_vtable (domain, object_array_klass.226);
  D.24421 = sig->param_count;
  D.24422 = (unsigned int) D.24421;
  D.24423 = mono_array_new_specific (D.24420, D.24422);
  mono_gc_wbarrier_set_field (this, D.24419, D.24423);
  D.24424 = &this->arg_types;
  byte_array_klass.227 = byte_array_klass;
  D.24426 = mono_class_vtable (domain, byte_array_klass.227);
  D.24421 = sig->param_count;
  D.24422 = (unsigned int) D.24421;
  D.24427 = mono_array_new_specific (D.24426, D.24422);
  mono_gc_wbarrier_set_field (this, D.24424, D.24427);
  this->async_result = 0B;
  this->call_type = 0;
  D.24421 = sig->param_count;
  D.24428 = (unsigned int) D.24421;
  D.24429 = D.24428 * 4;
  names = monoeg_malloc (D.24429);
  D.24402 = method->method;
  mono_method_get_param_names (D.24402, names);
  D.24430 = &this->names;
  string_array_klass.228 = string_array_klass;
  D.24432 = mono_class_vtable (domain, string_array_klass.228);
  D.24421 = sig->param_count;
  D.24422 = (unsigned int) D.24421;
  D.24433 = mono_array_new_specific (D.24432, D.24422);
  mono_gc_wbarrier_set_field (this, D.24430, D.24433);
  i = 0;
  goto <D.20177>;
  <D.20176>:
  i.229 = (unsigned int) i;
  D.24435 = i.229 * 4;
  D.24436 = names + D.24435;
  D.24437 = *D.24436;
  name = mono_string_new (domain, D.24437);
  {
    void * * __p;

    D.24438 = this->names;
    i.230 = (unsigned int) i;
    __p = mono_array_addr_with_size (D.24438, 4, i.230);
    D.24438 = this->names;
    mono_gc_wbarrier_set_arrayref (D.24438, __p, name);
  }
  i = i + 1;
  <D.20177>:
  D.24421 = sig->param_count;
  D.24440 = (int) D.24421;
  if (D.24440 > i) goto <D.20176>; else goto <D.20178>;
  <D.20178>:
  monoeg_g_free (names);
  i = 0;
  j = 0;
  goto <D.20183>;
  <D.20182>:
  D.24441 = sig->params[i];
  D.24442 = BIT_FIELD_REF <*D.24441, 32, 32>;
  D.24443 = D.24442 & 1073741824;
  if (D.24443 != 0) goto <D.24444>; else goto <D.24445>;
  <D.24444>:
  if (out_args != 0B) goto <D.24446>; else goto <D.24447>;
  <D.24446>:
  {
    struct MonoObject * arg;

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

      D.24450 = this->args;
      i.230 = (unsigned int) i;
      __p = mono_array_addr_with_size (D.24450, 4, i.230);
      D.24450 = this->args;
      mono_gc_wbarrier_set_arrayref (D.24450, __p, arg);
    }
    j = j + 1;
  }
  <D.24447>:
  arg_type = 2;
  D.24441 = sig->params[i];
  D.24451 = D.24441->attrs;
  D.24452 = (int) D.24451;
  D.24453 = D.24452 & 2;
  if (D.24453 == 0) goto <D.24454>; else goto <D.24455>;
  <D.24454>:
  arg_type = arg_type | 1;
  <D.24455>:
  goto <D.24456>;
  <D.24445>:
  arg_type = 1;
  D.24441 = sig->params[i];
  D.24451 = D.24441->attrs;
  D.24452 = (int) D.24451;
  D.24453 = D.24452 & 2;
  if (D.24453 != 0) goto <D.24457>; else goto <D.24458>;
  <D.24457>:
  arg_type = arg_type | 4;
  <D.24458>:
  <D.24456>:
  {
    guint8 * __p;

    D.24459 = this->arg_types;
    i.230 = (unsigned int) i;
    __p = mono_array_addr_with_size (D.24459, 1, i.230);
    *__p = arg_type;
  }
  i = i + 1;
  <D.20183>:
  D.24421 = sig->param_count;
  D.24440 = (int) D.24421;
  if (D.24440 > i) goto <D.20182>; else goto <D.20184>;
  <D.20184>:
}


mono_remoting_invoke (struct MonoObject * real_proxy, struct MonoMethodMessage * msg, struct MonoObject * * exc, struct MonoArray * * out_args)
{
  struct MonoVTable * D.24460;
  struct MonoDomain * D.24461;
  struct MonoClass * D.24464;
  _Bool D.24465;
  long int D.24466;
  long int D.24467;
  struct MonoObject * D.24470;
  struct MonoMethod * im;
  void * pa[4];

  try
    {
      D.24460 = real_proxy->vtable;
      D.24461 = D.24460->domain;
      im = D.24461->private_invoke_method;
      if (im == 0B) goto <D.24462>; else goto <D.24463>;
      <D.24462>:
      D.24464 = mono_defaults.real_proxy_class;
      im = mono_class_get_method_from_name (D.24464, "PrivateInvoke", 4);
      D.24465 = im == 0B;
      D.24466 = (long int) D.24465;
      D.24467 = __builtin_expect (D.24466, 0);
      if (D.24467 != 0) goto <D.24468>; else goto <D.24469>;
      <D.24468>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 5966, "im");
      <D.24469>:
      D.24460 = real_proxy->vtable;
      D.24461 = D.24460->domain;
      D.24461->private_invoke_method = im;
      <D.24463>:
      pa[0] = real_proxy;
      pa[1] = msg;
      pa[2] = exc;
      pa[3] = out_args;
      D.24470 = mono_runtime_invoke (im, 0B, &pa, exc);
      return D.24470;
    }
  finally
    {
      pa = {CLOBBER};
    }
}


mono_message_invoke (struct MonoObject * target, struct MonoMethodMessage * msg, struct MonoObject * * exc, struct MonoArray * * out_args)
{
  struct MonoVTable * D.24475;
  struct MonoClass * D.24476;
  struct MonoClass * D.24477;
  struct MonoRemoteClass * D.24482;
  struct MonoClass * D.24483;
  unsigned int D.24484;
  unsigned int D.24485;
  struct MonoRealProxy * D.24487;
  struct MonoObject * D.24488;
  struct MonoAppContext * D.24489;
  struct MonoObject * D.24491;
  struct MonoReflectionMethod * D.24492;
  struct MonoType * D.24493;
  unsigned int D.24494;
  unsigned int D.24495;
  short unsigned int D.24498;
  int D.24499;
  struct MonoClass * object_array_klass.232;
  struct MonoClass * D.24503;
  _Bool D.24504;
  long int D.24505;
  long int D.24506;
  struct MonoVTable * D.24509;
  unsigned int outarg_count.233;
  struct MonoArray * D.24511;
  void * iftmp.234;
  struct MonoClass * D.24513;
  unsigned int D.24514;
  unsigned int D.24515;
  struct MonoArray * D.24519;
  unsigned int i.235;
  char * D.24523;
  struct MonoArray * D.24524;
  unsigned int j.236;
  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.24473>; else goto <D.24474>;
  <D.24473>:
  D.24475 = target->vtable;
  D.24476 = D.24475->klass;
  D.24477 = mono_defaults.transparent_proxy_class;
  if (D.24476 == D.24477) goto <D.24478>; else goto <D.24479>;
  <D.24478>:
  {
    struct MonoTransparentProxy * tp;

    tp = target;
    D.24482 = tp->remote_class;
    D.24483 = D.24482->proxy_class;
    D.24484 = BIT_FIELD_REF <*D.24483, 32, 160>;
    D.24485 = D.24484 & 8388608;
    if (D.24485 != 0) goto <D.24486>; else goto <D.24480>;
    <D.24486>:
    D.24487 = tp->rp;
    D.24488 = D.24487->context;
    D.24489 = mono_context_get ();
    if (D.24488 == D.24489) goto <D.24490>; else goto <D.24480>;
    <D.24490>:
    D.24487 = tp->rp;
    target = D.24487->unwrapped_server;
    goto <D.24481>;
    <D.24480>:
    D.24487 = tp->rp;
    D.24491 = mono_remoting_invoke (D.24487, msg, exc, out_args);
    return D.24491;
    <D.24481>:
  }
  <D.24479>:
  <D.24474>:
  domain = mono_domain_get ();
  D.24492 = msg->method;
  method = D.24492->method;
  sig = mono_method_signature (method);
  i = 0;
  goto <D.20209>;
  <D.20208>:
  D.24493 = sig->params[i];
  D.24494 = BIT_FIELD_REF <*D.24493, 32, 32>;
  D.24495 = D.24494 & 1073741824;
  if (D.24495 != 0) goto <D.24496>; else goto <D.24497>;
  <D.24496>:
  outarg_count = outarg_count + 1;
  <D.24497>:
  i = i + 1;
  <D.20209>:
  D.24498 = sig->param_count;
  D.24499 = (int) D.24498;
  if (D.24499 > i) goto <D.20208>; else goto <D.20210>;
  <D.20210>:
  object_array_klass.232 = object_array_klass;
  if (object_array_klass.232 == 0B) goto <D.24501>; else goto <D.24502>;
  <D.24501>:
  {
    struct MonoClass * klass;

    D.24503 = mono_defaults.object_class;
    klass = mono_array_class_get (D.24503, 1);
    D.24504 = klass == 0B;
    D.24505 = (long int) D.24504;
    D.24506 = __builtin_expect (D.24505, 0);
    if (D.24506 != 0) goto <D.24507>; else goto <D.24508>;
    <D.24507>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 6014, "klass");
    <D.24508>:
    mono_memory_barrier ();
    object_array_klass = klass;
  }
  <D.24502>:
  object_array_klass.232 = object_array_klass;
  D.24509 = mono_class_vtable (domain, object_array_klass.232);
  outarg_count.233 = (unsigned int) outarg_count;
  D.24511 = mono_array_new_specific (D.24509, outarg_count.233);
  *out_args = D.24511;
  *exc = 0B;
  D.24513 = method->klass;
  D.24514 = BIT_FIELD_REF <*D.24513, 32, 160>;
  D.24515 = D.24514 & 8;
  if (D.24515 != 0) goto <D.24516>; else goto <D.24517>;
  <D.24516>:
  iftmp.234 = mono_object_unbox (target);
  goto <D.24518>;
  <D.24517>:
  iftmp.234 = target;
  <D.24518>:
  D.24519 = msg->args;
  ret = mono_runtime_invoke_array (method, iftmp.234, D.24519, exc);
  i = 0;
  j = 0;
  goto <D.20215>;
  <D.20214>:
  D.24493 = sig->params[i];
  D.24494 = BIT_FIELD_REF <*D.24493, 32, 32>;
  D.24495 = D.24494 & 1073741824;
  if (D.24495 != 0) goto <D.24520>; else goto <D.24521>;
  <D.24520>:
  {
    struct MonoObject * arg;

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

      D.24524 = *out_args;
      j.236 = (unsigned int) j;
      __p = mono_array_addr_with_size (D.24524, 4, j.236);
      D.24524 = *out_args;
      mono_gc_wbarrier_set_arrayref (D.24524, __p, arg);
    }
    j = j + 1;
  }
  <D.24521>:
  i = i + 1;
  <D.20215>:
  D.24498 = sig->param_count;
  D.24499 = (int) D.24498;
  if (D.24499 > i) goto <D.20214>; else goto <D.20216>;
  <D.20216>:
  D.24491 = ret;
  return D.24491;
}


mono_object_to_string (struct MonoObject * obj, struct MonoObject * * exc)
{
  _Bool D.24527;
  long int D.24528;
  long int D.24529;
  struct MonoMethod * to_string.237;
  struct MonoClass * D.24535;
  struct MonoMethod * to_string.238;
  struct MonoClass * D.24537;
  int D.24538;
  struct MonoString * D.24541;
  static struct MonoMethod * to_string = 0B;
  struct MonoMethod * method;
  void * target;

  target = obj;
  D.24527 = obj == 0B;
  D.24528 = (long int) D.24527;
  D.24529 = __builtin_expect (D.24528, 0);
  if (D.24529 != 0) goto <D.24530>; else goto <D.24531>;
  <D.24530>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 6052, "obj");
  <D.24531>:
  to_string.237 = to_string;
  if (to_string.237 == 0B) goto <D.24533>; else goto <D.24534>;
  <D.24533>:
  D.24535 = mono_get_object_class ();
  to_string.238 = mono_class_get_method_from_name_flags (D.24535, "ToString", 0, 70);
  to_string = to_string.238;
  <D.24534>:
  to_string.237 = to_string;
  method = mono_object_get_virtual_method (obj, to_string.237);
  D.24537 = mono_method_get_class (method);
  D.24538 = mono_class_is_valuetype (D.24537);
  if (D.24538 != 0) goto <D.24539>; else goto <D.24540>;
  <D.24539>:
  target = mono_object_unbox (obj);
  <D.24540>:
  D.24541 = mono_runtime_invoke (method, target, 0B, exc);
  return D.24541;
}


mono_print_unhandled_exception (struct MonoObject * exc)
{
  struct MonoVTable * D.24543;
  struct MonoDomain * D.24544;
  struct MonoException * D.24545;
  struct MonoArray * D.24549;
  struct MonoObject * other_exc.239;
  int D.24559;
  struct MonoString * str;
  char * message;
  gboolean free_message;
  struct MonoError error;

  try
    {
      message = "";
      free_message = 0;
      D.24543 = exc->vtable;
      D.24544 = D.24543->domain;
      D.24545 = D.24544->out_of_memory_ex;
      if (D.24545 == exc) goto <D.24546>; else goto <D.24547>;
      <D.24546>:
      message = monoeg_strdup ("OutOfMemoryException");
      free_message = 1;
      goto <D.24548>;
      <D.24547>:
      D.24549 = MEM[(struct MonoException *)exc].native_trace_ips;
      if (D.24549 != 0B) goto <D.24550>; else goto <D.24551>;
      <D.24550>:
      message = mono_exception_get_native_backtrace (exc);
      free_message = 1;
      goto <D.24552>;
      <D.24551>:
      {
        struct MonoObject * other_exc;

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

              original_backtrace = mono_exception_get_managed_backtrace (exc);
              other_exc.239 = other_exc;
              nested_backtrace = mono_exception_get_managed_backtrace (other_exc.239);
              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.24556>;
            <D.24555>:
            if (str != 0B) goto <D.24557>; else goto <D.24558>;
            <D.24557>:
            message = mono_string_to_utf8_checked (str, &error);
            D.24559 = mono_error_ok (&error);
            if (D.24559 == 0) goto <D.24560>; else goto <D.24561>;
            <D.24560>:
            mono_error_cleanup (&error);
            message = "";
            goto <D.24562>;
            <D.24561>:
            free_message = 1;
            <D.24562>:
            <D.24558>:
            <D.24556>:
          }
        finally
          {
            other_exc = {CLOBBER};
          }
      }
      <D.24552>:
      <D.24548>:
      monoeg_g_printerr ("\nUnhandled Exception:\n%s\n", message);
      if (free_message != 0) goto <D.24563>; else goto <D.24564>;
      <D.24563>:
      monoeg_g_free (message);
      <D.24564>:
    }
  finally
    {
      error = {CLOBBER};
    }
}


mono_delegate_ctor_with_method (struct MonoObject * this, struct MonoObject * target, void * addr, struct MonoMethod * method)
{
  _Bool D.24565;
  long int D.24566;
  long int D.24567;
  _Bool D.24570;
  long int D.24571;
  long int D.24572;
  struct MonoVTable * D.24577;
  long unsigned int D.24578;
  long unsigned int D.24579;
  struct MonoVTable * D.24583;
  struct MonoClass * D.24584;
  struct MonoClass * D.24585;
  _Bool D.24587;
  long int D.24588;
  long int D.24589;
  void * D.24592;
  struct MonoObject * * D.24593;
  void * (*<T1d25>) (struct MonoDomain *, struct MonoClass *) arch_create_delegate_trampoline.240;
  struct MonoVTable * D.24595;
  struct MonoDomain * D.24596;
  struct MonoClass * D.24597;
  void * D.24598;
  struct MonoDelegate * delegate;
  struct MonoClass * class;

  delegate = this;
  D.24565 = this == 0B;
  D.24566 = (long int) D.24565;
  D.24567 = __builtin_expect (D.24566, 0);
  if (D.24567 != 0) goto <D.24568>; else goto <D.24569>;
  <D.24568>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 6142, "this");
  <D.24569>:
  D.24570 = addr == 0B;
  D.24571 = (long int) D.24570;
  D.24572 = __builtin_expect (D.24571, 0);
  if (D.24572 != 0) goto <D.24573>; else goto <D.24574>;
  <D.24573>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 6143, "addr");
  <D.24574>:
  if (method != 0B) goto <D.24575>; else goto <D.24576>;
  <D.24575>:
  delegate->method = method;
  <D.24576>:
  D.24577 = this->vtable;
  class = D.24577->klass;
  D.24578 = mono_stats.delegate_creations;
  D.24579 = D.24578 + 1;
  mono_stats.delegate_creations = D.24579;
  if (target != 0B) goto <D.24582>; else goto <D.24580>;
  <D.24582>:
  D.24583 = target->vtable;
  D.24584 = D.24583->klass;
  D.24585 = mono_defaults.transparent_proxy_class;
  if (D.24584 == D.24585) goto <D.24586>; else goto <D.24580>;
  <D.24586>:
  D.24587 = method == 0B;
  D.24588 = (long int) D.24587;
  D.24589 = __builtin_expect (D.24588, 0);
  if (D.24589 != 0) goto <D.24590>; else goto <D.24591>;
  <D.24590>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 6153, "method");
  <D.24591>:
  method = mono_marshal_get_remoting_invoke (method);
  D.24592 = mono_compile_method (method);
  delegate->method_ptr = D.24592;
  D.24593 = &delegate->target;
  mono_gc_wbarrier_set_field (delegate, D.24593, target);
  goto <D.24581>;
  <D.24580>:
  delegate->method_ptr = addr;
  D.24593 = &delegate->target;
  mono_gc_wbarrier_set_field (delegate, D.24593, target);
  <D.24581>:
  arch_create_delegate_trampoline.240 = arch_create_delegate_trampoline;
  D.24595 = delegate->object.vtable;
  D.24596 = D.24595->domain;
  D.24595 = delegate->object.vtable;
  D.24597 = D.24595->klass;
  D.24598 = arch_create_delegate_trampoline.240 (D.24596, D.24597);
  delegate->invoke_impl = D.24598;
}


mono_delegate_ctor (struct MonoObject * this, struct MonoObject * target, void * addr)
{
  _Bool D.24599;
  long int D.24600;
  long int D.24601;
  void * D.24604;
  struct MonoDomain * D.24607;
  struct MonoDomain * D.24610;
  void * D.24611;
  struct MonoClass * D.24614;
  struct MonoGenericContainer * D.24615;
  _Bool D.24616;
  long int D.24617;
  long int D.24618;
  struct MonoDomain * domain;
  struct MonoJitInfo * ji;
  struct MonoMethod * method;

  domain = mono_domain_get ();
  method = 0B;
  D.24599 = addr == 0B;
  D.24600 = (long int) D.24599;
  D.24601 = __builtin_expect (D.24600, 0);
  if (D.24601 != 0) goto <D.24602>; else goto <D.24603>;
  <D.24602>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 6182, "addr");
  <D.24603>:
  D.24604 = mono_get_addr_from_ftnptr (addr);
  ji = mono_jit_info_table_find (domain, D.24604);
  if (ji == 0B) goto <D.24605>; else goto <D.24606>;
  <D.24605>:
  D.24607 = mono_get_root_domain ();
  if (D.24607 != domain) goto <D.24608>; else goto <D.24609>;
  <D.24608>:
  D.24610 = mono_get_root_domain ();
  D.24611 = mono_get_addr_from_ftnptr (addr);
  ji = mono_jit_info_table_find (D.24610, D.24611);
  <D.24609>:
  <D.24606>:
  if (ji != 0B) goto <D.24612>; else goto <D.24613>;
  <D.24612>:
  method = mono_jit_info_get_method (ji);
  D.24614 = method->klass;
  D.24615 = D.24614->generic_container;
  D.24616 = D.24615 != 0B;
  D.24617 = (long int) D.24616;
  D.24618 = __builtin_expect (D.24617, 0);
  if (D.24618 != 0) goto <D.24619>; else goto <D.24620>;
  <D.24619>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 6190, "!method->klass->generic_container");
  <D.24620>:
  <D.24613>:
  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.24621;
  struct MonoReflectionMethod * D.24624;
  short unsigned int D.24625;
  int D.24626;
  struct MonoReflectionMethod * D.24628;
  struct MonoType * D.24629;
  unsigned int D.24630;
  unsigned int D.24631;
  unsigned int i.241;
  unsigned int D.24635;
  void * * D.24636;
  void * D.24637;
  unsigned char D.24639;
  unsigned int D.24640;
  unsigned int D.24641;
  struct MonoArray * D.24645;
  unsigned int i.242;
  struct MonoDelegate * D.24651;
  struct MonoObject * D.24652;
  struct MonoMethodMessage * D.24653;
  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.24621 = mono_defaults.mono_method_message_class;
  msg = mono_object_new (domain, D.24621);
  if (invoke != 0B) goto <D.24622>; else goto <D.24623>;
  <D.24622>:
  D.24624 = mono_method_get_object (domain, invoke, 0B);
  mono_message_init (domain, msg, D.24624, 0B);
  D.24625 = sig->param_count;
  D.24626 = (int) D.24625;
  count = D.24626 + -2;
  goto <D.24627>;
  <D.24623>:
  D.24628 = mono_method_get_object (domain, method, 0B);
  mono_message_init (domain, msg, D.24628, 0B);
  D.24625 = sig->param_count;
  count = (int) D.24625;
  <D.24627>:
  i = 0;
  goto <D.20268>;
  <D.20267>:
  {
    void * vpos;
    struct MonoClass * class;
    struct MonoObject * arg;

    D.24629 = sig->params[i];
    D.24630 = BIT_FIELD_REF <*D.24629, 32, 32>;
    D.24631 = D.24630 & 1073741824;
    if (D.24631 != 0) goto <D.24632>; else goto <D.24633>;
    <D.24632>:
    i.241 = (unsigned int) i;
    D.24635 = i.241 * 4;
    D.24636 = params + D.24635;
    D.24637 = *D.24636;
    vpos = MEM[(void * *)D.24637];
    goto <D.24638>;
    <D.24633>:
    i.241 = (unsigned int) i;
    D.24635 = i.241 * 4;
    D.24636 = params + D.24635;
    vpos = *D.24636;
    <D.24638>:
    D.24629 = sig->params[i];
    D.24639 = D.24629->type;
    type = (int) D.24639;
    D.24629 = sig->params[i];
    class = mono_class_from_mono_type (D.24629);
    D.24640 = BIT_FIELD_REF <*class, 32, 160>;
    D.24641 = D.24640 & 8;
    if (D.24641 != 0) goto <D.24642>; else goto <D.24643>;
    <D.24642>:
    arg = mono_value_box (domain, class, vpos);
    goto <D.24644>;
    <D.24643>:
    arg = MEM[(struct MonoObject * *)vpos];
    <D.24644>:
    {
      void * * __p;

      D.24645 = msg->args;
      i.242 = (unsigned int) i;
      __p = mono_array_addr_with_size (D.24645, 4, i.242);
      D.24645 = msg->args;
      mono_gc_wbarrier_set_arrayref (D.24645, __p, arg);
    }
  }
  i = i + 1;
  <D.20268>:
  if (i < count) goto <D.20267>; else goto <D.20269>;
  <D.20269>:
  if (cb != 0B) goto <D.24647>; else goto <D.24648>;
  <D.24647>:
  if (state != 0B) goto <D.24649>; else goto <D.24650>;
  <D.24649>:
  i.241 = (unsigned int) i;
  D.24635 = i.241 * 4;
  D.24636 = params + D.24635;
  D.24637 = *D.24636;
  D.24651 = MEM[(struct MonoDelegate * *)D.24637];
  *cb = D.24651;
  i = i + 1;
  i.241 = (unsigned int) i;
  D.24635 = i.241 * 4;
  D.24636 = params + D.24635;
  D.24637 = *D.24636;
  D.24652 = MEM[(struct MonoObject * *)D.24637];
  *state = D.24652;
  <D.24650>:
  <D.24648>:
  D.24653 = msg;
  return D.24653;
}


mono_method_return_message_restore (struct MonoMethod * method, void * * params, struct MonoArray * out_args)
{
  unsigned int D.24657;
  unsigned int D.24660;
  unsigned int D.24661;
  struct MonoException * D.24666;
  unsigned int j.243;
  char * D.24668;
  unsigned char D.24669;
  _Bool D.24670;
  long int D.24671;
  long int D.24672;
  int D.24675;
  unsigned int i.244;
  unsigned int D.24679;
  void * * D.24680;
  void * D.24681;
  struct MonoObject * * D.24682;
  struct MonoVTable * D.24686;
  unsigned int D.24687;
  unsigned int D.24688;
  void * D.24691;
  void * D.24692;
  const void * D.24694;
  unsigned int size.245;
  struct MonoClass * D.24697;
  short unsigned int D.24698;
  int D.24699;
  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.24655>; else goto <D.24656>;
  <D.24655>:
  return;
  <D.24656>:
  D.24657 = mono_array_length (out_args);
  out_len = (int) D.24657;
  if (out_len == 0) goto <D.24658>; else goto <D.24659>;
  <D.24658>:
  return;
  <D.24659>:
  i = 0;
  j = 0;
  goto <D.20285>;
  <D.20284>:
  {
    struct MonoType * pt;

    pt = sig->params[i];
    D.24660 = BIT_FIELD_REF <*pt, 32, 32>;
    D.24661 = D.24660 & 1073741824;
    if (D.24661 != 0) goto <D.24662>; else goto <D.24663>;
    <D.24662>:
    {
      char * arg;

      if (j >= out_len) goto <D.24664>; else goto <D.24665>;
      <D.24664>:
      D.24666 = mono_get_exception_execution_engine ("The proxy call returned an incorrect number of output arguments");
      mono_raise_exception (D.24666);
      <D.24665>:
      j.243 = (unsigned int) j;
      D.24668 = mono_array_addr_with_size (out_args, 4, j.243);
      arg = MEM[(void * *)D.24668];
      D.24669 = pt->type;
      type = (int) D.24669;
      D.24670 = type == 1;
      D.24671 = (long int) D.24670;
      D.24672 = __builtin_expect (D.24671, 0);
      if (D.24672 != 0) goto <D.24673>; else goto <D.24674>;
      <D.24673>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 6283, "type != MONO_TYPE_VOID");
      <D.24674>:
      D.24675 = mono_type_is_reference (pt);
      if (D.24675 != 0) goto <D.24676>; else goto <D.24677>;
      <D.24676>:
      i.244 = (unsigned int) i;
      D.24679 = i.244 * 4;
      D.24680 = params + D.24679;
      D.24681 = *D.24680;
      D.24682 = MEM[(struct MonoObject * * *)D.24681];
      mono_gc_wbarrier_generic_store (D.24682, arg);
      goto <D.24683>;
      <D.24677>:
      if (arg != 0B) goto <D.24684>; else goto <D.24685>;
      <D.24684>:
      {
        struct MonoClass * class;

        D.24686 = MEM[(struct MonoObject *)arg].vtable;
        class = D.24686->klass;
        size = mono_class_value_size (class, 0B);
        D.24687 = BIT_FIELD_REF <*class, 32, 160>;
        D.24688 = D.24687 & 134217728;
        if (D.24688 != 0) goto <D.24689>; else goto <D.24690>;
        <D.24689>:
        i.244 = (unsigned int) i;
        D.24679 = i.244 * 4;
        D.24680 = params + D.24679;
        D.24681 = *D.24680;
        D.24691 = MEM[(void * *)D.24681];
        D.24692 = arg + 8;
        mono_gc_wbarrier_value_copy (D.24691, D.24692, 1, class);
        goto <D.24693>;
        <D.24690>:
        i.244 = (unsigned int) i;
        D.24679 = i.244 * 4;
        D.24680 = params + D.24679;
        D.24681 = *D.24680;
        D.24691 = MEM[(void * *)D.24681];
        D.24694 = arg + 8;
        size.245 = (unsigned int) size;
        mono_gc_memmove_atomic (D.24691, D.24694, size.245);
        <D.24693>:
      }
      goto <D.24696>;
      <D.24685>:
      D.24697 = mono_class_from_mono_type (pt);
      size = mono_class_value_size (D.24697, 0B);
      i.244 = (unsigned int) i;
      D.24679 = i.244 * 4;
      D.24680 = params + D.24679;
      D.24681 = *D.24680;
      D.24691 = MEM[(void * *)D.24681];
      size.245 = (unsigned int) size;
      mono_gc_bzero_atomic (D.24691, size.245);
      <D.24696>:
      <D.24683>:
      j = j + 1;
    }
    <D.24663>:
  }
  i = i + 1;
  <D.20285>:
  D.24698 = sig->param_count;
  D.24699 = (int) D.24698;
  if (D.24699 > i) goto <D.20284>; else goto <D.20286>;
  <D.20286>:
}


mono_load_remote_field (struct MonoObject * this, struct MonoClass * klass, struct MonoClassField * field, void * * res)
{
  struct MonoVTable * D.24701;
  struct MonoClass * D.24702;
  struct MonoClass * D.24703;
  _Bool D.24704;
  long int D.24705;
  long int D.24706;
  _Bool D.24709;
  long int D.24710;
  long int D.24711;
  struct MonoRemoteClass * D.24714;
  struct MonoClass * D.24715;
  unsigned int D.24716;
  unsigned int D.24717;
  struct MonoRealProxy * D.24720;
  struct MonoObject * D.24721;
  struct MonoAppContext * D.24722;
  struct MonoObject * D.24725;
  void * D.24726;
  struct MonoMethod * getter.246;
  struct MonoClass * D.24730;
  struct MonoMethod * getter.247;
  _Bool D.24732;
  long int D.24733;
  long int D.24734;
  struct MonoType * D.24737;
  struct MonoClass * D.24738;
  struct MonoArray * out_args.248;
  struct MonoReflectionMethod * D.24740;
  struct MonoArray * out_args.249;
  struct MonoArray * D.24742;
  struct MonoString * D.24743;
  const char * D.24744;
  struct MonoString * D.24745;
  struct MonoObject * exc.250;
  unsigned int D.24749;
  char * D.24752;
  struct MonoObject * D.24753;
  unsigned int D.24754;
  unsigned int D.24755;
  void * D.24758;
  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.24701 = this->vtable;
      D.24702 = D.24701->klass;
      D.24703 = mono_defaults.transparent_proxy_class;
      D.24704 = D.24702 != D.24703;
      D.24705 = (long int) D.24704;
      D.24706 = __builtin_expect (D.24705, 0);
      if (D.24706 != 0) goto <D.24707>; else goto <D.24708>;
      <D.24707>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 6334, "mono_object_is_transparent_proxy (this)");
      <D.24708>:
      D.24709 = res == 0B;
      D.24710 = (long int) D.24709;
      D.24711 = __builtin_expect (D.24710, 0);
      if (D.24711 != 0) goto <D.24712>; else goto <D.24713>;
      <D.24712>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 6335, "res != NULL");
      <D.24713>:
      D.24714 = tp->remote_class;
      D.24715 = D.24714->proxy_class;
      D.24716 = BIT_FIELD_REF <*D.24715, 32, 160>;
      D.24717 = D.24716 & 8388608;
      if (D.24717 != 0) goto <D.24718>; else goto <D.24719>;
      <D.24718>:
      D.24720 = tp->rp;
      D.24721 = D.24720->context;
      D.24722 = mono_context_get ();
      if (D.24721 == D.24722) goto <D.24723>; else goto <D.24724>;
      <D.24723>:
      D.24720 = tp->rp;
      D.24725 = D.24720->unwrapped_server;
      mono_field_get_value (D.24725, field, res);
      D.24726 = res;
      return D.24726;
      <D.24724>:
      <D.24719>:
      getter.246 = getter;
      if (getter.246 == 0B) goto <D.24728>; else goto <D.24729>;
      <D.24728>:
      D.24730 = mono_defaults.object_class;
      getter.247 = mono_class_get_method_from_name (D.24730, "FieldGetter", -1);
      getter = getter.247;
      getter.246 = getter;
      D.24732 = getter.246 == 0B;
      D.24733 = (long int) D.24732;
      D.24734 = __builtin_expect (D.24733, 0);
      if (D.24734 != 0) goto <D.24735>; else goto <D.24736>;
      <D.24735>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 6344, "getter");
      <D.24736>:
      <D.24729>:
      D.24737 = field->type;
      field_class = mono_class_from_mono_type (D.24737);
      D.24738 = mono_defaults.mono_method_message_class;
      msg = mono_object_new (domain, D.24738);
      D.24730 = mono_defaults.object_class;
      out_args.248 = mono_array_new (domain, D.24730, 1);
      out_args = out_args.248;
      getter.246 = getter;
      D.24740 = mono_method_get_object (domain, getter.246, 0B);
      out_args.249 = out_args;
      mono_message_init (domain, msg, D.24740, out_args.249);
      full_name = mono_type_get_full_name (klass);
      {
        void * * __p;

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

        D.24742 = msg->args;
        __p = mono_array_addr_with_size (D.24742, 4, 1);
        D.24742 = msg->args;
        D.24744 = mono_field_get_name (field);
        D.24745 = mono_string_new (domain, D.24744);
        mono_gc_wbarrier_set_arrayref (D.24742, __p, D.24745);
      }
      monoeg_g_free (full_name);
      D.24720 = tp->rp;
      mono_remoting_invoke (D.24720, msg, &exc, &out_args);
      exc.250 = exc;
      if (exc.250 != 0B) goto <D.24747>; else goto <D.24748>;
      <D.24747>:
      exc.250 = exc;
      mono_raise_exception (exc.250);
      <D.24748>:
      out_args.249 = out_args;
      D.24749 = mono_array_length (out_args.249);
      if (D.24749 == 0) goto <D.24750>; else goto <D.24751>;
      <D.24750>:
      D.24726 = 0B;
      return D.24726;
      <D.24751>:
      out_args.249 = out_args;
      D.24752 = mono_array_addr_with_size (out_args.249, 4, 0);
      D.24753 = MEM[(struct MonoObject * *)D.24752];
      *res = D.24753;
      D.24754 = BIT_FIELD_REF <*field_class, 32, 160>;
      D.24755 = D.24754 & 8;
      if (D.24755 != 0) goto <D.24756>; else goto <D.24757>;
      <D.24756>:
      D.24758 = *res;
      D.24726 = D.24758 + 8;
      return D.24726;
      <D.24757>:
      D.24726 = res;
      return D.24726;
    }
  finally
    {
      out_args = {CLOBBER};
      exc = {CLOBBER};
    }
}


mono_load_remote_field_new (struct MonoObject * this, struct MonoClass * klass, struct MonoClassField * field)
{
  struct MonoVTable * D.24761;
  struct MonoClass * D.24762;
  struct MonoClass * D.24763;
  _Bool D.24764;
  long int D.24765;
  long int D.24766;
  struct MonoType * D.24769;
  struct MonoRemoteClass * D.24770;
  struct MonoClass * D.24771;
  unsigned int D.24772;
  unsigned int D.24773;
  struct MonoRealProxy * D.24776;
  struct MonoObject * D.24777;
  struct MonoAppContext * D.24778;
  unsigned int D.24781;
  unsigned int D.24782;
  struct MonoObject * res.251;
  struct MonoObject * res.252;
  struct MonoObject * D.24788;
  struct MonoObject * D.24789;
  struct MonoMethod * getter.253;
  struct MonoClass * D.24793;
  struct MonoMethod * getter.254;
  _Bool D.24795;
  long int D.24796;
  long int D.24797;
  struct MonoClass * D.24800;
  struct MonoArray * out_args.255;
  struct MonoReflectionMethod * D.24802;
  struct MonoArray * out_args.256;
  struct MonoArray * D.24804;
  struct MonoString * D.24805;
  const char * D.24806;
  struct MonoString * D.24807;
  struct MonoObject * exc.257;
  unsigned int D.24811;
  char * D.24815;
  struct MonoObject * res.258;
  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.24761 = this->vtable;
      D.24762 = D.24761->klass;
      D.24763 = mono_defaults.transparent_proxy_class;
      D.24764 = D.24762 != D.24763;
      D.24765 = (long int) D.24764;
      D.24766 = __builtin_expect (D.24765, 0);
      if (D.24766 != 0) goto <D.24767>; else goto <D.24768>;
      <D.24767>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 6393, "mono_object_is_transparent_proxy (this)");
      <D.24768>:
      D.24769 = field->type;
      field_class = mono_class_from_mono_type (D.24769);
      D.24770 = tp->remote_class;
      D.24771 = D.24770->proxy_class;
      D.24772 = BIT_FIELD_REF <*D.24771, 32, 160>;
      D.24773 = D.24772 & 8388608;
      if (D.24773 != 0) goto <D.24774>; else goto <D.24775>;
      <D.24774>:
      D.24776 = tp->rp;
      D.24777 = D.24776->context;
      D.24778 = mono_context_get ();
      if (D.24777 == D.24778) goto <D.24779>; else goto <D.24780>;
      <D.24779>:
      {
        void * val;

        D.24781 = BIT_FIELD_REF <*field_class, 32, 160>;
        D.24782 = D.24781 & 8;
        if (D.24782 != 0) goto <D.24783>; else goto <D.24784>;
        <D.24783>:
        res.251 = mono_object_new (domain, field_class);
        res = res.251;
        res.252 = res;
        val = res.252 + 8;
        goto <D.24787>;
        <D.24784>:
        val = &res;
        <D.24787>:
        D.24776 = tp->rp;
        D.24788 = D.24776->unwrapped_server;
        mono_field_get_value (D.24788, field, val);
        D.24789 = res;
        return D.24789;
      }
      <D.24780>:
      <D.24775>:
      getter.253 = getter;
      if (getter.253 == 0B) goto <D.24791>; else goto <D.24792>;
      <D.24791>:
      D.24793 = mono_defaults.object_class;
      getter.254 = mono_class_get_method_from_name (D.24793, "FieldGetter", -1);
      getter = getter.254;
      getter.253 = getter;
      D.24795 = getter.253 == 0B;
      D.24796 = (long int) D.24795;
      D.24797 = __builtin_expect (D.24796, 0);
      if (D.24797 != 0) goto <D.24798>; else goto <D.24799>;
      <D.24798>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 6411, "getter");
      <D.24799>:
      <D.24792>:
      D.24800 = mono_defaults.mono_method_message_class;
      msg = mono_object_new (domain, D.24800);
      D.24793 = mono_defaults.object_class;
      out_args.255 = mono_array_new (domain, D.24793, 1);
      out_args = out_args.255;
      getter.253 = getter;
      D.24802 = mono_method_get_object (domain, getter.253, 0B);
      out_args.256 = out_args;
      mono_message_init (domain, msg, D.24802, out_args.256);
      full_name = mono_type_get_full_name (klass);
      {
        void * * __p;

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

        D.24804 = msg->args;
        __p = mono_array_addr_with_size (D.24804, 4, 1);
        D.24804 = msg->args;
        D.24806 = mono_field_get_name (field);
        D.24807 = mono_string_new (domain, D.24806);
        mono_gc_wbarrier_set_arrayref (D.24804, __p, D.24807);
      }
      monoeg_g_free (full_name);
      D.24776 = tp->rp;
      mono_remoting_invoke (D.24776, msg, &exc, &out_args);
      exc.257 = exc;
      if (exc.257 != 0B) goto <D.24809>; else goto <D.24810>;
      <D.24809>:
      exc.257 = exc;
      mono_raise_exception (exc.257);
      <D.24810>:
      out_args.256 = out_args;
      D.24811 = mono_array_length (out_args.256);
      if (D.24811 == 0) goto <D.24812>; else goto <D.24813>;
      <D.24812>:
      res = 0B;
      goto <D.24814>;
      <D.24813>:
      out_args.256 = out_args;
      D.24815 = mono_array_addr_with_size (out_args.256, 4, 0);
      res.258 = MEM[(struct MonoObject * *)D.24815];
      res = res.258;
      <D.24814>:
      D.24789 = res;
      return D.24789;
    }
  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.24819;
  struct MonoClass * D.24820;
  struct MonoClass * D.24821;
  _Bool D.24822;
  long int D.24823;
  long int D.24824;
  struct MonoType * D.24827;
  struct MonoRemoteClass * D.24828;
  struct MonoClass * D.24829;
  unsigned int D.24830;
  unsigned int D.24831;
  struct MonoRealProxy * D.24834;
  struct MonoObject * D.24835;
  struct MonoAppContext * D.24836;
  unsigned int D.24839;
  unsigned int D.24840;
  struct MonoObject * D.24843;
  struct MonoObject * D.24845;
  struct MonoMethod * setter.259;
  struct MonoClass * D.24849;
  struct MonoMethod * setter.260;
  _Bool D.24851;
  long int D.24852;
  long int D.24853;
  struct MonoClass * D.24859;
  struct MonoReflectionMethod * D.24860;
  struct MonoArray * D.24861;
  struct MonoString * D.24862;
  const char * D.24863;
  struct MonoString * D.24864;
  struct MonoObject * exc.261;
  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.24819 = this->vtable;
      D.24820 = D.24819->klass;
      D.24821 = mono_defaults.transparent_proxy_class;
      D.24822 = D.24820 != D.24821;
      D.24823 = (long int) D.24822;
      D.24824 = __builtin_expect (D.24823, 0);
      if (D.24824 != 0) goto <D.24825>; else goto <D.24826>;
      <D.24825>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 6460, "mono_object_is_transparent_proxy (this)");
      <D.24826>:
      D.24827 = field->type;
      field_class = mono_class_from_mono_type (D.24827);
      D.24828 = tp->remote_class;
      D.24829 = D.24828->proxy_class;
      D.24830 = BIT_FIELD_REF <*D.24829, 32, 160>;
      D.24831 = D.24830 & 8388608;
      if (D.24831 != 0) goto <D.24832>; else goto <D.24833>;
      <D.24832>:
      D.24834 = tp->rp;
      D.24835 = D.24834->context;
      D.24836 = mono_context_get ();
      if (D.24835 == D.24836) goto <D.24837>; else goto <D.24838>;
      <D.24837>:
      D.24839 = BIT_FIELD_REF <*field_class, 32, 160>;
      D.24840 = D.24839 & 8;
      if (D.24840 != 0) goto <D.24841>; else goto <D.24842>;
      <D.24841>:
      D.24834 = tp->rp;
      D.24843 = D.24834->unwrapped_server;
      mono_field_set_value (D.24843, field, val);
      goto <D.24844>;
      <D.24842>:
      D.24834 = tp->rp;
      D.24843 = D.24834->unwrapped_server;
      D.24845 = MEM[(struct MonoObject * *)val];
      mono_field_set_value (D.24843, field, D.24845);
      <D.24844>:
      return;
      <D.24838>:
      <D.24833>:
      setter.259 = setter;
      if (setter.259 == 0B) goto <D.24847>; else goto <D.24848>;
      <D.24847>:
      D.24849 = mono_defaults.object_class;
      setter.260 = mono_class_get_method_from_name (D.24849, "FieldSetter", -1);
      setter = setter.260;
      setter.259 = setter;
      D.24851 = setter.259 == 0B;
      D.24852 = (long int) D.24851;
      D.24853 = __builtin_expect (D.24852, 0);
      if (D.24853 != 0) goto <D.24854>; else goto <D.24855>;
      <D.24854>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 6472, "setter");
      <D.24855>:
      <D.24848>:
      D.24839 = BIT_FIELD_REF <*field_class, 32, 160>;
      D.24840 = D.24839 & 8;
      if (D.24840 != 0) goto <D.24856>; else goto <D.24857>;
      <D.24856>:
      arg = mono_value_box (domain, field_class, val);
      goto <D.24858>;
      <D.24857>:
      arg = MEM[(struct MonoObject * *)val];
      <D.24858>:
      D.24859 = mono_defaults.mono_method_message_class;
      msg = mono_object_new (domain, D.24859);
      setter.259 = setter;
      D.24860 = mono_method_get_object (domain, setter.259, 0B);
      mono_message_init (domain, msg, D.24860, 0B);
      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.24861 = msg->args;
        D.24862 = mono_string_new (domain, full_name);
        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.24861 = msg->args;
        D.24863 = mono_field_get_name (field);
        D.24864 = mono_string_new (domain, D.24863);
        mono_gc_wbarrier_set_arrayref (D.24861, __p, D.24864);
      }
      {
        void * * __p;

        D.24861 = msg->args;
        __p = mono_array_addr_with_size (D.24861, 4, 2);
        D.24861 = msg->args;
        mono_gc_wbarrier_set_arrayref (D.24861, __p, arg);
      }
      monoeg_g_free (full_name);
      D.24834 = tp->rp;
      mono_remoting_invoke (D.24834, msg, &exc, &out_args);
      exc.261 = exc;
      if (exc.261 != 0B) goto <D.24866>; else goto <D.24867>;
      <D.24866>:
      exc.261 = exc;
      mono_raise_exception (exc.261);
      <D.24867>:
    }
  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.24871;
  struct MonoClass * D.24872;
  struct MonoClass * D.24873;
  _Bool D.24874;
  long int D.24875;
  long int D.24876;
  struct MonoType * D.24879;
  struct MonoRemoteClass * D.24880;
  struct MonoClass * D.24881;
  unsigned int D.24882;
  unsigned int D.24883;
  struct MonoRealProxy * D.24886;
  struct MonoObject * D.24887;
  struct MonoAppContext * D.24888;
  unsigned int D.24891;
  unsigned int D.24892;
  struct MonoObject * D.24895;
  void * D.24896;
  struct MonoMethod * setter.262;
  struct MonoClass * D.24901;
  struct MonoMethod * setter.263;
  _Bool D.24903;
  long int D.24904;
  long int D.24905;
  struct MonoClass * D.24908;
  struct MonoReflectionMethod * D.24909;
  struct MonoArray * D.24910;
  struct MonoString * D.24911;
  const char * D.24912;
  struct MonoString * D.24913;
  struct MonoObject * exc.264;
  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.24871 = this->vtable;
      D.24872 = D.24871->klass;
      D.24873 = mono_defaults.transparent_proxy_class;
      D.24874 = D.24872 != D.24873;
      D.24875 = (long int) D.24874;
      D.24876 = __builtin_expect (D.24875, 0);
      if (D.24876 != 0) goto <D.24877>; else goto <D.24878>;
      <D.24877>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 6516, "mono_object_is_transparent_proxy (this)");
      <D.24878>:
      D.24879 = field->type;
      field_class = mono_class_from_mono_type (D.24879);
      D.24880 = tp->remote_class;
      D.24881 = D.24880->proxy_class;
      D.24882 = BIT_FIELD_REF <*D.24881, 32, 160>;
      D.24883 = D.24882 & 8388608;
      if (D.24883 != 0) goto <D.24884>; else goto <D.24885>;
      <D.24884>:
      D.24886 = tp->rp;
      D.24887 = D.24886->context;
      D.24888 = mono_context_get ();
      if (D.24887 == D.24888) goto <D.24889>; else goto <D.24890>;
      <D.24889>:
      D.24891 = BIT_FIELD_REF <*field_class, 32, 160>;
      D.24892 = D.24891 & 8;
      if (D.24892 != 0) goto <D.24893>; else goto <D.24894>;
      <D.24893>:
      D.24886 = tp->rp;
      D.24895 = D.24886->unwrapped_server;
      D.24896 = arg + 8;
      mono_field_set_value (D.24895, field, D.24896);
      goto <D.24897>;
      <D.24894>:
      D.24886 = tp->rp;
      D.24895 = D.24886->unwrapped_server;
      mono_field_set_value (D.24895, field, arg);
      <D.24897>:
      return;
      <D.24890>:
      <D.24885>:
      setter.262 = setter;
      if (setter.262 == 0B) goto <D.24899>; else goto <D.24900>;
      <D.24899>:
      D.24901 = mono_defaults.object_class;
      setter.263 = mono_class_get_method_from_name (D.24901, "FieldSetter", -1);
      setter = setter.263;
      setter.262 = setter;
      D.24903 = setter.262 == 0B;
      D.24904 = (long int) D.24903;
      D.24905 = __builtin_expect (D.24904, 0);
      if (D.24905 != 0) goto <D.24906>; else goto <D.24907>;
      <D.24906>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 6528, "setter");
      <D.24907>:
      <D.24900>:
      D.24908 = mono_defaults.mono_method_message_class;
      msg = mono_object_new (domain, D.24908);
      setter.262 = setter;
      D.24909 = mono_method_get_object (domain, setter.262, 0B);
      mono_message_init (domain, msg, D.24909, 0B);
      full_name = mono_type_get_full_name (klass);
      {
        void * * __p;

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

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

        D.24910 = msg->args;
        __p = mono_array_addr_with_size (D.24910, 4, 2);
        D.24910 = msg->args;
        mono_gc_wbarrier_set_arrayref (D.24910, __p, arg);
      }
      monoeg_g_free (full_name);
      D.24886 = tp->rp;
      mono_remoting_invoke (D.24886, msg, &exc, &out_args);
      exc.264 = exc;
      if (exc.264 != 0B) goto <D.24915>; else goto <D.24916>;
      <D.24915>:
      exc.264 = exc;
      mono_raise_exception (exc.264);
      <D.24916>:
    }
  finally
    {
      out_args = {CLOBBER};
      exc = {CLOBBER};
    }
}


mono_create_ftnptr (struct MonoDomain * domain, void * addr)
{
  void * D.24920;
  void * (*<T249e>) (struct MonoDomain *, void *) D.24921;

  D.24921 = callbacks.create_ftnptr;
  D.24920 = D.24921 (domain, addr);
  return D.24920;
}


mono_get_addr_from_ftnptr (void * descr)
{
  void * D.24923;
  void * (*<T1415>) (void *) D.24924;

  D.24924 = callbacks.get_addr_from_ftnptr;
  D.24923 = D.24924 (descr);
  return D.24923;
}


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

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


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

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


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

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


mono_array_addr_with_size (struct MonoArray * array, int size, uintptr_t idx)
{
  char * D.24932;
  double[0:] * D.24933;
  unsigned int size.265;
  unsigned int D.24935;

  D.24933 = &array->vector;
  size.265 = (unsigned int) size;
  D.24935 = size.265 * idx;
  D.24932 = D.24933 + D.24935;
  return D.24932;
}